drivers/staging/android/alarm.c

   1 /* drivers/rtc/alarm.c
   2  *
   3  * Copyright (C) 2007-2009 Google, Inc.
   4  *
   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.
   8  *
   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.
  13  *
  14  */
  15
  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"
  25
  26 /* XXX - Hack out wakelocks, while they are out of tree */
  27 struct wake_lock {
  28         int i;
  29 };
  30 #define wake_lock(x)
  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)
  36
  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)
  44
  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);
  48
  49 #define pr_alarm(debug_level_mask, args...) \
  50         do { \
  51                 if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) { \
  52                         pr_info(args); \
  53                 } \
  54         } while (0)
  55
  56 #define ANDROID_ALARM_WAKEUP_MASK ( \
  57         ANDROID_ALARM_RTC_WAKEUP_MASK | \
  58         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK)
  59
  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)
  63
  64 struct alarm_queue {
  65         struct rb_root alarms;
  66         struct rb_node *first;
  67         struct hrtimer timer;
  68         ktime_t delta;
  69         bool stopped;
  70         ktime_t stopped_time;
  71 };
  72
  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;
  80
  81 static void update_timer_locked(struct alarm_queue *base, bool head_removed)
  82 {
  83         struct android_alarm *alarm;
  84         bool is_wakeup = base == &alarms[ANDROID_ALARM_RTC_WAKEUP] ||
  85                         base == &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
  86
  87         if (base->stopped) {
  88                 pr_alarm(FLOW, "changed alarm while setting the wall time\n");
  89                 return;
  90         }
  91
  92         if (is_wakeup && !suspended && head_removed)
  93                 wake_unlock(&alarm_rtc_wake_lock);
  94
  95         if (!base->first)
  96                 return;
  97
  98         alarm = container_of(base->first, struct android_alarm, node);
  99
 100         pr_alarm(FLOW, "selected alarm, type %d, func %pF at %lld\n",
 101                 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
 102
 103         if (is_wakeup && suspended) {
 104                 pr_alarm(FLOW, "changed alarm while suspened\n");
 105                 wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
 106                 return;
 107         }
 108
 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);
 113 }
 114
 115 static void alarm_enqueue_locked(struct android_alarm *alarm)
 116 {
 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;
 121         int leftmost = 1;
 122         bool was_first = false;
 123
 124         pr_alarm(FLOW, "added alarm, type %d, func %pF at %lld\n",
 125                 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
 126
 127         if (base->first == &alarm->node) {
 128                 base->first = rb_next(&alarm->node);
 129                 was_first = true;
 130         }
 131         if (!RB_EMPTY_NODE(&alarm->node)) {
 132                 rb_erase(&alarm->node, &base->alarms);
 133                 RB_CLEAR_NODE(&alarm->node);
 134         }
 135
 136         while (*link) {
 137                 parent = *link;
 138                 entry = rb_entry(parent, struct android_alarm, node);
 139                 /*
 140                 * We dont care about collisions. Nodes with
 141                 * the same expiry time stay together.
 142                 */
 143                 if (alarm->expires.tv64 < entry->expires.tv64) {
 144                         link = &(*link)->rb_left;
 145                 } else {
 146                         link = &(*link)->rb_right;
 147                         leftmost = 0;
 148                 }
 149         }
 150         if (leftmost)
 151                 base->first = &alarm->node;
 152         if (leftmost || was_first)
 153                 update_timer_locked(base, was_first);
 154
 155         rb_link_node(&alarm->node, parent, link);
 156         rb_insert_color(&alarm->node, &base->alarms);
 157 }
 158
 159 /**
 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
 164  */
 165 void android_alarm_init(struct android_alarm *alarm,
 166         enum android_alarm_type type, void (*function)(struct android_alarm *))
 167 {
 168         RB_CLEAR_NODE(&alarm->node);
 169         alarm->type = type;
 170         alarm->function = function;
 171
 172         pr_alarm(FLOW, "created alarm, type %d, func %pF\n", type, function);
 173 }
 174
 175
 176 /**
 177  * android_alarm_start_range - (re)start an alarm
 178  * @alarm:      the alarm to be added
 179  * @start:      earliest expiry time
 180  * @end:        expiry time
 181  */
 182 void android_alarm_start_range(struct android_alarm *alarm, ktime_t start,
 183                                                                 ktime_t end)
 184 {
 185         unsigned long flags;
 186
 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);
 192 }
 193
 194 /**
 195  * android_alarm_try_to_cancel - try to deactivate an alarm
 196  * @alarm:      alarm to stop
 197  *
 198  * Returns:
 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)
 203  */
 204 int android_alarm_try_to_cancel(struct android_alarm *alarm)
 205 {
 206         struct alarm_queue *base = &alarms[alarm->type];
 207         unsigned long flags;
 208         bool first = false;
 209         int ret = 0;
 210
 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));
 216                 ret = 1;
 217                 if (base->first == &alarm->node) {
 218                         base->first = rb_next(&alarm->node);
 219                         first = true;
 220                 }
 221                 rb_erase(&alarm->node, &base->alarms);
 222                 RB_CLEAR_NODE(&alarm->node);
 223                 if (first)
 224                         update_timer_locked(base, true);
 225         } else
 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))
 230                 ret = -1;
 231         return ret;
 232 }
 233
 234 /**
 235  * android_alarm_cancel - cancel an alarm and wait for the handler to finish.
 236  * @alarm:      the alarm to be cancelled
 237  *
 238  * Returns:
 239  *  0 when the alarm was not active
 240  *  1 when the alarm was active
 241  */
 242 int android_alarm_cancel(struct android_alarm *alarm)
 243 {
 244         for (;;) {
 245                 int ret = android_alarm_try_to_cancel(alarm);
 246                 if (ret >= 0)
 247                         return ret;
 248                 cpu_relax();
 249         }
 250 }
 251
 252 /**
 253  * alarm_set_rtc - set the kernel and rtc walltime
 254  * @new_time:   timespec value containing the new time
 255  */
 256 int android_alarm_set_rtc(struct timespec new_time)
 257 {
 258         int i;
 259         int ret;
 260         unsigned long flags;
 261         struct rtc_time rtc_new_rtc_time;
 262         struct timespec tmp_time;
 263
 264         rtc_time_to_tm(new_time.tv_sec, &rtc_new_rtc_time);
 265
 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);
 272
 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);
 281         }
 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);
 292         }
 293         spin_unlock_irqrestore(&alarm_slock, flags);
 294         if (ret < 0) {
 295                 pr_alarm(ERROR, "alarm_set_rtc: Failed to set time\n");
 296                 goto err;
 297         }
 298         if (!alarm_rtc_dev) {
 299                 pr_alarm(ERROR,
 300                         "alarm_set_rtc: no RTC, time will be lost on reboot\n");
 301                 goto err;
 302         }
 303         ret = rtc_set_time(alarm_rtc_dev, &rtc_new_rtc_time);
 304         if (ret < 0)
 305                 pr_alarm(ERROR, "alarm_set_rtc: "
 306                         "Failed to set RTC, time will be lost on reboot\n");
 307 err:
 308         wake_unlock(&alarm_rtc_wake_lock);
 309         mutex_unlock(&alarm_setrtc_mutex);
 310         return ret;
 311 }
 312
 313 /**
 314  * alarm_get_elapsed_realtime - get the elapsed real time in ktime_t format
 315  *
 316  * returns the time in ktime_t format
 317  */
 318 ktime_t alarm_get_elapsed_realtime(void)
 319 {
 320         ktime_t now;
 321         unsigned long flags;
 322         struct alarm_queue *base = &alarms[ANDROID_ALARM_ELAPSED_REALTIME];
 323
 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);
 328         return now;
 329 }
 330
 331 static enum hrtimer_restart alarm_timer_triggered(struct hrtimer *timer)
 332 {
 333         struct alarm_queue *base;
 334         struct android_alarm *alarm;
 335         unsigned long flags;
 336         ktime_t now;
 337
 338         spin_lock_irqsave(&alarm_slock, flags);
 339
 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);
 343
 344         pr_alarm(INT, "alarm_timer_triggered type %ld at %lld\n",
 345                 base - alarms, ktime_to_ns(now));
 346
 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));
 353                         break;
 354                 }
 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);
 365         }
 366         if (!base->first)
 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;
 371 }
 372
 373 static void alarm_triggered_func(void *p)
 374 {
 375         struct rtc_device *rtc = alarm_rtc_dev;
 376         if (!(rtc->irq_data & RTC_AF))
 377                 return;
 378         pr_alarm(INT, "rtc alarm triggered\n");
 379         wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
 380 }
 381
 382 static int alarm_suspend(struct platform_device *pdev, pm_message_t state)
 383 {
 384         int                 err = 0;
 385         unsigned long       flags;
 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;
 394
 395         pr_alarm(SUSPEND, "alarm_suspend(%p, %d)\n", pdev, state.event);
 396
 397         spin_lock_irqsave(&alarm_slock, flags);
 398         suspended = true;
 399         spin_unlock_irqrestore(&alarm_slock, flags);
 400
 401         hrtimer_cancel(&alarms[ANDROID_ALARM_RTC_WAKEUP].timer);
 402         hrtimer_cancel(&alarms[
 403                         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].timer);
 404
 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;
 413         if (wakeup_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,
 419                                         wall_time.tv_nsec);
 420
 421                 rtc_alarm_time = timespec_sub(ktime_to_timespec(
 422                         hrtimer_get_expires(&wakeup_queue->timer)),
 423                         rtc_delta).tv_sec;
 424
 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);
 430                 pr_alarm(SUSPEND,
 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);
 439
 440                         spin_lock_irqsave(&alarm_slock, flags);
 441                         suspended = false;
 442                         wake_lock_timeout(&alarm_rtc_wake_lock, 2 * HZ);
 443                         update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP],
 444                                                                         false);
 445                         update_timer_locked(&alarms[
 446                                 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP], false);
 447                         err = -EBUSY;
 448                         spin_unlock_irqrestore(&alarm_slock, flags);
 449                 }
 450         }
 451         return err;
 452 }
 453
 454 static int alarm_resume(struct platform_device *pdev)
 455 {
 456         struct rtc_wkalrm alarm;
 457         unsigned long       flags;
 458
 459         pr_alarm(SUSPEND, "alarm_resume(%p)\n", pdev);
 460
 461         memset(&alarm, 0, sizeof(alarm));
 462         alarm.enabled = 0;
 463         rtc_set_alarm(alarm_rtc_dev, &alarm);
 464
 465         spin_lock_irqsave(&alarm_slock, flags);
 466         suspended = false;
 467         update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP], false);
 468         update_timer_locked(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP],
 469                                                                         false);
 470         spin_unlock_irqrestore(&alarm_slock, flags);
 471
 472         return 0;
 473 }
 474
 475 static struct rtc_task alarm_rtc_task = {
 476         .func = alarm_triggered_func
 477 };
 478
 479 static int rtc_alarm_add_device(struct device *dev,
 480                                 struct class_interface *class_intf)
 481 {
 482         int err;
 483         struct rtc_device *rtc = to_rtc_device(dev);
 484
 485         mutex_lock(&alarm_setrtc_mutex);
 486
 487         if (alarm_rtc_dev) {
 488                 err = -EBUSY;
 489                 goto err1;
 490         }
 491
 492         alarm_platform_dev =
 493                 platform_device_register_simple("alarm", -1, NULL, 0);
 494         if (IS_ERR(alarm_platform_dev)) {
 495                 err = PTR_ERR(alarm_platform_dev);
 496                 goto err2;
 497         }
 498         err = rtc_irq_register(rtc, &alarm_rtc_task);
 499         if (err)
 500                 goto err3;
 501         alarm_rtc_dev = rtc;
 502         pr_alarm(INIT_STATUS, "using rtc device, %s, for alarms", rtc->name);
 503         mutex_unlock(&alarm_setrtc_mutex);
 504
 505         return 0;
 506
 507 err3:
 508         platform_device_unregister(alarm_platform_dev);
 509 err2:
 510 err1:
 511         mutex_unlock(&alarm_setrtc_mutex);
 512         return err;
 513 }
 514
 515 static void rtc_alarm_remove_device(struct device *dev,
 516                                     struct class_interface *class_intf)
 517 {
 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;
 523         }
 524 }
 525
 526 static struct class_interface rtc_alarm_interface = {
 527         .add_dev = &rtc_alarm_add_device,
 528         .remove_dev = &rtc_alarm_remove_device,
 529 };
 530
 531 static struct platform_driver alarm_driver = {
 532         .suspend = alarm_suspend,
 533         .resume = alarm_resume,
 534         .driver = {
 535                 .name = "alarm"
 536         }
 537 };
 538
 539 static int __init alarm_late_init(void)
 540 {
 541         unsigned long   flags;
 542         struct timespec tmp_time, system_time;
 543
 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))
 549          */
 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));
 555
 556         spin_unlock_irqrestore(&alarm_slock, flags);
 557         return 0;
 558 }
 559
 560 static int __init alarm_driver_init(void)
 561 {
 562         int err;
 563         int i;
 564
 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;
 569         }
 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);
 574         if (err < 0)
 575                 goto err1;
 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);
 579         if (err < 0)
 580                 goto err2;
 581
 582         return 0;
 583
 584 err2:
 585         wake_lock_destroy(&alarm_rtc_wake_lock);
 586         platform_driver_unregister(&alarm_driver);
 587 err1:
 588         return err;
 589 }
 590
 591 static void  __exit alarm_exit(void)
 592 {
 593         class_interface_unregister(&rtc_alarm_interface);
 594         wake_lock_destroy(&alarm_rtc_wake_lock);
 595         platform_driver_unregister(&alarm_driver);
 596 }
 597
 598 late_initcall(alarm_late_init);
 599 module_init(alarm_driver_init);
 600 module_exit(alarm_exit);
 601