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