1 // SPDX-License-Identifier: GPL-2.0
5 * This interface provides a timer which is similarto hrtimers,
6 * but triggers a RTC alarm if the box is suspend.
8 * This interface is influenced by the Android RTC Alarm timer
11 * Copyright (C) 2010 IBM Corperation
13 * Author: John Stultz <john.stultz@linaro.org>
15 #include <linux/time.h>
16 #include <linux/hrtimer.h>
17 #include <linux/timerqueue.h>
18 #include <linux/rtc.h>
19 #include <linux/sched/signal.h>
20 #include <linux/sched/debug.h>
21 #include <linux/alarmtimer.h>
22 #include <linux/mutex.h>
23 #include <linux/platform_device.h>
24 #include <linux/posix-timers.h>
25 #include <linux/workqueue.h>
26 #include <linux/freezer.h>
27 #include <linux/compat.h>
28 #include <linux/module.h>
29 #include <linux/time_namespace.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 * @get_ktime: Function to read the time correlating to the base
41 * @get_timespec: Function to read the namespace time correlating to the base
42 * @base_clockid: clockid for the base
44 static struct alarm_base
{
46 struct timerqueue_head timerqueue
;
47 ktime_t (*get_ktime
)(void);
48 void (*get_timespec
)(struct timespec64
*tp
);
49 clockid_t base_clockid
;
50 } alarm_bases
[ALARM_NUMTYPE
];
52 #if defined(CONFIG_POSIX_TIMERS) || defined(CONFIG_RTC_CLASS)
53 /* freezer information to handle clock_nanosleep triggered wakeups */
54 static enum alarmtimer_type freezer_alarmtype
;
55 static ktime_t freezer_expires
;
56 static ktime_t freezer_delta
;
57 static DEFINE_SPINLOCK(freezer_delta_lock
);
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.
71 struct rtc_device
*alarmtimer_get_rtcdev(void)
74 struct rtc_device
*ret
;
76 spin_lock_irqsave(&rtcdev_lock
, flags
);
78 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
82 EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev
);
84 static int alarmtimer_rtc_add_device(struct device
*dev
,
85 struct class_interface
*class_intf
)
88 struct rtc_device
*rtc
= to_rtc_device(dev
);
89 struct platform_device
*pdev
;
95 if (!rtc
->ops
->set_alarm
)
97 if (!device_may_wakeup(rtc
->dev
.parent
))
100 pdev
= platform_device_register_data(dev
, "alarmtimer",
101 PLATFORM_DEVID_AUTO
, NULL
, 0);
103 device_init_wakeup(&pdev
->dev
, true);
105 spin_lock_irqsave(&rtcdev_lock
, flags
);
106 if (!IS_ERR(pdev
) && !rtcdev
) {
107 if (!try_module_get(rtc
->owner
)) {
113 /* hold a reference so it doesn't go away */
120 spin_unlock_irqrestore(&rtcdev_lock
, flags
);
122 platform_device_unregister(pdev
);
127 static inline void alarmtimer_rtc_timer_init(void)
129 rtc_timer_init(&rtctimer
, NULL
, NULL
);
132 static struct class_interface alarmtimer_rtc_interface
= {
133 .add_dev
= &alarmtimer_rtc_add_device
,
136 static int alarmtimer_rtc_interface_setup(void)
138 alarmtimer_rtc_interface
.class = rtc_class
;
139 return class_interface_register(&alarmtimer_rtc_interface
);
141 static void alarmtimer_rtc_interface_remove(void)
143 class_interface_unregister(&alarmtimer_rtc_interface
);
146 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
147 static inline void alarmtimer_rtc_interface_remove(void) { }
148 static inline void alarmtimer_rtc_timer_init(void) { }
152 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
153 * @base: pointer to the base where the timer is being run
154 * @alarm: pointer to alarm being enqueued.
156 * Adds alarm to a alarm_base timerqueue
158 * Must hold base->lock when calling.
160 static void alarmtimer_enqueue(struct alarm_base
*base
, struct alarm
*alarm
)
162 if (alarm
->state
& ALARMTIMER_STATE_ENQUEUED
)
163 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
165 timerqueue_add(&base
->timerqueue
, &alarm
->node
);
166 alarm
->state
|= ALARMTIMER_STATE_ENQUEUED
;
170 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
171 * @base: pointer to the base where the timer is running
172 * @alarm: pointer to alarm being removed
174 * Removes alarm to a alarm_base timerqueue
176 * Must hold base->lock when calling.
178 static void alarmtimer_dequeue(struct alarm_base
*base
, struct alarm
*alarm
)
180 if (!(alarm
->state
& ALARMTIMER_STATE_ENQUEUED
))
183 timerqueue_del(&base
->timerqueue
, &alarm
->node
);
184 alarm
->state
&= ~ALARMTIMER_STATE_ENQUEUED
;
189 * alarmtimer_fired - Handles alarm hrtimer being fired.
190 * @timer: pointer to hrtimer being run
192 * When a alarm timer fires, this runs through the timerqueue to
193 * see which alarms expired, and runs those. If there are more alarm
194 * timers queued for the future, we set the hrtimer to fire when
195 * the next future alarm timer expires.
197 static enum hrtimer_restart
alarmtimer_fired(struct hrtimer
*timer
)
199 struct alarm
*alarm
= container_of(timer
, struct alarm
, timer
);
200 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
202 int ret
= HRTIMER_NORESTART
;
203 int restart
= ALARMTIMER_NORESTART
;
205 spin_lock_irqsave(&base
->lock
, flags
);
206 alarmtimer_dequeue(base
, alarm
);
207 spin_unlock_irqrestore(&base
->lock
, flags
);
210 restart
= alarm
->function(alarm
, base
->get_ktime());
212 spin_lock_irqsave(&base
->lock
, flags
);
213 if (restart
!= ALARMTIMER_NORESTART
) {
214 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
215 alarmtimer_enqueue(base
, alarm
);
216 ret
= HRTIMER_RESTART
;
218 spin_unlock_irqrestore(&base
->lock
, flags
);
220 trace_alarmtimer_fired(alarm
, base
->get_ktime());
225 ktime_t
alarm_expires_remaining(const struct alarm
*alarm
)
227 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
228 return ktime_sub(alarm
->node
.expires
, base
->get_ktime());
230 EXPORT_SYMBOL_GPL(alarm_expires_remaining
);
232 #ifdef CONFIG_RTC_CLASS
234 * alarmtimer_suspend - Suspend time callback
237 * When we are going into suspend, we look through the bases
238 * to see which is the soonest timer to expire. We then
239 * set an rtc timer to fire that far into the future, which
240 * will wake us from suspend.
242 static int alarmtimer_suspend(struct device
*dev
)
244 ktime_t min
, now
, expires
;
246 struct rtc_device
*rtc
;
250 spin_lock_irqsave(&freezer_delta_lock
, flags
);
252 expires
= freezer_expires
;
253 type
= freezer_alarmtype
;
255 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
257 rtc
= alarmtimer_get_rtcdev();
258 /* If we have no rtcdev, just return */
262 /* Find the soonest timer to expire*/
263 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
264 struct alarm_base
*base
= &alarm_bases
[i
];
265 struct timerqueue_node
*next
;
268 spin_lock_irqsave(&base
->lock
, flags
);
269 next
= timerqueue_getnext(&base
->timerqueue
);
270 spin_unlock_irqrestore(&base
->lock
, flags
);
273 delta
= ktime_sub(next
->expires
, base
->get_ktime());
274 if (!min
|| (delta
< min
)) {
275 expires
= next
->expires
;
283 if (ktime_to_ns(min
) < 2 * NSEC_PER_SEC
) {
284 pm_wakeup_event(dev
, 2 * MSEC_PER_SEC
);
288 trace_alarmtimer_suspend(expires
, type
);
290 /* Setup an rtc timer to fire that far in the future */
291 rtc_timer_cancel(rtc
, &rtctimer
);
292 rtc_read_time(rtc
, &tm
);
293 now
= rtc_tm_to_ktime(tm
);
294 now
= ktime_add(now
, min
);
296 /* Set alarm, if in the past reject suspend briefly to handle */
297 ret
= rtc_timer_start(rtc
, &rtctimer
, now
, 0);
299 pm_wakeup_event(dev
, MSEC_PER_SEC
);
303 static int alarmtimer_resume(struct device
*dev
)
305 struct rtc_device
*rtc
;
307 rtc
= alarmtimer_get_rtcdev();
309 rtc_timer_cancel(rtc
, &rtctimer
);
314 static int alarmtimer_suspend(struct device
*dev
)
319 static int alarmtimer_resume(struct device
*dev
)
326 __alarm_init(struct alarm
*alarm
, enum alarmtimer_type type
,
327 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
329 timerqueue_init(&alarm
->node
);
330 alarm
->timer
.function
= alarmtimer_fired
;
331 alarm
->function
= function
;
333 alarm
->state
= ALARMTIMER_STATE_INACTIVE
;
337 * alarm_init - Initialize an alarm structure
338 * @alarm: ptr to alarm to be initialized
339 * @type: the type of the alarm
340 * @function: callback that is run when the alarm fires
342 void alarm_init(struct alarm
*alarm
, enum alarmtimer_type type
,
343 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
345 hrtimer_init(&alarm
->timer
, alarm_bases
[type
].base_clockid
,
347 __alarm_init(alarm
, type
, function
);
349 EXPORT_SYMBOL_GPL(alarm_init
);
352 * alarm_start - Sets an absolute alarm to fire
353 * @alarm: ptr to alarm to set
354 * @start: time to run the alarm
356 void alarm_start(struct alarm
*alarm
, ktime_t start
)
358 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
361 spin_lock_irqsave(&base
->lock
, flags
);
362 alarm
->node
.expires
= start
;
363 alarmtimer_enqueue(base
, alarm
);
364 hrtimer_start(&alarm
->timer
, alarm
->node
.expires
, HRTIMER_MODE_ABS
);
365 spin_unlock_irqrestore(&base
->lock
, flags
);
367 trace_alarmtimer_start(alarm
, base
->get_ktime());
369 EXPORT_SYMBOL_GPL(alarm_start
);
372 * alarm_start_relative - Sets a relative alarm to fire
373 * @alarm: ptr to alarm to set
374 * @start: time relative to now to run the alarm
376 void alarm_start_relative(struct alarm
*alarm
, ktime_t start
)
378 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
380 start
= ktime_add_safe(start
, base
->get_ktime());
381 alarm_start(alarm
, start
);
383 EXPORT_SYMBOL_GPL(alarm_start_relative
);
385 void alarm_restart(struct alarm
*alarm
)
387 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
390 spin_lock_irqsave(&base
->lock
, flags
);
391 hrtimer_set_expires(&alarm
->timer
, alarm
->node
.expires
);
392 hrtimer_restart(&alarm
->timer
);
393 alarmtimer_enqueue(base
, alarm
);
394 spin_unlock_irqrestore(&base
->lock
, flags
);
396 EXPORT_SYMBOL_GPL(alarm_restart
);
399 * alarm_try_to_cancel - Tries to cancel an alarm timer
400 * @alarm: ptr to alarm to be canceled
402 * Returns 1 if the timer was canceled, 0 if it was not running,
403 * and -1 if the callback was running
405 int alarm_try_to_cancel(struct alarm
*alarm
)
407 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
411 spin_lock_irqsave(&base
->lock
, flags
);
412 ret
= hrtimer_try_to_cancel(&alarm
->timer
);
414 alarmtimer_dequeue(base
, alarm
);
415 spin_unlock_irqrestore(&base
->lock
, flags
);
417 trace_alarmtimer_cancel(alarm
, base
->get_ktime());
420 EXPORT_SYMBOL_GPL(alarm_try_to_cancel
);
424 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
425 * @alarm: ptr to alarm to be canceled
427 * Returns 1 if the timer was canceled, 0 if it was not active.
429 int alarm_cancel(struct alarm
*alarm
)
432 int ret
= alarm_try_to_cancel(alarm
);
435 hrtimer_cancel_wait_running(&alarm
->timer
);
438 EXPORT_SYMBOL_GPL(alarm_cancel
);
441 u64
alarm_forward(struct alarm
*alarm
, ktime_t now
, ktime_t interval
)
446 delta
= ktime_sub(now
, alarm
->node
.expires
);
451 if (unlikely(delta
>= interval
)) {
452 s64 incr
= ktime_to_ns(interval
);
454 overrun
= ktime_divns(delta
, incr
);
456 alarm
->node
.expires
= ktime_add_ns(alarm
->node
.expires
,
459 if (alarm
->node
.expires
> now
)
462 * This (and the ktime_add() below) is the
463 * correction for exact:
468 alarm
->node
.expires
= ktime_add_safe(alarm
->node
.expires
, interval
);
471 EXPORT_SYMBOL_GPL(alarm_forward
);
473 u64
alarm_forward_now(struct alarm
*alarm
, ktime_t interval
)
475 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
477 return alarm_forward(alarm
, base
->get_ktime(), interval
);
479 EXPORT_SYMBOL_GPL(alarm_forward_now
);
481 #ifdef CONFIG_POSIX_TIMERS
483 static void alarmtimer_freezerset(ktime_t absexp
, enum alarmtimer_type type
)
485 struct alarm_base
*base
;
491 base
= &alarm_bases
[ALARM_REALTIME
];
492 type
= ALARM_REALTIME_FREEZER
;
495 base
= &alarm_bases
[ALARM_BOOTTIME
];
496 type
= ALARM_BOOTTIME_FREEZER
;
499 WARN_ONCE(1, "Invalid alarm type: %d\n", type
);
503 delta
= ktime_sub(absexp
, base
->get_ktime());
505 spin_lock_irqsave(&freezer_delta_lock
, flags
);
506 if (!freezer_delta
|| (delta
< freezer_delta
)) {
507 freezer_delta
= delta
;
508 freezer_expires
= absexp
;
509 freezer_alarmtype
= type
;
511 spin_unlock_irqrestore(&freezer_delta_lock
, flags
);
515 * clock2alarm - helper that converts from clockid to alarmtypes
518 static enum alarmtimer_type
clock2alarm(clockid_t clockid
)
520 if (clockid
== CLOCK_REALTIME_ALARM
)
521 return ALARM_REALTIME
;
522 if (clockid
== CLOCK_BOOTTIME_ALARM
)
523 return ALARM_BOOTTIME
;
528 * alarm_handle_timer - Callback for posix timers
529 * @alarm: alarm that fired
531 * Posix timer callback for expired alarm timers.
533 static enum alarmtimer_restart
alarm_handle_timer(struct alarm
*alarm
,
536 struct k_itimer
*ptr
= container_of(alarm
, struct k_itimer
,
537 it
.alarm
.alarmtimer
);
538 enum alarmtimer_restart result
= ALARMTIMER_NORESTART
;
542 spin_lock_irqsave(&ptr
->it_lock
, flags
);
545 if (ptr
->it_interval
)
546 si_private
= ++ptr
->it_requeue_pending
;
548 if (posix_timer_event(ptr
, si_private
) && ptr
->it_interval
) {
550 * Handle ignored signals and rearm the timer. This will go
551 * away once we handle ignored signals proper.
553 ptr
->it_overrun
+= alarm_forward_now(alarm
, ptr
->it_interval
);
554 ++ptr
->it_requeue_pending
;
556 result
= ALARMTIMER_RESTART
;
558 spin_unlock_irqrestore(&ptr
->it_lock
, flags
);
564 * alarm_timer_rearm - Posix timer callback for rearming timer
565 * @timr: Pointer to the posixtimer data struct
567 static void alarm_timer_rearm(struct k_itimer
*timr
)
569 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
571 timr
->it_overrun
+= alarm_forward_now(alarm
, timr
->it_interval
);
572 alarm_start(alarm
, alarm
->node
.expires
);
576 * alarm_timer_forward - Posix timer callback for forwarding timer
577 * @timr: Pointer to the posixtimer data struct
578 * @now: Current time to forward the timer against
580 static s64
alarm_timer_forward(struct k_itimer
*timr
, ktime_t now
)
582 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
584 return alarm_forward(alarm
, timr
->it_interval
, now
);
588 * alarm_timer_remaining - Posix timer callback to retrieve remaining time
589 * @timr: Pointer to the posixtimer data struct
590 * @now: Current time to calculate against
592 static ktime_t
alarm_timer_remaining(struct k_itimer
*timr
, ktime_t now
)
594 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
596 return ktime_sub(alarm
->node
.expires
, now
);
600 * alarm_timer_try_to_cancel - Posix timer callback to cancel a timer
601 * @timr: Pointer to the posixtimer data struct
603 static int alarm_timer_try_to_cancel(struct k_itimer
*timr
)
605 return alarm_try_to_cancel(&timr
->it
.alarm
.alarmtimer
);
609 * alarm_timer_wait_running - Posix timer callback to wait for a timer
610 * @timr: Pointer to the posixtimer data struct
612 * Called from the core code when timer cancel detected that the callback
613 * is running. @timr is unlocked and rcu read lock is held to prevent it
616 static void alarm_timer_wait_running(struct k_itimer
*timr
)
618 hrtimer_cancel_wait_running(&timr
->it
.alarm
.alarmtimer
.timer
);
622 * alarm_timer_arm - Posix timer callback to arm a timer
623 * @timr: Pointer to the posixtimer data struct
624 * @expires: The new expiry time
625 * @absolute: Expiry value is absolute time
626 * @sigev_none: Posix timer does not deliver signals
628 static void alarm_timer_arm(struct k_itimer
*timr
, ktime_t expires
,
629 bool absolute
, bool sigev_none
)
631 struct alarm
*alarm
= &timr
->it
.alarm
.alarmtimer
;
632 struct alarm_base
*base
= &alarm_bases
[alarm
->type
];
635 expires
= ktime_add_safe(expires
, base
->get_ktime());
637 alarm
->node
.expires
= expires
;
639 alarm_start(&timr
->it
.alarm
.alarmtimer
, expires
);
643 * alarm_clock_getres - posix getres interface
644 * @which_clock: clockid
645 * @tp: timespec to fill
647 * Returns the granularity of underlying alarm base clock
649 static int alarm_clock_getres(const clockid_t which_clock
, struct timespec64
*tp
)
651 if (!alarmtimer_get_rtcdev())
655 tp
->tv_nsec
= hrtimer_resolution
;
660 * alarm_clock_get_timespec - posix clock_get_timespec interface
661 * @which_clock: clockid
662 * @tp: timespec to fill.
664 * Provides the underlying alarm base time in a tasks time namespace.
666 static int alarm_clock_get_timespec(clockid_t which_clock
, struct timespec64
*tp
)
668 struct alarm_base
*base
= &alarm_bases
[clock2alarm(which_clock
)];
670 if (!alarmtimer_get_rtcdev())
673 base
->get_timespec(tp
);
679 * alarm_clock_get_ktime - posix clock_get_ktime interface
680 * @which_clock: clockid
682 * Provides the underlying alarm base time in the root namespace.
684 static ktime_t
alarm_clock_get_ktime(clockid_t which_clock
)
686 struct alarm_base
*base
= &alarm_bases
[clock2alarm(which_clock
)];
688 if (!alarmtimer_get_rtcdev())
691 return base
->get_ktime();
695 * alarm_timer_create - posix timer_create interface
696 * @new_timer: k_itimer pointer to manage
698 * Initializes the k_itimer structure.
700 static int alarm_timer_create(struct k_itimer
*new_timer
)
702 enum alarmtimer_type type
;
704 if (!alarmtimer_get_rtcdev())
707 if (!capable(CAP_WAKE_ALARM
))
710 type
= clock2alarm(new_timer
->it_clock
);
711 alarm_init(&new_timer
->it
.alarm
.alarmtimer
, type
, alarm_handle_timer
);
716 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
717 * @alarm: ptr to alarm that fired
719 * Wakes up the task that set the alarmtimer
721 static enum alarmtimer_restart
alarmtimer_nsleep_wakeup(struct alarm
*alarm
,
724 struct task_struct
*task
= (struct task_struct
*)alarm
->data
;
728 wake_up_process(task
);
729 return ALARMTIMER_NORESTART
;
733 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
734 * @alarm: ptr to alarmtimer
735 * @absexp: absolute expiration time
737 * Sets the alarm timer and sleeps until it is fired or interrupted.
739 static int alarmtimer_do_nsleep(struct alarm
*alarm
, ktime_t absexp
,
740 enum alarmtimer_type type
)
742 struct restart_block
*restart
;
743 alarm
->data
= (void *)current
;
745 set_current_state(TASK_INTERRUPTIBLE
);
746 alarm_start(alarm
, absexp
);
747 if (likely(alarm
->data
))
751 } while (alarm
->data
&& !signal_pending(current
));
753 __set_current_state(TASK_RUNNING
);
755 destroy_hrtimer_on_stack(&alarm
->timer
);
760 if (freezing(current
))
761 alarmtimer_freezerset(absexp
, type
);
762 restart
= ¤t
->restart_block
;
763 if (restart
->nanosleep
.type
!= TT_NONE
) {
764 struct timespec64 rmt
;
767 rem
= ktime_sub(absexp
, alarm_bases
[type
].get_ktime());
771 rmt
= ktime_to_timespec64(rem
);
773 return nanosleep_copyout(restart
, &rmt
);
775 return -ERESTART_RESTARTBLOCK
;
779 alarm_init_on_stack(struct alarm
*alarm
, enum alarmtimer_type type
,
780 enum alarmtimer_restart (*function
)(struct alarm
*, ktime_t
))
782 hrtimer_init_on_stack(&alarm
->timer
, alarm_bases
[type
].base_clockid
,
784 __alarm_init(alarm
, type
, function
);
788 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
789 * @restart: ptr to restart block
791 * Handles restarted clock_nanosleep calls
793 static long __sched
alarm_timer_nsleep_restart(struct restart_block
*restart
)
795 enum alarmtimer_type type
= restart
->nanosleep
.clockid
;
796 ktime_t exp
= restart
->nanosleep
.expires
;
799 alarm_init_on_stack(&alarm
, type
, alarmtimer_nsleep_wakeup
);
801 return alarmtimer_do_nsleep(&alarm
, exp
, type
);
805 * alarm_timer_nsleep - alarmtimer nanosleep
806 * @which_clock: clockid
807 * @flags: determins abstime or relative
808 * @tsreq: requested sleep time (abs or rel)
809 * @rmtp: remaining sleep time saved
811 * Handles clock_nanosleep calls against _ALARM clockids
813 static int alarm_timer_nsleep(const clockid_t which_clock
, int flags
,
814 const struct timespec64
*tsreq
)
816 enum alarmtimer_type type
= clock2alarm(which_clock
);
817 struct restart_block
*restart
= ¤t
->restart_block
;
822 if (!alarmtimer_get_rtcdev())
825 if (flags
& ~TIMER_ABSTIME
)
828 if (!capable(CAP_WAKE_ALARM
))
831 alarm_init_on_stack(&alarm
, type
, alarmtimer_nsleep_wakeup
);
833 exp
= timespec64_to_ktime(*tsreq
);
834 /* Convert (if necessary) to absolute time */
835 if (flags
!= TIMER_ABSTIME
) {
836 ktime_t now
= alarm_bases
[type
].get_ktime();
838 exp
= ktime_add_safe(now
, exp
);
840 exp
= timens_ktime_to_host(which_clock
, exp
);
843 ret
= alarmtimer_do_nsleep(&alarm
, exp
, type
);
844 if (ret
!= -ERESTART_RESTARTBLOCK
)
847 /* abs timers don't set remaining time or restart */
848 if (flags
== TIMER_ABSTIME
)
849 return -ERESTARTNOHAND
;
851 restart
->fn
= alarm_timer_nsleep_restart
;
852 restart
->nanosleep
.clockid
= type
;
853 restart
->nanosleep
.expires
= exp
;
857 const struct k_clock alarm_clock
= {
858 .clock_getres
= alarm_clock_getres
,
859 .clock_get_ktime
= alarm_clock_get_ktime
,
860 .clock_get_timespec
= alarm_clock_get_timespec
,
861 .timer_create
= alarm_timer_create
,
862 .timer_set
= common_timer_set
,
863 .timer_del
= common_timer_del
,
864 .timer_get
= common_timer_get
,
865 .timer_arm
= alarm_timer_arm
,
866 .timer_rearm
= alarm_timer_rearm
,
867 .timer_forward
= alarm_timer_forward
,
868 .timer_remaining
= alarm_timer_remaining
,
869 .timer_try_to_cancel
= alarm_timer_try_to_cancel
,
870 .timer_wait_running
= alarm_timer_wait_running
,
871 .nsleep
= alarm_timer_nsleep
,
873 #endif /* CONFIG_POSIX_TIMERS */
876 /* Suspend hook structures */
877 static const struct dev_pm_ops alarmtimer_pm_ops
= {
878 .suspend
= alarmtimer_suspend
,
879 .resume
= alarmtimer_resume
,
882 static struct platform_driver alarmtimer_driver
= {
884 .name
= "alarmtimer",
885 .pm
= &alarmtimer_pm_ops
,
889 static void get_boottime_timespec(struct timespec64
*tp
)
891 ktime_get_boottime_ts64(tp
);
892 timens_add_boottime(tp
);
896 * alarmtimer_init - Initialize alarm timer code
898 * This function initializes the alarm bases and registers
899 * the posix clock ids.
901 static int __init
alarmtimer_init(void)
906 alarmtimer_rtc_timer_init();
908 /* Initialize alarm bases */
909 alarm_bases
[ALARM_REALTIME
].base_clockid
= CLOCK_REALTIME
;
910 alarm_bases
[ALARM_REALTIME
].get_ktime
= &ktime_get_real
;
911 alarm_bases
[ALARM_REALTIME
].get_timespec
= ktime_get_real_ts64
;
912 alarm_bases
[ALARM_BOOTTIME
].base_clockid
= CLOCK_BOOTTIME
;
913 alarm_bases
[ALARM_BOOTTIME
].get_ktime
= &ktime_get_boottime
;
914 alarm_bases
[ALARM_BOOTTIME
].get_timespec
= get_boottime_timespec
;
915 for (i
= 0; i
< ALARM_NUMTYPE
; i
++) {
916 timerqueue_init_head(&alarm_bases
[i
].timerqueue
);
917 spin_lock_init(&alarm_bases
[i
].lock
);
920 error
= alarmtimer_rtc_interface_setup();
924 error
= platform_driver_register(&alarmtimer_driver
);
930 alarmtimer_rtc_interface_remove();
933 device_initcall(alarmtimer_init
);