drivers/rtc/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 #ifndef __i386__
  17 #include <asm/mach/time.h>
  18 #endif
  19 #include <linux/android_alarm.h>
  20 #include <linux/device.h>
  21 #include <linux/miscdevice.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/rtc.h>
  24 #include <linux/sched.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/sysdev.h>
  27 #include <linux/wakelock.h>
  28
  29 #define ANDROID_ALARM_PRINT_ERROR (1U << 0)
  30 #define ANDROID_ALARM_PRINT_INIT_STATUS (1U << 1)
  31 #define ANDROID_ALARM_PRINT_TSET (1U << 2)
  32 #define ANDROID_ALARM_PRINT_CALL (1U << 3)
  33 #define ANDROID_ALARM_PRINT_SUSPEND (1U << 4)
  34 #define ANDROID_ALARM_PRINT_INT (1U << 5)
  35 #define ANDROID_ALARM_PRINT_FLOW (1U << 6)
  36
  37 static int debug_mask = ANDROID_ALARM_PRINT_ERROR | \
  38                         ANDROID_ALARM_PRINT_INIT_STATUS;
  39 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
  40
  41 #define pr_alarm(debug_level_mask, args...) \
  42         do { \
  43                 if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) { \
  44                         pr_info(args); \
  45                 } \
  46         } while (0)
  47
  48 #define ANDROID_ALARM_WAKEUP_MASK ( \
  49         ANDROID_ALARM_RTC_WAKEUP_MASK | \
  50         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK)
  51
  52 /* support old usespace code */
  53 #define ANDROID_ALARM_SET_OLD               _IOW('a', 2, time_t) /* set alarm */
  54 #define ANDROID_ALARM_SET_AND_WAIT_OLD      _IOW('a', 3, time_t)
  55
  56 struct alarm_queue {
  57         struct rb_root alarms;
  58         struct rb_node *first;
  59         struct hrtimer timer;
  60         ktime_t delta;
  61         bool stopped;
  62         ktime_t stopped_time;
  63 };
  64
  65 static struct rtc_device *alarm_rtc_dev;
  66 static DEFINE_SPINLOCK(alarm_slock);
  67 static DEFINE_MUTEX(alarm_setrtc_mutex);
  68 static struct wake_lock alarm_rtc_wake_lock;
  69 static struct platform_device *alarm_platform_dev;
  70 struct alarm_queue alarms[ANDROID_ALARM_TYPE_COUNT];
  71 static bool suspended;
  72
  73 static void update_timer_locked(struct alarm_queue *base, bool head_removed)
  74 {
  75         struct alarm *alarm;
  76         bool is_wakeup = base == &alarms[ANDROID_ALARM_RTC_WAKEUP] ||
  77                         base == &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
  78
  79         if (base->stopped) {
  80                 pr_alarm(FLOW, "changed alarm while setting the wall time\n");
  81                 return;
  82         }
  83
  84         if (is_wakeup && !suspended && head_removed)
  85                 wake_unlock(&alarm_rtc_wake_lock);
  86
  87         if (!base->first)
  88                 return;
  89
  90         alarm = container_of(base->first, struct alarm, node);
  91
  92         pr_alarm(FLOW, "selected alarm, type %d, func %pF at %lld\n",
  93                 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
  94
  95         if (is_wakeup && suspended) {
  96                 pr_alarm(FLOW, "changed alarm while suspened\n");
  97                 wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
  98                 return;
  99         }
 100
 101         hrtimer_try_to_cancel(&base->timer);
 102         base->timer.node.expires = ktime_add(base->delta, alarm->expires);
 103         base->timer._softexpires = ktime_add(base->delta, alarm->softexpires);
 104         hrtimer_start_expires(&base->timer, HRTIMER_MODE_ABS);
 105 }
 106
 107 static void alarm_enqueue_locked(struct alarm *alarm)
 108 {
 109         struct alarm_queue *base = &alarms[alarm->type];
 110         struct rb_node **link = &base->alarms.rb_node;
 111         struct rb_node *parent = NULL;
 112         struct alarm *entry;
 113         int leftmost = 1;
 114         bool was_first = false;
 115
 116         pr_alarm(FLOW, "added alarm, type %d, func %pF at %lld\n",
 117                 alarm->type, alarm->function, ktime_to_ns(alarm->expires));
 118
 119         if (base->first == &alarm->node) {
 120                 base->first = rb_next(&alarm->node);
 121                 was_first = true;
 122         }
 123         if (!RB_EMPTY_NODE(&alarm->node)) {
 124                 rb_erase(&alarm->node, &base->alarms);
 125                 RB_CLEAR_NODE(&alarm->node);
 126         }
 127
 128         while (*link) {
 129                 parent = *link;
 130                 entry = rb_entry(parent, struct alarm, node);
 131                 /*
 132                 * We dont care about collisions. Nodes with
 133                 * the same expiry time stay together.
 134                 */
 135                 if (alarm->expires.tv64 < entry->expires.tv64) {
 136                         link = &(*link)->rb_left;
 137                 } else {
 138                         link = &(*link)->rb_right;
 139                         leftmost = 0;
 140                 }
 141         }
 142         if (leftmost)
 143                 base->first = &alarm->node;
 144         if (leftmost || was_first)
 145                 update_timer_locked(base, was_first);
 146
 147         rb_link_node(&alarm->node, parent, link);
 148         rb_insert_color(&alarm->node, &base->alarms);
 149 }
 150
 151 /**
 152  * alarm_init - initialize an alarm
 153  * @alarm:      the alarm to be initialized
 154  * @type:       the alarm type to be used
 155  * @function:   alarm callback function
 156  */
 157 void alarm_init(struct alarm *alarm,
 158         enum android_alarm_type type, void (*function)(struct alarm *))
 159 {
 160         RB_CLEAR_NODE(&alarm->node);
 161         alarm->type = type;
 162         alarm->function = function;
 163
 164         pr_alarm(FLOW, "created alarm, type %d, func %pF\n", type, function);
 165 }
 166
 167
 168 /**
 169  * alarm_start_range - (re)start an alarm
 170  * @alarm:      the alarm to be added
 171  * @start:      earliest expiry time
 172  * @end:        expiry time
 173  */
 174 void alarm_start_range(struct alarm *alarm, ktime_t start, ktime_t end)
 175 {
 176         unsigned long flags;
 177
 178         spin_lock_irqsave(&alarm_slock, flags);
 179         alarm->softexpires = start;
 180         alarm->expires = end;
 181         alarm_enqueue_locked(alarm);
 182         spin_unlock_irqrestore(&alarm_slock, flags);
 183 }
 184
 185 /**
 186  * alarm_try_to_cancel - try to deactivate an alarm
 187  * @alarm:      alarm to stop
 188  *
 189  * Returns:
 190  *  0 when the alarm was not active
 191  *  1 when the alarm was active
 192  * -1 when the alarm may currently be excuting the callback function and
 193  *    cannot be stopped (it may also be inactive)
 194  */
 195 int alarm_try_to_cancel(struct alarm *alarm)
 196 {
 197         struct alarm_queue *base = &alarms[alarm->type];
 198         unsigned long flags;
 199         bool first = false;
 200         int ret = 0;
 201
 202         spin_lock_irqsave(&alarm_slock, flags);
 203         if (!RB_EMPTY_NODE(&alarm->node)) {
 204                 pr_alarm(FLOW, "canceled alarm, type %d, func %pF at %lld\n",
 205                         alarm->type, alarm->function,
 206                         ktime_to_ns(alarm->expires));
 207                 ret = 1;
 208                 if (base->first == &alarm->node) {
 209                         base->first = rb_next(&alarm->node);
 210                         first = true;
 211                 }
 212                 rb_erase(&alarm->node, &base->alarms);
 213                 RB_CLEAR_NODE(&alarm->node);
 214                 if (first)
 215                         update_timer_locked(base, true);
 216         } else
 217                 pr_alarm(FLOW, "tried to cancel alarm, type %d, func %pF\n",
 218                         alarm->type, alarm->function);
 219         spin_unlock_irqrestore(&alarm_slock, flags);
 220         if (!ret && hrtimer_callback_running(&base->timer))
 221                 ret = -1;
 222         return ret;
 223 }
 224
 225 /**
 226  * alarm_cancel - cancel an alarm and wait for the handler to finish.
 227  * @alarm:      the alarm to be cancelled
 228  *
 229  * Returns:
 230  *  0 when the alarm was not active
 231  *  1 when the alarm was active
 232  */
 233 int alarm_cancel(struct alarm *alarm)
 234 {
 235         for (;;) {
 236                 int ret = alarm_try_to_cancel(alarm);
 237                 if (ret >= 0)
 238                         return ret;
 239                 cpu_relax();
 240         }
 241 }
 242
 243 /**
 244  * alarm_set_rtc - set the kernel and rtc walltime
 245  * @new_time:   timespec value containing the new time
 246  */
 247 int alarm_set_rtc(struct timespec new_time)
 248 {
 249         int i;
 250         int ret;
 251         unsigned long flags;
 252         struct rtc_time rtc_new_rtc_time;
 253         struct timespec tmp_time;
 254
 255         rtc_time_to_tm(new_time.tv_sec, &rtc_new_rtc_time);
 256
 257         pr_alarm(TSET, "set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
 258                 new_time.tv_sec, new_time.tv_nsec,
 259                 rtc_new_rtc_time.tm_hour, rtc_new_rtc_time.tm_min,
 260                 rtc_new_rtc_time.tm_sec, rtc_new_rtc_time.tm_mon + 1,
 261                 rtc_new_rtc_time.tm_mday,
 262                 rtc_new_rtc_time.tm_year + 1900);
 263
 264         mutex_lock(&alarm_setrtc_mutex);
 265         spin_lock_irqsave(&alarm_slock, flags);
 266         wake_lock(&alarm_rtc_wake_lock);
 267         getnstimeofday(&tmp_time);
 268         for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
 269                 hrtimer_try_to_cancel(&alarms[i].timer);
 270                 alarms[i].stopped = true;
 271                 alarms[i].stopped_time = timespec_to_ktime(tmp_time);
 272         }
 273         alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].delta =
 274                 alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta =
 275                 ktime_sub(alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta,
 276                         timespec_to_ktime(timespec_sub(tmp_time, new_time)));
 277         spin_unlock_irqrestore(&alarm_slock, flags);
 278         ret = do_settimeofday(&new_time);
 279         spin_lock_irqsave(&alarm_slock, flags);
 280         for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
 281                 alarms[i].stopped = false;
 282                 update_timer_locked(&alarms[i], false);
 283         }
 284         spin_unlock_irqrestore(&alarm_slock, flags);
 285         if (ret < 0) {
 286                 pr_alarm(ERROR, "alarm_set_rtc: Failed to set time\n");
 287                 goto err;
 288         }
 289         if (!alarm_rtc_dev) {
 290                 pr_alarm(ERROR,
 291                         "alarm_set_rtc: no RTC, time will be lost on reboot\n");
 292                 goto err;
 293         }
 294         ret = rtc_set_time(alarm_rtc_dev, &rtc_new_rtc_time);
 295         if (ret < 0)
 296                 pr_alarm(ERROR, "alarm_set_rtc: "
 297                         "Failed to set RTC, time will be lost on reboot\n");
 298 err:
 299         wake_unlock(&alarm_rtc_wake_lock);
 300         mutex_unlock(&alarm_setrtc_mutex);
 301         return ret;
 302 }
 303
 304 /**
 305  * alarm_get_elapsed_realtime - get the elapsed real time in ktime_t format
 306  *
 307  * returns the time in ktime_t format
 308  */
 309 ktime_t alarm_get_elapsed_realtime(void)
 310 {
 311         ktime_t now;
 312         unsigned long flags;
 313         struct alarm_queue *base = &alarms[ANDROID_ALARM_ELAPSED_REALTIME];
 314
 315         spin_lock_irqsave(&alarm_slock, flags);
 316         now = base->stopped ? base->stopped_time : ktime_get_real();
 317         now = ktime_sub(now, base->delta);
 318         spin_unlock_irqrestore(&alarm_slock, flags);
 319         return now;
 320 }
 321
 322 static enum hrtimer_restart alarm_timer_triggered(struct hrtimer *timer)
 323 {
 324         struct alarm_queue *base;
 325         struct alarm *alarm;
 326         unsigned long flags;
 327         ktime_t now;
 328
 329         spin_lock_irqsave(&alarm_slock, flags);
 330
 331         base = container_of(timer, struct alarm_queue, timer);
 332         now = base->stopped ? base->stopped_time : hrtimer_cb_get_time(timer);
 333         now = ktime_sub(now, base->delta);
 334
 335         pr_alarm(INT, "alarm_timer_triggered type %d at %lld\n",
 336                 base - alarms, ktime_to_ns(now));
 337
 338         while (base->first) {
 339                 alarm = container_of(base->first, struct alarm, node);
 340                 if (alarm->softexpires.tv64 > now.tv64) {
 341                         pr_alarm(FLOW, "don't call alarm, %pF, %lld (s %lld)\n",
 342                                 alarm->function, ktime_to_ns(alarm->expires),
 343                                 ktime_to_ns(alarm->softexpires));
 344                         break;
 345                 }
 346                 base->first = rb_next(&alarm->node);
 347                 rb_erase(&alarm->node, &base->alarms);
 348                 RB_CLEAR_NODE(&alarm->node);
 349                 pr_alarm(CALL, "call alarm, type %d, func %pF, %lld (s %lld)\n",
 350                         alarm->type, alarm->function,
 351                         ktime_to_ns(alarm->expires),
 352                         ktime_to_ns(alarm->softexpires));
 353                 spin_unlock_irqrestore(&alarm_slock, flags);
 354                 alarm->function(alarm);
 355                 spin_lock_irqsave(&alarm_slock, flags);
 356         }
 357         if (!base->first)
 358                 pr_alarm(FLOW, "no more alarms of type %d\n", base - alarms);
 359         update_timer_locked(base, true);
 360         spin_unlock_irqrestore(&alarm_slock, flags);
 361         return HRTIMER_NORESTART;
 362 }
 363
 364 static void alarm_triggered_func(void *p)
 365 {
 366         struct rtc_device *rtc = alarm_rtc_dev;
 367         if (!(rtc->irq_data & RTC_AF))
 368                 return;
 369         pr_alarm(INT, "rtc alarm triggered\n");
 370         wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
 371 }
 372
 373 static int alarm_suspend(struct platform_device *pdev, pm_message_t state)
 374 {
 375         int                 err = 0;
 376         unsigned long       flags;
 377         struct rtc_wkalrm   rtc_alarm;
 378         struct rtc_time     rtc_current_rtc_time;
 379         unsigned long       rtc_current_time;
 380         unsigned long       rtc_alarm_time;
 381         struct timespec     rtc_delta;
 382         struct timespec     wall_time;
 383         struct alarm_queue *wakeup_queue = NULL;
 384         struct alarm_queue *tmp_queue = NULL;
 385
 386         pr_alarm(SUSPEND, "alarm_suspend(%p, %d)\n", pdev, state.event);
 387
 388         spin_lock_irqsave(&alarm_slock, flags);
 389         suspended = true;
 390         spin_unlock_irqrestore(&alarm_slock, flags);
 391
 392         hrtimer_cancel(&alarms[ANDROID_ALARM_RTC_WAKEUP].timer);
 393         hrtimer_cancel(&alarms[
 394                         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].timer);
 395
 396         tmp_queue = &alarms[ANDROID_ALARM_RTC_WAKEUP];
 397         if (tmp_queue->first)
 398                 wakeup_queue = tmp_queue;
 399         tmp_queue = &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
 400         if (tmp_queue->first && (!wakeup_queue ||
 401                                 hrtimer_get_expires(&tmp_queue->timer).tv64 <
 402                                 hrtimer_get_expires(&wakeup_queue->timer).tv64))
 403                 wakeup_queue = tmp_queue;
 404         if (wakeup_queue) {
 405                 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
 406                 getnstimeofday(&wall_time);
 407                 rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
 408                 set_normalized_timespec(&rtc_delta,
 409                                         wall_time.tv_sec - rtc_current_time,
 410                                         wall_time.tv_nsec);
 411
 412                 rtc_alarm_time = timespec_sub(ktime_to_timespec(
 413                         hrtimer_get_expires(&wakeup_queue->timer)),
 414                         rtc_delta).tv_sec;
 415
 416                 rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
 417                 rtc_alarm.enabled = 1;
 418                 rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
 419                 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
 420                 rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
 421                 pr_alarm(SUSPEND,
 422                         "rtc alarm set at %ld, now %ld, rtc delta %ld.%09ld\n",
 423                         rtc_alarm_time, rtc_current_time,
 424                         rtc_delta.tv_sec, rtc_delta.tv_nsec);
 425                 if (rtc_current_time + 1 >= rtc_alarm_time) {
 426                         pr_alarm(SUSPEND, "alarm about to go off\n");
 427                         memset(&rtc_alarm, 0, sizeof(rtc_alarm));
 428                         rtc_alarm.enabled = 0;
 429                         rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
 430
 431                         spin_lock_irqsave(&alarm_slock, flags);
 432                         suspended = false;
 433                         wake_lock_timeout(&alarm_rtc_wake_lock, 2 * HZ);
 434                         update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP],
 435                                                                         false);
 436                         update_timer_locked(&alarms[
 437                                 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP], false);
 438                         err = -EBUSY;
 439                         spin_unlock_irqrestore(&alarm_slock, flags);
 440                 }
 441         }
 442         return err;
 443 }
 444
 445 static int alarm_resume(struct platform_device *pdev)
 446 {
 447         struct rtc_wkalrm alarm;
 448         unsigned long       flags;
 449
 450         pr_alarm(SUSPEND, "alarm_resume(%p)\n", pdev);
 451
 452         memset(&alarm, 0, sizeof(alarm));
 453         alarm.enabled = 0;
 454         rtc_set_alarm(alarm_rtc_dev, &alarm);
 455
 456         spin_lock_irqsave(&alarm_slock, flags);
 457         suspended = false;
 458         update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP], false);
 459         update_timer_locked(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP],
 460                                                                         false);
 461         spin_unlock_irqrestore(&alarm_slock, flags);
 462
 463         return 0;
 464 }
 465
 466 static struct rtc_task alarm_rtc_task = {
 467         .func = alarm_triggered_func
 468 };
 469
 470 static int rtc_alarm_add_device(struct device *dev,
 471                                 struct class_interface *class_intf)
 472 {
 473         int err;
 474         struct rtc_device *rtc = to_rtc_device(dev);
 475
 476         mutex_lock(&alarm_setrtc_mutex);
 477
 478         if (alarm_rtc_dev) {
 479                 err = -EBUSY;
 480                 goto err1;
 481         }
 482
 483         alarm_platform_dev =
 484                 platform_device_register_simple("alarm", -1, NULL, 0);
 485         if (IS_ERR(alarm_platform_dev)) {
 486                 err = PTR_ERR(alarm_platform_dev);
 487                 goto err2;
 488         }
 489         err = rtc_irq_register(rtc, &alarm_rtc_task);
 490         if (err)
 491                 goto err3;
 492         alarm_rtc_dev = rtc;
 493         pr_alarm(INIT_STATUS, "using rtc device, %s, for alarms", rtc->name);
 494         mutex_unlock(&alarm_setrtc_mutex);
 495
 496         return 0;
 497
 498 err3:
 499         platform_device_unregister(alarm_platform_dev);
 500 err2:
 501 err1:
 502         mutex_unlock(&alarm_setrtc_mutex);
 503         return err;
 504 }
 505
 506 static void rtc_alarm_remove_device(struct device *dev,
 507                                     struct class_interface *class_intf)
 508 {
 509         if (dev == &alarm_rtc_dev->dev) {
 510                 pr_alarm(INIT_STATUS, "lost rtc device for alarms");
 511                 rtc_irq_unregister(alarm_rtc_dev, &alarm_rtc_task);
 512                 platform_device_unregister(alarm_platform_dev);
 513                 alarm_rtc_dev = NULL;
 514         }
 515 }
 516
 517 static struct class_interface rtc_alarm_interface = {
 518         .add_dev = &rtc_alarm_add_device,
 519         .remove_dev = &rtc_alarm_remove_device,
 520 };
 521
 522 static struct platform_driver alarm_driver = {
 523         .suspend = alarm_suspend,
 524         .resume = alarm_resume,
 525         .driver = {
 526                 .name = "alarm"
 527         }
 528 };
 529
 530 static int __init alarm_late_init(void)
 531 {
 532         unsigned long   flags;
 533         struct timespec tmp_time, system_time;
 534
 535         /* this needs to run after the rtc is read at boot */
 536         spin_lock_irqsave(&alarm_slock, flags);
 537         /* We read the current rtc and system time so we can later calulate
 538          * elasped realtime to be (boot_systemtime + rtc - boot_rtc) ==
 539          * (rtc - (boot_rtc - boot_systemtime))
 540          */
 541         getnstimeofday(&tmp_time);
 542         ktime_get_ts(&system_time);
 543         alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].delta =
 544                 alarms[ANDROID_ALARM_ELAPSED_REALTIME].delta =
 545                         timespec_to_ktime(timespec_sub(tmp_time, system_time));
 546
 547         spin_unlock_irqrestore(&alarm_slock, flags);
 548         return 0;
 549 }
 550
 551 static int __init alarm_driver_init(void)
 552 {
 553         int err;
 554         int i;
 555
 556         for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
 557                 hrtimer_init(&alarms[i].timer,
 558                                 CLOCK_REALTIME, HRTIMER_MODE_ABS);
 559                 alarms[i].timer.function = alarm_timer_triggered;
 560         }
 561         hrtimer_init(&alarms[ANDROID_ALARM_SYSTEMTIME].timer,
 562                      CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
 563         alarms[ANDROID_ALARM_SYSTEMTIME].timer.function = alarm_timer_triggered;
 564         err = platform_driver_register(&alarm_driver);
 565         if (err < 0)
 566                 goto err1;
 567         wake_lock_init(&alarm_rtc_wake_lock, WAKE_LOCK_SUSPEND, "alarm_rtc");
 568         rtc_alarm_interface.class = rtc_class;
 569         err = class_interface_register(&rtc_alarm_interface);
 570         if (err < 0)
 571                 goto err2;
 572
 573         return 0;
 574
 575 err2:
 576         wake_lock_destroy(&alarm_rtc_wake_lock);
 577         platform_driver_unregister(&alarm_driver);
 578 err1:
 579         return err;
 580 }
 581
 582 static void  __exit alarm_exit(void)
 583 {
 584         class_interface_unregister(&rtc_alarm_interface);
 585         wake_lock_destroy(&alarm_rtc_wake_lock);
 586         platform_driver_unregister(&alarm_driver);
 587 }
 588
 589 late_initcall(alarm_late_init);
 590 module_init(alarm_driver_init);
 591 module_exit(alarm_exit);
 592