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