3 * Copyright (C) 2007-2009 Google, Inc.
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <linux/time.h>
17 #include <linux/module.h>
18 #include <linux/device.h>
19 #include <linux/miscdevice.h>
20 #include <linux/platform_device.h>
21 #include <linux/rtc.h>
22 #include <linux/sched.h>
23 #include <linux/spinlock.h>
24 #include "android_alarm.h"
26 /* XXX - Hack out wakelocks, while they are out of tree */
31 #define wake_lock_timeout(x, y)
32 #define wake_unlock(x)
33 #define WAKE_LOCK_SUSPEND 0
34 #define wake_lock_init(x, y, z) ((x)->i = 1)
35 #define wake_lock_destroy(x)
37 #define ANDROID_ALARM_PRINT_ERROR (1U << 0)
38 #define ANDROID_ALARM_PRINT_INIT_STATUS (1U << 1)
39 #define ANDROID_ALARM_PRINT_TSET (1U << 2)
40 #define ANDROID_ALARM_PRINT_CALL (1U << 3)
41 #define ANDROID_ALARM_PRINT_SUSPEND (1U << 4)
42 #define ANDROID_ALARM_PRINT_INT (1U << 5)
43 #define ANDROID_ALARM_PRINT_FLOW (1U << 6)
45 static int debug_mask = ANDROID_ALARM_PRINT_ERROR | \
46 ANDROID_ALARM_PRINT_INIT_STATUS;
47 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
49 #define pr_alarm(debug_level_mask, args...) \
51 if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) { \
56 #define ANDROID_ALARM_WAKEUP_MASK ( \
57 ANDROID_ALARM_RTC_WAKEUP_MASK | \
58 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK)
60 /* support old usespace code */
61 #define ANDROID_ALARM_SET_OLD _IOW('a', 2, time_t) /* set alarm */
62 #define ANDROID_ALARM_SET_AND_WAIT_OLD _IOW('a', 3, time_t)
65 struct rb_root alarms;
66 struct rb_node *first;
73 static struct rtc_device *alarm_rtc_dev;
74 static DEFINE_SPINLOCK(alarm_slock);
75 static DEFINE_MUTEX(alarm_setrtc_mutex);
76 static struct wake_lock alarm_rtc_wake_lock;
77 static struct platform_device *alarm_platform_dev;
78 struct alarm_queue alarms[ANDROID_ALARM_TYPE_COUNT];
79 static bool suspended;
81 static void update_timer_locked(struct alarm_queue *base, bool head_removed)
83 struct android_alarm *alarm;
84 bool is_wakeup = base == &alarms[ANDROID_ALARM_RTC_WAKEUP] ||
85 base == &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
88 pr_alarm(FLOW, "changed alarm while setting the wall time\n");
92 if (is_wakeup && !suspended && head_removed)
93 wake_unlock(&alarm_rtc_wake_lock);
98 alarm = container_of(base->first, struct android_alarm, node);
100 pr_alarm(FLOW, "selected alarm, type %d, func %pF at %lld\n",
101 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
103 if (is_wakeup && suspended) {
104 pr_alarm(FLOW, "changed alarm while suspened\n");
105 wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
109 hrtimer_try_to_cancel(&base->timer);
110 base->timer.node.expires = ktime_add(base->delta, alarm->expires);
111 base->timer._softexpires = ktime_add(base->delta, alarm->softexpires);
112 hrtimer_start_expires(&base->timer, HRTIMER_MODE_ABS);
115 static void alarm_enqueue_locked(struct android_alarm *alarm)
117 struct alarm_queue *base = &alarms[alarm->type];
118 struct rb_node **link = &base->alarms.rb_node;
119 struct rb_node *parent = NULL;
120 struct android_alarm *entry;
122 bool was_first = false;
124 pr_alarm(FLOW, "added alarm, type %d, func %pF at %lld\n",
125 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
127 if (base->first == &alarm->node) {
128 base->first = rb_next(&alarm->node);
131 if (!RB_EMPTY_NODE(&alarm->node)) {
132 rb_erase(&alarm->node, &base->alarms);
133 RB_CLEAR_NODE(&alarm->node);
138 entry = rb_entry(parent, struct android_alarm, node);
140 * We dont care about collisions. Nodes with
141 * the same expiry time stay together.
143 if (alarm->expires.tv64 < entry->expires.tv64) {
144 link = &(*link)->rb_left;
146 link = &(*link)->rb_right;
151 base->first = &alarm->node;
152 if (leftmost || was_first)
153 update_timer_locked(base, was_first);
155 rb_link_node(&alarm->node, parent, link);
156 rb_insert_color(&alarm->node, &base->alarms);
160 * android_alarm_init - initialize an alarm
161 * @alarm: the alarm to be initialized
162 * @type: the alarm type to be used
163 * @function: alarm callback function
165 void android_alarm_init(struct android_alarm *alarm,
166 enum android_alarm_type type, void (*function)(struct android_alarm *))
168 RB_CLEAR_NODE(&alarm->node);
170 alarm->function = function;
172 pr_alarm(FLOW, "created alarm, type %d, func %pF\n", type, function);
177 * android_alarm_start_range - (re)start an alarm
178 * @alarm: the alarm to be added
179 * @start: earliest expiry time
182 void android_alarm_start_range(struct android_alarm *alarm, ktime_t start,
187 spin_lock_irqsave(&alarm_slock, flags);
188 alarm->softexpires = start;
189 alarm->expires = end;
190 alarm_enqueue_locked(alarm);
191 spin_unlock_irqrestore(&alarm_slock, flags);
195 * android_alarm_try_to_cancel - try to deactivate an alarm
196 * @alarm: alarm to stop
199 * 0 when the alarm was not active
200 * 1 when the alarm was active
201 * -1 when the alarm may currently be excuting the callback function and
202 * cannot be stopped (it may also be inactive)
204 int android_alarm_try_to_cancel(struct android_alarm *alarm)
206 struct alarm_queue *base = &alarms[alarm->type];
211 spin_lock_irqsave(&alarm_slock, flags);
212 if (!RB_EMPTY_NODE(&alarm->node)) {
213 pr_alarm(FLOW, "canceled alarm, type %d, func %pF at %lld\n",
214 alarm->type, alarm->function,
215 ktime_to_ns(alarm->expires));
217 if (base->first == &alarm->node) {
218 base->first = rb_next(&alarm->node);
221 rb_erase(&alarm->node, &base->alarms);
222 RB_CLEAR_NODE(&alarm->node);
224 update_timer_locked(base, true);
226 pr_alarm(FLOW, "tried to cancel alarm, type %d, func %pF\n",
227 alarm->type, alarm->function);
228 spin_unlock_irqrestore(&alarm_slock, flags);
229 if (!ret && hrtimer_callback_running(&base->timer))
235 * android_alarm_cancel - cancel an alarm and wait for the handler to finish.
236 * @alarm: the alarm to be cancelled
239 * 0 when the alarm was not active
240 * 1 when the alarm was active
242 int android_alarm_cancel(struct android_alarm *alarm)
245 int ret = android_alarm_try_to_cancel(alarm);
253 * alarm_set_rtc - set the kernel and rtc walltime
254 * @new_time: timespec value containing the new time
256 int android_alarm_set_rtc(struct timespec new_time)
261 struct rtc_time rtc_new_rtc_time;
262 struct timespec tmp_time;
264 rtc_time_to_tm(new_time.tv_sec, &rtc_new_rtc_time);
266 pr_alarm(TSET, "set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
267 new_time.tv_sec, new_time.tv_nsec,
268 rtc_new_rtc_time.tm_hour, rtc_new_rtc_time.tm_min,
269 rtc_new_rtc_time.tm_sec, rtc_new_rtc_time.tm_mon + 1,
270 rtc_new_rtc_time.tm_mday,
271 rtc_new_rtc_time.tm_year + 1900);
273 mutex_lock(&alarm_setrtc_mutex);
274 spin_lock_irqsave(&alarm_slock, flags);
275 wake_lock(&alarm_rtc_wake_lock);
276 getnstimeofday(&tmp_time);
277 for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
278 hrtimer_try_to_cancel(&alarms[i].timer);
279 alarms[i].stopped = true;
280 alarms[i].stopped_time = timespec_to_ktime(tmp_time);
282 alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].delta =
283 alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta =
284 ktime_sub(alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta,
285 timespec_to_ktime(timespec_sub(tmp_time, new_time)));
286 spin_unlock_irqrestore(&alarm_slock, flags);
287 ret = do_settimeofday(&new_time);
288 spin_lock_irqsave(&alarm_slock, flags);
289 for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
290 alarms[i].stopped = false;
291 update_timer_locked(&alarms[i], false);
293 spin_unlock_irqrestore(&alarm_slock, flags);
295 pr_alarm(ERROR, "alarm_set_rtc: Failed to set time\n");
298 if (!alarm_rtc_dev) {
300 "alarm_set_rtc: no RTC, time will be lost on reboot\n");
303 ret = rtc_set_time(alarm_rtc_dev, &rtc_new_rtc_time);
305 pr_alarm(ERROR, "alarm_set_rtc: "
306 "Failed to set RTC, time will be lost on reboot\n");
308 wake_unlock(&alarm_rtc_wake_lock);
309 mutex_unlock(&alarm_setrtc_mutex);
314 * alarm_get_elapsed_realtime - get the elapsed real time in ktime_t format
316 * returns the time in ktime_t format
318 ktime_t alarm_get_elapsed_realtime(void)
322 struct alarm_queue *base = &alarms[ANDROID_ALARM_ELAPSED_REALTIME];
324 spin_lock_irqsave(&alarm_slock, flags);
325 now = base->stopped ? base->stopped_time : ktime_get_real();
326 now = ktime_sub(now, base->delta);
327 spin_unlock_irqrestore(&alarm_slock, flags);
331 static enum hrtimer_restart alarm_timer_triggered(struct hrtimer *timer)
333 struct alarm_queue *base;
334 struct android_alarm *alarm;
338 spin_lock_irqsave(&alarm_slock, flags);
340 base = container_of(timer, struct alarm_queue, timer);
341 now = base->stopped ? base->stopped_time : hrtimer_cb_get_time(timer);
342 now = ktime_sub(now, base->delta);
344 pr_alarm(INT, "alarm_timer_triggered type %ld at %lld\n",
345 base - alarms, ktime_to_ns(now));
347 while (base->first) {
348 alarm = container_of(base->first, struct android_alarm, node);
349 if (alarm->softexpires.tv64 > now.tv64) {
350 pr_alarm(FLOW, "don't call alarm, %pF, %lld (s %lld)\n",
351 alarm->function, ktime_to_ns(alarm->expires),
352 ktime_to_ns(alarm->softexpires));
355 base->first = rb_next(&alarm->node);
356 rb_erase(&alarm->node, &base->alarms);
357 RB_CLEAR_NODE(&alarm->node);
358 pr_alarm(CALL, "call alarm, type %d, func %pF, %lld (s %lld)\n",
359 alarm->type, alarm->function,
360 ktime_to_ns(alarm->expires),
361 ktime_to_ns(alarm->softexpires));
362 spin_unlock_irqrestore(&alarm_slock, flags);
363 alarm->function(alarm);
364 spin_lock_irqsave(&alarm_slock, flags);
367 pr_alarm(FLOW, "no more alarms of type %ld\n", base - alarms);
368 update_timer_locked(base, true);
369 spin_unlock_irqrestore(&alarm_slock, flags);
370 return HRTIMER_NORESTART;
373 static void alarm_triggered_func(void *p)
375 struct rtc_device *rtc = alarm_rtc_dev;
376 if (!(rtc->irq_data & RTC_AF))
378 pr_alarm(INT, "rtc alarm triggered\n");
379 wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
382 static int alarm_suspend(struct platform_device *pdev, pm_message_t state)
386 struct rtc_wkalrm rtc_alarm;
387 struct rtc_time rtc_current_rtc_time;
388 unsigned long rtc_current_time;
389 unsigned long rtc_alarm_time;
390 struct timespec rtc_delta;
391 struct timespec wall_time;
392 struct alarm_queue *wakeup_queue = NULL;
393 struct alarm_queue *tmp_queue = NULL;
395 pr_alarm(SUSPEND, "alarm_suspend(%p, %d)\n", pdev, state.event);
397 spin_lock_irqsave(&alarm_slock, flags);
399 spin_unlock_irqrestore(&alarm_slock, flags);
401 hrtimer_cancel(&alarms[ANDROID_ALARM_RTC_WAKEUP].timer);
402 hrtimer_cancel(&alarms[
403 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].timer);
405 tmp_queue = &alarms[ANDROID_ALARM_RTC_WAKEUP];
406 if (tmp_queue->first)
407 wakeup_queue = tmp_queue;
408 tmp_queue = &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
409 if (tmp_queue->first && (!wakeup_queue ||
410 hrtimer_get_expires(&tmp_queue->timer).tv64 <
411 hrtimer_get_expires(&wakeup_queue->timer).tv64))
412 wakeup_queue = tmp_queue;
414 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
415 getnstimeofday(&wall_time);
416 rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
417 set_normalized_timespec(&rtc_delta,
418 wall_time.tv_sec - rtc_current_time,
421 rtc_alarm_time = timespec_sub(ktime_to_timespec(
422 hrtimer_get_expires(&wakeup_queue->timer)),
425 rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
426 rtc_alarm.enabled = 1;
427 rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
428 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
429 rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
431 "rtc alarm set at %ld, now %ld, rtc delta %ld.%09ld\n",
432 rtc_alarm_time, rtc_current_time,
433 rtc_delta.tv_sec, rtc_delta.tv_nsec);
434 if (rtc_current_time + 1 >= rtc_alarm_time) {
435 pr_alarm(SUSPEND, "alarm about to go off\n");
436 memset(&rtc_alarm, 0, sizeof(rtc_alarm));
437 rtc_alarm.enabled = 0;
438 rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
440 spin_lock_irqsave(&alarm_slock, flags);
442 wake_lock_timeout(&alarm_rtc_wake_lock, 2 * HZ);
443 update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP],
445 update_timer_locked(&alarms[
446 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP], false);
448 spin_unlock_irqrestore(&alarm_slock, flags);
454 static int alarm_resume(struct platform_device *pdev)
456 struct rtc_wkalrm alarm;
459 pr_alarm(SUSPEND, "alarm_resume(%p)\n", pdev);
461 memset(&alarm, 0, sizeof(alarm));
463 rtc_set_alarm(alarm_rtc_dev, &alarm);
465 spin_lock_irqsave(&alarm_slock, flags);
467 update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP], false);
468 update_timer_locked(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP],
470 spin_unlock_irqrestore(&alarm_slock, flags);
475 static struct rtc_task alarm_rtc_task = {
476 .func = alarm_triggered_func
479 static int rtc_alarm_add_device(struct device *dev,
480 struct class_interface *class_intf)
483 struct rtc_device *rtc = to_rtc_device(dev);
485 mutex_lock(&alarm_setrtc_mutex);
493 platform_device_register_simple("alarm", -1, NULL, 0);
494 if (IS_ERR(alarm_platform_dev)) {
495 err = PTR_ERR(alarm_platform_dev);
498 err = rtc_irq_register(rtc, &alarm_rtc_task);
502 pr_alarm(INIT_STATUS, "using rtc device, %s, for alarms", rtc->name);
503 mutex_unlock(&alarm_setrtc_mutex);
508 platform_device_unregister(alarm_platform_dev);
511 mutex_unlock(&alarm_setrtc_mutex);
515 static void rtc_alarm_remove_device(struct device *dev,
516 struct class_interface *class_intf)
518 if (dev == &alarm_rtc_dev->dev) {
519 pr_alarm(INIT_STATUS, "lost rtc device for alarms");
520 rtc_irq_unregister(alarm_rtc_dev, &alarm_rtc_task);
521 platform_device_unregister(alarm_platform_dev);
522 alarm_rtc_dev = NULL;
526 static struct class_interface rtc_alarm_interface = {
527 .add_dev = &rtc_alarm_add_device,
528 .remove_dev = &rtc_alarm_remove_device,
531 static struct platform_driver alarm_driver = {
532 .suspend = alarm_suspend,
533 .resume = alarm_resume,
539 static int __init alarm_late_init(void)
542 struct timespec tmp_time, system_time;
544 /* this needs to run after the rtc is read at boot */
545 spin_lock_irqsave(&alarm_slock, flags);
546 /* We read the current rtc and system time so we can later calulate
547 * elasped realtime to be (boot_systemtime + rtc - boot_rtc) ==
548 * (rtc - (boot_rtc - boot_systemtime))
550 getnstimeofday(&tmp_time);
551 ktime_get_ts(&system_time);
552 alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].delta =
553 alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta =
554 timespec_to_ktime(timespec_sub(tmp_time, system_time));
556 spin_unlock_irqrestore(&alarm_slock, flags);
560 static int __init alarm_driver_init(void)
565 for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
566 hrtimer_init(&alarms[i].timer,
567 CLOCK_REALTIME, HRTIMER_MODE_ABS);
568 alarms[i].timer.function = alarm_timer_triggered;
570 hrtimer_init(&alarms[ANDROID_ALARM_SYSTEMTIME].timer,
571 CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
572 alarms[ANDROID_ALARM_SYSTEMTIME].timer.function = alarm_timer_triggered;
573 err = platform_driver_register(&alarm_driver);
576 wake_lock_init(&alarm_rtc_wake_lock, WAKE_LOCK_SUSPEND, "alarm_rtc");
577 rtc_alarm_interface.class = rtc_class;
578 err = class_interface_register(&rtc_alarm_interface);
585 wake_lock_destroy(&alarm_rtc_wake_lock);
586 platform_driver_unregister(&alarm_driver);
591 static void __exit alarm_exit(void)
593 class_interface_unregister(&rtc_alarm_interface);
594 wake_lock_destroy(&alarm_rtc_wake_lock);
595 platform_driver_unregister(&alarm_driver);
598 late_initcall(alarm_late_init);
599 module_init(alarm_driver_init);
600 module_exit(alarm_exit);