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/sched/signal.h>
23 #include <linux/alarmtimer.h>
24 #include <linux/mutex.h>
25 #include <linux/platform_device.h>
26 #include <linux/posix-timers.h>
27 #include <linux/workqueue.h>
28 #include <linux/freezer.h>
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/alarmtimer.h>
34 * struct alarm_base - Alarm timer bases
35 * @lock: Lock for syncrhonized access to the base
36 * @timerqueue: Timerqueue head managing the list of events
37 * @gettime: Function to read the time correlating to the base
38 * @base_clockid: clockid for the base
40 static struct alarm_base {
42 struct timerqueue_head timerqueue;
43 ktime_t (*gettime)(void);
44 clockid_t base_clockid;
45 } alarm_bases[ALARM_NUMTYPE];
47 /* freezer information to handle clock_nanosleep triggered wakeups */
48 static enum alarmtimer_type freezer_alarmtype;
49 static ktime_t freezer_expires;
50 static ktime_t freezer_delta;
51 static DEFINE_SPINLOCK(freezer_delta_lock);
53 static struct wakeup_source *ws;
55 #ifdef CONFIG_RTC_CLASS
56 /* rtc timer and device for setting alarm wakeups at suspend */
57 static struct rtc_timer rtctimer;
58 static struct rtc_device *rtcdev;
59 static DEFINE_SPINLOCK(rtcdev_lock);
62 * alarmtimer_get_rtcdev - Return selected rtcdevice
64 * This function returns the rtc device to use for wakealarms.
65 * If one has not already been chosen, it checks to see if a
66 * functional rtc device is available.
68 struct rtc_device *alarmtimer_get_rtcdev(void)
71 struct rtc_device *ret;
73 spin_lock_irqsave(&rtcdev_lock, flags);
75 spin_unlock_irqrestore(&rtcdev_lock, flags);
79 EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev);
81 static int alarmtimer_rtc_add_device(struct device *dev,
82 struct class_interface *class_intf)
85 struct rtc_device *rtc = to_rtc_device(dev);
90 if (!rtc->ops->set_alarm)
92 if (!device_may_wakeup(rtc->dev.parent))
95 spin_lock_irqsave(&rtcdev_lock, flags);
98 /* hold a reference so it doesn't go away */
101 spin_unlock_irqrestore(&rtcdev_lock, flags);
105 static inline void alarmtimer_rtc_timer_init(void)
107 rtc_timer_init(&rtctimer, NULL, NULL);
110 static struct class_interface alarmtimer_rtc_interface = {
111 .add_dev = &alarmtimer_rtc_add_device,
114 static int alarmtimer_rtc_interface_setup(void)
116 alarmtimer_rtc_interface.class = rtc_class;
117 return class_interface_register(&alarmtimer_rtc_interface);
119 static void alarmtimer_rtc_interface_remove(void)
121 class_interface_unregister(&alarmtimer_rtc_interface);
124 struct rtc_device *alarmtimer_get_rtcdev(void)
128 #define rtcdev (NULL)
129 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
130 static inline void alarmtimer_rtc_interface_remove(void) { }
131 static inline void alarmtimer_rtc_timer_init(void) { }
135 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
136 * @base: pointer to the base where the timer is being run
137 * @alarm: pointer to alarm being enqueued.
139 * Adds alarm to a alarm_base timerqueue
141 * Must hold base->lock when calling.
143 static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
145 if (alarm->state & ALARMTIMER_STATE_ENQUEUED)
146 timerqueue_del(&base->timerqueue, &alarm->node);
148 timerqueue_add(&base->timerqueue, &alarm->node);
149 alarm->state |= ALARMTIMER_STATE_ENQUEUED;
153 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
154 * @base: pointer to the base where the timer is running
155 * @alarm: pointer to alarm being removed
157 * Removes alarm to a alarm_base timerqueue
159 * Must hold base->lock when calling.
161 static void alarmtimer_dequeue(struct alarm_base *base, struct alarm *alarm)
163 if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
166 timerqueue_del(&base->timerqueue, &alarm->node);
167 alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
172 * alarmtimer_fired - Handles alarm hrtimer being fired.
173 * @timer: pointer to hrtimer being run
175 * When a alarm timer fires, this runs through the timerqueue to
176 * see which alarms expired, and runs those. If there are more alarm
177 * timers queued for the future, we set the hrtimer to fire when
178 * when the next future alarm timer expires.
180 static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
182 struct alarm *alarm = container_of(timer, struct alarm, timer);
183 struct alarm_base *base = &alarm_bases[alarm->type];
185 int ret = HRTIMER_NORESTART;
186 int restart = ALARMTIMER_NORESTART;
188 spin_lock_irqsave(&base->lock, flags);
189 alarmtimer_dequeue(base, alarm);
190 spin_unlock_irqrestore(&base->lock, flags);
193 restart = alarm->function(alarm, base->gettime());
195 spin_lock_irqsave(&base->lock, flags);
196 if (restart != ALARMTIMER_NORESTART) {
197 hrtimer_set_expires(&alarm->timer, alarm->node.expires);
198 alarmtimer_enqueue(base, alarm);
199 ret = HRTIMER_RESTART;
201 spin_unlock_irqrestore(&base->lock, flags);
203 trace_alarmtimer_fired(alarm, base->gettime());
208 ktime_t alarm_expires_remaining(const struct alarm *alarm)
210 struct alarm_base *base = &alarm_bases[alarm->type];
211 return ktime_sub(alarm->node.expires, base->gettime());
213 EXPORT_SYMBOL_GPL(alarm_expires_remaining);
215 #ifdef CONFIG_RTC_CLASS
217 * alarmtimer_suspend - Suspend time callback
221 * When we are going into suspend, we look through the bases
222 * to see which is the soonest timer to expire. We then
223 * set an rtc timer to fire that far into the future, which
224 * will wake us from suspend.
226 static int alarmtimer_suspend(struct device *dev)
228 ktime_t min, now, expires;
230 struct rtc_device *rtc;
234 spin_lock_irqsave(&freezer_delta_lock, flags);
236 expires = freezer_expires;
237 type = freezer_alarmtype;
239 spin_unlock_irqrestore(&freezer_delta_lock, flags);
241 rtc = alarmtimer_get_rtcdev();
242 /* If we have no rtcdev, just return */
246 /* Find the soonest timer to expire*/
247 for (i = 0; i < ALARM_NUMTYPE; i++) {
248 struct alarm_base *base = &alarm_bases[i];
249 struct timerqueue_node *next;
252 spin_lock_irqsave(&base->lock, flags);
253 next = timerqueue_getnext(&base->timerqueue);
254 spin_unlock_irqrestore(&base->lock, flags);
257 delta = ktime_sub(next->expires, base->gettime());
258 if (!min || (delta < min)) {
259 expires = next->expires;
267 if (ktime_to_ns(min) < 2 * NSEC_PER_SEC) {
268 __pm_wakeup_event(ws, 2 * MSEC_PER_SEC);
272 trace_alarmtimer_suspend(expires, type);
274 /* Setup an rtc timer to fire that far in the future */
275 rtc_timer_cancel(rtc, &rtctimer);
276 rtc_read_time(rtc, &tm);
277 now = rtc_tm_to_ktime(tm);
278 now = ktime_add(now, min);
280 /* Set alarm, if in the past reject suspend briefly to handle */
281 ret = rtc_timer_start(rtc, &rtctimer, now, 0);
283 __pm_wakeup_event(ws, MSEC_PER_SEC);
287 static int alarmtimer_resume(struct device *dev)
289 struct rtc_device *rtc;
291 rtc = alarmtimer_get_rtcdev();
293 rtc_timer_cancel(rtc, &rtctimer);
298 static int alarmtimer_suspend(struct device *dev)
303 static int alarmtimer_resume(struct device *dev)
309 static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
311 struct alarm_base *base;
317 base = &alarm_bases[ALARM_REALTIME];
318 type = ALARM_REALTIME_FREEZER;
321 base = &alarm_bases[ALARM_BOOTTIME];
322 type = ALARM_BOOTTIME_FREEZER;
325 WARN_ONCE(1, "Invalid alarm type: %d\n", type);
329 delta = ktime_sub(absexp, base->gettime());
331 spin_lock_irqsave(&freezer_delta_lock, flags);
332 if (!freezer_delta || (delta < freezer_delta)) {
333 freezer_delta = delta;
334 freezer_expires = absexp;
335 freezer_alarmtype = type;
337 spin_unlock_irqrestore(&freezer_delta_lock, flags);
342 * alarm_init - Initialize an alarm structure
343 * @alarm: ptr to alarm to be initialized
344 * @type: the type of the alarm
345 * @function: callback that is run when the alarm fires
347 void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
348 enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
350 timerqueue_init(&alarm->node);
351 hrtimer_init(&alarm->timer, alarm_bases[type].base_clockid,
353 alarm->timer.function = alarmtimer_fired;
354 alarm->function = function;
356 alarm->state = ALARMTIMER_STATE_INACTIVE;
358 EXPORT_SYMBOL_GPL(alarm_init);
361 * alarm_start - Sets an absolute alarm to fire
362 * @alarm: ptr to alarm to set
363 * @start: time to run the alarm
365 void alarm_start(struct alarm *alarm, ktime_t start)
367 struct alarm_base *base = &alarm_bases[alarm->type];
370 spin_lock_irqsave(&base->lock, flags);
371 alarm->node.expires = start;
372 alarmtimer_enqueue(base, alarm);
373 hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
374 spin_unlock_irqrestore(&base->lock, flags);
376 trace_alarmtimer_start(alarm, base->gettime());
378 EXPORT_SYMBOL_GPL(alarm_start);
381 * alarm_start_relative - Sets a relative alarm to fire
382 * @alarm: ptr to alarm to set
383 * @start: time relative to now to run the alarm
385 void alarm_start_relative(struct alarm *alarm, ktime_t start)
387 struct alarm_base *base = &alarm_bases[alarm->type];
389 start = ktime_add(start, base->gettime());
390 alarm_start(alarm, start);
392 EXPORT_SYMBOL_GPL(alarm_start_relative);
394 void alarm_restart(struct alarm *alarm)
396 struct alarm_base *base = &alarm_bases[alarm->type];
399 spin_lock_irqsave(&base->lock, flags);
400 hrtimer_set_expires(&alarm->timer, alarm->node.expires);
401 hrtimer_restart(&alarm->timer);
402 alarmtimer_enqueue(base, alarm);
403 spin_unlock_irqrestore(&base->lock, flags);
405 EXPORT_SYMBOL_GPL(alarm_restart);
408 * alarm_try_to_cancel - Tries to cancel an alarm timer
409 * @alarm: ptr to alarm to be canceled
411 * Returns 1 if the timer was canceled, 0 if it was not running,
412 * and -1 if the callback was running
414 int alarm_try_to_cancel(struct alarm *alarm)
416 struct alarm_base *base = &alarm_bases[alarm->type];
420 spin_lock_irqsave(&base->lock, flags);
421 ret = hrtimer_try_to_cancel(&alarm->timer);
423 alarmtimer_dequeue(base, alarm);
424 spin_unlock_irqrestore(&base->lock, flags);
426 trace_alarmtimer_cancel(alarm, base->gettime());
429 EXPORT_SYMBOL_GPL(alarm_try_to_cancel);
433 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
434 * @alarm: ptr to alarm to be canceled
436 * Returns 1 if the timer was canceled, 0 if it was not active.
438 int alarm_cancel(struct alarm *alarm)
441 int ret = alarm_try_to_cancel(alarm);
447 EXPORT_SYMBOL_GPL(alarm_cancel);
450 u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
455 delta = ktime_sub(now, alarm->node.expires);
460 if (unlikely(delta >= interval)) {
461 s64 incr = ktime_to_ns(interval);
463 overrun = ktime_divns(delta, incr);
465 alarm->node.expires = ktime_add_ns(alarm->node.expires,
468 if (alarm->node.expires > now)
471 * This (and the ktime_add() below) is the
472 * correction for exact:
477 alarm->node.expires = ktime_add(alarm->node.expires, interval);
480 EXPORT_SYMBOL_GPL(alarm_forward);
482 u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
484 struct alarm_base *base = &alarm_bases[alarm->type];
486 return alarm_forward(alarm, base->gettime(), interval);
488 EXPORT_SYMBOL_GPL(alarm_forward_now);
492 * clock2alarm - helper that converts from clockid to alarmtypes
495 static enum alarmtimer_type clock2alarm(clockid_t clockid)
497 if (clockid == CLOCK_REALTIME_ALARM)
498 return ALARM_REALTIME;
499 if (clockid == CLOCK_BOOTTIME_ALARM)
500 return ALARM_BOOTTIME;
505 * alarm_handle_timer - Callback for posix timers
506 * @alarm: alarm that fired
508 * Posix timer callback for expired alarm timers.
510 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
514 struct k_itimer *ptr = container_of(alarm, struct k_itimer,
515 it.alarm.alarmtimer);
516 enum alarmtimer_restart result = ALARMTIMER_NORESTART;
518 spin_lock_irqsave(&ptr->it_lock, flags);
519 if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
520 if (IS_ENABLED(CONFIG_POSIX_TIMERS) &&
521 posix_timer_event(ptr, 0) != 0)
525 /* Re-add periodic timers */
526 if (ptr->it.alarm.interval) {
527 ptr->it_overrun += alarm_forward(alarm, now,
528 ptr->it.alarm.interval);
529 result = ALARMTIMER_RESTART;
531 spin_unlock_irqrestore(&ptr->it_lock, flags);
537 * alarm_clock_getres - posix getres interface
538 * @which_clock: clockid
539 * @tp: timespec to fill
541 * Returns the granularity of underlying alarm base clock
543 static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
545 if (!alarmtimer_get_rtcdev())
549 tp->tv_nsec = hrtimer_resolution;
554 * alarm_clock_get - posix clock_get interface
555 * @which_clock: clockid
556 * @tp: timespec to fill.
558 * Provides the underlying alarm base time.
560 static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
562 struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
564 if (!alarmtimer_get_rtcdev())
567 *tp = ktime_to_timespec(base->gettime());
572 * alarm_timer_create - posix timer_create interface
573 * @new_timer: k_itimer pointer to manage
575 * Initializes the k_itimer structure.
577 static int alarm_timer_create(struct k_itimer *new_timer)
579 enum alarmtimer_type type;
581 if (!alarmtimer_get_rtcdev())
584 if (!capable(CAP_WAKE_ALARM))
587 type = clock2alarm(new_timer->it_clock);
588 alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
593 * alarm_timer_get - posix timer_get interface
594 * @new_timer: k_itimer pointer
595 * @cur_setting: itimerspec data to fill
597 * Copies out the current itimerspec data
599 static void alarm_timer_get(struct k_itimer *timr,
600 struct itimerspec *cur_setting)
602 ktime_t relative_expiry_time =
603 alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
605 if (ktime_to_ns(relative_expiry_time) > 0) {
606 cur_setting->it_value = ktime_to_timespec(relative_expiry_time);
608 cur_setting->it_value.tv_sec = 0;
609 cur_setting->it_value.tv_nsec = 0;
612 cur_setting->it_interval = ktime_to_timespec(timr->it.alarm.interval);
616 * alarm_timer_del - posix timer_del interface
617 * @timr: k_itimer pointer to be deleted
619 * Cancels any programmed alarms for the given timer.
621 static int alarm_timer_del(struct k_itimer *timr)
626 if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
633 * alarm_timer_set - posix timer_set interface
634 * @timr: k_itimer pointer to be deleted
635 * @flags: timer flags
636 * @new_setting: itimerspec to be used
637 * @old_setting: itimerspec being replaced
639 * Sets the timer to new_setting, and starts the timer.
641 static int alarm_timer_set(struct k_itimer *timr, int flags,
642 struct itimerspec *new_setting,
643 struct itimerspec *old_setting)
650 if (flags & ~TIMER_ABSTIME)
654 alarm_timer_get(timr, old_setting);
656 /* If the timer was already set, cancel it */
657 if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
660 /* start the timer */
661 timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
662 exp = timespec_to_ktime(new_setting->it_value);
663 /* Convert (if necessary) to absolute time */
664 if (flags != TIMER_ABSTIME) {
667 now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
668 exp = ktime_add(now, exp);
671 alarm_start(&timr->it.alarm.alarmtimer, exp);
676 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
677 * @alarm: ptr to alarm that fired
679 * Wakes up the task that set the alarmtimer
681 static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
684 struct task_struct *task = (struct task_struct *)alarm->data;
688 wake_up_process(task);
689 return ALARMTIMER_NORESTART;
693 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
694 * @alarm: ptr to alarmtimer
695 * @absexp: absolute expiration time
697 * Sets the alarm timer and sleeps until it is fired or interrupted.
699 static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
701 alarm->data = (void *)current;
703 set_current_state(TASK_INTERRUPTIBLE);
704 alarm_start(alarm, absexp);
705 if (likely(alarm->data))
709 } while (alarm->data && !signal_pending(current));
711 __set_current_state(TASK_RUNNING);
713 return (alarm->data == NULL);
718 * update_rmtp - Update remaining timespec value
719 * @exp: expiration time
721 * @rmtp: user pointer to remaining timepsec value
723 * Helper function that fills in rmtp value with time between
724 * now and the exp value
726 static int update_rmtp(ktime_t exp, enum alarmtimer_type type,
727 struct timespec __user *rmtp)
732 rem = ktime_sub(exp, alarm_bases[type].gettime());
736 rmt = ktime_to_timespec(rem);
738 if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
746 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
747 * @restart: ptr to restart block
749 * Handles restarted clock_nanosleep calls
751 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
753 enum alarmtimer_type type = restart->nanosleep.clockid;
755 struct timespec __user *rmtp;
759 exp = restart->nanosleep.expires;
760 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
762 if (alarmtimer_do_nsleep(&alarm, exp))
765 if (freezing(current))
766 alarmtimer_freezerset(exp, type);
768 rmtp = restart->nanosleep.rmtp;
770 ret = update_rmtp(exp, type, rmtp);
776 /* The other values in restart are already filled in */
777 ret = -ERESTART_RESTARTBLOCK;
783 * alarm_timer_nsleep - alarmtimer nanosleep
784 * @which_clock: clockid
785 * @flags: determins abstime or relative
786 * @tsreq: requested sleep time (abs or rel)
787 * @rmtp: remaining sleep time saved
789 * Handles clock_nanosleep calls against _ALARM clockids
791 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
792 struct timespec *tsreq, struct timespec __user *rmtp)
794 enum alarmtimer_type type = clock2alarm(which_clock);
798 struct restart_block *restart;
800 if (!alarmtimer_get_rtcdev())
803 if (flags & ~TIMER_ABSTIME)
806 if (!capable(CAP_WAKE_ALARM))
809 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
811 exp = timespec_to_ktime(*tsreq);
812 /* Convert (if necessary) to absolute time */
813 if (flags != TIMER_ABSTIME) {
814 ktime_t now = alarm_bases[type].gettime();
815 exp = ktime_add(now, exp);
818 if (alarmtimer_do_nsleep(&alarm, exp))
821 if (freezing(current))
822 alarmtimer_freezerset(exp, type);
824 /* abs timers don't set remaining time or restart */
825 if (flags == TIMER_ABSTIME) {
826 ret = -ERESTARTNOHAND;
831 ret = update_rmtp(exp, type, rmtp);
836 restart = ¤t->restart_block;
837 restart->fn = alarm_timer_nsleep_restart;
838 restart->nanosleep.clockid = type;
839 restart->nanosleep.expires = exp;
840 restart->nanosleep.rmtp = rmtp;
841 ret = -ERESTART_RESTARTBLOCK;
848 /* Suspend hook structures */
849 static const struct dev_pm_ops alarmtimer_pm_ops = {
850 .suspend = alarmtimer_suspend,
851 .resume = alarmtimer_resume,
854 static struct platform_driver alarmtimer_driver = {
856 .name = "alarmtimer",
857 .pm = &alarmtimer_pm_ops,
862 * alarmtimer_init - Initialize alarm timer code
864 * This function initializes the alarm bases and registers
865 * the posix clock ids.
867 static int __init alarmtimer_init(void)
869 struct platform_device *pdev;
872 struct k_clock alarm_clock = {
873 .clock_getres = alarm_clock_getres,
874 .clock_get = alarm_clock_get,
875 .timer_create = alarm_timer_create,
876 .timer_set = alarm_timer_set,
877 .timer_del = alarm_timer_del,
878 .timer_get = alarm_timer_get,
879 .nsleep = alarm_timer_nsleep,
882 alarmtimer_rtc_timer_init();
884 if (IS_ENABLED(CONFIG_POSIX_TIMERS)) {
885 posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
886 posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
889 /* Initialize alarm bases */
890 alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
891 alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
892 alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
893 alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
894 for (i = 0; i < ALARM_NUMTYPE; i++) {
895 timerqueue_init_head(&alarm_bases[i].timerqueue);
896 spin_lock_init(&alarm_bases[i].lock);
899 error = alarmtimer_rtc_interface_setup();
903 error = platform_driver_register(&alarmtimer_driver);
907 pdev = platform_device_register_simple("alarmtimer", -1, NULL, 0);
909 error = PTR_ERR(pdev);
912 ws = wakeup_source_register("alarmtimer");
916 platform_driver_unregister(&alarmtimer_driver);
918 alarmtimer_rtc_interface_remove();
921 device_initcall(alarmtimer_init);