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