]>
Commit | Line | Data |
---|---|---|
d8e5219f | 1 | /* |
1da177e4 LT |
2 | * linux/arch/cris/kernel/fasttimer.c |
3 | * | |
4 | * Fast timers for ETRAX100/ETRAX100LX | |
1da177e4 | 5 | * |
d8e5219f | 6 | * Copyright (C) 2000-2007 Axis Communications AB, Lund, Sweden |
1da177e4 LT |
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/mm.h> | |
15 | #include <linux/vmalloc.h> | |
16 | #include <linux/interrupt.h> | |
17 | #include <linux/time.h> | |
18 | #include <linux/delay.h> | |
19 | ||
20 | #include <asm/segment.h> | |
21 | #include <asm/io.h> | |
22 | #include <asm/irq.h> | |
23 | #include <asm/delay.h> | |
24 | #include <asm/rtc.h> | |
25 | ||
1da177e4 | 26 | |
556dcee7 | 27 | #include <arch/svinto.h> |
1da177e4 LT |
28 | #include <asm/fasttimer.h> |
29 | #include <linux/proc_fs.h> | |
30 | ||
31 | ||
32 | #define DEBUG_LOG_INCLUDED | |
33 | #define FAST_TIMER_LOG | |
4200c35d | 34 | /* #define FAST_TIMER_TEST */ |
1da177e4 LT |
35 | |
36 | #define FAST_TIMER_SANITY_CHECKS | |
37 | ||
38 | #ifdef FAST_TIMER_SANITY_CHECKS | |
d8e5219f | 39 | static int sanity_failed; |
1da177e4 LT |
40 | #endif |
41 | ||
42 | #define D1(x) | |
43 | #define D2(x) | |
44 | #define DP(x) | |
45 | ||
d8e5219f JN |
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; | |
1da177e4 LT |
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]; | |
d8e5219f JN |
60 | static unsigned int debug_log_cnt; |
61 | static unsigned int debug_log_cnt_wrapped; | |
1da177e4 LT |
62 | |
63 | #define DEBUG_LOG(string, value) \ | |
64 | { \ | |
65 | unsigned long log_flags; \ | |
7e920426 | 66 | local_irq_save(log_flags); \ |
1da177e4 LT |
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 | } \ | |
7e920426 | 74 | local_irq_restore(log_flags); \ |
1da177e4 LT |
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 */ | |
2f1f53bd | 116 | inline void do_gettimeofday_fast(struct fasttime_t *tv) |
1da177e4 | 117 | { |
d8e5219f JN |
118 | tv->tv_jiff = jiffies; |
119 | tv->tv_usec = GET_JIFFIES_USEC(); | |
1da177e4 LT |
120 | } |
121 | ||
2f1f53bd | 122 | inline int fasttime_cmp(struct fasttime_t *t0, struct fasttime_t *t1) |
1da177e4 | 123 | { |
d8e5219f JN |
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; | |
1da177e4 LT |
136 | } |
137 | ||
2f1f53bd | 138 | inline void start_timer1(unsigned long delay_us) |
1da177e4 LT |
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 | ||
d8e5219f | 179 | D1(printk(KERN_DEBUG "start_timer1 : %d us freq: %i div: %i\n", |
1da177e4 LT |
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 | ||
7e920426 | 221 | local_irq_save(flags); |
1da177e4 LT |
222 | |
223 | do_gettimeofday_fast(&t->tv_set); | |
224 | tmp = fast_timer_list; | |
225 | ||
4200c35d JN |
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 | |
1da177e4 LT |
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; | |
d8e5219f | 246 | t->tv_expires.tv_jiff = t->tv_set.tv_jiff + delay_us / 1000000 / HZ; |
1da177e4 LT |
247 | if (t->tv_expires.tv_usec > 1000000) |
248 | { | |
249 | t->tv_expires.tv_usec -= 1000000; | |
d8e5219f | 250 | t->tv_expires.tv_jiff += HZ; |
1da177e4 LT |
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 */ | |
2f1f53bd | 258 | if (tmp == NULL || fasttime_cmp(&t->tv_expires, &tmp->tv_expires) < 0) |
1da177e4 LT |
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 */ | |
2f1f53bd JN |
274 | while (tmp->next && fasttime_cmp(&t->tv_expires, |
275 | &tmp->next->tv_expires) > 0) | |
1da177e4 LT |
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 | ||
d8e5219f | 291 | done: |
7e920426 | 292 | local_irq_restore(flags); |
1da177e4 LT |
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 | ||
7e920426 | 322 | local_irq_save(flags); |
1da177e4 LT |
323 | ret = detach_fast_timer(t); |
324 | t->next = t->prev = NULL; | |
7e920426 | 325 | local_irq_restore(flags); |
1da177e4 LT |
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 | |
d8e5219f | 335 | timer1_handler(int irq, void *dev_id) |
1da177e4 LT |
336 | { |
337 | struct fast_timer *t; | |
338 | unsigned long flags; | |
339 | ||
d8e5219f JN |
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 | */ | |
7e920426 | 347 | local_irq_save(flags); |
1da177e4 LT |
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 | ||
1da177e4 LT |
364 | t = fast_timer_list; |
365 | while (t) | |
366 | { | |
d8e5219f JN |
367 | struct fasttime_t tv; |
368 | fast_timer_function_type *f; | |
369 | unsigned long d; | |
1da177e4 LT |
370 | |
371 | /* Has it really expired? */ | |
372 | do_gettimeofday_fast(&tv); | |
d8e5219f JN |
373 | D1(printk(KERN_DEBUG "t: %is %06ius\n", |
374 | tv.tv_jiff, tv.tv_usec)); | |
1da177e4 | 375 | |
2f1f53bd | 376 | if (fasttime_cmp(&t->tv_expires, &tv) <= 0) |
1da177e4 LT |
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 */ | |
1da177e4 LT |
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; | |
1da177e4 | 399 | |
d8e5219f JN |
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 | |
1da177e4 | 415 | DEBUG_LOG("!timer1 %i function==NULL!\n", fast_timer_ints); |
1da177e4 LT |
416 | } |
417 | else | |
418 | { | |
419 | /* Timer is to early, let's set it again using the normal routines */ | |
420 | D1(printk(".\n")); | |
421 | } | |
422 | ||
1da177e4 LT |
423 | if ((t = fast_timer_list) != NULL) |
424 | { | |
425 | /* Start next timer.. */ | |
d8e5219f JN |
426 | long us = 0; |
427 | struct fasttime_t tv; | |
1da177e4 LT |
428 | |
429 | do_gettimeofday_fast(&tv); | |
d8e5219f JN |
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 | ||
1da177e4 LT |
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 | } | |
1da177e4 LT |
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 | } | |
1da177e4 LT |
456 | } |
457 | ||
d8e5219f JN |
458 | local_irq_restore(flags); |
459 | ||
1da177e4 LT |
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 | { | |
d77eab8c | 470 | wait_queue_head_t *sleep_wait_p = (wait_queue_head_t *)data; |
1da177e4 LT |
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; | |
1da177e4 LT |
480 | wait_queue_head_t sleep_wait; |
481 | init_waitqueue_head(&sleep_wait); | |
1da177e4 LT |
482 | |
483 | D1(printk("schedule_usleep(%d)\n", us)); | |
1da177e4 LT |
484 | start_one_shot_timer(&t, wake_up_func, (unsigned long)&sleep_wait, us, |
485 | "usleep"); | |
d8e5219f JN |
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 | ||
1da177e4 | 490 | D1(printk("done schedule_usleep(%d)\n", us)); |
1da177e4 LT |
491 | } |
492 | ||
493 | #ifdef CONFIG_PROC_FS | |
494 | static int proc_fasttimer_read(char *buf, char **start, off_t offset, int len | |
495 | ,int *eof, void *data_unused); | |
496 | static struct proc_dir_entry *fasttimer_proc_entry; | |
497 | #endif /* CONFIG_PROC_FS */ | |
498 | ||
499 | #ifdef CONFIG_PROC_FS | |
500 | ||
501 | /* This value is very much based on testing */ | |
502 | #define BIG_BUF_SIZE (500 + NUM_TIMER_STATS * 300) | |
503 | ||
504 | static int proc_fasttimer_read(char *buf, char **start, off_t offset, int len | |
505 | ,int *eof, void *data_unused) | |
506 | { | |
507 | unsigned long flags; | |
508 | int i = 0; | |
509 | int num_to_show; | |
d8e5219f | 510 | struct fasttime_t tv; |
1da177e4 LT |
511 | struct fast_timer *t, *nextt; |
512 | static char *bigbuf = NULL; | |
513 | static unsigned long used; | |
514 | ||
515 | if (!bigbuf && !(bigbuf = vmalloc(BIG_BUF_SIZE))) | |
516 | { | |
517 | used = 0; | |
d8e5219f JN |
518 | if (buf) |
519 | buf[0] = '\0'; | |
1da177e4 LT |
520 | return 0; |
521 | } | |
522 | ||
523 | if (!offset || !used) | |
524 | { | |
525 | do_gettimeofday_fast(&tv); | |
526 | ||
527 | used = 0; | |
528 | used += sprintf(bigbuf + used, "Fast timers added: %i\n", | |
529 | fast_timers_added); | |
530 | used += sprintf(bigbuf + used, "Fast timers started: %i\n", | |
531 | fast_timers_started); | |
532 | used += sprintf(bigbuf + used, "Fast timer interrupts: %i\n", | |
533 | fast_timer_ints); | |
534 | used += sprintf(bigbuf + used, "Fast timers expired: %i\n", | |
535 | fast_timers_expired); | |
536 | used += sprintf(bigbuf + used, "Fast timers deleted: %i\n", | |
537 | fast_timers_deleted); | |
538 | used += sprintf(bigbuf + used, "Fast timer running: %s\n", | |
539 | fast_timer_running ? "yes" : "no"); | |
540 | used += sprintf(bigbuf + used, "Current time: %lu.%06lu\n", | |
d8e5219f | 541 | (unsigned long)tv.tv_jiff, |
1da177e4 LT |
542 | (unsigned long)tv.tv_usec); |
543 | #ifdef FAST_TIMER_SANITY_CHECKS | |
544 | used += sprintf(bigbuf + used, "Sanity failed: %i\n", | |
545 | sanity_failed); | |
546 | #endif | |
547 | used += sprintf(bigbuf + used, "\n"); | |
548 | ||
549 | #ifdef DEBUG_LOG_INCLUDED | |
550 | { | |
551 | int end_i = debug_log_cnt; | |
552 | i = 0; | |
553 | ||
554 | if (debug_log_cnt_wrapped) | |
555 | { | |
556 | i = debug_log_cnt; | |
557 | } | |
558 | ||
559 | while ((i != end_i || (debug_log_cnt_wrapped && !used)) && | |
560 | used+100 < BIG_BUF_SIZE) | |
561 | { | |
562 | used += sprintf(bigbuf + used, debug_log_string[i], | |
563 | debug_log_value[i]); | |
564 | i = (i+1) % DEBUG_LOG_MAX; | |
565 | } | |
566 | } | |
567 | used += sprintf(bigbuf + used, "\n"); | |
568 | #endif | |
569 | ||
570 | num_to_show = (fast_timers_started < NUM_TIMER_STATS ? fast_timers_started: | |
571 | NUM_TIMER_STATS); | |
572 | used += sprintf(bigbuf + used, "Timers started: %i\n", fast_timers_started); | |
573 | for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE) ; i++) | |
574 | { | |
575 | int cur = (fast_timers_started - i - 1) % NUM_TIMER_STATS; | |
576 | ||
577 | #if 1 //ndef FAST_TIMER_LOG | |
578 | used += sprintf(bigbuf + used, "div: %i freq: %i delay: %i" | |
579 | "\n", | |
580 | timer_div_settings[cur], | |
581 | timer_freq_settings[cur], | |
582 | timer_delay_settings[cur] | |
583 | ); | |
584 | #endif | |
585 | #ifdef FAST_TIMER_LOG | |
586 | t = &timer_started_log[cur]; | |
587 | used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu " | |
588 | "d: %6li us data: 0x%08lX" | |
589 | "\n", | |
590 | t->name, | |
d8e5219f | 591 | (unsigned long)t->tv_set.tv_jiff, |
1da177e4 | 592 | (unsigned long)t->tv_set.tv_usec, |
d8e5219f | 593 | (unsigned long)t->tv_expires.tv_jiff, |
1da177e4 LT |
594 | (unsigned long)t->tv_expires.tv_usec, |
595 | t->delay_us, | |
596 | t->data | |
597 | ); | |
598 | #endif | |
599 | } | |
600 | used += sprintf(bigbuf + used, "\n"); | |
601 | ||
602 | #ifdef FAST_TIMER_LOG | |
603 | num_to_show = (fast_timers_added < NUM_TIMER_STATS ? fast_timers_added: | |
604 | NUM_TIMER_STATS); | |
605 | used += sprintf(bigbuf + used, "Timers added: %i\n", fast_timers_added); | |
606 | for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE); i++) | |
607 | { | |
608 | t = &timer_added_log[(fast_timers_added - i - 1) % NUM_TIMER_STATS]; | |
609 | used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu " | |
610 | "d: %6li us data: 0x%08lX" | |
611 | "\n", | |
612 | t->name, | |
d8e5219f | 613 | (unsigned long)t->tv_set.tv_jiff, |
1da177e4 | 614 | (unsigned long)t->tv_set.tv_usec, |
d8e5219f | 615 | (unsigned long)t->tv_expires.tv_jiff, |
1da177e4 LT |
616 | (unsigned long)t->tv_expires.tv_usec, |
617 | t->delay_us, | |
618 | t->data | |
619 | ); | |
620 | } | |
621 | used += sprintf(bigbuf + used, "\n"); | |
622 | ||
623 | num_to_show = (fast_timers_expired < NUM_TIMER_STATS ? fast_timers_expired: | |
624 | NUM_TIMER_STATS); | |
625 | used += sprintf(bigbuf + used, "Timers expired: %i\n", fast_timers_expired); | |
626 | for (i = 0; i < num_to_show && (used+100 < BIG_BUF_SIZE); i++) | |
627 | { | |
628 | t = &timer_expired_log[(fast_timers_expired - i - 1) % NUM_TIMER_STATS]; | |
629 | used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu " | |
630 | "d: %6li us data: 0x%08lX" | |
631 | "\n", | |
632 | t->name, | |
d8e5219f | 633 | (unsigned long)t->tv_set.tv_jiff, |
1da177e4 | 634 | (unsigned long)t->tv_set.tv_usec, |
d8e5219f | 635 | (unsigned long)t->tv_expires.tv_jiff, |
1da177e4 LT |
636 | (unsigned long)t->tv_expires.tv_usec, |
637 | t->delay_us, | |
638 | t->data | |
639 | ); | |
640 | } | |
641 | used += sprintf(bigbuf + used, "\n"); | |
642 | #endif | |
643 | ||
644 | used += sprintf(bigbuf + used, "Active timers:\n"); | |
7e920426 | 645 | local_irq_save(flags); |
1da177e4 LT |
646 | t = fast_timer_list; |
647 | while (t != NULL && (used+100 < BIG_BUF_SIZE)) | |
648 | { | |
649 | nextt = t->next; | |
7e920426 | 650 | local_irq_restore(flags); |
1da177e4 LT |
651 | used += sprintf(bigbuf + used, "%-14s s: %6lu.%06lu e: %6lu.%06lu " |
652 | "d: %6li us data: 0x%08lX" | |
653 | /* " func: 0x%08lX" */ | |
654 | "\n", | |
655 | t->name, | |
d8e5219f | 656 | (unsigned long)t->tv_set.tv_jiff, |
1da177e4 | 657 | (unsigned long)t->tv_set.tv_usec, |
d8e5219f | 658 | (unsigned long)t->tv_expires.tv_jiff, |
1da177e4 LT |
659 | (unsigned long)t->tv_expires.tv_usec, |
660 | t->delay_us, | |
661 | t->data | |
662 | /* , t->function */ | |
663 | ); | |
d8e5219f | 664 | local_irq_save(flags); |
1da177e4 LT |
665 | if (t->next != nextt) |
666 | { | |
667 | printk(KERN_WARNING "timer removed!\n"); | |
668 | } | |
669 | t = nextt; | |
670 | } | |
7e920426 | 671 | local_irq_restore(flags); |
1da177e4 LT |
672 | } |
673 | ||
674 | if (used - offset < len) | |
675 | { | |
676 | len = used - offset; | |
677 | } | |
678 | ||
679 | memcpy(buf, bigbuf + offset, len); | |
680 | *start = buf; | |
681 | *eof = 1; | |
682 | ||
683 | return len; | |
684 | } | |
685 | #endif /* PROC_FS */ | |
686 | ||
687 | #ifdef FAST_TIMER_TEST | |
688 | static volatile unsigned long i = 0; | |
689 | static volatile int num_test_timeout = 0; | |
690 | static struct fast_timer tr[10]; | |
691 | static int exp_num[10]; | |
692 | ||
d8e5219f | 693 | static struct fasttime_t tv_exp[100]; |
1da177e4 LT |
694 | |
695 | static void test_timeout(unsigned long data) | |
696 | { | |
697 | do_gettimeofday_fast(&tv_exp[data]); | |
698 | exp_num[data] = num_test_timeout; | |
699 | ||
700 | num_test_timeout++; | |
701 | } | |
702 | ||
703 | static void test_timeout1(unsigned long data) | |
704 | { | |
705 | do_gettimeofday_fast(&tv_exp[data]); | |
706 | exp_num[data] = num_test_timeout; | |
707 | if (data < 7) | |
708 | { | |
709 | start_one_shot_timer(&tr[i], test_timeout1, i, 1000, "timeout1"); | |
710 | i++; | |
711 | } | |
712 | num_test_timeout++; | |
713 | } | |
714 | ||
715 | DP( | |
716 | static char buf0[2000]; | |
717 | static char buf1[2000]; | |
718 | static char buf2[2000]; | |
719 | static char buf3[2000]; | |
720 | static char buf4[2000]; | |
721 | ); | |
722 | ||
723 | static char buf5[6000]; | |
724 | static int j_u[1000]; | |
725 | ||
726 | static void fast_timer_test(void) | |
727 | { | |
728 | int prev_num; | |
729 | int j; | |
730 | ||
d8e5219f | 731 | struct fasttime_t tv, tv0, tv1, tv2; |
1da177e4 LT |
732 | |
733 | printk("fast_timer_test() start\n"); | |
734 | do_gettimeofday_fast(&tv); | |
735 | ||
736 | for (j = 0; j < 1000; j++) | |
737 | { | |
738 | j_u[j] = GET_JIFFIES_USEC(); | |
739 | } | |
740 | for (j = 0; j < 100; j++) | |
741 | { | |
742 | do_gettimeofday_fast(&tv_exp[j]); | |
743 | } | |
d8e5219f JN |
744 | printk(KERN_DEBUG "fast_timer_test() %is %06i\n", |
745 | tv.tv_jiff, tv.tv_usec); | |
1da177e4 LT |
746 | |
747 | for (j = 0; j < 1000; j++) | |
748 | { | |
749 | 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]); | |
750 | j += 4; | |
751 | } | |
752 | for (j = 0; j < 100; j++) | |
753 | { | |
d8e5219f JN |
754 | printk(KERN_DEBUG "%i.%i %i.%i %i.%i %i.%i %i.%i\n", |
755 | tv_exp[j].tv_jiff, tv_exp[j].tv_usec, | |
756 | tv_exp[j+1].tv_jiff, tv_exp[j+1].tv_usec, | |
757 | tv_exp[j+2].tv_jiff, tv_exp[j+2].tv_usec, | |
758 | tv_exp[j+3].tv_jiff, tv_exp[j+3].tv_usec, | |
759 | tv_exp[j+4].tv_jiff, tv_exp[j+4].tv_usec); | |
1da177e4 LT |
760 | j += 4; |
761 | } | |
762 | do_gettimeofday_fast(&tv0); | |
763 | start_one_shot_timer(&tr[i], test_timeout, i, 50000, "test0"); | |
764 | DP(proc_fasttimer_read(buf0, NULL, 0, 0, 0)); | |
765 | i++; | |
766 | start_one_shot_timer(&tr[i], test_timeout, i, 70000, "test1"); | |
767 | DP(proc_fasttimer_read(buf1, NULL, 0, 0, 0)); | |
768 | i++; | |
769 | start_one_shot_timer(&tr[i], test_timeout, i, 40000, "test2"); | |
770 | DP(proc_fasttimer_read(buf2, NULL, 0, 0, 0)); | |
771 | i++; | |
772 | start_one_shot_timer(&tr[i], test_timeout, i, 60000, "test3"); | |
773 | DP(proc_fasttimer_read(buf3, NULL, 0, 0, 0)); | |
774 | i++; | |
775 | start_one_shot_timer(&tr[i], test_timeout1, i, 55000, "test4xx"); | |
776 | DP(proc_fasttimer_read(buf4, NULL, 0, 0, 0)); | |
777 | i++; | |
778 | do_gettimeofday_fast(&tv1); | |
779 | ||
780 | proc_fasttimer_read(buf5, NULL, 0, 0, 0); | |
781 | ||
782 | prev_num = num_test_timeout; | |
783 | while (num_test_timeout < i) | |
784 | { | |
785 | if (num_test_timeout != prev_num) | |
786 | { | |
787 | prev_num = num_test_timeout; | |
788 | } | |
789 | } | |
790 | do_gettimeofday_fast(&tv2); | |
d8e5219f JN |
791 | printk(KERN_DEBUG "Timers started %is %06i\n", |
792 | tv0.tv_jiff, tv0.tv_usec); | |
793 | printk(KERN_DEBUG "Timers started at %is %06i\n", | |
794 | tv1.tv_jiff, tv1.tv_usec); | |
795 | printk(KERN_DEBUG "Timers done %is %06i\n", | |
796 | tv2.tv_jiff, tv2.tv_usec); | |
1da177e4 LT |
797 | DP(printk("buf0:\n"); |
798 | printk(buf0); | |
799 | printk("buf1:\n"); | |
800 | printk(buf1); | |
801 | printk("buf2:\n"); | |
802 | printk(buf2); | |
803 | printk("buf3:\n"); | |
804 | printk(buf3); | |
805 | printk("buf4:\n"); | |
806 | printk(buf4); | |
807 | ); | |
808 | printk("buf5:\n"); | |
809 | printk(buf5); | |
810 | ||
811 | printk("timers set:\n"); | |
812 | for(j = 0; j<i; j++) | |
813 | { | |
814 | struct fast_timer *t = &tr[j]; | |
815 | printk("%-10s set: %6is %06ius exp: %6is %06ius " | |
816 | "data: 0x%08X func: 0x%08X\n", | |
817 | t->name, | |
d8e5219f | 818 | t->tv_set.tv_jiff, |
1da177e4 | 819 | t->tv_set.tv_usec, |
d8e5219f | 820 | t->tv_expires.tv_jiff, |
1da177e4 LT |
821 | t->tv_expires.tv_usec, |
822 | t->data, | |
823 | t->function | |
824 | ); | |
825 | ||
826 | printk(" del: %6ius did exp: %6is %06ius as #%i error: %6li\n", | |
827 | t->delay_us, | |
d8e5219f | 828 | tv_exp[j].tv_jiff, |
1da177e4 LT |
829 | tv_exp[j].tv_usec, |
830 | exp_num[j], | |
d8e5219f JN |
831 | (tv_exp[j].tv_jiff - t->tv_expires.tv_jiff) * |
832 | 1000000 + tv_exp[j].tv_usec - | |
833 | t->tv_expires.tv_usec); | |
1da177e4 LT |
834 | } |
835 | proc_fasttimer_read(buf5, NULL, 0, 0, 0); | |
836 | printk("buf5 after all done:\n"); | |
837 | printk(buf5); | |
838 | printk("fast_timer_test() done\n"); | |
839 | } | |
840 | #endif | |
841 | ||
842 | ||
d8e5219f | 843 | int fast_timer_init(void) |
1da177e4 LT |
844 | { |
845 | /* For some reason, request_irq() hangs when called froom time_init() */ | |
846 | if (!fast_timer_is_init) | |
847 | { | |
848 | #if 0 && defined(FAST_TIMER_TEST) | |
849 | int i; | |
850 | #endif | |
851 | ||
852 | printk(KERN_INFO "fast_timer_init()\n"); | |
853 | ||
854 | #if 0 && defined(FAST_TIMER_TEST) | |
855 | for (i = 0; i <= TIMER0_DIV; i++) | |
856 | { | |
857 | /* We must be careful not to get overflow... */ | |
858 | printk("%3i %6u\n", i, timer0_value_us[i]); | |
859 | } | |
860 | #endif | |
861 | #ifdef CONFIG_PROC_FS | |
862 | if ((fasttimer_proc_entry = create_proc_entry( "fasttimer", 0, 0 ))) | |
863 | fasttimer_proc_entry->read_proc = proc_fasttimer_read; | |
864 | #endif /* PROC_FS */ | |
7e920426 | 865 | if(request_irq(TIMER1_IRQ_NBR, timer1_handler, 0, |
1da177e4 LT |
866 | "fast timer int", NULL)) |
867 | { | |
868 | printk("err: timer1 irq\n"); | |
869 | } | |
870 | fast_timer_is_init = 1; | |
871 | #ifdef FAST_TIMER_TEST | |
872 | printk("do test\n"); | |
873 | fast_timer_test(); | |
874 | #endif | |
875 | } | |
d8e5219f | 876 | return 0; |
1da177e4 | 877 | } |
d8e5219f | 878 | __initcall(fast_timer_init); |