1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
29
30
31
32
33
34
35
36
37static struct alarm_base {
38 spinlock_t lock;
39 struct timerqueue_head timerqueue;
40 ktime_t (*gettime)(void);
41 clockid_t base_clockid;
42} alarm_bases[ALARM_NUMTYPE];
43
44
45static ktime_t freezer_delta;
46static DEFINE_SPINLOCK(freezer_delta_lock);
47
48static struct wakeup_source *ws;
49
50#ifdef CONFIG_RTC_CLASS
51
52static struct rtc_timer rtctimer;
53static struct rtc_device *rtcdev;
54static DEFINE_SPINLOCK(rtcdev_lock);
55
56
57
58
59
60
61
62
63struct rtc_device *alarmtimer_get_rtcdev(void)
64{
65 unsigned long flags;
66 struct rtc_device *ret;
67
68 spin_lock_irqsave(&rtcdev_lock, flags);
69 ret = rtcdev;
70 spin_unlock_irqrestore(&rtcdev_lock, flags);
71
72 return ret;
73}
74EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev);
75
76static int alarmtimer_rtc_add_device(struct device *dev,
77 struct class_interface *class_intf)
78{
79 unsigned long flags;
80 struct rtc_device *rtc = to_rtc_device(dev);
81
82 if (rtcdev)
83 return -EBUSY;
84
85 if (!rtc->ops->set_alarm)
86 return -1;
87 if (!device_may_wakeup(rtc->dev.parent))
88 return -1;
89
90 spin_lock_irqsave(&rtcdev_lock, flags);
91 if (!rtcdev) {
92 rtcdev = rtc;
93
94 get_device(dev);
95 }
96 spin_unlock_irqrestore(&rtcdev_lock, flags);
97 return 0;
98}
99
100static inline void alarmtimer_rtc_timer_init(void)
101{
102 rtc_timer_init(&rtctimer, NULL, NULL);
103}
104
105static struct class_interface alarmtimer_rtc_interface = {
106 .add_dev = &alarmtimer_rtc_add_device,
107};
108
109static int alarmtimer_rtc_interface_setup(void)
110{
111 alarmtimer_rtc_interface.class = rtc_class;
112 return class_interface_register(&alarmtimer_rtc_interface);
113}
114static void alarmtimer_rtc_interface_remove(void)
115{
116 class_interface_unregister(&alarmtimer_rtc_interface);
117}
118#else
119struct rtc_device *alarmtimer_get_rtcdev(void)
120{
121 return NULL;
122}
123#define rtcdev (NULL)
124static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
125static inline void alarmtimer_rtc_interface_remove(void) { }
126static inline void alarmtimer_rtc_timer_init(void) { }
127#endif
128
129
130
131
132
133
134
135
136
137
138static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
139{
140 if (alarm->state & ALARMTIMER_STATE_ENQUEUED)
141 timerqueue_del(&base->timerqueue, &alarm->node);
142
143 timerqueue_add(&base->timerqueue, &alarm->node);
144 alarm->state |= ALARMTIMER_STATE_ENQUEUED;
145}
146
147
148
149
150
151
152
153
154
155
156static void alarmtimer_dequeue(struct alarm_base *base, struct alarm *alarm)
157{
158 if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
159 return;
160
161 timerqueue_del(&base->timerqueue, &alarm->node);
162 alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
163}
164
165
166
167
168
169
170
171
172
173
174
175static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
176{
177 struct alarm *alarm = container_of(timer, struct alarm, timer);
178 struct alarm_base *base = &alarm_bases[alarm->type];
179 unsigned long flags;
180 int ret = HRTIMER_NORESTART;
181 int restart = ALARMTIMER_NORESTART;
182
183 spin_lock_irqsave(&base->lock, flags);
184 alarmtimer_dequeue(base, alarm);
185 spin_unlock_irqrestore(&base->lock, flags);
186
187 if (alarm->function)
188 restart = alarm->function(alarm, base->gettime());
189
190 spin_lock_irqsave(&base->lock, flags);
191 if (restart != ALARMTIMER_NORESTART) {
192 hrtimer_set_expires(&alarm->timer, alarm->node.expires);
193 alarmtimer_enqueue(base, alarm);
194 ret = HRTIMER_RESTART;
195 }
196 spin_unlock_irqrestore(&base->lock, flags);
197
198 return ret;
199
200}
201
202ktime_t alarm_expires_remaining(const struct alarm *alarm)
203{
204 struct alarm_base *base = &alarm_bases[alarm->type];
205 return ktime_sub(alarm->node.expires, base->gettime());
206}
207EXPORT_SYMBOL_GPL(alarm_expires_remaining);
208
209#ifdef CONFIG_RTC_CLASS
210
211
212
213
214
215
216
217
218
219
220static int alarmtimer_suspend(struct device *dev)
221{
222 struct rtc_time tm;
223 ktime_t min, now;
224 unsigned long flags;
225 struct rtc_device *rtc;
226 int i;
227 int ret;
228
229 spin_lock_irqsave(&freezer_delta_lock, flags);
230 min = freezer_delta;
231 freezer_delta = ktime_set(0, 0);
232 spin_unlock_irqrestore(&freezer_delta_lock, flags);
233
234 rtc = alarmtimer_get_rtcdev();
235
236 if (!rtc)
237 return 0;
238
239
240 for (i = 0; i < ALARM_NUMTYPE; i++) {
241 struct alarm_base *base = &alarm_bases[i];
242 struct timerqueue_node *next;
243 ktime_t delta;
244
245 spin_lock_irqsave(&base->lock, flags);
246 next = timerqueue_getnext(&base->timerqueue);
247 spin_unlock_irqrestore(&base->lock, flags);
248 if (!next)
249 continue;
250 delta = ktime_sub(next->expires, base->gettime());
251 if (!min.tv64 || (delta.tv64 < min.tv64))
252 min = delta;
253 }
254 if (min.tv64 == 0)
255 return 0;
256
257 if (ktime_to_ns(min) < 2 * NSEC_PER_SEC) {
258 __pm_wakeup_event(ws, 2 * MSEC_PER_SEC);
259 return -EBUSY;
260 }
261
262
263 rtc_timer_cancel(rtc, &rtctimer);
264 rtc_read_time(rtc, &tm);
265 now = rtc_tm_to_ktime(tm);
266 now = ktime_add(now, min);
267
268
269 ret = rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0));
270 if (ret < 0)
271 __pm_wakeup_event(ws, MSEC_PER_SEC);
272 return ret;
273}
274#else
275static int alarmtimer_suspend(struct device *dev)
276{
277 return 0;
278}
279#endif
280
281static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
282{
283 ktime_t delta;
284 unsigned long flags;
285 struct alarm_base *base = &alarm_bases[type];
286
287 delta = ktime_sub(absexp, base->gettime());
288
289 spin_lock_irqsave(&freezer_delta_lock, flags);
290 if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64))
291 freezer_delta = delta;
292 spin_unlock_irqrestore(&freezer_delta_lock, flags);
293}
294
295
296
297
298
299
300
301
302void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
303 enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
304{
305 timerqueue_init(&alarm->node);
306 hrtimer_init(&alarm->timer, alarm_bases[type].base_clockid,
307 HRTIMER_MODE_ABS);
308 alarm->timer.function = alarmtimer_fired;
309 alarm->function = function;
310 alarm->type = type;
311 alarm->state = ALARMTIMER_STATE_INACTIVE;
312}
313EXPORT_SYMBOL_GPL(alarm_init);
314
315
316
317
318
319
320void alarm_start(struct alarm *alarm, ktime_t start)
321{
322 struct alarm_base *base = &alarm_bases[alarm->type];
323 unsigned long flags;
324
325 spin_lock_irqsave(&base->lock, flags);
326 alarm->node.expires = start;
327 alarmtimer_enqueue(base, alarm);
328 hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
329 spin_unlock_irqrestore(&base->lock, flags);
330}
331EXPORT_SYMBOL_GPL(alarm_start);
332
333
334
335
336
337
338void alarm_start_relative(struct alarm *alarm, ktime_t start)
339{
340 struct alarm_base *base = &alarm_bases[alarm->type];
341
342 start = ktime_add(start, base->gettime());
343 alarm_start(alarm, start);
344}
345EXPORT_SYMBOL_GPL(alarm_start_relative);
346
347void alarm_restart(struct alarm *alarm)
348{
349 struct alarm_base *base = &alarm_bases[alarm->type];
350 unsigned long flags;
351
352 spin_lock_irqsave(&base->lock, flags);
353 hrtimer_set_expires(&alarm->timer, alarm->node.expires);
354 hrtimer_restart(&alarm->timer);
355 alarmtimer_enqueue(base, alarm);
356 spin_unlock_irqrestore(&base->lock, flags);
357}
358EXPORT_SYMBOL_GPL(alarm_restart);
359
360
361
362
363
364
365
366
367int alarm_try_to_cancel(struct alarm *alarm)
368{
369 struct alarm_base *base = &alarm_bases[alarm->type];
370 unsigned long flags;
371 int ret;
372
373 spin_lock_irqsave(&base->lock, flags);
374 ret = hrtimer_try_to_cancel(&alarm->timer);
375 if (ret >= 0)
376 alarmtimer_dequeue(base, alarm);
377 spin_unlock_irqrestore(&base->lock, flags);
378 return ret;
379}
380EXPORT_SYMBOL_GPL(alarm_try_to_cancel);
381
382
383
384
385
386
387
388
389int alarm_cancel(struct alarm *alarm)
390{
391 for (;;) {
392 int ret = alarm_try_to_cancel(alarm);
393 if (ret >= 0)
394 return ret;
395 cpu_relax();
396 }
397}
398EXPORT_SYMBOL_GPL(alarm_cancel);
399
400
401u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
402{
403 u64 overrun = 1;
404 ktime_t delta;
405
406 delta = ktime_sub(now, alarm->node.expires);
407
408 if (delta.tv64 < 0)
409 return 0;
410
411 if (unlikely(delta.tv64 >= interval.tv64)) {
412 s64 incr = ktime_to_ns(interval);
413
414 overrun = ktime_divns(delta, incr);
415
416 alarm->node.expires = ktime_add_ns(alarm->node.expires,
417 incr*overrun);
418
419 if (alarm->node.expires.tv64 > now.tv64)
420 return overrun;
421
422
423
424
425 overrun++;
426 }
427
428 alarm->node.expires = ktime_add(alarm->node.expires, interval);
429 return overrun;
430}
431EXPORT_SYMBOL_GPL(alarm_forward);
432
433u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
434{
435 struct alarm_base *base = &alarm_bases[alarm->type];
436
437 return alarm_forward(alarm, base->gettime(), interval);
438}
439EXPORT_SYMBOL_GPL(alarm_forward_now);
440
441
442
443
444
445
446static enum alarmtimer_type clock2alarm(clockid_t clockid)
447{
448 if (clockid == CLOCK_REALTIME_ALARM)
449 return ALARM_REALTIME;
450 if (clockid == CLOCK_BOOTTIME_ALARM)
451 return ALARM_BOOTTIME;
452 return -1;
453}
454
455
456
457
458
459
460
461static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
462 ktime_t now)
463{
464 unsigned long flags;
465 struct k_itimer *ptr = container_of(alarm, struct k_itimer,
466 it.alarm.alarmtimer);
467 enum alarmtimer_restart result = ALARMTIMER_NORESTART;
468
469 spin_lock_irqsave(&ptr->it_lock, flags);
470 if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
471 if (posix_timer_event(ptr, 0) != 0)
472 ptr->it_overrun++;
473 }
474
475
476 if (ptr->it.alarm.interval.tv64) {
477 ptr->it_overrun += alarm_forward(alarm, now,
478 ptr->it.alarm.interval);
479 result = ALARMTIMER_RESTART;
480 }
481 spin_unlock_irqrestore(&ptr->it_lock, flags);
482
483 return result;
484}
485
486
487
488
489
490
491
492
493static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
494{
495 if (!alarmtimer_get_rtcdev())
496 return -EINVAL;
497
498 tp->tv_sec = 0;
499 tp->tv_nsec = hrtimer_resolution;
500 return 0;
501}
502
503
504
505
506
507
508
509
510static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
511{
512 struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
513
514 if (!alarmtimer_get_rtcdev())
515 return -EINVAL;
516
517 *tp = ktime_to_timespec(base->gettime());
518 return 0;
519}
520
521
522
523
524
525
526
527static int alarm_timer_create(struct k_itimer *new_timer)
528{
529 enum alarmtimer_type type;
530 struct alarm_base *base;
531
532 if (!alarmtimer_get_rtcdev())
533 return -ENOTSUPP;
534
535 if (!capable(CAP_WAKE_ALARM))
536 return -EPERM;
537
538 type = clock2alarm(new_timer->it_clock);
539 base = &alarm_bases[type];
540 alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
541 return 0;
542}
543
544
545
546
547
548
549
550
551static void alarm_timer_get(struct k_itimer *timr,
552 struct itimerspec *cur_setting)
553{
554 ktime_t relative_expiry_time =
555 alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
556
557 if (ktime_to_ns(relative_expiry_time) > 0) {
558 cur_setting->it_value = ktime_to_timespec(relative_expiry_time);
559 } else {
560 cur_setting->it_value.tv_sec = 0;
561 cur_setting->it_value.tv_nsec = 0;
562 }
563
564 cur_setting->it_interval = ktime_to_timespec(timr->it.alarm.interval);
565}
566
567
568
569
570
571
572
573static int alarm_timer_del(struct k_itimer *timr)
574{
575 if (!rtcdev)
576 return -ENOTSUPP;
577
578 if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
579 return TIMER_RETRY;
580
581 return 0;
582}
583
584
585
586
587
588
589
590
591
592
593static int alarm_timer_set(struct k_itimer *timr, int flags,
594 struct itimerspec *new_setting,
595 struct itimerspec *old_setting)
596{
597 ktime_t exp;
598
599 if (!rtcdev)
600 return -ENOTSUPP;
601
602 if (flags & ~TIMER_ABSTIME)
603 return -EINVAL;
604
605 if (old_setting)
606 alarm_timer_get(timr, old_setting);
607
608
609 if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
610 return TIMER_RETRY;
611
612
613 timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
614 exp = timespec_to_ktime(new_setting->it_value);
615
616 if (flags != TIMER_ABSTIME) {
617 ktime_t now;
618
619 now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
620 exp = ktime_add(now, exp);
621 }
622
623 alarm_start(&timr->it.alarm.alarmtimer, exp);
624 return 0;
625}
626
627
628
629
630
631
632
633static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
634 ktime_t now)
635{
636 struct task_struct *task = (struct task_struct *)alarm->data;
637
638 alarm->data = NULL;
639 if (task)
640 wake_up_process(task);
641 return ALARMTIMER_NORESTART;
642}
643
644
645
646
647
648
649
650
651static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
652{
653 alarm->data = (void *)current;
654 do {
655 set_current_state(TASK_INTERRUPTIBLE);
656 alarm_start(alarm, absexp);
657 if (likely(alarm->data))
658 schedule();
659
660 alarm_cancel(alarm);
661 } while (alarm->data && !signal_pending(current));
662
663 __set_current_state(TASK_RUNNING);
664
665 return (alarm->data == NULL);
666}
667
668
669
670
671
672
673
674
675
676
677
678static int update_rmtp(ktime_t exp, enum alarmtimer_type type,
679 struct timespec __user *rmtp)
680{
681 struct timespec rmt;
682 ktime_t rem;
683
684 rem = ktime_sub(exp, alarm_bases[type].gettime());
685
686 if (rem.tv64 <= 0)
687 return 0;
688 rmt = ktime_to_timespec(rem);
689
690 if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
691 return -EFAULT;
692
693 return 1;
694
695}
696
697
698
699
700
701
702
703static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
704{
705 enum alarmtimer_type type = restart->nanosleep.clockid;
706 ktime_t exp;
707 struct timespec __user *rmtp;
708 struct alarm alarm;
709 int ret = 0;
710
711 exp.tv64 = restart->nanosleep.expires;
712 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
713
714 if (alarmtimer_do_nsleep(&alarm, exp))
715 goto out;
716
717 if (freezing(current))
718 alarmtimer_freezerset(exp, type);
719
720 rmtp = restart->nanosleep.rmtp;
721 if (rmtp) {
722 ret = update_rmtp(exp, type, rmtp);
723 if (ret <= 0)
724 goto out;
725 }
726
727
728
729 ret = -ERESTART_RESTARTBLOCK;
730out:
731 return ret;
732}
733
734
735
736
737
738
739
740
741
742
743static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
744 struct timespec *tsreq, struct timespec __user *rmtp)
745{
746 enum alarmtimer_type type = clock2alarm(which_clock);
747 struct alarm alarm;
748 ktime_t exp;
749 int ret = 0;
750 struct restart_block *restart;
751
752 if (!alarmtimer_get_rtcdev())
753 return -ENOTSUPP;
754
755 if (flags & ~TIMER_ABSTIME)
756 return -EINVAL;
757
758 if (!capable(CAP_WAKE_ALARM))
759 return -EPERM;
760
761 alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
762
763 exp = timespec_to_ktime(*tsreq);
764
765 if (flags != TIMER_ABSTIME) {
766 ktime_t now = alarm_bases[type].gettime();
767 exp = ktime_add(now, exp);
768 }
769
770 if (alarmtimer_do_nsleep(&alarm, exp))
771 goto out;
772
773 if (freezing(current))
774 alarmtimer_freezerset(exp, type);
775
776
777 if (flags == TIMER_ABSTIME) {
778 ret = -ERESTARTNOHAND;
779 goto out;
780 }
781
782 if (rmtp) {
783 ret = update_rmtp(exp, type, rmtp);
784 if (ret <= 0)
785 goto out;
786 }
787
788 restart = ¤t->restart_block;
789 restart->fn = alarm_timer_nsleep_restart;
790 restart->nanosleep.clockid = type;
791 restart->nanosleep.expires = exp.tv64;
792 restart->nanosleep.rmtp = rmtp;
793 ret = -ERESTART_RESTARTBLOCK;
794
795out:
796 return ret;
797}
798
799
800
801static const struct dev_pm_ops alarmtimer_pm_ops = {
802 .suspend = alarmtimer_suspend,
803};
804
805static struct platform_driver alarmtimer_driver = {
806 .driver = {
807 .name = "alarmtimer",
808 .pm = &alarmtimer_pm_ops,
809 }
810};
811
812
813
814
815
816
817
818static int __init alarmtimer_init(void)
819{
820 struct platform_device *pdev;
821 int error = 0;
822 int i;
823 struct k_clock alarm_clock = {
824 .clock_getres = alarm_clock_getres,
825 .clock_get = alarm_clock_get,
826 .timer_create = alarm_timer_create,
827 .timer_set = alarm_timer_set,
828 .timer_del = alarm_timer_del,
829 .timer_get = alarm_timer_get,
830 .nsleep = alarm_timer_nsleep,
831 };
832
833 alarmtimer_rtc_timer_init();
834
835 posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
836 posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
837
838
839 alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
840 alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
841 alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
842 alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
843 for (i = 0; i < ALARM_NUMTYPE; i++) {
844 timerqueue_init_head(&alarm_bases[i].timerqueue);
845 spin_lock_init(&alarm_bases[i].lock);
846 }
847
848 error = alarmtimer_rtc_interface_setup();
849 if (error)
850 return error;
851
852 error = platform_driver_register(&alarmtimer_driver);
853 if (error)
854 goto out_if;
855
856 pdev = platform_device_register_simple("alarmtimer", -1, NULL, 0);
857 if (IS_ERR(pdev)) {
858 error = PTR_ERR(pdev);
859 goto out_drv;
860 }
861 ws = wakeup_source_register("alarmtimer");
862 return 0;
863
864out_drv:
865 platform_driver_unregister(&alarmtimer_driver);
866out_if:
867 alarmtimer_rtc_interface_remove();
868 return error;
869}
870device_initcall(alarmtimer_init);
871