4 * This interface provides a timer which is similarto hrtimers,
5 * but triggers a RTC alarm if the box is suspend.
7 * This interface is influenced by the Android RTC Alarm timer
10 * Copyright (C) 2010 IBM Corperation
12 * Author: John Stultz <john.stultz@linaro.org>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License version 2 as
16 * published by the Free Software Foundation.
18 #include <linux/time.h>
19 #include <linux/hrtimer.h>
20 #include <linux/timerqueue.h>
21 #include <linux/rtc.h>
22 #include <linux/alarmtimer.h>
23 #include <linux/mutex.h>
24 #include <linux/platform_device.h>
25 #include <linux/posix-timers.h>
26 #include <linux/workqueue.h>
27 #include <linux/freezer.h>
30 * struct alarm_base - Alarm timer bases
31 * @lock: Lock for syncrhonized access to the base
32 * @timerqueue: Timerqueue head managing the list of events
33 * @timer: hrtimer used to schedule events while running
34 * @gettime: Function to read the time correlating to the base
35 * @base_clockid: clockid for the base
37 static struct alarm_base {
39 struct timerqueue_head timerqueue;
41 ktime_t (*gettime)(void);
42 clockid_t base_clockid;
43 } alarm_bases[ALARM_NUMTYPE];
45 /* freezer delta & lock used to handle clock_nanosleep triggered wakeups */
46 static ktime_t freezer_delta;
47 static DEFINE_SPINLOCK(freezer_delta_lock);
49 #ifdef CONFIG_RTC_CLASS
50 /* rtc timer and device for setting alarm wakeups at suspend */
51 static struct rtc_timer rtctimer;
52 static struct rtc_device *rtcdev;
53 static DEFINE_SPINLOCK(rtcdev_lock);
56 * has_wakealarm - check rtc device has wakealarm ability
57 * @dev: current device
58 * @name_ptr: name to be returned
60 * This helper function checks to see if the rtc device can wake
63 static int has_wakealarm(struct device *dev, void *name_ptr)
65 struct rtc_device *candidate = to_rtc_device(dev);
67 if (!candidate->ops->set_alarm)
69 if (!device_may_wakeup(candidate->dev.parent))
72 *(const char **)name_ptr = dev_name(dev);
77 * alarmtimer_get_rtcdev - Return selected rtcdevice
79 * This function returns the rtc device to use for wakealarms.
80 * If one has not already been chosen, it checks to see if a
81 * functional rtc device is available.
83 static struct rtc_device *alarmtimer_get_rtcdev(void)
88 struct rtc_device *ret;
90 spin_lock_irqsave(&rtcdev_lock, flags);
92 /* Find an rtc device and init the rtc_timer */
93 dev = class_find_device(rtc_class, NULL, &str, has_wakealarm);
94 /* If we have a device then str is valid. See has_wakealarm() */
96 rtcdev = rtc_class_open(str);
98 * Drop the reference we got in class_find_device,
99 * rtc_open takes its own.
102 rtc_timer_init(&rtctimer, NULL, NULL);
106 spin_unlock_irqrestore(&rtcdev_lock, flags);
111 #define alarmtimer_get_rtcdev() (0)
117 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
118 * @base: pointer to the base where the timer is being run
119 * @alarm: pointer to alarm being enqueued.
121 * Adds alarm to a alarm_base timerqueue and if necessary sets
124 * Must hold base->lock when calling.
126 static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
128 timerqueue_add(&base->timerqueue, &alarm->node);
129 if (&alarm->node == timerqueue_getnext(&base->timerqueue)) {
130 hrtimer_try_to_cancel(&base->timer);
131 hrtimer_start(&base->timer, alarm->node.expires,
137 * alarmtimer_remove - Removes an alarm timer from an alarm_base timerqueue
138 * @base: pointer to the base where the timer is running
139 * @alarm: pointer to alarm being removed
141 * Removes alarm to a alarm_base timerqueue and if necessary sets
142 * a new timer to run.
144 * Must hold base->lock when calling.
146 static void alarmtimer_remove(struct alarm_base *base, struct alarm *alarm)
148 struct timerqueue_node *next = timerqueue_getnext(&base->timerqueue);
150 timerqueue_del(&base->timerqueue, &alarm->node);
151 if (next == &alarm->node) {
152 hrtimer_try_to_cancel(&base->timer);
153 next = timerqueue_getnext(&base->timerqueue);
156 hrtimer_start(&base->timer, next->expires, HRTIMER_MODE_ABS);
162 * alarmtimer_fired - Handles alarm hrtimer being fired.
163 * @timer: pointer to hrtimer being run
165 * When a alarm timer fires, this runs through the timerqueue to
166 * see which alarms expired, and runs those. If there are more alarm
167 * timers queued for the future, we set the hrtimer to fire when
168 * when the next future alarm timer expires.
170 static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
172 struct alarm_base *base = container_of(timer, struct alarm_base, timer);
173 struct timerqueue_node *next;
176 int ret = HRTIMER_NORESTART;
177 int restart = ALARMTIMER_NORESTART;
179 spin_lock_irqsave(&base->lock, flags);
180 now = base->gettime();
181 while ((next = timerqueue_getnext(&base->timerqueue))) {
183 ktime_t expired = next->expires;
185 if (expired.tv64 >= now.tv64)
188 alarm = container_of(next, struct alarm, node);
190 timerqueue_del(&base->timerqueue, &alarm->node);
193 spin_unlock_irqrestore(&base->lock, flags);
195 restart = alarm->function(alarm, now);
196 spin_lock_irqsave(&base->lock, flags);
198 if (restart != ALARMTIMER_NORESTART) {
199 timerqueue_add(&base->timerqueue, &alarm->node);
205 hrtimer_set_expires(&base->timer, next->expires);
206 ret = HRTIMER_RESTART;
208 spin_unlock_irqrestore(&base->lock, flags);
214 #ifdef CONFIG_RTC_CLASS
216 * alarmtimer_suspend - Suspend time callback
220 * When we are going into suspend, we look through the bases
221 * to see which is the soonest timer to expire. We then
222 * set an rtc timer to fire that far into the future, which
223 * will wake us from suspend.
225 static int alarmtimer_suspend(struct device *dev)
230 struct rtc_device *rtc;
233 spin_lock_irqsave(&freezer_delta_lock, flags);
235 freezer_delta = ktime_set(0, 0);
236 spin_unlock_irqrestore(&freezer_delta_lock, flags);
239 /* If we have no rtcdev, just return */
243 /* Find the soonest timer to expire*/
244 for (i = 0; i < ALARM_NUMTYPE; i++) {
245 struct alarm_base *base = &alarm_bases[i];
246 struct timerqueue_node *next;
249 spin_lock_irqsave(&base->lock, flags);
250 next = timerqueue_getnext(&base->timerqueue);
251 spin_unlock_irqrestore(&base->lock, flags);
254 delta = ktime_sub(next->expires, base->gettime());
255 if (!min.tv64 || (delta.tv64 < min.tv64))
261 /* XXX - Should we enforce a minimum sleep time? */
262 WARN_ON(min.tv64 < NSEC_PER_SEC);
264 /* Setup an rtc timer to fire that far in the future */
265 rtc_timer_cancel(rtc, &rtctimer);
266 rtc_read_time(rtc, &tm);
267 now = rtc_tm_to_ktime(tm);
268 now = ktime_add(now, min);
270 rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0));
275 static int alarmtimer_suspend(struct device *dev)
281 static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
285 struct alarm_base *base = &alarm_bases[type];
287 delta = ktime_sub(absexp, base->gettime());
289 spin_lock_irqsave(&freezer_delta_lock, flags);
290 if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64))
291 freezer_delta = delta;
292 spin_unlock_irqrestore(&freezer_delta_lock, flags);
297 * alarm_init - Initialize an alarm structure
298 * @alarm: ptr to alarm to be initialized
299 * @type: the type of the alarm
300 * @function: callback that is run when the alarm fires
302 void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
303 enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
305 timerqueue_init(&alarm->node);
306 alarm->function = function;
312 * alarm_start - Sets an alarm to fire
313 * @alarm: ptr to alarm to set
314 * @start: time to run the alarm
316 void alarm_start(struct alarm *alarm, ktime_t start)
318 struct alarm_base *base = &alarm_bases[alarm->type];
321 spin_lock_irqsave(&base->lock, flags);
323 alarmtimer_remove(base, alarm);
324 alarm->node.expires = start;
325 alarmtimer_enqueue(base, alarm);
327 spin_unlock_irqrestore(&base->lock, flags);
331 * alarm_cancel - Tries to cancel an alarm timer
332 * @alarm: ptr to alarm to be canceled
334 void alarm_cancel(struct alarm *alarm)
336 struct alarm_base *base = &alarm_bases[alarm->type];
339 spin_lock_irqsave(&base->lock, flags);
341 alarmtimer_remove(base, alarm);
343 spin_unlock_irqrestore(&base->lock, flags);
348 u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
353 delta = ktime_sub(now, alarm->node.expires);
358 if (unlikely(delta.tv64 >= interval.tv64)) {
359 s64 incr = ktime_to_ns(interval);
361 overrun = ktime_divns(delta, incr);
363 alarm->node.expires = ktime_add_ns(alarm->node.expires,
366 if (alarm->node.expires.tv64 > now.tv64)
369 * This (and the ktime_add() below) is the
370 * correction for exact:
375 alarm->node.expires = ktime_add(alarm->node.expires, interval);
383 * clock2alarm - helper that converts from clockid to alarmtypes
386 static enum alarmtimer_type clock2alarm(clockid_t clockid)
388 if (clockid == CLOCK_REALTIME_ALARM)
389 return ALARM_REALTIME;
390 if (clockid == CLOCK_BOOTTIME_ALARM)
391 return ALARM_BOOTTIME;
396 * alarm_handle_timer - Callback for posix timers
397 * @alarm: alarm that fired
399 * Posix timer callback for expired alarm timers.
401 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
404 struct k_itimer *ptr = container_of(alarm, struct k_itimer,
405 it.alarm.alarmtimer);
406 if (posix_timer_event(ptr, 0) != 0)
409 /* Re-add periodic timers */
410 if (ptr->it.alarm.interval.tv64) {
411 ptr->it_overrun += alarm_forward(alarm, now,
412 ptr->it.alarm.interval);
413 return ALARMTIMER_RESTART;
415 return ALARMTIMER_NORESTART;
419 * alarm_clock_getres - posix getres interface
420 * @which_clock: clockid
421 * @tp: timespec to fill
423 * Returns the granularity of underlying alarm base clock
425 static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
427 clockid_t baseid = alarm_bases[clock2alarm(which_clock)].base_clockid;
429 if (!alarmtimer_get_rtcdev())
432 return hrtimer_get_res(baseid, tp);
436 * alarm_clock_get - posix clock_get interface
437 * @which_clock: clockid
438 * @tp: timespec to fill.
440 * Provides the underlying alarm base time.
442 static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
444 struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
446 if (!alarmtimer_get_rtcdev())
449 *tp = ktime_to_timespec(base->gettime());
454 * alarm_timer_create - posix timer_create interface
455 * @new_timer: k_itimer pointer to manage
457 * Initializes the k_itimer structure.
459 static int alarm_timer_create(struct k_itimer *new_timer)
461 enum alarmtimer_type type;
462 struct alarm_base *base;
464 if (!alarmtimer_get_rtcdev())
467 if (!capable(CAP_WAKE_ALARM))
470 type = clock2alarm(new_timer->it_clock);
471 base = &alarm_bases[type];
472 alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
477 * alarm_timer_get - posix timer_get interface
478 * @new_timer: k_itimer pointer
479 * @cur_setting: itimerspec data to fill
481 * Copies the itimerspec data out from the k_itimer
483 static void alarm_timer_get(struct k_itimer *timr,
484 struct itimerspec *cur_setting)
486 memset(cur_setting, 0, sizeof(struct itimerspec));
488 cur_setting->it_interval =
489 ktime_to_timespec(timr->it.alarm.interval);
490 cur_setting->it_value =
491 ktime_to_timespec(timr->it.alarm.alarmtimer.node.expires);
496 * alarm_timer_del - posix timer_del interface
497 * @timr: k_itimer pointer to be deleted
499 * Cancels any programmed alarms for the given timer.
501 static int alarm_timer_del(struct k_itimer *timr)
506 alarm_cancel(&timr->it.alarm.alarmtimer);
511 * alarm_timer_set - posix timer_set interface
512 * @timr: k_itimer pointer to be deleted
513 * @flags: timer flags
514 * @new_setting: itimerspec to be used
515 * @old_setting: itimerspec being replaced
517 * Sets the timer to new_setting, and starts the timer.
519 static int alarm_timer_set(struct k_itimer *timr, int flags,
520 struct itimerspec *new_setting,
521 struct itimerspec *old_setting)
527 alarm_timer_get(timr, old_setting);
529 /* If the timer was already set, cancel it */
530 alarm_cancel(&timr->it.alarm.alarmtimer);
532 /* start the timer */
533 timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
534 alarm_start(&timr->it.alarm.alarmtimer,
535 timespec_to_ktime(new_setting->it_value));
540 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
541 * @alarm: ptr to alarm that fired
543 * Wakes up the task that set the alarmtimer
545 static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
548 struct task_struct *task = (struct task_struct *)alarm->data;
552 wake_up_process(task);
553 return ALARMTIMER_NORESTART;
557 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
558 * @alarm: ptr to alarmtimer
559 * @absexp: absolute expiration time
561 * Sets the alarm timer and sleeps until it is fired or interrupted.
563 static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
565 alarm->data = (void *)current;
567 set_current_state(TASK_INTERRUPTIBLE);
568 alarm_start(alarm, absexp);
569 if (likely(alarm->data))
573 } while (alarm->data && !signal_pending(current));
575 __set_current_state(TASK_RUNNING);
577 return (alarm->data == NULL);
582 * update_rmtp - Update remaining timespec value
583 * @exp: expiration time
585 * @rmtp: user pointer to remaining timepsec value
587 * Helper function that fills in rmtp value with time between
588 * now and the exp value
590 static int update_rmtp(ktime_t exp, enum alarmtimer_type type,
591 struct timespec __user *rmtp)
596 rem = ktime_sub(exp, alarm_bases[type].gettime());
600 rmt = ktime_to_timespec(rem);
602 if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
610 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
611 * @restart: ptr to restart block
613 * Handles restarted clock_nanosleep calls
615 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
617 enum alarmtimer_type type = restart->nanosleep.clockid;
619 struct timespec __user *rmtp;
623 exp.tv64 = restart->nanosleep.expires;
624 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
626 if (alarmtimer_do_nsleep(&alarm, exp))
629 if (freezing(current))
630 alarmtimer_freezerset(exp, type);
632 rmtp = restart->nanosleep.rmtp;
634 ret = update_rmtp(exp, type, rmtp);
640 /* The other values in restart are already filled in */
641 ret = -ERESTART_RESTARTBLOCK;
647 * alarm_timer_nsleep - alarmtimer nanosleep
648 * @which_clock: clockid
649 * @flags: determins abstime or relative
650 * @tsreq: requested sleep time (abs or rel)
651 * @rmtp: remaining sleep time saved
653 * Handles clock_nanosleep calls against _ALARM clockids
655 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
656 struct timespec *tsreq, struct timespec __user *rmtp)
658 enum alarmtimer_type type = clock2alarm(which_clock);
662 struct restart_block *restart;
664 if (!alarmtimer_get_rtcdev())
667 if (!capable(CAP_WAKE_ALARM))
670 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
672 exp = timespec_to_ktime(*tsreq);
673 /* Convert (if necessary) to absolute time */
674 if (flags != TIMER_ABSTIME) {
675 ktime_t now = alarm_bases[type].gettime();
676 exp = ktime_add(now, exp);
679 if (alarmtimer_do_nsleep(&alarm, exp))
682 if (freezing(current))
683 alarmtimer_freezerset(exp, type);
685 /* abs timers don't set remaining time or restart */
686 if (flags == TIMER_ABSTIME) {
687 ret = -ERESTARTNOHAND;
692 ret = update_rmtp(exp, type, rmtp);
697 restart = ¤t_thread_info()->restart_block;
698 restart->fn = alarm_timer_nsleep_restart;
699 restart->nanosleep.clockid = type;
700 restart->nanosleep.expires = exp.tv64;
701 restart->nanosleep.rmtp = rmtp;
702 ret = -ERESTART_RESTARTBLOCK;
709 /* Suspend hook structures */
710 static const struct dev_pm_ops alarmtimer_pm_ops = {
711 .suspend = alarmtimer_suspend,
714 static struct platform_driver alarmtimer_driver = {
716 .name = "alarmtimer",
717 .pm = &alarmtimer_pm_ops,
722 * alarmtimer_init - Initialize alarm timer code
724 * This function initializes the alarm bases and registers
725 * the posix clock ids.
727 static int __init alarmtimer_init(void)
731 struct k_clock alarm_clock = {
732 .clock_getres = alarm_clock_getres,
733 .clock_get = alarm_clock_get,
734 .timer_create = alarm_timer_create,
735 .timer_set = alarm_timer_set,
736 .timer_del = alarm_timer_del,
737 .timer_get = alarm_timer_get,
738 .nsleep = alarm_timer_nsleep,
741 posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
742 posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
744 /* Initialize alarm bases */
745 alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
746 alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
747 alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
748 alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
749 for (i = 0; i < ALARM_NUMTYPE; i++) {
750 timerqueue_init_head(&alarm_bases[i].timerqueue);
751 spin_lock_init(&alarm_bases[i].lock);
752 hrtimer_init(&alarm_bases[i].timer,
753 alarm_bases[i].base_clockid,
755 alarm_bases[i].timer.function = alarmtimer_fired;
757 error = platform_driver_register(&alarmtimer_driver);
758 platform_device_register_simple("alarmtimer", -1, NULL, 0);
762 device_initcall(alarmtimer_init);