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/sched/debug.h>
24 #include <linux/alarmtimer.h>
25 #include <linux/mutex.h>
26 #include <linux/platform_device.h>
27 #include <linux/posix-timers.h>
28 #include <linux/workqueue.h>
29 #include <linux/freezer.h>
31 #include "posix-timers.h"
33 #define CREATE_TRACE_POINTS
34 #include <trace/events/alarmtimer.h>
37 * struct alarm_base - Alarm timer bases
38 * @lock: Lock for syncrhonized access to the base
39 * @timerqueue: Timerqueue head managing the list of events
40 * @gettime: Function to read the time correlating to the base
41 * @base_clockid: clockid for the base
43 static struct alarm_base
{
45 struct timerqueue_head timerqueue
;
46 ktime_t (*gettime
)(void);
47 clockid_t base_clockid
;
48 } alarm_bases
[ALARM_NUMTYPE
];
50 #if defined(CONFIG_POSIX_TIMERS) || defined(CONFIG_RTC_CLASS)
51 /* freezer information to handle clock_nanosleep triggered wakeups */
52 static enum alarmtimer_type freezer_alarmtype
;
53 static ktime_t freezer_expires
;
54 static ktime_t freezer_delta
;
55 static DEFINE_SPINLOCK(freezer_delta_lock
);
58 static struct wakeup_source
*ws
;
60 #ifdef CONFIG_RTC_CLASS
61 /* rtc timer and device for setting alarm wakeups at suspend */
62 static struct rtc_timer rtctimer
;
63 static struct rtc_device
*rtcdev
;
64 static DEFINE_SPINLOCK(rtcdev_lock
);
67 * alarmtimer_get_rtcdev - Return selected rtcdevice
69 * This function returns the rtc device to use for wakealarms.
70 * If one has not already been chosen, it checks to see if a
71 * functional rtc device is available.
73 struct rtc_device
*alarmtimer_get_rtcdev(void)
76 struct rtc_device
*ret
;
78 spin_lock_irqsave(&rtcdev_lock
, flags
);
80 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
84 EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev
);
86 static int alarmtimer_rtc_add_device(struct device
*dev
,
87 struct class_interface
*class_intf
)
90 struct rtc_device
*rtc
= to_rtc_device(dev
);
95 if (!rtc
->ops
->set_alarm
)
97 if (!device_may_wakeup(rtc
->dev
.parent
))
100 spin_lock_irqsave(&rtcdev_lock
, flags
);
103 /* hold a reference so it doesn't go away */
106 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
110 static inline void alarmtimer_rtc_timer_init(void)
112 rtc_timer_init(&rtctimer
, NULL
, NULL
);
115 static struct class_interface alarmtimer_rtc_interface
= {
116 .add_dev
= &alarmtimer_rtc_add_device
,
119 static int alarmtimer_rtc_interface_setup(void)
121 alarmtimer_rtc_interface
.class = rtc_class
;
122 return class_interface_register(&alarmtimer_rtc_interface
);
124 static void alarmtimer_rtc_interface_remove(void)
126 class_interface_unregister(&alarmtimer_rtc_interface
);
129 struct rtc_device
*alarmtimer_get_rtcdev(void)
133 #define rtcdev (NULL)
134 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
135 static inline void alarmtimer_rtc_interface_remove(void) { }
136 static inline void alarmtimer_rtc_timer_init(void) { }
140 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
141 * @base: pointer to the base where the timer is being run
142 * @alarm: pointer to alarm being enqueued.
144 * Adds alarm to a alarm_base timerqueue
146 * Must hold base->lock when calling.
148 static void alarmtimer_enqueue(struct alarm_base
*base
, struct alarm
*alarm
)
150 if (alarm
->state
& ALARMTIMER_STATE_ENQUEUED
)
151 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
153 timerqueue_add(&base
->timerqueue
, &alarm
->node
);
154 alarm
->state
|= ALARMTIMER_STATE_ENQUEUED
;
158 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
159 * @base: pointer to the base where the timer is running
160 * @alarm: pointer to alarm being removed
162 * Removes alarm to a alarm_base timerqueue
164 * Must hold base->lock when calling.
166 static void alarmtimer_dequeue(struct alarm_base
*base
, struct alarm
*alarm
)
168 if (!(alarm
->state
& ALARMTIMER_STATE_ENQUEUED
))
171 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
172 alarm
->state
&= ~ALARMTIMER_STATE_ENQUEUED
;
177 * alarmtimer_fired - Handles alarm hrtimer being fired.
178 * @timer: pointer to hrtimer being run
180 * When a alarm timer fires, this runs through the timerqueue to
181 * see which alarms expired, and runs those. If there are more alarm
182 * timers queued for the future, we set the hrtimer to fire when
183 * when the next future alarm timer expires.
185 static enum hrtimer_restart
alarmtimer_fired(struct hrtimer
*timer
)
187 struct alarm
*alarm
= container_of(timer
, struct alarm
, timer
);
188 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
190 int ret
= HRTIMER_NORESTART
;
191 int restart
= ALARMTIMER_NORESTART
;
193 spin_lock_irqsave(&base
->lock
, flags
);
194 alarmtimer_dequeue(base
, alarm
);
195 spin_unlock_irqrestore(&base
->lock
, flags
);
198 restart
= alarm
->function(alarm
, base
->gettime());
200 spin_lock_irqsave(&base
->lock
, flags
);
201 if (restart
!= ALARMTIMER_NORESTART
) {
202 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
203 alarmtimer_enqueue(base
, alarm
);
204 ret
= HRTIMER_RESTART
;
206 spin_unlock_irqrestore(&base
->lock
, flags
);
208 trace_alarmtimer_fired(alarm
, base
->gettime());
213 ktime_t
alarm_expires_remaining(const struct alarm
*alarm
)
215 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
216 return ktime_sub(alarm
->node
.expires
, base
->gettime());
218 EXPORT_SYMBOL_GPL(alarm_expires_remaining
);
220 #ifdef CONFIG_RTC_CLASS
222 * alarmtimer_suspend - Suspend time callback
226 * When we are going into suspend, we look through the bases
227 * to see which is the soonest timer to expire. We then
228 * set an rtc timer to fire that far into the future, which
229 * will wake us from suspend.
231 static int alarmtimer_suspend(struct device
*dev
)
233 ktime_t min
, now
, expires
;
235 struct rtc_device
*rtc
;
239 spin_lock_irqsave(&freezer_delta_lock
, flags
);
241 expires
= freezer_expires
;
242 type
= freezer_alarmtype
;
244 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
246 rtc
= alarmtimer_get_rtcdev();
247 /* If we have no rtcdev, just return */
251 /* Find the soonest timer to expire*/
252 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
253 struct alarm_base
*base
= &alarm_bases
[i
];
254 struct timerqueue_node
*next
;
257 spin_lock_irqsave(&base
->lock
, flags
);
258 next
= timerqueue_getnext(&base
->timerqueue
);
259 spin_unlock_irqrestore(&base
->lock
, flags
);
262 delta
= ktime_sub(next
->expires
, base
->gettime());
263 if (!min
|| (delta
< min
)) {
264 expires
= next
->expires
;
272 if (ktime_to_ns(min
) < 2 * NSEC_PER_SEC
) {
273 __pm_wakeup_event(ws
, 2 * MSEC_PER_SEC
);
277 trace_alarmtimer_suspend(expires
, type
);
279 /* Setup an rtc timer to fire that far in the future */
280 rtc_timer_cancel(rtc
, &rtctimer
);
281 rtc_read_time(rtc
, &tm
);
282 now
= rtc_tm_to_ktime(tm
);
283 now
= ktime_add(now
, min
);
285 /* Set alarm, if in the past reject suspend briefly to handle */
286 ret
= rtc_timer_start(rtc
, &rtctimer
, now
, 0);
288 __pm_wakeup_event(ws
, MSEC_PER_SEC
);
292 static int alarmtimer_resume(struct device
*dev
)
294 struct rtc_device
*rtc
;
296 rtc
= alarmtimer_get_rtcdev();
298 rtc_timer_cancel(rtc
, &rtctimer
);
303 static int alarmtimer_suspend(struct device
*dev
)
308 static int alarmtimer_resume(struct device
*dev
)
315 * alarm_init - Initialize an alarm structure
316 * @alarm: ptr to alarm to be initialized
317 * @type: the type of the alarm
318 * @function: callback that is run when the alarm fires
320 void alarm_init(struct alarm
*alarm
, enum alarmtimer_type type
,
321 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
323 timerqueue_init(&alarm
->node
);
324 hrtimer_init(&alarm
->timer
, alarm_bases
[type
].base_clockid
,
326 alarm
->timer
.function
= alarmtimer_fired
;
327 alarm
->function
= function
;
329 alarm
->state
= ALARMTIMER_STATE_INACTIVE
;
331 EXPORT_SYMBOL_GPL(alarm_init
);
334 * alarm_start - Sets an absolute alarm to fire
335 * @alarm: ptr to alarm to set
336 * @start: time to run the alarm
338 void alarm_start(struct alarm
*alarm
, ktime_t start
)
340 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
343 spin_lock_irqsave(&base
->lock
, flags
);
344 alarm
->node
.expires
= start
;
345 alarmtimer_enqueue(base
, alarm
);
346 hrtimer_start(&alarm
->timer
, alarm
->node
.expires
, HRTIMER_MODE_ABS
);
347 spin_unlock_irqrestore(&base
->lock
, flags
);
349 trace_alarmtimer_start(alarm
, base
->gettime());
351 EXPORT_SYMBOL_GPL(alarm_start
);
354 * alarm_start_relative - Sets a relative alarm to fire
355 * @alarm: ptr to alarm to set
356 * @start: time relative to now to run the alarm
358 void alarm_start_relative(struct alarm
*alarm
, ktime_t start
)
360 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
362 start
= ktime_add_safe(start
, base
->gettime());
363 alarm_start(alarm
, start
);
365 EXPORT_SYMBOL_GPL(alarm_start_relative
);
367 void alarm_restart(struct alarm
*alarm
)
369 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
372 spin_lock_irqsave(&base
->lock
, flags
);
373 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
374 hrtimer_restart(&alarm
->timer
);
375 alarmtimer_enqueue(base
, alarm
);
376 spin_unlock_irqrestore(&base
->lock
, flags
);
378 EXPORT_SYMBOL_GPL(alarm_restart
);
381 * alarm_try_to_cancel - Tries to cancel an alarm timer
382 * @alarm: ptr to alarm to be canceled
384 * Returns 1 if the timer was canceled, 0 if it was not running,
385 * and -1 if the callback was running
387 int alarm_try_to_cancel(struct alarm
*alarm
)
389 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
393 spin_lock_irqsave(&base
->lock
, flags
);
394 ret
= hrtimer_try_to_cancel(&alarm
->timer
);
396 alarmtimer_dequeue(base
, alarm
);
397 spin_unlock_irqrestore(&base
->lock
, flags
);
399 trace_alarmtimer_cancel(alarm
, base
->gettime());
402 EXPORT_SYMBOL_GPL(alarm_try_to_cancel
);
406 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
407 * @alarm: ptr to alarm to be canceled
409 * Returns 1 if the timer was canceled, 0 if it was not active.
411 int alarm_cancel(struct alarm
*alarm
)
414 int ret
= alarm_try_to_cancel(alarm
);
420 EXPORT_SYMBOL_GPL(alarm_cancel
);
423 u64
alarm_forward(struct alarm
*alarm
, ktime_t now
, ktime_t interval
)
428 delta
= ktime_sub(now
, alarm
->node
.expires
);
433 if (unlikely(delta
>= interval
)) {
434 s64 incr
= ktime_to_ns(interval
);
436 overrun
= ktime_divns(delta
, incr
);
438 alarm
->node
.expires
= ktime_add_ns(alarm
->node
.expires
,
441 if (alarm
->node
.expires
> now
)
444 * This (and the ktime_add() below) is the
445 * correction for exact:
450 alarm
->node
.expires
= ktime_add_safe(alarm
->node
.expires
, interval
);
453 EXPORT_SYMBOL_GPL(alarm_forward
);
455 u64
alarm_forward_now(struct alarm
*alarm
, ktime_t interval
)
457 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
459 return alarm_forward(alarm
, base
->gettime(), interval
);
461 EXPORT_SYMBOL_GPL(alarm_forward_now
);
463 #ifdef CONFIG_POSIX_TIMERS
465 static void alarmtimer_freezerset(ktime_t absexp
, enum alarmtimer_type type
)
467 struct alarm_base
*base
;
473 base
= &alarm_bases
[ALARM_REALTIME
];
474 type
= ALARM_REALTIME_FREEZER
;
477 base
= &alarm_bases
[ALARM_BOOTTIME
];
478 type
= ALARM_BOOTTIME_FREEZER
;
481 WARN_ONCE(1, "Invalid alarm type: %d\n", type
);
485 delta
= ktime_sub(absexp
, base
->gettime());
487 spin_lock_irqsave(&freezer_delta_lock
, flags
);
488 if (!freezer_delta
|| (delta
< freezer_delta
)) {
489 freezer_delta
= delta
;
490 freezer_expires
= absexp
;
491 freezer_alarmtype
= type
;
493 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
497 * clock2alarm - helper that converts from clockid to alarmtypes
500 static enum alarmtimer_type
clock2alarm(clockid_t clockid
)
502 if (clockid
== CLOCK_REALTIME_ALARM
)
503 return ALARM_REALTIME
;
504 if (clockid
== CLOCK_BOOTTIME_ALARM
)
505 return ALARM_BOOTTIME
;
510 * alarm_handle_timer - Callback for posix timers
511 * @alarm: alarm that fired
513 * Posix timer callback for expired alarm timers.
515 static enum alarmtimer_restart
alarm_handle_timer(struct alarm
*alarm
,
518 struct k_itimer
*ptr
= container_of(alarm
, struct k_itimer
,
519 it
.alarm
.alarmtimer
);
520 enum alarmtimer_restart result
= ALARMTIMER_NORESTART
;
524 spin_lock_irqsave(&ptr
->it_lock
, flags
);
527 if (ptr
->it_interval
)
528 si_private
= ++ptr
->it_requeue_pending
;
530 if (posix_timer_event(ptr
, si_private
) && ptr
->it_interval
) {
532 * Handle ignored signals and rearm the timer. This will go
533 * away once we handle ignored signals proper.
535 ptr
->it_overrun
+= alarm_forward_now(alarm
, ptr
->it_interval
);
536 ++ptr
->it_requeue_pending
;
538 result
= ALARMTIMER_RESTART
;
540 spin_unlock_irqrestore(&ptr
->it_lock
, flags
);
546 * alarm_timer_rearm - Posix timer callback for rearming timer
547 * @timr: Pointer to the posixtimer data struct
549 static void alarm_timer_rearm(struct k_itimer
*timr
)
551 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
553 timr
->it_overrun
+= alarm_forward_now(alarm
, timr
->it_interval
);
554 alarm_start(alarm
, alarm
->node
.expires
);
558 * alarm_timer_forward - Posix timer callback for forwarding timer
559 * @timr: Pointer to the posixtimer data struct
560 * @now: Current time to forward the timer against
562 static int alarm_timer_forward(struct k_itimer
*timr
, ktime_t now
)
564 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
566 return (int) alarm_forward(alarm
, timr
->it_interval
, now
);
570 * alarm_timer_remaining - Posix timer callback to retrieve remaining time
571 * @timr: Pointer to the posixtimer data struct
572 * @now: Current time to calculate against
574 static ktime_t
alarm_timer_remaining(struct k_itimer
*timr
, ktime_t now
)
576 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
578 return ktime_sub(now
, alarm
->node
.expires
);
582 * alarm_timer_try_to_cancel - Posix timer callback to cancel a timer
583 * @timr: Pointer to the posixtimer data struct
585 static int alarm_timer_try_to_cancel(struct k_itimer
*timr
)
587 return alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
);
591 * alarm_timer_arm - Posix timer callback to arm a timer
592 * @timr: Pointer to the posixtimer data struct
593 * @expires: The new expiry time
594 * @absolute: Expiry value is absolute time
595 * @sigev_none: Posix timer does not deliver signals
597 static void alarm_timer_arm(struct k_itimer
*timr
, ktime_t expires
,
598 bool absolute
, bool sigev_none
)
600 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
601 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
604 expires
= ktime_add_safe(expires
, base
->gettime());
606 alarm
->node
.expires
= expires
;
608 alarm_start(&timr
->it
.alarm
.alarmtimer
, expires
);
612 * alarm_clock_getres - posix getres interface
613 * @which_clock: clockid
614 * @tp: timespec to fill
616 * Returns the granularity of underlying alarm base clock
618 static int alarm_clock_getres(const clockid_t which_clock
, struct timespec64
*tp
)
620 if (!alarmtimer_get_rtcdev())
624 tp
->tv_nsec
= hrtimer_resolution
;
629 * alarm_clock_get - posix clock_get interface
630 * @which_clock: clockid
631 * @tp: timespec to fill.
633 * Provides the underlying alarm base time.
635 static int alarm_clock_get(clockid_t which_clock
, struct timespec64
*tp
)
637 struct alarm_base
*base
= &alarm_bases
[clock2alarm(which_clock
)];
639 if (!alarmtimer_get_rtcdev())
642 *tp
= ktime_to_timespec64(base
->gettime());
647 * alarm_timer_create - posix timer_create interface
648 * @new_timer: k_itimer pointer to manage
650 * Initializes the k_itimer structure.
652 static int alarm_timer_create(struct k_itimer
*new_timer
)
654 enum alarmtimer_type type
;
656 if (!alarmtimer_get_rtcdev())
659 if (!capable(CAP_WAKE_ALARM
))
662 type
= clock2alarm(new_timer
->it_clock
);
663 alarm_init(&new_timer
->it
.alarm
.alarmtimer
, type
, alarm_handle_timer
);
668 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
669 * @alarm: ptr to alarm that fired
671 * Wakes up the task that set the alarmtimer
673 static enum alarmtimer_restart
alarmtimer_nsleep_wakeup(struct alarm
*alarm
,
676 struct task_struct
*task
= (struct task_struct
*)alarm
->data
;
680 wake_up_process(task
);
681 return ALARMTIMER_NORESTART
;
685 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
686 * @alarm: ptr to alarmtimer
687 * @absexp: absolute expiration time
689 * Sets the alarm timer and sleeps until it is fired or interrupted.
691 static int alarmtimer_do_nsleep(struct alarm
*alarm
, ktime_t absexp
,
692 enum alarmtimer_type type
)
694 struct timespec __user
*rmtp
;
695 alarm
->data
= (void *)current
;
697 set_current_state(TASK_INTERRUPTIBLE
);
698 alarm_start(alarm
, absexp
);
699 if (likely(alarm
->data
))
703 } while (alarm
->data
&& !signal_pending(current
));
705 __set_current_state(TASK_RUNNING
);
710 if (freezing(current
))
711 alarmtimer_freezerset(absexp
, type
);
712 rmtp
= current
->restart_block
.nanosleep
.rmtp
;
717 rem
= ktime_sub(absexp
, alarm_bases
[type
].gettime());
721 rmt
= ktime_to_timespec(rem
);
723 if (copy_to_user(rmtp
, &rmt
, sizeof(*rmtp
)))
726 return -ERESTART_RESTARTBLOCK
;
730 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
731 * @restart: ptr to restart block
733 * Handles restarted clock_nanosleep calls
735 static long __sched
alarm_timer_nsleep_restart(struct restart_block
*restart
)
737 enum alarmtimer_type type
= restart
->nanosleep
.clockid
;
738 ktime_t exp
= restart
->nanosleep
.expires
;
741 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
743 return alarmtimer_do_nsleep(&alarm
, exp
, type
);
747 * alarm_timer_nsleep - alarmtimer nanosleep
748 * @which_clock: clockid
749 * @flags: determins abstime or relative
750 * @tsreq: requested sleep time (abs or rel)
751 * @rmtp: remaining sleep time saved
753 * Handles clock_nanosleep calls against _ALARM clockids
755 static int alarm_timer_nsleep(const clockid_t which_clock
, int flags
,
756 struct timespec64
*tsreq
)
758 enum alarmtimer_type type
= clock2alarm(which_clock
);
759 struct restart_block
*restart
= ¤t
->restart_block
;
764 if (!alarmtimer_get_rtcdev())
767 if (flags
& ~TIMER_ABSTIME
)
770 if (!capable(CAP_WAKE_ALARM
))
773 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
775 exp
= timespec64_to_ktime(*tsreq
);
776 /* Convert (if necessary) to absolute time */
777 if (flags
!= TIMER_ABSTIME
) {
778 ktime_t now
= alarm_bases
[type
].gettime();
779 exp
= ktime_add(now
, exp
);
782 ret
= alarmtimer_do_nsleep(&alarm
, exp
, type
);
783 if (ret
!= -ERESTART_RESTARTBLOCK
)
786 /* abs timers don't set remaining time or restart */
787 if (flags
== TIMER_ABSTIME
)
788 return -ERESTARTNOHAND
;
790 restart
->fn
= alarm_timer_nsleep_restart
;
791 restart
->nanosleep
.clockid
= type
;
792 restart
->nanosleep
.expires
= exp
;
796 const struct k_clock alarm_clock
= {
797 .clock_getres
= alarm_clock_getres
,
798 .clock_get
= alarm_clock_get
,
799 .timer_create
= alarm_timer_create
,
800 .timer_set
= common_timer_set
,
801 .timer_del
= common_timer_del
,
802 .timer_get
= common_timer_get
,
803 .timer_arm
= alarm_timer_arm
,
804 .timer_rearm
= alarm_timer_rearm
,
805 .timer_forward
= alarm_timer_forward
,
806 .timer_remaining
= alarm_timer_remaining
,
807 .timer_try_to_cancel
= alarm_timer_try_to_cancel
,
808 .nsleep
= alarm_timer_nsleep
,
810 #endif /* CONFIG_POSIX_TIMERS */
813 /* Suspend hook structures */
814 static const struct dev_pm_ops alarmtimer_pm_ops
= {
815 .suspend
= alarmtimer_suspend
,
816 .resume
= alarmtimer_resume
,
819 static struct platform_driver alarmtimer_driver
= {
821 .name
= "alarmtimer",
822 .pm
= &alarmtimer_pm_ops
,
827 * alarmtimer_init - Initialize alarm timer code
829 * This function initializes the alarm bases and registers
830 * the posix clock ids.
832 static int __init
alarmtimer_init(void)
834 struct platform_device
*pdev
;
838 alarmtimer_rtc_timer_init();
840 /* Initialize alarm bases */
841 alarm_bases
[ALARM_REALTIME
].base_clockid
= CLOCK_REALTIME
;
842 alarm_bases
[ALARM_REALTIME
].gettime
= &ktime_get_real
;
843 alarm_bases
[ALARM_BOOTTIME
].base_clockid
= CLOCK_BOOTTIME
;
844 alarm_bases
[ALARM_BOOTTIME
].gettime
= &ktime_get_boottime
;
845 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
846 timerqueue_init_head(&alarm_bases
[i
].timerqueue
);
847 spin_lock_init(&alarm_bases
[i
].lock
);
850 error
= alarmtimer_rtc_interface_setup();
854 error
= platform_driver_register(&alarmtimer_driver
);
858 pdev
= platform_device_register_simple("alarmtimer", -1, NULL
, 0);
860 error
= PTR_ERR(pdev
);
863 ws
= wakeup_source_register("alarmtimer");
867 platform_driver_unregister(&alarmtimer_driver
);
869 alarmtimer_rtc_interface_remove();
872 device_initcall(alarmtimer_init
);