~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/cris/arch-v10/kernel/fasttimer.c

Version: ~ [ linux-4.15-rc3 ] ~ [ linux-4.14.5 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.68 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.105 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.47 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.87 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.51 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.96 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp