Linux-2.6.12-rc2
[linux-2.6.git] / arch / cris / arch-v10 / kernel / fasttimer.c
1 /* $Id: fasttimer.c,v 1.6 2004/05/14 10:18:39 starvik Exp $
2  * linux/arch/cris/kernel/fasttimer.c
3  *
4  * Fast timers for ETRAX100/ETRAX100LX
5  * This may be useful in other OS than Linux so use 2 space indentation...
6  *
7  * $Log: fasttimer.c,v $
8  * Revision 1.6  2004/05/14 10:18:39  starvik
9  * Export fast_timer_list
10  *
11  * Revision 1.5  2004/05/14 07:58:01  starvik
12  * Merge of changes from 2.4
13  *
14  * Revision 1.4  2003/07/04 08:27:41  starvik
15  * Merge of Linux 2.5.74
16  *
17  * Revision 1.3  2002/12/12 08:26:32  starvik
18  * Don't use C-comments inside CVS comments
19  *
20  * Revision 1.2  2002/12/11 15:42:02  starvik
21  * Extracted v10 (ETRAX 100LX) specific stuff from arch/cris/kernel/
22  *
23  * Revision 1.1  2002/11/18 07:58:06  starvik
24  * Fast timers (from Linux 2.4)
25  *
26  * Revision 1.5  2002/10/15 06:21:39  starvik
27  * Added call to init_waitqueue_head
28  *
29  * Revision 1.4  2002/05/28 17:47:59  johana
30  * Added del_fast_timer()
31  *
32  * Revision 1.3  2002/05/28 16:16:07  johana
33  * Handle empty fast_timer_list
34  *
35  * Revision 1.2  2002/05/27 15:38:42  johana
36  * Made it compile without warnings on Linux 2.4.
37  * (includes, wait_queue, PROC_FS and snprintf)
38  *
39  * Revision 1.1  2002/05/27 15:32:25  johana
40  * arch/etrax100/kernel/fasttimer.c v1.8 from the elinux tree.
41  *
42  * Revision 1.8  2001/11/27 13:50:40  pkj
43  * Disable interrupts while stopping the timer and while modifying the
44  * list of active timers in timer1_handler() as it may be interrupted
45  * by other interrupts (e.g., the serial interrupt) which may add fast
46  * timers.
47  *
48  * Revision 1.7  2001/11/22 11:50:32  pkj
49  * * Only store information about the last 16 timers.
50  * * proc_fasttimer_read() now uses an allocated buffer, since it
51  *   requires more space than just a page even for only writing the
52  *   last 16 timers. The buffer is only allocated on request, so
53  *   unless /proc/fasttimer is read, it is never allocated.
54  * * Renamed fast_timer_started to fast_timers_started to match
55  *   fast_timers_added and fast_timers_expired.
56  * * Some clean-up.
57  *
58  * Revision 1.6  2000/12/13 14:02:08  johana
59  * Removed volatile for fast_timer_list
60  *
61  * Revision 1.5  2000/12/13 13:55:35  johana
62  * Added DEBUG_LOG, added som cli() and cleanup
63  *
64  * Revision 1.4  2000/12/05 13:48:50  johana
65  * Added range check when writing proc file, modified timer int handling
66  *
67  * Revision 1.3  2000/11/23 10:10:20  johana
68  * More debug/logging possibilities.
69  * Moved GET_JIFFIES_USEC() to timex.h and time.c
70  *
71  * Revision 1.2  2000/11/01 13:41:04  johana
72  * Clean up and bugfixes.
73  * Created new do_gettimeofday_fast() that gets a timeval struct
74  * with time based on jiffies and *R_TIMER0_DATA, uses a table
75  * for fast conversion of timer value to microseconds.
76  * (Much faster the standard do_gettimeofday() and we don't really
77  * wan't to use the true time - we wan't the "uptime" so timers don't screw up
78  * when we change the time.
79  * TODO: Add efficient support for continuous timers as well.
80  *
81  * Revision 1.1  2000/10/26 15:49:16  johana
82  * Added fasttimer, highresolution timers.
83  *
84  * Copyright (C) 2000,2001 2002 Axis Communications AB, Lund, Sweden
85  */
86
87 #include <linux/errno.h>
88 #include <linux/sched.h>
89 #include <linux/kernel.h>
90 #include <linux/param.h>
91 #include <linux/string.h>
92 #include <linux/mm.h>
93 #include <linux/vmalloc.h>
94 #include <linux/interrupt.h>
95 #include <linux/time.h>
96 #include <linux/delay.h>
97
98 #include <asm/segment.h>
99 #include <asm/io.h>
100 #include <asm/irq.h>
101 #include <asm/delay.h>
102 #include <asm/rtc.h>
103
104 #include <linux/config.h>
105 #include <linux/version.h>
106
107 #include <asm/arch/svinto.h>
108 #include <asm/fasttimer.h>
109 #include <linux/proc_fs.h>
110
111
112 #define DEBUG_LOG_INCLUDED
113 #define FAST_TIMER_LOG
114 //#define FAST_TIMER_TEST
115
116 #define FAST_TIMER_SANITY_CHECKS
117
118 #ifdef FAST_TIMER_SANITY_CHECKS
119 #define SANITYCHECK(x) x
120 static int sanity_failed = 0;
121 #else
122 #define SANITYCHECK(x)
123 #endif
124
125 #define D1(x)
126 #define D2(x)
127 #define DP(x)
128
129 #define __INLINE__ inline
130
131 static int fast_timer_running = 0;
132 static int fast_timers_added = 0;
133 static int fast_timers_started = 0;
134 static int fast_timers_expired = 0;
135 static int fast_timers_deleted = 0;
136 static int fast_timer_is_init = 0;
137 static int fast_timer_ints = 0;
138
139 struct fast_timer *fast_timer_list = NULL;
140
141 #ifdef DEBUG_LOG_INCLUDED
142 #define DEBUG_LOG_MAX 128
143 static const char * debug_log_string[DEBUG_LOG_MAX];
144 static unsigned long debug_log_value[DEBUG_LOG_MAX];
145 static int debug_log_cnt = 0;
146 static int debug_log_cnt_wrapped = 0;
147
148 #define DEBUG_LOG(string, value) \
149 { \
150   unsigned long log_flags; \
151   save_flags(log_flags); \
152   cli(); \
153   debug_log_string[debug_log_cnt] = (string); \
154   debug_log_value[debug_log_cnt] = (unsigned long)(value); \
155   if (++debug_log_cnt >= DEBUG_LOG_MAX) \
156   { \
157     debug_log_cnt = debug_log_cnt % DEBUG_LOG_MAX; \
158     debug_log_cnt_wrapped = 1; \
159   } \
160   restore_flags(log_flags); \
161 }
162 #else
163 #define DEBUG_LOG(string, value)
164 #endif
165
166
167 /* The frequencies for index = clkselx number in R_TIMER_CTRL */
168 #define NUM_TIMER_FREQ 15
169 #define MAX_USABLE_TIMER_FREQ 7
170 #define MAX_DELAY_US  853333L
171 const unsigned long timer_freq_100[NUM_TIMER_FREQ] =
172 {
173   3,   /* 0 3333 - 853333 us */
174   6,   /* 1 1666 - 426666 us */
175   12,  /* 2  833 - 213333 us */
176   24,  /* 3  416 - 106666 us */
177   48,  /* 4  208 -  53333 us */
178   96,  /* 5  104 -  26666 us */
179   192, /* 6   52 -  13333 us */
180   384, /* 7   26 -   6666 us */
181   576,
182   1152,
183   2304,
184   4608,
185   9216,
186   18432,
187   62500,
188   /* 15 = cascade */
189 };
190 #define NUM_TIMER_STATS 16
191 #ifdef FAST_TIMER_LOG
192 struct fast_timer timer_added_log[NUM_TIMER_STATS];
193 struct fast_timer timer_started_log[NUM_TIMER_STATS];
194 struct fast_timer timer_expired_log[NUM_TIMER_STATS];
195 #endif
196
197 int timer_div_settings[NUM_TIMER_STATS];
198 int timer_freq_settings[NUM_TIMER_STATS];
199 int timer_delay_settings[NUM_TIMER_STATS];
200
201 /* Not true gettimeofday, only checks the jiffies (uptime) + useconds */
202 void __INLINE__ do_gettimeofday_fast(struct timeval *tv)
203 {
204   unsigned long sec = jiffies;
205   unsigned long usec = GET_JIFFIES_USEC();
206
207   usec += (sec % HZ) * (1000000 / HZ);
208   sec = sec / HZ;
209
210   if (usec > 1000000)
211   {
212     usec -= 1000000;
213     sec++;
214   }
215   tv->tv_sec = sec;
216   tv->tv_usec = usec;
217 }
218
219 int __INLINE__ timeval_cmp(struct timeval *t0, struct timeval *t1)
220 {
221   if (t0->tv_sec < t1->tv_sec)
222   {
223     return -1;
224   }
225   else if (t0->tv_sec > t1->tv_sec)
226   {
227     return 1;
228   }
229   if (t0->tv_usec < t1->tv_usec)
230   {
231     return -1;
232   }
233   else if (t0->tv_usec > t1->tv_usec)
234   {
235     return 1;
236   }
237   return 0;
238 }
239
240 void __INLINE__ start_timer1(unsigned long delay_us)
241 {
242   int freq_index = 0; /* This is the lowest resolution */
243   unsigned long upper_limit = MAX_DELAY_US;
244
245   unsigned long div;
246   /* Start/Restart the timer to the new shorter value */
247   /* t = 1/freq = 1/19200 = 53us
248    * T=div*t,  div = T/t = delay_us*freq/1000000
249    */
250 #if 1 /* Adaptive timer settings */
251   while (delay_us < upper_limit && freq_index < MAX_USABLE_TIMER_FREQ)
252   {
253     freq_index++;
254     upper_limit >>= 1; /* Divide by 2 using shift */
255   }
256   if (freq_index > 0)
257   {
258     freq_index--;
259   }
260 #else
261   freq_index = 6;
262 #endif
263   div = delay_us * timer_freq_100[freq_index]/10000;
264   if (div < 2)
265   {
266     /* Maybe increase timer freq? */
267     div = 2;
268   }
269   if (div > 255)
270   {
271     div = 0; /* This means 256, the max the timer takes */
272     /* If a longer timeout than the timer can handle is used,
273      * then we must restart it when it goes off.
274      */
275   }
276
277   timer_div_settings[fast_timers_started % NUM_TIMER_STATS] = div;
278   timer_freq_settings[fast_timers_started % NUM_TIMER_STATS] = freq_index;
279   timer_delay_settings[fast_timers_started % NUM_TIMER_STATS] = delay_us;
280
281   D1(printk("start_timer1 : %d us freq: %i div: %i\n",
282             delay_us, freq_index, div));
283   /* Clear timer1 irq */
284   *R_IRQ_MASK0_CLR = IO_STATE(R_IRQ_MASK0_CLR, timer1, clr);
285
286   /* Set timer values */
287   *R_TIMER_CTRL = r_timer_ctrl_shadow =
288     (r_timer_ctrl_shadow &
289      ~IO_MASK(R_TIMER_CTRL, timerdiv1) &
290      ~IO_MASK(R_TIMER_CTRL, tm1) &
291      ~IO_MASK(R_TIMER_CTRL, clksel1)) |
292     IO_FIELD(R_TIMER_CTRL, timerdiv1, div) |
293     IO_STATE(R_TIMER_CTRL, tm1, stop_ld) |
294     IO_FIELD(R_TIMER_CTRL, clksel1, freq_index ); /* 6=c19k2Hz */
295
296   /* Ack interrupt */
297   *R_TIMER_CTRL =  r_timer_ctrl_shadow |
298     IO_STATE(R_TIMER_CTRL, i1, clr);
299
300   /* Start timer */
301   *R_TIMER_CTRL = r_timer_ctrl_shadow =
302     (r_timer_ctrl_shadow & ~IO_MASK(R_TIMER_CTRL, tm1)) |
303     IO_STATE(R_TIMER_CTRL, tm1, run);
304
305   /* Enable timer1 irq */
306   *R_IRQ_MASK0_SET = IO_STATE(R_IRQ_MASK0_SET, timer1, set);
307   fast_timers_started++;
308   fast_timer_running = 1;
309 }
310
311 /* In version 1.4 this function takes 27 - 50 us */
312 void start_one_shot_timer(struct fast_timer *t,
313                           fast_timer_function_type *function,
314                           unsigned long data,
315                           unsigned long delay_us,
316                           const char *name)
317 {
318   unsigned long flags;
319   struct fast_timer *tmp;
320
321   D1(printk("sft %s %d us\n", name, delay_us));
322
323   save_flags(flags);
324   cli();
325
326   do_gettimeofday_fast(&t->tv_set);
327   tmp = fast_timer_list;
328
329   SANITYCHECK({ /* Check so this is not in the list already... */
330     while (tmp != NULL)
331     {
332       if (tmp == t)
333       {
334         printk(KERN_WARNING
335                "timer name: %s data: 0x%08lX already in list!\n", name, data);
336         sanity_failed++;
337         return;
338       }
339       else
340       {
341         tmp = tmp->next;
342       }
343     }
344     tmp = fast_timer_list;
345   });
346
347   t->delay_us = delay_us;
348   t->function = function;
349   t->data = data;
350   t->name = name;
351
352   t->tv_expires.tv_usec = t->tv_set.tv_usec + delay_us % 1000000;
353   t->tv_expires.tv_sec  = t->tv_set.tv_sec  + delay_us / 1000000;
354   if (t->tv_expires.tv_usec > 1000000)
355   {
356     t->tv_expires.tv_usec -= 1000000;
357     t->tv_expires.tv_sec++;
358   }
359 #ifdef FAST_TIMER_LOG
360   timer_added_log[fast_timers_added % NUM_TIMER_STATS] = *t;
361 #endif
362   fast_timers_added++;
363
364   /* Check if this should timeout before anything else */
365   if (tmp == NULL || timeval_cmp(&t->tv_expires, &tmp->tv_expires) < 0)
366   {
367     /* Put first in list and modify the timer value */
368     t->prev = NULL;
369     t->next = fast_timer_list;
370     if (fast_timer_list)
371     {
372       fast_timer_list->prev = t;
373     }
374     fast_timer_list = t;
375 #ifdef FAST_TIMER_LOG
376     timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t;
377 #endif
378     start_timer1(delay_us);
379   } else {
380     /* Put in correct place in list */
381     while (tmp->next &&
382            timeval_cmp(&t->tv_expires, &tmp->next->tv_expires) > 0)
383     {
384       tmp = tmp->next;
385     }
386     /* Insert t after tmp */
387     t->prev = tmp;
388     t->next = tmp->next;
389     if (tmp->next)
390     {
391       tmp->next->prev = t;
392     }
393     tmp->next = t;
394   }
395
396   D2(printk("start_one_shot_timer: %d us done\n", delay_us));
397
398   restore_flags(flags);
399 } /* start_one_shot_timer */
400
401 static inline int fast_timer_pending (const struct fast_timer * t)
402 {
403   return (t->next != NULL) || (t->prev != NULL) || (t == fast_timer_list);
404 }
405
406 static inline int detach_fast_timer (struct fast_timer *t)
407 {
408   struct fast_timer *next, *prev;
409   if (!fast_timer_pending(t))
410     return 0;
411   next = t->next;
412   prev = t->prev;
413   if (next)
414     next->prev = prev;
415   if (prev)
416     prev->next = next;
417   else
418     fast_timer_list = next;
419   fast_timers_deleted++;
420   return 1;
421 }
422
423 int del_fast_timer(struct fast_timer * t)
424 {
425   unsigned long flags;
426   int ret;
427   
428   save_flags(flags);
429   cli();
430   ret = detach_fast_timer(t);
431   t->next = t->prev = NULL;
432   restore_flags(flags);
433   return ret;
434 } /* del_fast_timer */
435
436
437 /* Interrupt routines or functions called in interrupt context */
438
439 /* Timer 1 interrupt handler */
440
441 static irqreturn_t
442 timer1_handler(int irq, void *dev_id, struct pt_regs *regs)
443 {
444   struct fast_timer *t;
445   unsigned long flags;
446
447   save_flags(flags);
448   cli();
449
450   /* Clear timer1 irq */
451   *R_IRQ_MASK0_CLR = IO_STATE(R_IRQ_MASK0_CLR, timer1, clr);
452
453   /* First stop timer, then ack interrupt */
454   /* Stop timer */
455   *R_TIMER_CTRL = r_timer_ctrl_shadow =
456     (r_timer_ctrl_shadow & ~IO_MASK(R_TIMER_CTRL, tm1)) |
457     IO_STATE(R_TIMER_CTRL, tm1, stop_ld);
458
459   /* Ack interrupt */
460   *R_TIMER_CTRL =  r_timer_ctrl_shadow | IO_STATE(R_TIMER_CTRL, i1, clr);
461
462   fast_timer_running = 0;
463   fast_timer_ints++;
464
465   restore_flags(flags);
466
467   t = fast_timer_list;
468   while (t)
469   {
470     struct timeval tv;
471
472     /* Has it really expired? */
473     do_gettimeofday_fast(&tv);
474     D1(printk("t: %is %06ius\n", tv.tv_sec, tv.tv_usec));
475
476     if (timeval_cmp(&t->tv_expires, &tv) <= 0)
477     {
478       /* Yes it has expired */
479 #ifdef FAST_TIMER_LOG
480       timer_expired_log[fast_timers_expired % NUM_TIMER_STATS] = *t;
481 #endif
482       fast_timers_expired++;
483
484       /* Remove this timer before call, since it may reuse the timer */
485       save_flags(flags);
486       cli();
487       if (t->prev)
488       {
489         t->prev->next = t->next;
490       }
491       else
492       {
493         fast_timer_list = t->next;
494       }
495       if (t->next)
496       {
497         t->next->prev = t->prev;
498       }
499       t->prev = NULL;
500       t->next = NULL;
501       restore_flags(flags);
502
503       if (t->function != NULL)
504       {
505         t->function(t->data);
506       }
507       else
508       {
509         DEBUG_LOG("!timer1 %i function==NULL!\n", fast_timer_ints);
510       }
511     }
512     else
513     {
514       /* Timer is to early, let's set it again using the normal routines */
515       D1(printk(".\n"));
516     }
517
518     save_flags(flags);
519     cli();
520     if ((t = fast_timer_list) != NULL)
521     {
522       /* Start next timer.. */
523       long us;
524       struct timeval tv;
525
526       do_gettimeofday_fast(&tv);
527       us = ((t->tv_expires.tv_sec - tv.tv_sec) * 1000000 +
528             t->tv_expires.tv_usec - tv.tv_usec);
529       if (us > 0)
530       {
531         if (!fast_timer_running)
532         {
533 #ifdef FAST_TIMER_LOG
534           timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t;
535 #endif
536           start_timer1(us);
537         }
538         restore_flags(flags);
539         break;
540       }
541       else
542       {
543         /* Timer already expired, let's handle it better late than never.
544          * The normal loop handles it
545          */
546         D1(printk("e! %d\n", us));
547       }
548     }
549     restore_flags(flags);
550   }
551
552   if (!t)
553   {
554     D1(printk("t1 stop!\n"));
555   }
556
557   return IRQ_HANDLED;
558 }
559
560 static void wake_up_func(unsigned long data)
561 {
562 #ifdef DECLARE_WAITQUEUE
563   wait_queue_head_t  *sleep_wait_p = (wait_queue_head_t*)data;
564 #else
565   struct wait_queue **sleep_wait_p = (struct wait_queue **)data;
566 #endif
567   wake_up(sleep_wait_p);
568 }
569
570
571 /* Useful API */
572
573 void schedule_usleep(unsigned long us)
574 {
575   struct fast_timer t;
576 #ifdef DECLARE_WAITQUEUE
577   wait_queue_head_t sleep_wait;
578   init_waitqueue_head(&sleep_wait);
579   {
580   DECLARE_WAITQUEUE(wait, current);
581 #else
582   struct wait_queue *sleep_wait = NULL;
583   struct wait_queue wait = { current, NULL };
584 #endif
585
586   D1(printk("schedule_usleep(%d)\n", us));
587   add_wait_queue(&sleep_wait, &wait);
588   set_current_state(TASK_INTERRUPTIBLE);
589   start_one_shot_timer(&t, wake_up_func, (unsigned long)&sleep_wait, us,
590                        "usleep");
591   schedule();
592   set_current_state(TASK_RUNNING);
593   remove_wait_queue(&sleep_wait, &wait);
594   D1(printk("done schedule_usleep(%d)\n", us));
595 #ifdef DECLARE_WAITQUEUE
596   }
597 #endif  
598 }
599
600 #ifdef CONFIG_PROC_FS
601 static int proc_fasttimer_read(char *buf, char **start, off_t offset, int len
602                        ,int *eof, void *data_unused);
603 static struct proc_dir_entry *fasttimer_proc_entry;
604 #endif /* CONFIG_PROC_FS */
605
606 #ifdef CONFIG_PROC_FS
607
608 /* This value is very much based on testing */
609 #define BIG_BUF_SIZE (500 + NUM_TIMER_STATS * 300)
610
611 static int proc_fasttimer_read(char *buf, char **start, off_t offset, int len
612                        ,int *eof, void *data_unused)
613 {
614   unsigned long flags;
615   int i = 0;
616   int num_to_show;
617   struct timeval tv;
618   struct fast_timer *t, *nextt;
619   static char *bigbuf = NULL;
620   static unsigned long used;
621
622   if (!bigbuf && !(bigbuf = vmalloc(BIG_BUF_SIZE)))
623   {
624     used = 0;
625     bigbuf[0] = '\0';
626     return 0;
627   }
628
629   if (!offset || !used)
630   {
631     do_gettimeofday_fast(&tv);
632
633     used = 0;
634     used += sprintf(bigbuf + used, "Fast timers added:     %i\n",
635                     fast_timers_added);
636     used += sprintf(bigbuf + used, "Fast timers started:   %i\n",
637                     fast_timers_started);
638     used += sprintf(bigbuf + used, "Fast timer interrupts: %i\n",
639                     fast_timer_ints);
640     used += sprintf(bigbuf + used, "Fast timers expired:   %i\n",
641                     fast_timers_expired);
642     used += sprintf(bigbuf + used, "Fast timers deleted:   %i\n",
643                     fast_timers_deleted);
644     used += sprintf(bigbuf + used, "Fast timer running:    %s\n",
645                     fast_timer_running ? "yes" : "no");
646     used += sprintf(bigbuf + used, "Current time:          %lu.%06lu\n",
647                     (unsigned long)tv.tv_sec,
648                     (unsigned long)tv.tv_usec);
649 #ifdef FAST_TIMER_SANITY_CHECKS
650     used += sprintf(bigbuf + used, "Sanity failed:         %i\n",
651                     sanity_failed);
652 #endif
653     used += sprintf(bigbuf + used, "\n");
654
655 #ifdef DEBUG_LOG_INCLUDED
656     {
657       int end_i = debug_log_cnt;
658       i = 0;
659
660       if (debug_log_cnt_wrapped)
661       {
662         i = debug_log_cnt;
663       }
664
665       while ((i != end_i || (debug_log_cnt_wrapped && !used)) &&
666              used+100 < BIG_BUF_SIZE)
667       {
668         used += sprintf(bigbuf + used, debug_log_string[i],
669                         debug_log_value[i]);
670         i = (i+1) % DEBUG_LOG_MAX;
671       }
672     }
673     used += sprintf(bigbuf + used, "\n");
674 #endif
675
676     num_to_show = (fast_timers_started < NUM_TIMER_STATS ? fast_timers_started:
677                    NUM_TIMER_STATS);
678     used += sprintf(bigbuf + used, "Timers started: %i\n", fast_timers_started);
679     for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE) ; i++)
680     {
681       int cur = (fast_timers_started - i - 1) % NUM_TIMER_STATS;
682
683 #if 1 //ndef FAST_TIMER_LOG
684       used += sprintf(bigbuf + used, "div: %i freq: %i delay: %i"
685                       "\n",
686                       timer_div_settings[cur],
687                       timer_freq_settings[cur],
688                       timer_delay_settings[cur]
689                       );
690 #endif
691 #ifdef FAST_TIMER_LOG
692       t = &timer_started_log[cur];
693       used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu "
694                       "d: %6li us data: 0x%08lX"
695                       "\n",
696                       t->name,
697                       (unsigned long)t->tv_set.tv_sec,
698                       (unsigned long)t->tv_set.tv_usec,
699                       (unsigned long)t->tv_expires.tv_sec,
700                       (unsigned long)t->tv_expires.tv_usec,
701                       t->delay_us,
702                       t->data
703                       );
704 #endif
705     }
706     used += sprintf(bigbuf + used, "\n");
707
708 #ifdef FAST_TIMER_LOG
709     num_to_show = (fast_timers_added < NUM_TIMER_STATS ? fast_timers_added:
710                    NUM_TIMER_STATS);
711     used += sprintf(bigbuf + used, "Timers added: %i\n", fast_timers_added);
712     for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE); i++)
713     {
714       t = &timer_added_log[(fast_timers_added - i - 1) % NUM_TIMER_STATS];
715       used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu "
716                       "d: %6li us data: 0x%08lX"
717                       "\n",
718                       t->name,
719                       (unsigned long)t->tv_set.tv_sec,
720                       (unsigned long)t->tv_set.tv_usec,
721                       (unsigned long)t->tv_expires.tv_sec,
722                       (unsigned long)t->tv_expires.tv_usec,
723                       t->delay_us,
724                       t->data
725                       );
726     }
727     used += sprintf(bigbuf + used, "\n");
728
729     num_to_show = (fast_timers_expired < NUM_TIMER_STATS ? fast_timers_expired:
730                    NUM_TIMER_STATS);
731     used += sprintf(bigbuf + used, "Timers expired: %i\n", fast_timers_expired);
732     for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE); i++)
733     {
734       t = &timer_expired_log[(fast_timers_expired - i - 1) % NUM_TIMER_STATS];
735       used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu "
736                       "d: %6li us data: 0x%08lX"
737                       "\n",
738                       t->name,
739                       (unsigned long)t->tv_set.tv_sec,
740                       (unsigned long)t->tv_set.tv_usec,
741                       (unsigned long)t->tv_expires.tv_sec,
742                       (unsigned long)t->tv_expires.tv_usec,
743                       t->delay_us,
744                       t->data
745                       );
746     }
747     used += sprintf(bigbuf + used, "\n");
748 #endif
749
750     used += sprintf(bigbuf + used, "Active timers:\n");
751     save_flags(flags);
752     cli();
753     t = fast_timer_list;
754     while (t != NULL && (used+100 < BIG_BUF_SIZE))
755     {
756       nextt = t->next;
757       restore_flags(flags);
758       used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu "
759                       "d: %6li us data: 0x%08lX"
760 /*                      " func: 0x%08lX" */
761                       "\n",
762                       t->name,
763                       (unsigned long)t->tv_set.tv_sec,
764                       (unsigned long)t->tv_set.tv_usec,
765                       (unsigned long)t->tv_expires.tv_sec,
766                       (unsigned long)t->tv_expires.tv_usec,
767                       t->delay_us,
768                       t->data
769 /*                      , t->function */
770                       );
771       cli();
772       if (t->next != nextt)
773       {
774         printk(KERN_WARNING "timer removed!\n");
775       }
776       t = nextt;
777     }
778     restore_flags(flags);
779   }
780
781   if (used - offset < len)
782   {
783     len = used - offset;
784   }
785
786   memcpy(buf, bigbuf + offset, len);
787   *start = buf;
788   *eof = 1;
789
790   return len;
791 }
792 #endif /* PROC_FS */
793
794 #ifdef FAST_TIMER_TEST
795 static volatile unsigned long i = 0;
796 static volatile int num_test_timeout = 0;
797 static struct fast_timer tr[10];
798 static int exp_num[10];
799
800 static struct timeval tv_exp[100];
801
802 static void test_timeout(unsigned long data)
803 {
804   do_gettimeofday_fast(&tv_exp[data]);
805   exp_num[data] = num_test_timeout;
806
807   num_test_timeout++;
808 }
809
810 static void test_timeout1(unsigned long data)
811 {
812   do_gettimeofday_fast(&tv_exp[data]);
813   exp_num[data] = num_test_timeout;
814   if (data < 7)
815   {
816     start_one_shot_timer(&tr[i], test_timeout1, i, 1000, "timeout1");
817     i++;
818   }
819   num_test_timeout++;
820 }
821
822 DP(
823 static char buf0[2000];
824 static char buf1[2000];
825 static char buf2[2000];
826 static char buf3[2000];
827 static char buf4[2000];
828 );
829
830 static char buf5[6000];
831 static int j_u[1000];
832
833 static void fast_timer_test(void)
834 {
835   int prev_num;
836   int j;
837
838   struct timeval tv, tv0, tv1, tv2;
839
840   printk("fast_timer_test() start\n");
841   do_gettimeofday_fast(&tv);
842
843   for (j = 0; j < 1000; j++)
844   {
845     j_u[j] = GET_JIFFIES_USEC();
846   }
847   for (j = 0; j < 100; j++)
848   {
849     do_gettimeofday_fast(&tv_exp[j]);
850   }
851   printk("fast_timer_test() %is %06i\n", tv.tv_sec, tv.tv_usec);
852
853   for (j = 0; j < 1000; j++)
854   {
855     printk("%i %i %i %i %i\n",j_u[j], j_u[j+1], j_u[j+2], j_u[j+3], j_u[j+4]);
856     j += 4;
857   }
858   for (j = 0; j < 100; j++)
859   {
860     printk("%i.%i %i.%i %i.%i %i.%i %i.%i\n",
861            tv_exp[j].tv_sec,tv_exp[j].tv_usec,
862            tv_exp[j+1].tv_sec,tv_exp[j+1].tv_usec,
863            tv_exp[j+2].tv_sec,tv_exp[j+2].tv_usec,
864            tv_exp[j+3].tv_sec,tv_exp[j+3].tv_usec,
865            tv_exp[j+4].tv_sec,tv_exp[j+4].tv_usec);
866     j += 4;
867   }
868   do_gettimeofday_fast(&tv0);
869   start_one_shot_timer(&tr[i], test_timeout, i, 50000, "test0");
870   DP(proc_fasttimer_read(buf0, NULL, 0, 0, 0));
871   i++;
872   start_one_shot_timer(&tr[i], test_timeout, i, 70000, "test1");
873   DP(proc_fasttimer_read(buf1, NULL, 0, 0, 0));
874   i++;
875   start_one_shot_timer(&tr[i], test_timeout, i, 40000, "test2");
876   DP(proc_fasttimer_read(buf2, NULL, 0, 0, 0));
877   i++;
878   start_one_shot_timer(&tr[i], test_timeout, i, 60000, "test3");
879   DP(proc_fasttimer_read(buf3, NULL, 0, 0, 0));
880   i++;
881   start_one_shot_timer(&tr[i], test_timeout1, i, 55000, "test4xx");
882   DP(proc_fasttimer_read(buf4, NULL, 0, 0, 0));
883   i++;
884   do_gettimeofday_fast(&tv1);
885
886   proc_fasttimer_read(buf5, NULL, 0, 0, 0);
887
888   prev_num = num_test_timeout;
889   while (num_test_timeout < i)
890   {
891     if (num_test_timeout != prev_num)
892     {
893       prev_num = num_test_timeout;
894     }
895   }
896   do_gettimeofday_fast(&tv2);
897   printk("Timers started    %is %06i\n", tv0.tv_sec, tv0.tv_usec);
898   printk("Timers started at %is %06i\n", tv1.tv_sec, tv1.tv_usec);
899   printk("Timers done       %is %06i\n", tv2.tv_sec, tv2.tv_usec);
900   DP(printk("buf0:\n");
901      printk(buf0);
902      printk("buf1:\n");
903      printk(buf1);
904      printk("buf2:\n");
905      printk(buf2);
906      printk("buf3:\n");
907      printk(buf3);
908      printk("buf4:\n");
909      printk(buf4);
910   );
911   printk("buf5:\n");
912   printk(buf5);
913
914   printk("timers set:\n");
915   for(j = 0; j<i; j++)
916   {
917     struct fast_timer *t = &tr[j];
918     printk("%-10s set: %6is %06ius exp: %6is %06ius "
919            "data: 0x%08X func: 0x%08X\n",
920            t->name,
921            t->tv_set.tv_sec,
922            t->tv_set.tv_usec,
923            t->tv_expires.tv_sec,
924            t->tv_expires.tv_usec,
925            t->data,
926            t->function
927            );
928
929     printk("           del: %6ius     did exp: %6is %06ius as #%i error: %6li\n",
930            t->delay_us,
931            tv_exp[j].tv_sec,
932            tv_exp[j].tv_usec,
933            exp_num[j],
934            (tv_exp[j].tv_sec - t->tv_expires.tv_sec)*1000000 + tv_exp[j].tv_usec - t->tv_expires.tv_usec);
935   }
936   proc_fasttimer_read(buf5, NULL, 0, 0, 0);
937   printk("buf5 after all done:\n");
938   printk(buf5);
939   printk("fast_timer_test() done\n");
940 }
941 #endif
942
943
944 void fast_timer_init(void)
945 {
946   /* For some reason, request_irq() hangs when called froom time_init() */
947   if (!fast_timer_is_init)
948   {
949 #if 0 && defined(FAST_TIMER_TEST)
950     int i;
951 #endif
952
953     printk(KERN_INFO "fast_timer_init()\n");
954
955 #if 0 && defined(FAST_TIMER_TEST)
956     for (i = 0; i <= TIMER0_DIV; i++)
957     {
958       /* We must be careful not to get overflow... */
959       printk("%3i %6u\n", i, timer0_value_us[i]);
960     }
961 #endif
962 #ifdef CONFIG_PROC_FS
963    if ((fasttimer_proc_entry = create_proc_entry( "fasttimer", 0, 0 )))
964      fasttimer_proc_entry->read_proc = proc_fasttimer_read;
965 #endif /* PROC_FS */
966     if(request_irq(TIMER1_IRQ_NBR, timer1_handler, SA_SHIRQ,
967                    "fast timer int", NULL))
968     {
969       printk("err: timer1 irq\n");
970     }
971     fast_timer_is_init = 1;
972 #ifdef FAST_TIMER_TEST
973     printk("do test\n");
974     fast_timer_test();
975 #endif
976   }
977 }