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>
29 #define CREATE_TRACE_POINTS
30 #include <trace/events/alarmtimer.h>
33 * struct alarm_base - Alarm timer bases
34 * @lock: Lock for syncrhonized access to the base
35 * @timerqueue: Timerqueue head managing the list of events
36 * @gettime: Function to read the time correlating to the base
37 * @base_clockid: clockid for the base
39 static struct alarm_base
{
41 struct timerqueue_head timerqueue
;
42 ktime_t (*gettime
)(void);
43 clockid_t base_clockid
;
44 } alarm_bases
[ALARM_NUMTYPE
];
46 /* freezer information to handle clock_nanosleep triggered wakeups */
47 static enum alarmtimer_type freezer_alarmtype
;
48 static ktime_t freezer_expires
;
49 static ktime_t freezer_delta
;
50 static DEFINE_SPINLOCK(freezer_delta_lock
);
52 static struct wakeup_source
*ws
;
54 #ifdef CONFIG_RTC_CLASS
55 /* rtc timer and device for setting alarm wakeups at suspend */
56 static struct rtc_timer rtctimer
;
57 static struct rtc_device
*rtcdev
;
58 static DEFINE_SPINLOCK(rtcdev_lock
);
61 * alarmtimer_get_rtcdev - Return selected rtcdevice
63 * This function returns the rtc device to use for wakealarms.
64 * If one has not already been chosen, it checks to see if a
65 * functional rtc device is available.
67 struct rtc_device
*alarmtimer_get_rtcdev(void)
70 struct rtc_device
*ret
;
72 spin_lock_irqsave(&rtcdev_lock
, flags
);
74 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
78 EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev
);
80 static int alarmtimer_rtc_add_device(struct device
*dev
,
81 struct class_interface
*class_intf
)
84 struct rtc_device
*rtc
= to_rtc_device(dev
);
89 if (!rtc
->ops
->set_alarm
)
91 if (!device_may_wakeup(rtc
->dev
.parent
))
94 spin_lock_irqsave(&rtcdev_lock
, flags
);
97 /* hold a reference so it doesn't go away */
100 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
104 static inline void alarmtimer_rtc_timer_init(void)
106 rtc_timer_init(&rtctimer
, NULL
, NULL
);
109 static struct class_interface alarmtimer_rtc_interface
= {
110 .add_dev
= &alarmtimer_rtc_add_device
,
113 static int alarmtimer_rtc_interface_setup(void)
115 alarmtimer_rtc_interface
.class = rtc_class
;
116 return class_interface_register(&alarmtimer_rtc_interface
);
118 static void alarmtimer_rtc_interface_remove(void)
120 class_interface_unregister(&alarmtimer_rtc_interface
);
123 struct rtc_device
*alarmtimer_get_rtcdev(void)
127 #define rtcdev (NULL)
128 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
129 static inline void alarmtimer_rtc_interface_remove(void) { }
130 static inline void alarmtimer_rtc_timer_init(void) { }
134 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
135 * @base: pointer to the base where the timer is being run
136 * @alarm: pointer to alarm being enqueued.
138 * Adds alarm to a alarm_base timerqueue
140 * Must hold base->lock when calling.
142 static void alarmtimer_enqueue(struct alarm_base
*base
, struct alarm
*alarm
)
144 if (alarm
->state
& ALARMTIMER_STATE_ENQUEUED
)
145 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
147 timerqueue_add(&base
->timerqueue
, &alarm
->node
);
148 alarm
->state
|= ALARMTIMER_STATE_ENQUEUED
;
152 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
153 * @base: pointer to the base where the timer is running
154 * @alarm: pointer to alarm being removed
156 * Removes alarm to a alarm_base timerqueue
158 * Must hold base->lock when calling.
160 static void alarmtimer_dequeue(struct alarm_base
*base
, struct alarm
*alarm
)
162 if (!(alarm
->state
& ALARMTIMER_STATE_ENQUEUED
))
165 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
166 alarm
->state
&= ~ALARMTIMER_STATE_ENQUEUED
;
171 * alarmtimer_fired - Handles alarm hrtimer being fired.
172 * @timer: pointer to hrtimer being run
174 * When a alarm timer fires, this runs through the timerqueue to
175 * see which alarms expired, and runs those. If there are more alarm
176 * timers queued for the future, we set the hrtimer to fire when
177 * when the next future alarm timer expires.
179 static enum hrtimer_restart
alarmtimer_fired(struct hrtimer
*timer
)
181 struct alarm
*alarm
= container_of(timer
, struct alarm
, timer
);
182 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
184 int ret
= HRTIMER_NORESTART
;
185 int restart
= ALARMTIMER_NORESTART
;
187 spin_lock_irqsave(&base
->lock
, flags
);
188 alarmtimer_dequeue(base
, alarm
);
189 spin_unlock_irqrestore(&base
->lock
, flags
);
192 restart
= alarm
->function(alarm
, base
->gettime());
194 spin_lock_irqsave(&base
->lock
, flags
);
195 if (restart
!= ALARMTIMER_NORESTART
) {
196 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
197 alarmtimer_enqueue(base
, alarm
);
198 ret
= HRTIMER_RESTART
;
200 spin_unlock_irqrestore(&base
->lock
, flags
);
202 trace_alarmtimer_fired(alarm
, base
->gettime());
207 ktime_t
alarm_expires_remaining(const struct alarm
*alarm
)
209 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
210 return ktime_sub(alarm
->node
.expires
, base
->gettime());
212 EXPORT_SYMBOL_GPL(alarm_expires_remaining
);
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
)
227 ktime_t min
, now
, expires
;
229 struct rtc_device
*rtc
;
233 spin_lock_irqsave(&freezer_delta_lock
, flags
);
235 expires
= freezer_expires
;
236 type
= freezer_alarmtype
;
237 freezer_delta
= ktime_set(0, 0);
238 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
240 rtc
= alarmtimer_get_rtcdev();
241 /* If we have no rtcdev, just return */
245 /* Find the soonest timer to expire*/
246 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
247 struct alarm_base
*base
= &alarm_bases
[i
];
248 struct timerqueue_node
*next
;
251 spin_lock_irqsave(&base
->lock
, flags
);
252 next
= timerqueue_getnext(&base
->timerqueue
);
253 spin_unlock_irqrestore(&base
->lock
, flags
);
256 delta
= ktime_sub(next
->expires
, base
->gettime());
257 if (!min
.tv64
|| (delta
.tv64
< min
.tv64
)) {
258 expires
= next
->expires
;
266 if (ktime_to_ns(min
) < 2 * NSEC_PER_SEC
) {
267 __pm_wakeup_event(ws
, 2 * MSEC_PER_SEC
);
271 trace_alarmtimer_suspend(expires
, type
);
273 /* Setup an rtc timer to fire that far in the future */
274 rtc_timer_cancel(rtc
, &rtctimer
);
275 rtc_read_time(rtc
, &tm
);
276 now
= rtc_tm_to_ktime(tm
);
277 now
= ktime_add(now
, min
);
279 /* Set alarm, if in the past reject suspend briefly to handle */
280 ret
= rtc_timer_start(rtc
, &rtctimer
, now
, ktime_set(0, 0));
282 __pm_wakeup_event(ws
, MSEC_PER_SEC
);
286 static int alarmtimer_resume(struct device
*dev
)
288 struct rtc_device
*rtc
;
290 rtc
= alarmtimer_get_rtcdev();
292 rtc_timer_cancel(rtc
, &rtctimer
);
297 static int alarmtimer_suspend(struct device
*dev
)
302 static int alarmtimer_resume(struct device
*dev
)
308 static void alarmtimer_freezerset(ktime_t absexp
, enum alarmtimer_type type
)
310 struct alarm_base
*base
;
316 base
= &alarm_bases
[ALARM_REALTIME
];
317 type
= ALARM_REALTIME_FREEZER
;
320 base
= &alarm_bases
[ALARM_BOOTTIME
];
321 type
= ALARM_BOOTTIME_FREEZER
;
324 WARN_ONCE(1, "Invalid alarm type: %d\n", type
);
328 delta
= ktime_sub(absexp
, base
->gettime());
330 spin_lock_irqsave(&freezer_delta_lock
, flags
);
331 if (!freezer_delta
.tv64
|| (delta
.tv64
< freezer_delta
.tv64
)) {
332 freezer_delta
= delta
;
333 freezer_expires
= absexp
;
334 freezer_alarmtype
= type
;
336 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
341 * alarm_init - Initialize an alarm structure
342 * @alarm: ptr to alarm to be initialized
343 * @type: the type of the alarm
344 * @function: callback that is run when the alarm fires
346 void alarm_init(struct alarm
*alarm
, enum alarmtimer_type type
,
347 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
349 timerqueue_init(&alarm
->node
);
350 hrtimer_init(&alarm
->timer
, alarm_bases
[type
].base_clockid
,
352 alarm
->timer
.function
= alarmtimer_fired
;
353 alarm
->function
= function
;
355 alarm
->state
= ALARMTIMER_STATE_INACTIVE
;
357 EXPORT_SYMBOL_GPL(alarm_init
);
360 * alarm_start - Sets an absolute alarm to fire
361 * @alarm: ptr to alarm to set
362 * @start: time to run the alarm
364 void alarm_start(struct alarm
*alarm
, ktime_t start
)
366 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
369 spin_lock_irqsave(&base
->lock
, flags
);
370 alarm
->node
.expires
= start
;
371 alarmtimer_enqueue(base
, alarm
);
372 hrtimer_start(&alarm
->timer
, alarm
->node
.expires
, HRTIMER_MODE_ABS
);
373 spin_unlock_irqrestore(&base
->lock
, flags
);
375 trace_alarmtimer_start(alarm
, base
->gettime());
377 EXPORT_SYMBOL_GPL(alarm_start
);
380 * alarm_start_relative - Sets a relative alarm to fire
381 * @alarm: ptr to alarm to set
382 * @start: time relative to now to run the alarm
384 void alarm_start_relative(struct alarm
*alarm
, ktime_t start
)
386 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
388 start
= ktime_add(start
, base
->gettime());
389 alarm_start(alarm
, start
);
391 EXPORT_SYMBOL_GPL(alarm_start_relative
);
393 void alarm_restart(struct alarm
*alarm
)
395 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
398 spin_lock_irqsave(&base
->lock
, flags
);
399 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
400 hrtimer_restart(&alarm
->timer
);
401 alarmtimer_enqueue(base
, alarm
);
402 spin_unlock_irqrestore(&base
->lock
, flags
);
404 EXPORT_SYMBOL_GPL(alarm_restart
);
407 * alarm_try_to_cancel - Tries to cancel an alarm timer
408 * @alarm: ptr to alarm to be canceled
410 * Returns 1 if the timer was canceled, 0 if it was not running,
411 * and -1 if the callback was running
413 int alarm_try_to_cancel(struct alarm
*alarm
)
415 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
419 spin_lock_irqsave(&base
->lock
, flags
);
420 ret
= hrtimer_try_to_cancel(&alarm
->timer
);
422 alarmtimer_dequeue(base
, alarm
);
423 spin_unlock_irqrestore(&base
->lock
, flags
);
425 trace_alarmtimer_cancel(alarm
, base
->gettime());
428 EXPORT_SYMBOL_GPL(alarm_try_to_cancel
);
432 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
433 * @alarm: ptr to alarm to be canceled
435 * Returns 1 if the timer was canceled, 0 if it was not active.
437 int alarm_cancel(struct alarm
*alarm
)
440 int ret
= alarm_try_to_cancel(alarm
);
446 EXPORT_SYMBOL_GPL(alarm_cancel
);
449 u64
alarm_forward(struct alarm
*alarm
, ktime_t now
, ktime_t interval
)
454 delta
= ktime_sub(now
, alarm
->node
.expires
);
459 if (unlikely(delta
.tv64
>= interval
.tv64
)) {
460 s64 incr
= ktime_to_ns(interval
);
462 overrun
= ktime_divns(delta
, incr
);
464 alarm
->node
.expires
= ktime_add_ns(alarm
->node
.expires
,
467 if (alarm
->node
.expires
.tv64
> now
.tv64
)
470 * This (and the ktime_add() below) is the
471 * correction for exact:
476 alarm
->node
.expires
= ktime_add(alarm
->node
.expires
, interval
);
479 EXPORT_SYMBOL_GPL(alarm_forward
);
481 u64
alarm_forward_now(struct alarm
*alarm
, ktime_t interval
)
483 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
485 return alarm_forward(alarm
, base
->gettime(), interval
);
487 EXPORT_SYMBOL_GPL(alarm_forward_now
);
491 * clock2alarm - helper that converts from clockid to alarmtypes
494 static enum alarmtimer_type
clock2alarm(clockid_t clockid
)
496 if (clockid
== CLOCK_REALTIME_ALARM
)
497 return ALARM_REALTIME
;
498 if (clockid
== CLOCK_BOOTTIME_ALARM
)
499 return ALARM_BOOTTIME
;
504 * alarm_handle_timer - Callback for posix timers
505 * @alarm: alarm that fired
507 * Posix timer callback for expired alarm timers.
509 static enum alarmtimer_restart
alarm_handle_timer(struct alarm
*alarm
,
513 struct k_itimer
*ptr
= container_of(alarm
, struct k_itimer
,
514 it
.alarm
.alarmtimer
);
515 enum alarmtimer_restart result
= ALARMTIMER_NORESTART
;
517 spin_lock_irqsave(&ptr
->it_lock
, flags
);
518 if ((ptr
->it_sigev_notify
& ~SIGEV_THREAD_ID
) != SIGEV_NONE
) {
519 if (posix_timer_event(ptr
, 0) != 0)
523 /* Re-add periodic timers */
524 if (ptr
->it
.alarm
.interval
.tv64
) {
525 ptr
->it_overrun
+= alarm_forward(alarm
, now
,
526 ptr
->it
.alarm
.interval
);
527 result
= ALARMTIMER_RESTART
;
529 spin_unlock_irqrestore(&ptr
->it_lock
, flags
);
535 * alarm_clock_getres - posix getres interface
536 * @which_clock: clockid
537 * @tp: timespec to fill
539 * Returns the granularity of underlying alarm base clock
541 static int alarm_clock_getres(const clockid_t which_clock
, struct timespec
*tp
)
543 if (!alarmtimer_get_rtcdev())
547 tp
->tv_nsec
= hrtimer_resolution
;
552 * alarm_clock_get - posix clock_get interface
553 * @which_clock: clockid
554 * @tp: timespec to fill.
556 * Provides the underlying alarm base time.
558 static int alarm_clock_get(clockid_t which_clock
, struct timespec
*tp
)
560 struct alarm_base
*base
= &alarm_bases
[clock2alarm(which_clock
)];
562 if (!alarmtimer_get_rtcdev())
565 *tp
= ktime_to_timespec(base
->gettime());
570 * alarm_timer_create - posix timer_create interface
571 * @new_timer: k_itimer pointer to manage
573 * Initializes the k_itimer structure.
575 static int alarm_timer_create(struct k_itimer
*new_timer
)
577 enum alarmtimer_type type
;
579 if (!alarmtimer_get_rtcdev())
582 if (!capable(CAP_WAKE_ALARM
))
585 type
= clock2alarm(new_timer
->it_clock
);
586 alarm_init(&new_timer
->it
.alarm
.alarmtimer
, type
, alarm_handle_timer
);
591 * alarm_timer_get - posix timer_get interface
592 * @new_timer: k_itimer pointer
593 * @cur_setting: itimerspec data to fill
595 * Copies out the current itimerspec data
597 static void alarm_timer_get(struct k_itimer
*timr
,
598 struct itimerspec
*cur_setting
)
600 ktime_t relative_expiry_time
=
601 alarm_expires_remaining(&(timr
->it
.alarm
.alarmtimer
));
603 if (ktime_to_ns(relative_expiry_time
) > 0) {
604 cur_setting
->it_value
= ktime_to_timespec(relative_expiry_time
);
606 cur_setting
->it_value
.tv_sec
= 0;
607 cur_setting
->it_value
.tv_nsec
= 0;
610 cur_setting
->it_interval
= ktime_to_timespec(timr
->it
.alarm
.interval
);
614 * alarm_timer_del - posix timer_del interface
615 * @timr: k_itimer pointer to be deleted
617 * Cancels any programmed alarms for the given timer.
619 static int alarm_timer_del(struct k_itimer
*timr
)
624 if (alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
) < 0)
631 * alarm_timer_set - posix timer_set interface
632 * @timr: k_itimer pointer to be deleted
633 * @flags: timer flags
634 * @new_setting: itimerspec to be used
635 * @old_setting: itimerspec being replaced
637 * Sets the timer to new_setting, and starts the timer.
639 static int alarm_timer_set(struct k_itimer
*timr
, int flags
,
640 struct itimerspec
*new_setting
,
641 struct itimerspec
*old_setting
)
648 if (flags
& ~TIMER_ABSTIME
)
652 alarm_timer_get(timr
, old_setting
);
654 /* If the timer was already set, cancel it */
655 if (alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
) < 0)
658 /* start the timer */
659 timr
->it
.alarm
.interval
= timespec_to_ktime(new_setting
->it_interval
);
660 exp
= timespec_to_ktime(new_setting
->it_value
);
661 /* Convert (if necessary) to absolute time */
662 if (flags
!= TIMER_ABSTIME
) {
665 now
= alarm_bases
[timr
->it
.alarm
.alarmtimer
.type
].gettime();
666 exp
= ktime_add(now
, exp
);
669 alarm_start(&timr
->it
.alarm
.alarmtimer
, exp
);
674 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
675 * @alarm: ptr to alarm that fired
677 * Wakes up the task that set the alarmtimer
679 static enum alarmtimer_restart
alarmtimer_nsleep_wakeup(struct alarm
*alarm
,
682 struct task_struct
*task
= (struct task_struct
*)alarm
->data
;
686 wake_up_process(task
);
687 return ALARMTIMER_NORESTART
;
691 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
692 * @alarm: ptr to alarmtimer
693 * @absexp: absolute expiration time
695 * Sets the alarm timer and sleeps until it is fired or interrupted.
697 static int alarmtimer_do_nsleep(struct alarm
*alarm
, ktime_t absexp
)
699 alarm
->data
= (void *)current
;
701 set_current_state(TASK_INTERRUPTIBLE
);
702 alarm_start(alarm
, absexp
);
703 if (likely(alarm
->data
))
707 } while (alarm
->data
&& !signal_pending(current
));
709 __set_current_state(TASK_RUNNING
);
711 return (alarm
->data
== NULL
);
716 * update_rmtp - Update remaining timespec value
717 * @exp: expiration time
719 * @rmtp: user pointer to remaining timepsec value
721 * Helper function that fills in rmtp value with time between
722 * now and the exp value
724 static int update_rmtp(ktime_t exp
, enum alarmtimer_type type
,
725 struct timespec __user
*rmtp
)
730 rem
= ktime_sub(exp
, alarm_bases
[type
].gettime());
734 rmt
= ktime_to_timespec(rem
);
736 if (copy_to_user(rmtp
, &rmt
, sizeof(*rmtp
)))
744 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
745 * @restart: ptr to restart block
747 * Handles restarted clock_nanosleep calls
749 static long __sched
alarm_timer_nsleep_restart(struct restart_block
*restart
)
751 enum alarmtimer_type type
= restart
->nanosleep
.clockid
;
753 struct timespec __user
*rmtp
;
757 exp
.tv64
= restart
->nanosleep
.expires
;
758 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
760 if (alarmtimer_do_nsleep(&alarm
, exp
))
763 if (freezing(current
))
764 alarmtimer_freezerset(exp
, type
);
766 rmtp
= restart
->nanosleep
.rmtp
;
768 ret
= update_rmtp(exp
, type
, rmtp
);
774 /* The other values in restart are already filled in */
775 ret
= -ERESTART_RESTARTBLOCK
;
781 * alarm_timer_nsleep - alarmtimer nanosleep
782 * @which_clock: clockid
783 * @flags: determins abstime or relative
784 * @tsreq: requested sleep time (abs or rel)
785 * @rmtp: remaining sleep time saved
787 * Handles clock_nanosleep calls against _ALARM clockids
789 static int alarm_timer_nsleep(const clockid_t which_clock
, int flags
,
790 struct timespec
*tsreq
, struct timespec __user
*rmtp
)
792 enum alarmtimer_type type
= clock2alarm(which_clock
);
796 struct restart_block
*restart
;
798 if (!alarmtimer_get_rtcdev())
801 if (flags
& ~TIMER_ABSTIME
)
804 if (!capable(CAP_WAKE_ALARM
))
807 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
809 exp
= timespec_to_ktime(*tsreq
);
810 /* Convert (if necessary) to absolute time */
811 if (flags
!= TIMER_ABSTIME
) {
812 ktime_t now
= alarm_bases
[type
].gettime();
813 exp
= ktime_add(now
, exp
);
816 if (alarmtimer_do_nsleep(&alarm
, exp
))
819 if (freezing(current
))
820 alarmtimer_freezerset(exp
, type
);
822 /* abs timers don't set remaining time or restart */
823 if (flags
== TIMER_ABSTIME
) {
824 ret
= -ERESTARTNOHAND
;
829 ret
= update_rmtp(exp
, type
, rmtp
);
834 restart
= ¤t
->restart_block
;
835 restart
->fn
= alarm_timer_nsleep_restart
;
836 restart
->nanosleep
.clockid
= type
;
837 restart
->nanosleep
.expires
= exp
.tv64
;
838 restart
->nanosleep
.rmtp
= rmtp
;
839 ret
= -ERESTART_RESTARTBLOCK
;
846 /* Suspend hook structures */
847 static const struct dev_pm_ops alarmtimer_pm_ops
= {
848 .suspend
= alarmtimer_suspend
,
849 .resume
= alarmtimer_resume
,
852 static struct platform_driver alarmtimer_driver
= {
854 .name
= "alarmtimer",
855 .pm
= &alarmtimer_pm_ops
,
860 * alarmtimer_init - Initialize alarm timer code
862 * This function initializes the alarm bases and registers
863 * the posix clock ids.
865 static int __init
alarmtimer_init(void)
867 struct platform_device
*pdev
;
870 struct k_clock alarm_clock
= {
871 .clock_getres
= alarm_clock_getres
,
872 .clock_get
= alarm_clock_get
,
873 .timer_create
= alarm_timer_create
,
874 .timer_set
= alarm_timer_set
,
875 .timer_del
= alarm_timer_del
,
876 .timer_get
= alarm_timer_get
,
877 .nsleep
= alarm_timer_nsleep
,
880 alarmtimer_rtc_timer_init();
882 if (IS_ENABLED(CONFIG_POSIX_TIMERS
)) {
883 posix_timers_register_clock(CLOCK_REALTIME_ALARM
, &alarm_clock
);
884 posix_timers_register_clock(CLOCK_BOOTTIME_ALARM
, &alarm_clock
);
887 /* Initialize alarm bases */
888 alarm_bases
[ALARM_REALTIME
].base_clockid
= CLOCK_REALTIME
;
889 alarm_bases
[ALARM_REALTIME
].gettime
= &ktime_get_real
;
890 alarm_bases
[ALARM_BOOTTIME
].base_clockid
= CLOCK_BOOTTIME
;
891 alarm_bases
[ALARM_BOOTTIME
].gettime
= &ktime_get_boottime
;
892 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
893 timerqueue_init_head(&alarm_bases
[i
].timerqueue
);
894 spin_lock_init(&alarm_bases
[i
].lock
);
897 error
= alarmtimer_rtc_interface_setup();
901 error
= platform_driver_register(&alarmtimer_driver
);
905 pdev
= platform_device_register_simple("alarmtimer", -1, NULL
, 0);
907 error
= PTR_ERR(pdev
);
910 ws
= wakeup_source_register("alarmtimer");
914 platform_driver_unregister(&alarmtimer_driver
);
916 alarmtimer_rtc_interface_remove();
919 device_initcall(alarmtimer_init
);