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>
28 #include <linux/xlog.h>
29 #include <linux/module.h>
30 #include <mach/mtk_rtc.h>
32 #define XLOG_MYTAG "Power/Alarm"
34 #define ANDROID_ALARM_PRINT_INFO (1U << 0)
35 #define ANDROID_ALARM_PRINT_IO (1U << 1)
36 #define ANDROID_ALARM_PRINT_INT (1U << 2)
38 static int debug_mask
= ANDROID_ALARM_PRINT_INFO
;
39 module_param_named(debug_mask
, debug_mask
, int, S_IRUGO
| S_IWUSR
| S_IWGRP
);
41 #define alarm_dbg(debug_level_mask, fmt, args...) \
43 if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) \
44 xlog_printk(ANDROID_LOG_INFO, XLOG_MYTAG, fmt, ##args); \
48 * struct alarm_base - Alarm timer bases
49 * @lock: Lock for syncrhonized access to the base
50 * @timerqueue: Timerqueue head managing the list of events
51 * @timer: hrtimer used to schedule events while running
52 * @gettime: Function to read the time correlating to the base
53 * @base_clockid: clockid for the base
55 static struct alarm_base
{
57 struct timerqueue_head timerqueue
;
58 ktime_t (*gettime
)(void);
59 clockid_t base_clockid
;
60 } alarm_bases
[ALARM_NUMTYPE
];
62 /* freezer delta & lock used to handle clock_nanosleep triggered wakeups */
63 static ktime_t freezer_delta
;
64 static DEFINE_SPINLOCK(freezer_delta_lock
);
66 static struct wakeup_source
*ws
;
68 #ifdef CONFIG_RTC_CLASS
69 /* rtc timer and device for setting alarm wakeups at suspend */
70 static struct rtc_timer rtctimer
;
71 static struct rtc_device
*rtcdev
;
72 static DEFINE_SPINLOCK(rtcdev_lock
);
75 * alarmtimer_get_rtcdev - Return selected rtcdevice
77 * This function returns the rtc device to use for wakealarms.
78 * If one has not already been chosen, it checks to see if a
79 * functional rtc device is available.
81 struct rtc_device
*alarmtimer_get_rtcdev(void)
84 struct rtc_device
*ret
;
86 spin_lock_irqsave(&rtcdev_lock
, flags
);
88 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
94 static int alarmtimer_rtc_add_device(struct device
*dev
,
95 struct class_interface
*class_intf
)
98 struct rtc_device
*rtc
= to_rtc_device(dev
);
103 if (!rtc
->ops
->set_alarm
)
105 //if (!device_may_wakeup(rtc->dev.parent))
108 spin_lock_irqsave(&rtcdev_lock
, flags
);
111 /* hold a reference so it doesn't go away */
114 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
118 static inline void alarmtimer_rtc_timer_init(void)
120 rtc_timer_init(&rtctimer
, NULL
, NULL
);
123 static struct class_interface alarmtimer_rtc_interface
= {
124 .add_dev
= &alarmtimer_rtc_add_device
,
127 static int alarmtimer_rtc_interface_setup(void)
129 alarmtimer_rtc_interface
.class = rtc_class
;
130 return class_interface_register(&alarmtimer_rtc_interface
);
132 static void alarmtimer_rtc_interface_remove(void)
134 class_interface_unregister(&alarmtimer_rtc_interface
);
137 struct rtc_device
*alarmtimer_get_rtcdev(void)
141 #define rtcdev (NULL)
142 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
143 static inline void alarmtimer_rtc_interface_remove(void) { }
144 static inline void alarmtimer_rtc_timer_init(void) { }
147 void alarm_set_power_on(struct timespec new_pwron_time
, bool logo
)
149 unsigned long pwron_time
;
150 struct rtc_wkalrm alm
;
151 struct rtc_device
*alarm_rtc_dev
;
154 printk("alarm set power on\n");
157 /* round down the second */
158 new_pwron_time
.tv_sec
= (new_pwron_time
.tv_sec
/ 60) * 60;
160 if (new_pwron_time
.tv_sec
> 0) {
161 pwron_time
= new_pwron_time
.tv_sec
;
163 pwron_time
+= RTC_PWRON_SEC
;
165 alm
.enabled
= (logo
? 3 : 2);
170 alarm_rtc_dev
= alarmtimer_get_rtcdev();
171 rtc_time_to_tm(pwron_time
, &alm
.time
);
173 rtc_timer_cancel(alarm_rtc_dev, &rtctimer);
174 now = rtc_tm_to_ktime(alm.time);
175 rtc_timer_start(alarm_rtc_dev, &rtctimer, now, ktime_set(0, 0));
177 rtc_timer_cancel(alarm_rtc_dev
, &rtctimer
);
178 rtc_set_alarm(alarm_rtc_dev
, &alm
);
179 rtc_set_alarm_poweron(alarm_rtc_dev
, &alm
);
182 void alarm_get_power_on(struct rtc_wkalrm
*alm
)
187 memset(alm
, 0, sizeof(struct rtc_wkalrm
));
188 #ifndef CONFIG_MTK_FPGA
189 rtc_read_pwron_alarm(alm
);
194 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
195 * @base: pointer to the base where the timer is being run
196 * @alarm: pointer to alarm being enqueued.
198 * Adds alarm to a alarm_base timerqueue
200 * Must hold base->lock when calling.
202 static void alarmtimer_enqueue(struct alarm_base
*base
, struct alarm
*alarm
)
204 if (alarm
->state
& ALARMTIMER_STATE_ENQUEUED
)
205 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
207 timerqueue_add(&base
->timerqueue
, &alarm
->node
);
208 alarm
->state
|= ALARMTIMER_STATE_ENQUEUED
;
212 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
213 * @base: pointer to the base where the timer is running
214 * @alarm: pointer to alarm being removed
216 * Removes alarm to a alarm_base timerqueue
218 * Must hold base->lock when calling.
220 static void alarmtimer_dequeue(struct alarm_base
*base
, struct alarm
*alarm
)
222 if (!(alarm
->state
& ALARMTIMER_STATE_ENQUEUED
))
225 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
226 alarm
->state
&= ~ALARMTIMER_STATE_ENQUEUED
;
231 * alarmtimer_fired - Handles alarm hrtimer being fired.
232 * @timer: pointer to hrtimer being run
234 * When a alarm timer fires, this runs through the timerqueue to
235 * see which alarms expired, and runs those. If there are more alarm
236 * timers queued for the future, we set the hrtimer to fire when
237 * when the next future alarm timer expires.
239 static enum hrtimer_restart
alarmtimer_fired(struct hrtimer
*timer
)
241 struct alarm
*alarm
= container_of(timer
, struct alarm
, timer
);
242 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
244 int ret
= HRTIMER_NORESTART
;
245 int restart
= ALARMTIMER_NORESTART
;
247 alarm_dbg(INT
, "alarmtimer_fired \n");
249 spin_lock_irqsave(&base
->lock
, flags
);
250 alarmtimer_dequeue(base
, alarm
);
251 spin_unlock_irqrestore(&base
->lock
, flags
);
254 restart
= alarm
->function(alarm
, base
->gettime());
256 spin_lock_irqsave(&base
->lock
, flags
);
257 if (restart
!= ALARMTIMER_NORESTART
) {
258 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
259 alarmtimer_enqueue(base
, alarm
);
260 ret
= HRTIMER_RESTART
;
262 spin_unlock_irqrestore(&base
->lock
, flags
);
268 ktime_t
alarm_expires_remaining(const struct alarm
*alarm
)
270 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
271 return ktime_sub(alarm
->node
.expires
, base
->gettime());
274 #ifdef CONFIG_RTC_CLASS
276 * alarmtimer_suspend - Suspend time callback
280 * When we are going into suspend, we look through the bases
281 * to see which is the soonest timer to expire. We then
282 * set an rtc timer to fire that far into the future, which
283 * will wake us from suspend.
285 static int alarmtimer_suspend(struct device
*dev
)
290 struct rtc_device
*rtc
;
294 spin_lock_irqsave(&freezer_delta_lock
, flags
);
296 freezer_delta
= ktime_set(0, 0);
297 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
299 rtc
= alarmtimer_get_rtcdev();
300 /* If we have no rtcdev, just return */
304 /* Find the soonest timer to expire*/
305 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
306 struct alarm_base
*base
= &alarm_bases
[i
];
307 struct timerqueue_node
*next
;
310 spin_lock_irqsave(&base
->lock
, flags
);
311 next
= timerqueue_getnext(&base
->timerqueue
);
312 spin_unlock_irqrestore(&base
->lock
, flags
);
315 delta
= ktime_sub(next
->expires
, base
->gettime());
316 if (!min
.tv64
|| (delta
.tv64
< min
.tv64
))
320 alarm_dbg(INT
, "min.tv64 == 0\n");
323 if (ktime_to_ns(min
) < 2 * NSEC_PER_SEC
) {
324 alarm_dbg(INT
, "min.tv64 < 2S, give up suspend\n");
325 __pm_wakeup_event(ws
, 2 * MSEC_PER_SEC
);
329 /* Setup an rtc timer to fire that far in the future */
330 rtc_timer_cancel(rtc
, &rtctimer
);
331 rtc_read_time(rtc
, &tm
);
332 now
= rtc_tm_to_ktime(tm
);
333 now
= ktime_add(now
, min
);
335 alarm_dbg(INFO
, "now:%02d=%02d:%02d %02d/%02d/%04d. min.tv64=%lld\n",
336 tm
.tm_hour
, tm
.tm_min
,
337 tm
.tm_sec
, tm
.tm_mon
+ 1,
339 tm
.tm_year
+ 1900, min
.tv64
);
340 /* Set alarm, if in the past reject suspend briefly to handle */
341 ret
= rtc_timer_start(rtc
, &rtctimer
, now
, ktime_set(0, 0));
343 __pm_wakeup_event(ws
, MSEC_PER_SEC
);
347 static int alarmtimer_suspend(struct device
*dev
)
353 static void alarmtimer_freezerset(ktime_t absexp
, enum alarmtimer_type type
)
357 struct alarm_base
*base
= &alarm_bases
[type
];
359 delta
= ktime_sub(absexp
, base
->gettime());
361 spin_lock_irqsave(&freezer_delta_lock
, flags
);
362 if (!freezer_delta
.tv64
|| (delta
.tv64
< freezer_delta
.tv64
))
363 freezer_delta
= delta
;
364 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
369 * alarm_init - Initialize an alarm structure
370 * @alarm: ptr to alarm to be initialized
371 * @type: the type of the alarm
372 * @function: callback that is run when the alarm fires
374 void alarm_init(struct alarm
*alarm
, enum alarmtimer_type type
,
375 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
377 timerqueue_init(&alarm
->node
);
378 hrtimer_init(&alarm
->timer
, alarm_bases
[type
].base_clockid
,
380 alarm
->timer
.function
= alarmtimer_fired
;
381 alarm
->function
= function
;
383 alarm
->state
= ALARMTIMER_STATE_INACTIVE
;
387 * alarm_start - Sets an absolute alarm to fire
388 * @alarm: ptr to alarm to set
389 * @start: time to run the alarm
391 int alarm_start(struct alarm
*alarm
, ktime_t start
)
393 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
397 spin_lock_irqsave(&base
->lock
, flags
);
398 alarm
->node
.expires
= start
;
399 alarmtimer_enqueue(base
, alarm
);
400 ret
= hrtimer_start(&alarm
->timer
, alarm
->node
.expires
,
402 spin_unlock_irqrestore(&base
->lock
, flags
);
407 * alarm_start_relative - Sets a relative alarm to fire
408 * @alarm: ptr to alarm to set
409 * @start: time relative to now to run the alarm
411 int alarm_start_relative(struct alarm
*alarm
, ktime_t start
)
413 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
415 start
= ktime_add(start
, base
->gettime());
416 return alarm_start(alarm
, start
);
419 void alarm_restart(struct alarm
*alarm
)
421 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
424 spin_lock_irqsave(&base
->lock
, flags
);
425 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
426 hrtimer_restart(&alarm
->timer
);
427 alarmtimer_enqueue(base
, alarm
);
428 spin_unlock_irqrestore(&base
->lock
, flags
);
432 * alarm_try_to_cancel - Tries to cancel an alarm timer
433 * @alarm: ptr to alarm to be canceled
435 * Returns 1 if the timer was canceled, 0 if it was not running,
436 * and -1 if the callback was running
438 int alarm_try_to_cancel(struct alarm
*alarm
)
440 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
444 spin_lock_irqsave(&base
->lock
, flags
);
445 ret
= hrtimer_try_to_cancel(&alarm
->timer
);
447 alarmtimer_dequeue(base
, alarm
);
448 spin_unlock_irqrestore(&base
->lock
, flags
);
454 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
455 * @alarm: ptr to alarm to be canceled
457 * Returns 1 if the timer was canceled, 0 if it was not active.
459 int alarm_cancel(struct alarm
*alarm
)
462 int ret
= alarm_try_to_cancel(alarm
);
470 u64
alarm_forward(struct alarm
*alarm
, ktime_t now
, ktime_t interval
)
475 delta
= ktime_sub(now
, alarm
->node
.expires
);
480 if (unlikely(delta
.tv64
>= interval
.tv64
)) {
481 s64 incr
= ktime_to_ns(interval
);
483 overrun
= ktime_divns(delta
, incr
);
485 alarm
->node
.expires
= ktime_add_ns(alarm
->node
.expires
,
488 if (alarm
->node
.expires
.tv64
> now
.tv64
)
491 * This (and the ktime_add() below) is the
492 * correction for exact:
497 alarm
->node
.expires
= ktime_add(alarm
->node
.expires
, interval
);
501 u64
alarm_forward_now(struct alarm
*alarm
, ktime_t interval
)
503 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
505 return alarm_forward(alarm
, base
->gettime(), interval
);
511 * clock2alarm - helper that converts from clockid to alarmtypes
514 static enum alarmtimer_type
clock2alarm(clockid_t clockid
)
516 if (clockid
== CLOCK_REALTIME_ALARM
)
517 return ALARM_REALTIME
;
518 if (clockid
== CLOCK_BOOTTIME_ALARM
)
519 return ALARM_BOOTTIME
;
524 * alarm_handle_timer - Callback for posix timers
525 * @alarm: alarm that fired
527 * Posix timer callback for expired alarm timers.
529 static enum alarmtimer_restart
alarm_handle_timer(struct alarm
*alarm
,
533 struct k_itimer
*ptr
= container_of(alarm
, struct k_itimer
,
534 it
.alarm
.alarmtimer
);
535 enum alarmtimer_restart result
= ALARMTIMER_NORESTART
;
537 spin_lock_irqsave(&ptr
->it_lock
, flags
);
538 if ((ptr
->it_sigev_notify
& ~SIGEV_THREAD_ID
) != SIGEV_NONE
) {
539 if (posix_timer_event(ptr
, 0) != 0)
543 /* Re-add periodic timers */
544 if (ptr
->it
.alarm
.interval
.tv64
) {
545 ptr
->it_overrun
+= alarm_forward(alarm
, now
,
546 ptr
->it
.alarm
.interval
);
547 result
= ALARMTIMER_RESTART
;
549 spin_unlock_irqrestore(&ptr
->it_lock
, flags
);
555 * alarm_clock_getres - posix getres interface
556 * @which_clock: clockid
557 * @tp: timespec to fill
559 * Returns the granularity of underlying alarm base clock
561 static int alarm_clock_getres(const clockid_t which_clock
, struct timespec
*tp
)
563 clockid_t baseid
= alarm_bases
[clock2alarm(which_clock
)].base_clockid
;
565 if (!alarmtimer_get_rtcdev())
568 return hrtimer_get_res(baseid
, tp
);
572 * alarm_clock_get - posix clock_get interface
573 * @which_clock: clockid
574 * @tp: timespec to fill.
576 * Provides the underlying alarm base time.
578 static int alarm_clock_get(clockid_t which_clock
, struct timespec
*tp
)
580 struct alarm_base
*base
= &alarm_bases
[clock2alarm(which_clock
)];
582 if (!alarmtimer_get_rtcdev())
585 *tp
= ktime_to_timespec(base
->gettime());
590 * alarm_timer_create - posix timer_create interface
591 * @new_timer: k_itimer pointer to manage
593 * Initializes the k_itimer structure.
595 static int alarm_timer_create(struct k_itimer
*new_timer
)
597 enum alarmtimer_type type
;
598 struct alarm_base
*base
;
600 if (!alarmtimer_get_rtcdev())
603 if (!capable(CAP_WAKE_ALARM
))
606 type
= clock2alarm(new_timer
->it_clock
);
607 base
= &alarm_bases
[type
];
608 alarm_init(&new_timer
->it
.alarm
.alarmtimer
, type
, alarm_handle_timer
);
613 * alarm_timer_get - posix timer_get interface
614 * @new_timer: k_itimer pointer
615 * @cur_setting: itimerspec data to fill
617 * Copies the itimerspec data out from the k_itimer
619 static void alarm_timer_get(struct k_itimer
*timr
,
620 struct itimerspec
*cur_setting
)
622 memset(cur_setting
, 0, sizeof(struct itimerspec
));
624 cur_setting
->it_interval
=
625 ktime_to_timespec(timr
->it
.alarm
.interval
);
626 cur_setting
->it_value
=
627 ktime_to_timespec(timr
->it
.alarm
.alarmtimer
.node
.expires
);
632 * alarm_timer_del - posix timer_del interface
633 * @timr: k_itimer pointer to be deleted
635 * Cancels any programmed alarms for the given timer.
637 static int alarm_timer_del(struct k_itimer
*timr
)
642 if (alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
) < 0)
649 * alarm_timer_set - posix timer_set interface
650 * @timr: k_itimer pointer to be deleted
651 * @flags: timer flags
652 * @new_setting: itimerspec to be used
653 * @old_setting: itimerspec being replaced
655 * Sets the timer to new_setting, and starts the timer.
657 static int alarm_timer_set(struct k_itimer
*timr
, int flags
,
658 struct itimerspec
*new_setting
,
659 struct itimerspec
*old_setting
)
666 if (flags
& ~TIMER_ABSTIME
)
670 alarm_timer_get(timr
, old_setting
);
672 /* If the timer was already set, cancel it */
673 if (alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
) < 0)
676 /* start the timer */
677 timr
->it
.alarm
.interval
= timespec_to_ktime(new_setting
->it_interval
);
678 exp
= timespec_to_ktime(new_setting
->it_value
);
679 /* Convert (if necessary) to absolute time */
680 if (flags
!= TIMER_ABSTIME
) {
683 now
= alarm_bases
[timr
->it
.alarm
.alarmtimer
.type
].gettime();
684 exp
= ktime_add(now
, exp
);
687 alarm_start(&timr
->it
.alarm
.alarmtimer
, exp
);
692 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
693 * @alarm: ptr to alarm that fired
695 * Wakes up the task that set the alarmtimer
697 static enum alarmtimer_restart
alarmtimer_nsleep_wakeup(struct alarm
*alarm
,
700 struct task_struct
*task
= (struct task_struct
*)alarm
->data
;
704 wake_up_process(task
);
705 return ALARMTIMER_NORESTART
;
709 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
710 * @alarm: ptr to alarmtimer
711 * @absexp: absolute expiration time
713 * Sets the alarm timer and sleeps until it is fired or interrupted.
715 static int alarmtimer_do_nsleep(struct alarm
*alarm
, ktime_t absexp
)
717 alarm
->data
= (void *)current
;
719 set_current_state(TASK_INTERRUPTIBLE
);
720 alarm_start(alarm
, absexp
);
721 if (likely(alarm
->data
))
725 } while (alarm
->data
&& !signal_pending(current
));
727 __set_current_state(TASK_RUNNING
);
729 return (alarm
->data
== NULL
);
734 * update_rmtp - Update remaining timespec value
735 * @exp: expiration time
737 * @rmtp: user pointer to remaining timepsec value
739 * Helper function that fills in rmtp value with time between
740 * now and the exp value
742 static int update_rmtp(ktime_t exp
, enum alarmtimer_type type
,
743 struct timespec __user
*rmtp
)
748 rem
= ktime_sub(exp
, alarm_bases
[type
].gettime());
752 rmt
= ktime_to_timespec(rem
);
754 if (copy_to_user(rmtp
, &rmt
, sizeof(*rmtp
)))
762 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
763 * @restart: ptr to restart block
765 * Handles restarted clock_nanosleep calls
767 static long __sched
alarm_timer_nsleep_restart(struct restart_block
*restart
)
769 enum alarmtimer_type type
= restart
->nanosleep
.clockid
;
771 struct timespec __user
*rmtp
;
775 exp
.tv64
= restart
->nanosleep
.expires
;
776 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
778 if (alarmtimer_do_nsleep(&alarm
, exp
))
781 if (freezing(current
))
782 alarmtimer_freezerset(exp
, type
);
784 rmtp
= restart
->nanosleep
.rmtp
;
786 ret
= update_rmtp(exp
, type
, rmtp
);
792 /* The other values in restart are already filled in */
793 ret
= -ERESTART_RESTARTBLOCK
;
799 * alarm_timer_nsleep - alarmtimer nanosleep
800 * @which_clock: clockid
801 * @flags: determins abstime or relative
802 * @tsreq: requested sleep time (abs or rel)
803 * @rmtp: remaining sleep time saved
805 * Handles clock_nanosleep calls against _ALARM clockids
807 static int alarm_timer_nsleep(const clockid_t which_clock
, int flags
,
808 struct timespec
*tsreq
, struct timespec __user
*rmtp
)
810 enum alarmtimer_type type
= clock2alarm(which_clock
);
814 struct restart_block
*restart
;
816 if (!alarmtimer_get_rtcdev())
819 if (flags
& ~TIMER_ABSTIME
)
822 if (!capable(CAP_WAKE_ALARM
))
825 alarm_init(&alarm
, type
, alarmtimer_nsleep_wakeup
);
827 exp
= timespec_to_ktime(*tsreq
);
828 /* Convert (if necessary) to absolute time */
829 if (flags
!= TIMER_ABSTIME
) {
830 ktime_t now
= alarm_bases
[type
].gettime();
831 exp
= ktime_add(now
, exp
);
834 if (alarmtimer_do_nsleep(&alarm
, exp
))
837 if (freezing(current
))
838 alarmtimer_freezerset(exp
, type
);
840 /* abs timers don't set remaining time or restart */
841 if (flags
== TIMER_ABSTIME
) {
842 ret
= -ERESTARTNOHAND
;
847 ret
= update_rmtp(exp
, type
, rmtp
);
852 restart
= ¤t_thread_info()->restart_block
;
853 restart
->fn
= alarm_timer_nsleep_restart
;
854 restart
->nanosleep
.clockid
= type
;
855 restart
->nanosleep
.expires
= exp
.tv64
;
856 restart
->nanosleep
.rmtp
= rmtp
;
857 ret
= -ERESTART_RESTARTBLOCK
;
864 /* Suspend hook structures */
865 static const struct dev_pm_ops alarmtimer_pm_ops
= {
866 .suspend
= alarmtimer_suspend
,
869 static struct platform_driver alarmtimer_driver
= {
871 .name
= "alarmtimer",
872 .pm
= &alarmtimer_pm_ops
,
877 * alarmtimer_init - Initialize alarm timer code
879 * This function initializes the alarm bases and registers
880 * the posix clock ids.
882 static int __init
alarmtimer_init(void)
884 struct platform_device
*pdev
;
887 struct k_clock alarm_clock
= {
888 .clock_getres
= alarm_clock_getres
,
889 .clock_get
= alarm_clock_get
,
890 .timer_create
= alarm_timer_create
,
891 .timer_set
= alarm_timer_set
,
892 .timer_del
= alarm_timer_del
,
893 .timer_get
= alarm_timer_get
,
894 .nsleep
= alarm_timer_nsleep
,
897 alarmtimer_rtc_timer_init();
899 posix_timers_register_clock(CLOCK_REALTIME_ALARM
, &alarm_clock
);
900 posix_timers_register_clock(CLOCK_BOOTTIME_ALARM
, &alarm_clock
);
902 /* Initialize alarm bases */
903 alarm_bases
[ALARM_REALTIME
].base_clockid
= CLOCK_REALTIME
;
904 alarm_bases
[ALARM_REALTIME
].gettime
= &ktime_get_real
;
905 alarm_bases
[ALARM_BOOTTIME
].base_clockid
= CLOCK_BOOTTIME
;
906 alarm_bases
[ALARM_BOOTTIME
].gettime
= &ktime_get_boottime
;
907 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
908 timerqueue_init_head(&alarm_bases
[i
].timerqueue
);
909 spin_lock_init(&alarm_bases
[i
].lock
);
912 error
= alarmtimer_rtc_interface_setup();
916 error
= platform_driver_register(&alarmtimer_driver
);
920 pdev
= platform_device_register_simple("alarmtimer", -1, NULL
, 0);
922 error
= PTR_ERR(pdev
);
925 ws
= wakeup_source_register("alarmtimer");
929 platform_driver_unregister(&alarmtimer_driver
);
931 alarmtimer_rtc_interface_remove();
934 device_initcall(alarmtimer_init
);