1/* 2 * linux/arch/cris/kernel/fasttimer.c 3 * 4 * Fast timers for ETRAX FS 5 * 6 * Copyright (C) 2000-2006 Axis Communications AB, Lund, Sweden 7 */ 8 9#include <linux/errno.h> 10#include <linux/sched.h> 11#include <linux/kernel.h> 12#include <linux/param.h> 13#include <linux/string.h> 14#include <linux/vmalloc.h> 15#include <linux/interrupt.h> 16#include <linux/time.h> 17#include <linux/delay.h> 18 19#include <asm/irq.h> 20 21#include <hwregs/reg_map.h> 22#include <hwregs/reg_rdwr.h> 23#include <hwregs/timer_defs.h> 24#include <asm/fasttimer.h> 25#include <linux/proc_fs.h> 26#include <linux/seq_file.h> 27 28/* 29 * timer0 is running at 100MHz and generating jiffies timer ticks 30 * at 100 or 1000 HZ. 31 * fasttimer gives an API that gives timers that expire "between" the jiffies 32 * giving microsecond resolution (10 ns). 33 * fasttimer uses reg_timer_rw_trig register to get interrupt when 34 * r_time reaches a certain value. 35 */ 36 37 38#define DEBUG_LOG_INCLUDED 39#define FAST_TIMER_LOG 40/* #define FAST_TIMER_TEST */ 41 42#define FAST_TIMER_SANITY_CHECKS 43 44#ifdef FAST_TIMER_SANITY_CHECKS 45static int sanity_failed; 46#endif 47 48#define D1(x) 49#define D2(x) 50#define DP(x) 51 52static unsigned int fast_timer_running; 53static unsigned int fast_timers_added; 54static unsigned int fast_timers_started; 55static unsigned int fast_timers_expired; 56static unsigned int fast_timers_deleted; 57static unsigned int fast_timer_is_init; 58static unsigned int fast_timer_ints; 59 60struct fast_timer *fast_timer_list = NULL; 61 62#ifdef DEBUG_LOG_INCLUDED 63#define DEBUG_LOG_MAX 128 64static const char * debug_log_string[DEBUG_LOG_MAX]; 65static unsigned long debug_log_value[DEBUG_LOG_MAX]; 66static unsigned int debug_log_cnt; 67static unsigned int debug_log_cnt_wrapped; 68 69#define DEBUG_LOG(string, value) \ 70{ \ 71 unsigned long log_flags; \ 72 local_irq_save(log_flags); \ 73 debug_log_string[debug_log_cnt] = (string); \ 74 debug_log_value[debug_log_cnt] = (unsigned long)(value); \ 75 if (++debug_log_cnt >= DEBUG_LOG_MAX) \ 76 { \ 77 debug_log_cnt = debug_log_cnt % DEBUG_LOG_MAX; \ 78 debug_log_cnt_wrapped = 1; \ 79 } \ 80 local_irq_restore(log_flags); \ 81} 82#else 83#define DEBUG_LOG(string, value) 84#endif 85 86 87#define NUM_TIMER_STATS 16 88#ifdef FAST_TIMER_LOG 89struct fast_timer timer_added_log[NUM_TIMER_STATS]; 90struct fast_timer timer_started_log[NUM_TIMER_STATS]; 91struct fast_timer timer_expired_log[NUM_TIMER_STATS]; 92#endif 93 94int timer_div_settings[NUM_TIMER_STATS]; 95int timer_delay_settings[NUM_TIMER_STATS]; 96 97struct work_struct fast_work; 98 99static void 100timer_trig_handler(struct work_struct *work); 101 102 103 104/* Not true gettimeofday, only checks the jiffies (uptime) + useconds */ 105inline void do_gettimeofday_fast(struct fasttime_t *tv) 106{ 107 tv->tv_jiff = jiffies; 108 tv->tv_usec = GET_JIFFIES_USEC(); 109} 110 111inline int fasttime_cmp(struct fasttime_t *t0, struct fasttime_t *t1) 112{ 113 /* Compare jiffies. Takes care of wrapping */ 114 if (time_before(t0->tv_jiff, t1->tv_jiff)) 115 return -1; 116 else if (time_after(t0->tv_jiff, t1->tv_jiff)) 117 return 1; 118 119 /* Compare us */ 120 if (t0->tv_usec < t1->tv_usec) 121 return -1; 122 else if (t0->tv_usec > t1->tv_usec) 123 return 1; 124 return 0; 125} 126 127/* Called with ints off */ 128inline void start_timer_trig(unsigned long delay_us) 129{ 130 reg_timer_rw_ack_intr ack_intr = { 0 }; 131 reg_timer_rw_intr_mask intr_mask; 132 reg_timer_rw_trig trig; 133 reg_timer_rw_trig_cfg trig_cfg = { 0 }; 134 reg_timer_r_time r_time0; 135 reg_timer_r_time r_time1; 136 unsigned char trig_wrap; 137 unsigned char time_wrap; 138 139 r_time0 = REG_RD(timer, regi_timer0, r_time); 140 141 D1(printk("start_timer_trig : %d us freq: %i div: %i\n", 142 delay_us, freq_index, div)); 143 /* Clear trig irq */ 144 intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask); 145 intr_mask.trig = 0; 146 REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask); 147 148 /* Set timer values and check if trigger wraps. */ 149 /* r_time is 100MHz (10 ns resolution) */ 150 trig_wrap = (trig = r_time0 + delay_us*(1000/10)) < r_time0; 151 152 timer_div_settings[fast_timers_started % NUM_TIMER_STATS] = trig; 153 timer_delay_settings[fast_timers_started % NUM_TIMER_STATS] = delay_us; 154 155 /* Ack interrupt */ 156 ack_intr.trig = 1; 157 REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr); 158 159 /* Start timer */ 160 REG_WR(timer, regi_timer0, rw_trig, trig); 161 trig_cfg.tmr = regk_timer_time; 162 REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg); 163 164 /* Check if we have already passed the trig time */ 165 r_time1 = REG_RD(timer, regi_timer0, r_time); 166 time_wrap = r_time1 < r_time0; 167 168 if ((trig_wrap && !time_wrap) || (r_time1 < trig)) { 169 /* No, Enable trig irq */ 170 intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask); 171 intr_mask.trig = 1; 172 REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask); 173 fast_timers_started++; 174 fast_timer_running = 1; 175 } else { 176 /* We have passed the time, disable trig point, ack intr */ 177 trig_cfg.tmr = regk_timer_off; 178 REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg); 179 REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr); 180 /* call the int routine */ 181 INIT_WORK(&fast_work, timer_trig_handler); 182 schedule_work(&fast_work); 183 } 184 185} 186 187/* In version 1.4 this function takes 27 - 50 us */ 188void start_one_shot_timer(struct fast_timer *t, 189 fast_timer_function_type *function, 190 unsigned long data, 191 unsigned long delay_us, 192 const char *name) 193{ 194 unsigned long flags; 195 struct fast_timer *tmp; 196 197 D1(printk("sft %s %d us\n", name, delay_us)); 198 199 local_irq_save(flags); 200 201 do_gettimeofday_fast(&t->tv_set); 202 tmp = fast_timer_list; 203 204#ifdef FAST_TIMER_SANITY_CHECKS 205 /* Check so this is not in the list already... */ 206 while (tmp != NULL) { 207 if (tmp == t) { 208 printk(KERN_DEBUG 209 "timer name: %s data: 0x%08lX already " 210 "in list!\n", name, data); 211 sanity_failed++; 212 goto done; 213 } else 214 tmp = tmp->next; 215 } 216 tmp = fast_timer_list; 217#endif 218 219 t->delay_us = delay_us; 220 t->function = function; 221 t->data = data; 222 t->name = name; 223 224 t->tv_expires.tv_usec = t->tv_set.tv_usec + delay_us % 1000000; 225 t->tv_expires.tv_jiff = t->tv_set.tv_jiff + delay_us / 1000000 / HZ; 226 if (t->tv_expires.tv_usec > 1000000) { 227 t->tv_expires.tv_usec -= 1000000; 228 t->tv_expires.tv_jiff += HZ; 229 } 230#ifdef FAST_TIMER_LOG 231 timer_added_log[fast_timers_added % NUM_TIMER_STATS] = *t; 232#endif 233 fast_timers_added++; 234 235 /* Check if this should timeout before anything else */ 236 if (tmp == NULL || fasttime_cmp(&t->tv_expires, &tmp->tv_expires) < 0) { 237 /* Put first in list and modify the timer value */ 238 t->prev = NULL; 239 t->next = fast_timer_list; 240 if (fast_timer_list) 241 fast_timer_list->prev = t; 242 fast_timer_list = t; 243#ifdef FAST_TIMER_LOG 244 timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t; 245#endif 246 start_timer_trig(delay_us); 247 } else { 248 /* Put in correct place in list */ 249 while (tmp->next && 250 fasttime_cmp(&t->tv_expires, &tmp->next->tv_expires) > 0) 251 tmp = tmp->next; 252 /* Insert t after tmp */ 253 t->prev = tmp; 254 t->next = tmp->next; 255 if (tmp->next) 256 { 257 tmp->next->prev = t; 258 } 259 tmp->next = t; 260 } 261 262 D2(printk("start_one_shot_timer: %d us done\n", delay_us)); 263 264done: 265 local_irq_restore(flags); 266} /* start_one_shot_timer */ 267 268static inline int fast_timer_pending (const struct fast_timer * t) 269{ 270 return (t->next != NULL) || (t->prev != NULL) || (t == fast_timer_list); 271} 272 273static inline int detach_fast_timer (struct fast_timer *t) 274{ 275 struct fast_timer *next, *prev; 276 if (!fast_timer_pending(t)) 277 return 0; 278 next = t->next; 279 prev = t->prev; 280 if (next) 281 next->prev = prev; 282 if (prev) 283 prev->next = next; 284 else 285 fast_timer_list = next; 286 fast_timers_deleted++; 287 return 1; 288} 289 290int del_fast_timer(struct fast_timer * t) 291{ 292 unsigned long flags; 293 int ret; 294 295 local_irq_save(flags); 296 ret = detach_fast_timer(t); 297 t->next = t->prev = NULL; 298 local_irq_restore(flags); 299 return ret; 300} /* del_fast_timer */ 301 302 303/* Interrupt routines or functions called in interrupt context */ 304 305/* Timer interrupt handler for trig interrupts */ 306 307static irqreturn_t 308timer_trig_interrupt(int irq, void *dev_id) 309{ 310 reg_timer_r_masked_intr masked_intr; 311 /* Check if the timer interrupt is for us (a trig int) */ 312 masked_intr = REG_RD(timer, regi_timer0, r_masked_intr); 313 if (!masked_intr.trig) 314 return IRQ_NONE; 315 timer_trig_handler(NULL); 316 return IRQ_HANDLED; 317} 318 319static void timer_trig_handler(struct work_struct *work) 320{ 321 reg_timer_rw_ack_intr ack_intr = { 0 }; 322 reg_timer_rw_intr_mask intr_mask; 323 reg_timer_rw_trig_cfg trig_cfg = { 0 }; 324 struct fast_timer *t; 325 unsigned long flags; 326 327 /* We keep interrupts disabled not only when we modify the 328 * fast timer list, but any time we hold a reference to a 329 * timer in the list, since del_fast_timer may be called 330 * from (another) interrupt context. Thus, the only time 331 * when interrupts are enabled is when calling the timer 332 * callback function. 333 */ 334 local_irq_save(flags); 335 336 /* Clear timer trig interrupt */ 337 intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask); 338 intr_mask.trig = 0; 339 REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask); 340 341 /* First stop timer, then ack interrupt */ 342 /* Stop timer */ 343 trig_cfg.tmr = regk_timer_off; 344 REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg); 345 346 /* Ack interrupt */ 347 ack_intr.trig = 1; 348 REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr); 349 350 fast_timer_running = 0; 351 fast_timer_ints++; 352 353 fast_timer_function_type *f; 354 unsigned long d; 355 356 t = fast_timer_list; 357 while (t) { 358 struct fasttime_t tv; 359 360 /* Has it really expired? */ 361 do_gettimeofday_fast(&tv); 362 D1(printk(KERN_DEBUG 363 "t: %is %06ius\n", tv.tv_jiff, tv.tv_usec)); 364 365 if (fasttime_cmp(&t->tv_expires, &tv) <= 0) { 366 /* Yes it has expired */ 367#ifdef FAST_TIMER_LOG 368 timer_expired_log[fast_timers_expired % NUM_TIMER_STATS] = *t; 369#endif 370 fast_timers_expired++; 371 372 /* Remove this timer before call, since it may reuse the timer */ 373 if (t->prev) 374 t->prev->next = t->next; 375 else 376 fast_timer_list = t->next; 377 if (t->next) 378 t->next->prev = t->prev; 379 t->prev = NULL; 380 t->next = NULL; 381 382 /* Save function callback data before enabling 383 * interrupts, since the timer may be removed and we 384 * don't know how it was allocated (e.g. ->function 385 * and ->data may become overwritten after deletion 386 * if the timer was stack-allocated). 387 */ 388 f = t->function; 389 d = t->data; 390 391 if (f != NULL) { 392 /* Run the callback function with interrupts 393 * enabled. */ 394 local_irq_restore(flags); 395 f(d); 396 local_irq_save(flags); 397 } else 398 DEBUG_LOG("!trimertrig %i function==NULL!\n", fast_timer_ints); 399 } else { 400 /* Timer is to early, let's set it again using the normal routines */ 401 D1(printk(".\n")); 402 } 403 404 t = fast_timer_list; 405 if (t != NULL) { 406 /* Start next timer.. */ 407 long us = 0; 408 struct fasttime_t tv; 409 410 do_gettimeofday_fast(&tv); 411 412 /* time_after_eq takes care of wrapping */ 413 if (time_after_eq(t->tv_expires.tv_jiff, tv.tv_jiff)) 414 us = ((t->tv_expires.tv_jiff - tv.tv_jiff) * 415 1000000 / HZ + t->tv_expires.tv_usec - 416 tv.tv_usec); 417 418 if (us > 0) { 419 if (!fast_timer_running) { 420#ifdef FAST_TIMER_LOG 421 timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t; 422#endif 423 start_timer_trig(us); 424 } 425 break; 426 } else { 427 /* Timer already expired, let's handle it better late than never. 428 * The normal loop handles it 429 */ 430 D1(printk("e! %d\n", us)); 431 } 432 } 433 } 434 435 local_irq_restore(flags); 436 437 if (!t) 438 D1(printk("ttrig stop!\n")); 439} 440 441static void wake_up_func(unsigned long data) 442{ 443 wait_queue_head_t *sleep_wait_p = (wait_queue_head_t*)data; 444 wake_up(sleep_wait_p); 445} 446 447 448/* Useful API */ 449 450void schedule_usleep(unsigned long us) 451{ 452 struct fast_timer t; 453 wait_queue_head_t sleep_wait; 454 init_waitqueue_head(&sleep_wait); 455 456 D1(printk("schedule_usleep(%d)\n", us)); 457 start_one_shot_timer(&t, wake_up_func, (unsigned long)&sleep_wait, us, 458 "usleep"); 459 /* Uninterruptible sleep on the fast timer. (The condition is 460 * somewhat redundant since the timer is what wakes us up.) */ 461 wait_event(sleep_wait, !fast_timer_pending(&t)); 462 463 D1(printk("done schedule_usleep(%d)\n", us)); 464} 465 466#ifdef CONFIG_PROC_FS 467/* This value is very much based on testing */ 468#define BIG_BUF_SIZE (500 + NUM_TIMER_STATS * 300) 469 470static int proc_fasttimer_show(struct seq_file *m, void *v) 471{ 472 unsigned long flags; 473 int i = 0; 474 int num_to_show; 475 struct fasttime_t tv; 476 struct fast_timer *t, *nextt; 477 478 do_gettimeofday_fast(&tv); 479 480 seq_printf(m, "Fast timers added: %i\n", fast_timers_added); 481 seq_printf(m, "Fast timers started: %i\n", fast_timers_started); 482 seq_printf(m, "Fast timer interrupts: %i\n", fast_timer_ints); 483 seq_printf(m, "Fast timers expired: %i\n", fast_timers_expired); 484 seq_printf(m, "Fast timers deleted: %i\n", fast_timers_deleted); 485 seq_printf(m, "Fast timer running: %s\n", 486 fast_timer_running ? "yes" : "no"); 487 seq_printf(m, "Current time: %lu.%06lu\n", 488 (unsigned long)tv.tv_jiff, 489 (unsigned long)tv.tv_usec); 490#ifdef FAST_TIMER_SANITY_CHECKS 491 seq_printf(m, "Sanity failed: %i\n", sanity_failed); 492#endif 493 seq_putc(m, '\n'); 494 495#ifdef DEBUG_LOG_INCLUDED 496 { 497 int end_i = debug_log_cnt; 498 i = 0; 499 500 if (debug_log_cnt_wrapped) 501 i = debug_log_cnt; 502 503 while ((i != end_i || debug_log_cnt_wrapped)) { 504 seq_printf(m, debug_log_string[i], debug_log_value[i]); 505 if (seq_has_overflowed(m)) 506 return 0; 507 i = (i+1) % DEBUG_LOG_MAX; 508 } 509 } 510 seq_putc(m, '\n'); 511#endif 512 513 num_to_show = (fast_timers_started < NUM_TIMER_STATS ? fast_timers_started: 514 NUM_TIMER_STATS); 515 seq_printf(m, "Timers started: %i\n", fast_timers_started); 516 for (i = 0; i < num_to_show; i++) { 517 int cur = (fast_timers_started - i - 1) % NUM_TIMER_STATS; 518 519#if 1 //ndef FAST_TIMER_LOG 520 seq_printf(m, "div: %i delay: %i\n", 521 timer_div_settings[cur], 522 timer_delay_settings[cur]); 523#endif 524#ifdef FAST_TIMER_LOG 525 t = &timer_started_log[cur]; 526 seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n", 527 t->name, 528 (unsigned long)t->tv_set.tv_jiff, 529 (unsigned long)t->tv_set.tv_usec, 530 (unsigned long)t->tv_expires.tv_jiff, 531 (unsigned long)t->tv_expires.tv_usec, 532 t->delay_us, 533 t->data); 534 if (seq_has_overflowed(m)) 535 return 0; 536#endif 537 } 538 seq_putc(m, '\n'); 539 540#ifdef FAST_TIMER_LOG 541 num_to_show = (fast_timers_added < NUM_TIMER_STATS ? fast_timers_added: 542 NUM_TIMER_STATS); 543 seq_printf(m, "Timers added: %i\n", fast_timers_added); 544 for (i = 0; i < num_to_show; i++) { 545 t = &timer_added_log[(fast_timers_added - i - 1) % NUM_TIMER_STATS]; 546 seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n", 547 t->name, 548 (unsigned long)t->tv_set.tv_jiff, 549 (unsigned long)t->tv_set.tv_usec, 550 (unsigned long)t->tv_expires.tv_jiff, 551 (unsigned long)t->tv_expires.tv_usec, 552 t->delay_us, 553 t->data); 554 if (seq_has_overflowed(m)) 555 return 0; 556 } 557 seq_putc(m, '\n'); 558 559 num_to_show = (fast_timers_expired < NUM_TIMER_STATS ? fast_timers_expired: 560 NUM_TIMER_STATS); 561 seq_printf(m, "Timers expired: %i\n", fast_timers_expired); 562 for (i = 0; i < num_to_show; i++){ 563 t = &timer_expired_log[(fast_timers_expired - i - 1) % NUM_TIMER_STATS]; 564 seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n", 565 t->name, 566 (unsigned long)t->tv_set.tv_jiff, 567 (unsigned long)t->tv_set.tv_usec, 568 (unsigned long)t->tv_expires.tv_jiff, 569 (unsigned long)t->tv_expires.tv_usec, 570 t->delay_us, 571 t->data); 572 if (seq_has_overflowed(m)) 573 return 0; 574 } 575 seq_putc(m, '\n'); 576#endif 577 578 seq_puts(m, "Active timers:\n"); 579 local_irq_save(flags); 580 t = fast_timer_list; 581 while (t != NULL){ 582 nextt = t->next; 583 local_irq_restore(flags); 584 seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n", 585 t->name, 586 (unsigned long)t->tv_set.tv_jiff, 587 (unsigned long)t->tv_set.tv_usec, 588 (unsigned long)t->tv_expires.tv_jiff, 589 (unsigned long)t->tv_expires.tv_usec, 590 t->delay_us, 591 t->data); 592 if (seq_has_overflowed(m)) 593 return 0; 594 local_irq_save(flags); 595 if (t->next != nextt) 596 printk("timer removed!\n"); 597 t = nextt; 598 } 599 local_irq_restore(flags); 600 return 0; 601} 602 603static int proc_fasttimer_open(struct inode *inode, struct file *file) 604{ 605 return single_open_size(file, proc_fasttimer_show, PDE_DATA(inode), BIG_BUF_SIZE); 606} 607 608static const struct file_operations proc_fasttimer_fops = { 609 .open = proc_fasttimer_open, 610 .read = seq_read, 611 .llseek = seq_lseek, 612 .release = single_release, 613}; 614 615#endif /* PROC_FS */ 616 617#ifdef FAST_TIMER_TEST 618static volatile unsigned long i = 0; 619static volatile int num_test_timeout = 0; 620static struct fast_timer tr[10]; 621static int exp_num[10]; 622 623static struct fasttime_t tv_exp[100]; 624 625static void test_timeout(unsigned long data) 626{ 627 do_gettimeofday_fast(&tv_exp[data]); 628 exp_num[data] = num_test_timeout; 629 630 num_test_timeout++; 631} 632 633static void test_timeout1(unsigned long data) 634{ 635 do_gettimeofday_fast(&tv_exp[data]); 636 exp_num[data] = num_test_timeout; 637 if (data < 7) 638 { 639 start_one_shot_timer(&tr[i], test_timeout1, i, 1000, "timeout1"); 640 i++; 641 } 642 num_test_timeout++; 643} 644 645DP( 646static char buf0[2000]; 647static char buf1[2000]; 648static char buf2[2000]; 649static char buf3[2000]; 650static char buf4[2000]; 651); 652 653static char buf5[6000]; 654static int j_u[1000]; 655 656static void fast_timer_test(void) 657{ 658 int prev_num; 659 int j; 660 661 struct fasttime_t tv, tv0, tv1, tv2; 662 663 printk("fast_timer_test() start\n"); 664 do_gettimeofday_fast(&tv); 665 666 for (j = 0; j < 1000; j++) 667 { 668 j_u[j] = GET_JIFFIES_USEC(); 669 } 670 for (j = 0; j < 100; j++) 671 { 672 do_gettimeofday_fast(&tv_exp[j]); 673 } 674 printk(KERN_DEBUG "fast_timer_test() %is %06i\n", tv.tv_jiff, tv.tv_usec); 675 676 for (j = 0; j < 1000; j++) 677 { 678 printk(KERN_DEBUG "%i %i %i %i %i\n", 679 j_u[j], j_u[j+1], j_u[j+2], j_u[j+3], j_u[j+4]); 680 j += 4; 681 } 682 for (j = 0; j < 100; j++) 683 { 684 printk(KERN_DEBUG "%i.%i %i.%i %i.%i %i.%i %i.%i\n", 685 tv_exp[j].tv_jiff, tv_exp[j].tv_usec, 686 tv_exp[j+1].tv_jiff, tv_exp[j+1].tv_usec, 687 tv_exp[j+2].tv_jiff, tv_exp[j+2].tv_usec, 688 tv_exp[j+3].tv_jiff, tv_exp[j+3].tv_usec, 689 tv_exp[j+4].tv_jiff, tv_exp[j+4].tv_usec); 690 j += 4; 691 } 692 do_gettimeofday_fast(&tv0); 693 start_one_shot_timer(&tr[i], test_timeout, i, 50000, "test0"); 694 DP(proc_fasttimer_read(buf0, NULL, 0, 0, 0)); 695 i++; 696 start_one_shot_timer(&tr[i], test_timeout, i, 70000, "test1"); 697 DP(proc_fasttimer_read(buf1, NULL, 0, 0, 0)); 698 i++; 699 start_one_shot_timer(&tr[i], test_timeout, i, 40000, "test2"); 700 DP(proc_fasttimer_read(buf2, NULL, 0, 0, 0)); 701 i++; 702 start_one_shot_timer(&tr[i], test_timeout, i, 60000, "test3"); 703 DP(proc_fasttimer_read(buf3, NULL, 0, 0, 0)); 704 i++; 705 start_one_shot_timer(&tr[i], test_timeout1, i, 55000, "test4xx"); 706 DP(proc_fasttimer_read(buf4, NULL, 0, 0, 0)); 707 i++; 708 do_gettimeofday_fast(&tv1); 709 710 proc_fasttimer_read(buf5, NULL, 0, 0, 0); 711 712 prev_num = num_test_timeout; 713 while (num_test_timeout < i) 714 { 715 if (num_test_timeout != prev_num) 716 prev_num = num_test_timeout; 717 } 718 do_gettimeofday_fast(&tv2); 719 printk(KERN_INFO "Timers started %is %06i\n", 720 tv0.tv_jiff, tv0.tv_usec); 721 printk(KERN_INFO "Timers started at %is %06i\n", 722 tv1.tv_jiff, tv1.tv_usec); 723 printk(KERN_INFO "Timers done %is %06i\n", 724 tv2.tv_jiff, tv2.tv_usec); 725 DP(printk("buf0:\n"); 726 printk(buf0); 727 printk("buf1:\n"); 728 printk(buf1); 729 printk("buf2:\n"); 730 printk(buf2); 731 printk("buf3:\n"); 732 printk(buf3); 733 printk("buf4:\n"); 734 printk(buf4); 735 ); 736 printk("buf5:\n"); 737 printk(buf5); 738 739 printk("timers set:\n"); 740 for(j = 0; j<i; j++) 741 { 742 struct fast_timer *t = &tr[j]; 743 printk("%-10s set: %6is %06ius exp: %6is %06ius " 744 "data: 0x%08X func: 0x%08X\n", 745 t->name, 746 t->tv_set.tv_jiff, 747 t->tv_set.tv_usec, 748 t->tv_expires.tv_jiff, 749 t->tv_expires.tv_usec, 750 t->data, 751 t->function 752 ); 753 754 printk(" del: %6ius did exp: %6is %06ius as #%i error: %6li\n", 755 t->delay_us, 756 tv_exp[j].tv_jiff, 757 tv_exp[j].tv_usec, 758 exp_num[j], 759 (tv_exp[j].tv_jiff - t->tv_expires.tv_jiff) * 760 1000000 + tv_exp[j].tv_usec - 761 t->tv_expires.tv_usec); 762 } 763 proc_fasttimer_read(buf5, NULL, 0, 0, 0); 764 printk("buf5 after all done:\n"); 765 printk(buf5); 766 printk("fast_timer_test() done\n"); 767} 768#endif 769 770 771int fast_timer_init(void) 772{ 773 /* For some reason, request_irq() hangs when called froom time_init() */ 774 if (!fast_timer_is_init) 775 { 776 printk("fast_timer_init()\n"); 777 778#ifdef CONFIG_PROC_FS 779 proc_create("fasttimer", 0, NULL, &proc_fasttimer_fops); 780#endif /* PROC_FS */ 781 if (request_irq(TIMER0_INTR_VECT, timer_trig_interrupt, 782 IRQF_SHARED, 783 "fast timer int", &fast_timer_list)) 784 printk(KERN_ERR "err: fasttimer irq\n"); 785 fast_timer_is_init = 1; 786#ifdef FAST_TIMER_TEST 787 printk("do test\n"); 788 fast_timer_test(); 789#endif 790 } 791 return 0; 792} 793__initcall(fast_timer_init); 794