finally move buildroot-ng to trunk
[openwrt/staging/dedeckeh.git] / package / nvram / src / linux_timer.c
1 /*
2 * Copyright 2004, Broadcom Corporation
3 * All Rights Reserved.
4 *
5 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
7 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
9 *
10 * Low resolution timer interface linux specific implementation.
11 *
12 * $Id$
13 */
14
15 /*
16 * debug facilities
17 */
18 #define TIMER_DEBUG 0
19 #if TIMER_DEBUG
20 #define TIMERDBG(fmt, args...) printf("%s: " fmt "\n" , __FUNCTION__ , ## args)
21 #else
22 #define TIMERDBG(fmt, args...)
23 #endif
24
25
26 /*
27 * POSIX timer support for Linux. Taken from linux_timer.c in upnp
28 */
29
30 #define __USE_GNU
31
32
33 #include <stdlib.h> // for malloc, free, etc.
34 #include <string.h> // for memset, strncasecmp, etc.
35 #include <assert.h> // for assert, of course.
36 #include <signal.h> // for sigemptyset, etc.
37 #include <stdio.h> // for printf, etc.
38 #include <sys/time.h>
39 #include <time.h>
40
41 /* define TIMER_PROFILE to enable code which guages how accurate the timer functions are.
42 For each expiring timer the code will print the expected time interval and the actual time interval.
43 #define TIMER_PROFILE
44 */
45 #undef TIMER_PROFILE
46
47 /*
48 timer_cancel( ) - cancel a timer
49 timer_connect( ) - connect a user routine to the timer signal
50 timer_create( ) - allocate a timer using the specified clock for a timing base (POSIX)
51 timer_delete( ) - remove a previously created timer (POSIX)
52 timer_gettime( ) - get the remaining time before expiration and the reload value (POSIX)
53 timer_getoverrun( ) - return the timer expiration overrun (POSIX)
54 timer_settime( ) - set the time until the next expiration and arm timer (POSIX)
55 nanosleep( ) - suspend the current task until the time interval elapses (POSIX)
56 */
57
58 #define MS_PER_SEC 1000
59 #define US_PER_SEC 1000000
60 #define US_PER_MS 1000
61 #define UCLOCKS_PER_SEC 1000000
62
63 typedef void (*event_callback_t)(timer_t, int);
64
65 #ifndef TIMESPEC_TO_TIMEVAL
66 # define TIMESPEC_TO_TIMEVAL(tv, ts) { \
67 (tv)->tv_sec = (ts)->tv_sec; \
68 (tv)->tv_usec = (ts)->tv_nsec / 1000; \
69 }
70 #endif
71
72 #ifndef TIMEVAL_TO_TIMESPEC
73 # define TIMEVAL_TO_TIMESPEC(tv, ts) { \
74 (ts)->tv_sec = (tv)->tv_sec; \
75 (ts)->tv_nsec = (tv)->tv_usec * 1000; \
76 }
77 #endif
78
79 #define ROUNDUP(x,y) ((((x)+(y)-1)/(y))*(y))
80
81 #define timerroundup(t,g) \
82 do { \
83 if (!timerisset(t)) (t)->tv_usec=1; \
84 if ((t)->tv_sec == 0) (t)->tv_usec=ROUNDUP((t)->tv_usec, g); \
85 } while (0)
86
87 typedef long uclock_t;
88
89 #define TFLAG_NONE 0
90 #define TFLAG_CANCELLED (1<<0)
91 #define TFLAG_DELETED (1<<1)
92
93 struct event {
94 struct timeval it_interval;
95 struct timeval it_value;
96 event_callback_t func;
97 int arg;
98 unsigned short flags;
99 struct event *next;
100 #ifdef TIMER_PROFILE
101 uint expected_ms;
102 uclock_t start;
103 #endif
104 };
105
106 void timer_cancel(timer_t timerid);
107
108 static void alarm_handler(int i);
109 static void check_event_queue();
110 static void print_event_queue();
111 static void check_timer();
112 #if THIS_FINDS_USE
113 static int count_queue(struct event *);
114 #endif
115 static int timer_change_settime(timer_t timer_id, const struct itimerspec *timer_spec);
116 void block_timer();
117 void unblock_timer();
118
119 static struct event *event_queue = NULL;
120 static struct event *event_freelist;
121 static uint g_granularity;
122 static int g_maxevents = 0;
123
124 uclock_t uclock()
125 {
126 struct timeval tv;
127
128 gettimeofday(&tv, NULL);
129 return ((tv.tv_sec * US_PER_SEC) + tv.tv_usec);
130 }
131
132
133 void init_event_queue(int n)
134 {
135 int i;
136 struct itimerval tv;
137
138 g_maxevents = n;
139 event_freelist = (struct event *) malloc(n * sizeof(struct event));
140 memset(event_freelist, 0, n * sizeof(struct event));
141
142 for (i = 0; i < (n-1); i++)
143 event_freelist[i].next = &event_freelist[i+1];
144
145 event_freelist[i].next = NULL;
146
147 tv.it_interval.tv_sec = 0;
148 tv.it_interval.tv_usec = 1;
149 tv.it_value.tv_sec = 0;
150 tv.it_value.tv_usec = 0;
151 setitimer (ITIMER_REAL, &tv, 0);
152 setitimer (ITIMER_REAL, 0, &tv);
153 g_granularity = tv.it_interval.tv_usec;
154
155 signal(SIGALRM, alarm_handler);
156 }
157
158
159 int clock_gettime(
160 clockid_t clock_id, /* clock ID (always CLOCK_REALTIME) */
161 struct timespec * tp /* where to store current time */
162 )
163 {
164 struct timeval tv;
165 int n;
166
167
168 n = gettimeofday(&tv, NULL);
169 TIMEVAL_TO_TIMESPEC(&tv, tp);
170
171 return n;
172 }
173
174
175 int timer_create(
176 clockid_t clock_id, /* clock ID (always CLOCK_REALTIME) */
177 struct sigevent * evp, /* user event handler */
178 timer_t * pTimer /* ptr to return value */
179 )
180 {
181 struct event *event;
182
183 if (clock_id != CLOCK_REALTIME) {
184 TIMERDBG("timer_create can only support clock id CLOCK_REALTIME");
185 exit(1);
186 }
187
188 if (evp != NULL) {
189 if (evp->sigev_notify != SIGEV_SIGNAL || evp->sigev_signo != SIGALRM) {
190 TIMERDBG("timer_create can only support signalled alarms using SIGALRM");
191 exit(1);
192 }
193 }
194
195 event = event_freelist;
196 if (event == NULL) {
197 print_event_queue();
198 }
199 assert(event != NULL);
200
201 event->flags = TFLAG_NONE;
202
203 event_freelist = event->next;
204 event->next = NULL;
205
206 check_event_queue();
207
208 *pTimer = (timer_t) event;
209
210 return 0;
211 }
212
213 int timer_delete(
214 timer_t timerid /* timer ID */
215 )
216 {
217 struct event *event = (struct event *) timerid;
218
219 if (event->flags & TFLAG_DELETED) {
220 TIMERDBG("Cannot delete a deleted event");
221 return 1;
222 }
223
224 timer_cancel(timerid);
225
226 event->flags |= TFLAG_DELETED;
227
228 event->next = event_freelist;
229 event_freelist = event;
230
231 return 0;
232 }
233
234 int timer_connect
235 (
236 timer_t timerid, /* timer ID */
237 void (*routine)(timer_t, int), /* user routine */
238 int arg /* user argument */
239 )
240 {
241 struct event *event = (struct event *) timerid;
242
243 assert(routine != NULL);
244 event->func = routine;
245 event->arg = arg;
246
247 return 0;
248 }
249
250 /*
251 * Please Call this function only from the call back functions of the alarm_handler.
252 * This is just a hack
253 */
254 int timer_change_settime
255 (
256 timer_t timerid, /* timer ID */
257 const struct itimerspec * value /* time to be set */
258 )
259 {
260 struct event *event = (struct event *) timerid;
261
262 TIMESPEC_TO_TIMEVAL(&event->it_interval, &value->it_interval);
263 TIMESPEC_TO_TIMEVAL(&event->it_value, &value->it_value);
264
265 return 1;
266 }
267
268 int timer_settime
269 (
270 timer_t timerid, /* timer ID */
271 int flags, /* absolute or relative */
272 const struct itimerspec * value, /* time to be set */
273 struct itimerspec * ovalue /* previous time set (NULL=no result) */
274 )
275 {
276 struct itimerval itimer;
277 struct event *event = (struct event *) timerid;
278 struct event **ppevent;
279
280 TIMESPEC_TO_TIMEVAL(&event->it_interval, &value->it_interval);
281 TIMESPEC_TO_TIMEVAL(&event->it_value, &value->it_value);
282
283 /* if .it_value is zero, the timer is disarmed */
284 if (!timerisset(&event->it_value)) {
285 timer_cancel(timerid);
286 return 0;
287 }
288
289 block_timer();
290
291 #ifdef TIMER_PROFILE
292 event->expected_ms = (event->it_value.tv_sec * MS_PER_SEC) + (event->it_value.tv_usec / US_PER_MS);
293 event->start = uclock();
294 #endif
295 if (event->next) {
296 TIMERDBG("calling timer_settime with a timer that is already on the queue.");
297 }
298
299
300 /* We always want to make sure that the event at the head of the
301 queue has a timeout greater than the itimer granularity.
302 Otherwise we end up with the situation that the time remaining
303 on an itimer is greater than the time at the head of the queue
304 in the first place. */
305 timerroundup(&event->it_value, g_granularity);
306
307 timerclear(&itimer.it_value);
308 getitimer(ITIMER_REAL, &itimer);
309 if (timerisset(&itimer.it_value)) {
310 // reset the top timer to have an interval equal to the remaining interval
311 // when the timer was cancelled.
312 if (event_queue) {
313 if (timercmp(&(itimer.it_value), &(event_queue->it_value), >)) {
314 // it is an error if the amount of time remaining is more than the amount of time
315 // requested by the top event.
316 //
317 TIMERDBG("timer_settime: TIMER ERROR!");
318
319 } else {
320 // some portion of the top event has already expired.
321 // Reset the interval of the top event to remaining
322 // time left in that interval.
323 //
324 event_queue->it_value = itimer.it_value;
325
326 // if we were the earliest timer before now, we are still the earliest timer now.
327 // we do not need to reorder the list.
328 }
329 }
330 }
331
332 // Now, march down the list, decrementing the new timer by the
333 // current it_value of each event on the queue.
334 ppevent = &event_queue;
335 while (*ppevent) {
336 if ( timercmp(&(event->it_value), &((*ppevent)->it_value), <) ) {
337 // if the proposed event will trigger sooner than the next event
338 // in the queue, we will insert the new event just before the next one.
339 //
340 // we also need to adjust the delta value to the next event.
341 timersub(&((*ppevent)->it_value), &(event->it_value), &((*ppevent)->it_value));
342 break;
343 }
344 // subtract the interval of the next event from the proposed interval.
345 timersub(&(event->it_value), &((*ppevent)->it_value), &(event->it_value));
346
347 ppevent = &((*ppevent)->next);
348 }
349
350 // we have found our proper place in the queue,
351 // link our new event into the pending event queue.
352 event->next = *ppevent;
353 *ppevent = event;
354
355 check_event_queue();
356
357 // if our new event ended up at the front of the queue, reissue the timer.
358 if (event == event_queue) {
359 timerroundup(&event_queue->it_value, g_granularity);
360 timerclear(&itimer.it_interval);
361 itimer.it_value = event_queue->it_value;
362
363 // we want to be sure to never turn off the timer completely,
364 // so if the next interval is zero, set it to some small value.
365 if (!timerisset(&(itimer.it_value)))
366 itimer.it_value = (struct timeval) { 0, 1 };
367
368 assert(!timerisset(&itimer.it_interval));
369 assert(itimer.it_value.tv_sec > 0 || itimer.it_value.tv_usec >= g_granularity);
370 assert(event_queue->it_value.tv_sec > 0 || event_queue->it_value.tv_usec >= g_granularity);
371 setitimer(ITIMER_REAL, &itimer, NULL);
372 check_timer();
373 }
374
375 event->flags &= ~TFLAG_CANCELLED;
376
377 unblock_timer();
378
379 return 0;
380 }
381
382 static void check_timer()
383 {
384 struct itimerval itimer;
385
386 getitimer(ITIMER_REAL, &itimer);
387 if (timerisset(&itimer.it_interval)) {
388 TIMERDBG("ERROR timer interval is set.");
389 }
390 if (timercmp(&(itimer.it_value), &(event_queue->it_value), >)) {
391 TIMERDBG("ERROR timer expires later than top event.");
392 }
393 }
394
395
396 static void check_event_queue()
397 {
398 struct timeval sum;
399 struct event *event;
400 int i = 0;
401
402 #ifdef notdef
403 int nfree = 0;
404 struct event *p;
405 for (p = event_freelist; p; p = p->next)
406 nfree++;
407 printf("%d free events\n", nfree);
408 #endif
409
410 timerclear(&sum);
411 for (event = event_queue; event; event = event->next) {
412 if (i > g_maxevents) {
413 TIMERDBG("timer queue looks like it loops back on itself!");
414 print_event_queue();
415 exit(1);
416 }
417 i++;
418 }
419 }
420
421 #if THIS_FINDS_USE
422 /* The original upnp version has this unused function, so I left it in
423 to maintain the resemblance. */
424 static int count_queue(struct event *event_queue)
425 {
426 struct event *event;
427 int i = 0;
428 for (event = event_queue; event; event = event->next)
429 i++;
430 return i;
431 }
432 #endif
433
434 static void print_event_queue()
435 {
436 struct event *event;
437 int i = 0;
438
439 for (event = event_queue; event; event = event->next) {
440 printf("#%d (0x%x)->0x%x: \t%d sec %d usec\t%p\n",
441 i++, (unsigned int) event, (unsigned int) event->next, (int) event->it_value.tv_sec, (int) event->it_value.tv_usec, event->func);
442 if (i > g_maxevents) {
443 printf("...(giving up)\n");
444 break;
445 }
446 }
447 }
448
449 // The top element of the event queue must have expired.
450 // Remove that element, run its function, and reset the timer.
451 // if there is no interval, recycle the event structure.
452 static void alarm_handler(int i)
453 {
454 struct event *event, **ppevent;
455 struct itimerval itimer;
456 struct timeval small_interval = { 0, g_granularity/2 };
457 #ifdef TIMER_PROFILE
458 uint junk;
459 uclock_t end;
460 uint actual;
461 #endif
462
463 block_timer();
464
465 // Loop through the event queue and remove the first event plus any
466 // subsequent events that will expire very soon thereafter (within 'small_interval'}.
467 //
468 do {
469 // remove the top event.
470 event = event_queue;
471 event_queue = event_queue->next;
472 event->next = NULL;
473
474 #ifdef TIMER_PROFILE
475 end = uclock();
476 actual = ((end-event->start)/((uclock_t)UCLOCKS_PER_SEC/1000));
477 if (actual < 0)
478 junk = end;
479 TIMERDBG("expected %d ms actual %d ms", event->expected_ms, ((end-event->start)/((uclock_t)UCLOCKS_PER_SEC/1000)));
480 #endif
481
482 // call the event callback function
483 (*(event->func))((timer_t) event, (int)event->arg);
484
485 /* If the event has been cancelled, do NOT put it back on the queue. */
486 if ( !(event->flags & TFLAG_CANCELLED) ) {
487
488 // if the event is a recurring event, reset the timer and
489 // find its correct place in the sorted list of events.
490 //
491 if (timerisset(&event->it_interval)) {
492 // event is recurring...
493 //
494 event->it_value = event->it_interval;
495 #ifdef TIMER_PROFILE
496 event->expected_ms = (event->it_value.tv_sec * MS_PER_SEC) + (event->it_value.tv_usec / US_PER_MS);
497 event->start = uclock();
498 #endif
499 timerroundup(&event->it_value, g_granularity);
500
501 // Now, march down the list, decrementing the new timer by the
502 // current delta of each event on the queue.
503 ppevent = &event_queue;
504 while (*ppevent) {
505 if ( timercmp(&(event->it_value), &((*ppevent)->it_value), <) ) {
506 // if the proposed event will trigger sooner than the next event
507 // in the queue, we will insert the new event just before the next one.
508 //
509 // we also need to adjust the delta value to the next event.
510 timersub(&((*ppevent)->it_value), &(event->it_value), &((*ppevent)->it_value));
511 break;
512 }
513 timersub(&(event->it_value), &((*ppevent)->it_value), &(event->it_value));
514 ppevent = &((*ppevent)->next);
515 }
516
517 // we have found our proper place in the queue,
518 // link our new event into the pending event queue.
519 event->next = *ppevent;
520 *ppevent = event;
521 } else {
522 // there is no interval, so recycle the event structure.
523 //timer_delete((timer_t) event);
524 }
525 }
526
527 check_event_queue();
528
529 } while (event_queue && timercmp(&event_queue->it_value, &small_interval, <));
530
531 // re-issue the timer...
532 if (event_queue) {
533 timerroundup(&event_queue->it_value, g_granularity);
534
535 timerclear(&itimer.it_interval);
536 itimer.it_value = event_queue->it_value;
537 // we want to be sure to never turn off the timer completely,
538 // so if the next interval is zero, set it to some small value.
539 if (!timerisset(&(itimer.it_value)))
540 itimer.it_value = (struct timeval) { 0, 1 };
541
542 setitimer(ITIMER_REAL, &itimer, NULL);
543 check_timer();
544 } else {
545 TIMERDBG("There are no events in the queue - timer not reset.");
546 }
547
548 unblock_timer();
549 }
550
551 static int block_count = 0;
552
553 void block_timer()
554 {
555 sigset_t set;
556
557 if (block_count++ == 0) {
558 sigemptyset(&set);
559 sigaddset(&set, SIGALRM);
560 sigprocmask(SIG_BLOCK, &set, NULL);
561 }
562 }
563
564 void unblock_timer()
565 {
566 sigset_t set;
567
568 if (--block_count == 0) {
569 sigemptyset(&set);
570 sigaddset(&set, SIGALRM);
571 sigprocmask(SIG_UNBLOCK, &set, NULL);
572 }
573 }
574
575 void timer_cancel_all()
576 {
577 struct itimerval timeroff = { { 0, 0 }, { 0, 0} };
578 struct event *event;
579 struct event **ppevent;
580
581 setitimer(ITIMER_REAL, &timeroff, NULL);
582
583 ppevent = &event_queue;
584 while (*ppevent) {
585 event = *ppevent;
586 *ppevent = event->next;
587 event->next = NULL;
588 }
589 }
590
591
592
593 void timer_cancel(timer_t timerid)
594 {
595 struct itimerval itimer;
596 struct itimerval timeroff = { { 0, 0 }, { 0, 0} };
597 struct event *event = (struct event *) timerid;
598 struct event **ppevent;
599
600 if (event->flags & TFLAG_CANCELLED) {
601 TIMERDBG("Cannot cancel a cancelled event");
602 return;
603 }
604
605 block_timer();
606
607 ppevent = &event_queue;
608 while (*ppevent) {
609 if ( *ppevent == event ) {
610
611 /* RACE CONDITION - if the alarm goes off while we are in
612 this loop, and if the timer we want to cancel is the
613 next to expire, the alarm will end up firing
614 after this routine is complete, causing it to go off early. */
615
616 /* If the cancelled timer is the next to expire,
617 we need to do something special to clean up correctly. */
618 if (event == event_queue && event->next != NULL) {
619 timerclear(&itimer.it_value);
620 getitimer(ITIMER_REAL, &itimer);
621
622 /* subtract the time that has already passed while waiting for this timer... */
623 timersub(&(event->it_value), &(itimer.it_value), &(event->it_value));
624
625 /* and add any remainder to the next timer in the list */
626 timeradd(&(event->next->it_value), &(event->it_value), &(event->next->it_value));
627 }
628
629 *ppevent = event->next;
630 event->next = NULL;
631
632 if (event_queue) {
633 timerroundup(&event_queue->it_value, g_granularity);
634 timerclear(&itimer.it_interval);
635 itimer.it_value = event_queue->it_value;
636
637 /* We want to be sure to never turn off the timer
638 completely if there are more events on the queue,
639 so if the next interval is zero, set it to some
640 small value. */
641
642 if (!timerisset(&(itimer.it_value)))
643 itimer.it_value = (struct timeval) { 0, 1 };
644
645 assert(itimer.it_value.tv_sec > 0 || itimer.it_value.tv_usec >= g_granularity);
646 assert(event_queue->it_value.tv_sec > 0 || event_queue->it_value.tv_usec >= g_granularity);
647 setitimer(ITIMER_REAL, &itimer, NULL);
648 check_timer();
649 } else {
650 setitimer(ITIMER_REAL, &timeroff, NULL);
651 }
652 break;
653 }
654 ppevent = &((*ppevent)->next);
655 }
656
657 event->flags |= TFLAG_CANCELLED;
658
659 unblock_timer();
660 }
661
662 /*
663 * timer related headers
664 */
665 #include "bcmtimer.h"
666
667 /*
668 * locally used global variables and constants
669 */
670
671 /*
672 * Initialize internal resources used in the timer module. It must be called
673 * before any other timer function calls. The param 'timer_entries' is used
674 * to pre-allocate fixed number of timer entries.
675 */
676 int bcm_timer_module_init(int timer_entries, bcm_timer_module_id *module_id)
677 {
678 init_event_queue(timer_entries);
679 *module_id = (bcm_timer_module_id)event_freelist;
680 return 0;
681 }
682
683 /*
684 * Cleanup internal resources used by this timer module. It deletes all
685 * pending timer entries from the backend timer system as well.
686 */
687 int bcm_timer_module_cleanup(bcm_timer_module_id module_id)
688 {
689 module_id = 0;
690 return 0;
691 }
692
693 /* Enable/Disable timer module */
694 int bcm_timer_module_enable(bcm_timer_module_id module_id, int enable)
695 {
696 if (enable)
697 unblock_timer();
698 else
699 block_timer();
700 return 0;
701 }
702
703 int bcm_timer_create(bcm_timer_module_id module_id, bcm_timer_id *timer_id)
704 {
705 module_id = 0;
706 return timer_create(CLOCK_REALTIME, NULL, (timer_t *)timer_id);
707 }
708
709 int bcm_timer_delete(bcm_timer_id timer_id)
710 {
711 return timer_delete((timer_t)timer_id);
712 }
713
714 int bcm_timer_gettime(bcm_timer_id timer_id, struct itimerspec *timer_spec)
715 {
716 return -1;
717 }
718
719 int bcm_timer_settime(bcm_timer_id timer_id, const struct itimerspec *timer_spec)
720 {
721 return timer_settime((timer_t)timer_id, 0, timer_spec, NULL);
722 }
723
724 int bcm_timer_connect(bcm_timer_id timer_id, bcm_timer_cb func, int data)
725 {
726 return timer_connect((timer_t)timer_id, (void *)func, data);
727 }
728
729 int bcm_timer_cancel(bcm_timer_id timer_id)
730 {
731 timer_cancel((timer_t)timer_id);
732 return 0;
733 }
734 int bcm_timer_change_expirytime(bcm_timer_id timer_id, const struct itimerspec *timer_spec)
735 {
736 timer_change_settime((timer_t)timer_id, timer_spec);
737 return 1;
738 }