drivers/rtc/alarm.c

   1 /* drivers/rtc/alarm.c
   2  *
   3  * Copyright (C) 2007 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_ERRORS (1U << 0)
  28 #define ANDROID_ALARM_PRINT_INIT_STATUS (1U << 1)
  29 #define ANDROID_ALARM_PRINT_INFO (1U << 2)
  30 #define ANDROID_ALARM_PRINT_IO (1U << 3)
  31 #define ANDROID_ALARM_PRINT_INT (1U << 4)
  32 #define ANDROID_ALARM_PRINT_FLOW (1U << 5)
  33
  34 #if 0
  35 #define ANDROID_ALARM_DPRINTF_MASK (~0)
  36 #define ANDROID_ALARM_DPRINTF(debug_level_mask, args...) \
  37         do { \
  38                 if (ANDROID_ALARM_DPRINTF_MASK & debug_level_mask) { \
  39                         printk(args); \
  40                 } \
  41         } while (0)
  42 #else
  43 #define ANDROID_ALARM_DPRINTF(args...)
  44 #endif
  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 static struct rtc_device *alarm_rtc_dev;
  55 static int alarm_opened;
  56 static DEFINE_SPINLOCK(alarm_slock);
  57 static DEFINE_MUTEX(alarm_setrtc_mutex);
  58 static struct wake_lock alarm_wake_lock;
  59 static struct wake_lock alarm_rtc_wake_lock;
  60 static DECLARE_WAIT_QUEUE_HEAD(alarm_wait_queue);
  61 static uint32_t alarm_pending;
  62 static uint32_t alarm_enabled;
  63 static uint32_t wait_pending;
  64 static struct platform_device *alarm_platform_dev;
  65 static struct hrtimer alarm_timer[ANDROID_ALARM_TYPE_COUNT];
  66 static struct timespec alarm_time[ANDROID_ALARM_TYPE_COUNT];
  67 static struct timespec elapsed_rtc_delta;
  68
  69 static void alarm_start_hrtimer(enum android_alarm_type alarm_type)
  70 {
  71         struct timespec hr_alarm_time;
  72         if (!(alarm_enabled & (1U << alarm_type)))
  73                 return;
  74         hr_alarm_time = alarm_time[alarm_type];
  75         if (alarm_type == ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP ||
  76             alarm_type == ANDROID_ALARM_ELAPSED_REALTIME)
  77                 set_normalized_timespec(&hr_alarm_time,
  78                         hr_alarm_time.tv_sec + elapsed_rtc_delta.tv_sec,
  79                         hr_alarm_time.tv_nsec + elapsed_rtc_delta.tv_nsec);
  80         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_FLOW,
  81                 "alarm start hrtimer %d at %ld.%09ld\n",
  82                 alarm_type, hr_alarm_time.tv_sec, hr_alarm_time.tv_nsec);
  83         hrtimer_start(&alarm_timer[alarm_type],
  84                       timespec_to_ktime(hr_alarm_time), HRTIMER_MODE_ABS);
  85 }
  86
  87 static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  88 {
  89         int rv = 0;
  90         unsigned long flags;
  91         int i;
  92         struct timespec new_alarm_time;
  93         struct timespec new_rtc_time;
  94         struct timespec tmp_time;
  95         struct rtc_time rtc_new_rtc_time;
  96         enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd);
  97         uint32_t alarm_type_mask = 1U << alarm_type;
  98
  99         if (alarm_type >= ANDROID_ALARM_TYPE_COUNT)
 100                 return -EINVAL;
 101
 102         if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) {
 103                 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 104                         return -EPERM;
 105                 if (file->private_data == NULL &&
 106                     cmd != ANDROID_ALARM_SET_RTC) {
 107                         spin_lock_irqsave(&alarm_slock, flags);
 108                         if (alarm_opened) {
 109                                 spin_unlock_irqrestore(&alarm_slock, flags);
 110                                 return -EBUSY;
 111                         }
 112                         alarm_opened = 1;
 113                         file->private_data = (void *)1;
 114                         spin_unlock_irqrestore(&alarm_slock, flags);
 115                 }
 116         }
 117
 118         switch (ANDROID_ALARM_BASE_CMD(cmd)) {
 119         case ANDROID_ALARM_CLEAR(0):
 120                 spin_lock_irqsave(&alarm_slock, flags);
 121                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_IO,
 122                                       "alarm %d clear\n", alarm_type);
 123                 hrtimer_try_to_cancel(&alarm_timer[alarm_type]);
 124                 if (alarm_pending) {
 125                         alarm_pending &= ~alarm_type_mask;
 126                         if (!alarm_pending && !wait_pending)
 127                                 wake_unlock(&alarm_wake_lock);
 128                 }
 129                 alarm_enabled &= ~alarm_type_mask;
 130                 spin_unlock_irqrestore(&alarm_slock, flags);
 131                 break;
 132
 133         case ANDROID_ALARM_SET_OLD:
 134         case ANDROID_ALARM_SET_AND_WAIT_OLD:
 135                 if (get_user(new_alarm_time.tv_sec, (int __user *)arg)) {
 136                         rv = -EFAULT;
 137                         goto err1;
 138                 }
 139                 new_alarm_time.tv_nsec = 0;
 140                 goto from_old_alarm_set;
 141
 142         case ANDROID_ALARM_SET_AND_WAIT(0):
 143         case ANDROID_ALARM_SET(0):
 144                 if (copy_from_user(&new_alarm_time, (void __user *)arg,
 145                     sizeof(new_alarm_time))) {
 146                         rv = -EFAULT;
 147                         goto err1;
 148                 }
 149 from_old_alarm_set:
 150                 spin_lock_irqsave(&alarm_slock, flags);
 151                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_IO,
 152                         "alarm %d set %ld.%09ld\n", alarm_type,
 153                         new_alarm_time.tv_sec, new_alarm_time.tv_nsec);
 154                 alarm_time[alarm_type] = new_alarm_time;
 155                 alarm_enabled |= alarm_type_mask;
 156                 alarm_start_hrtimer(alarm_type);
 157                 spin_unlock_irqrestore(&alarm_slock, flags);
 158                 if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_SET_AND_WAIT(0)
 159                     && cmd != ANDROID_ALARM_SET_AND_WAIT_OLD)
 160                         break;
 161                 /* fall though */
 162         case ANDROID_ALARM_WAIT:
 163                 spin_lock_irqsave(&alarm_slock, flags);
 164                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_IO, "alarm wait\n");
 165                 if (!alarm_pending && wait_pending) {
 166                         wake_unlock(&alarm_wake_lock);
 167                         wait_pending = 0;
 168                 }
 169                 spin_unlock_irqrestore(&alarm_slock, flags);
 170                 rv = wait_event_interruptible(alarm_wait_queue, alarm_pending);
 171                 if (rv)
 172                         goto err1;
 173                 spin_lock_irqsave(&alarm_slock, flags);
 174                 rv = alarm_pending;
 175                 wait_pending = 1;
 176                 alarm_pending = 0;
 177                 if (rv & ANDROID_ALARM_WAKEUP_MASK)
 178                         wake_unlock(&alarm_rtc_wake_lock);
 179                 spin_unlock_irqrestore(&alarm_slock, flags);
 180                 break;
 181         case ANDROID_ALARM_SET_RTC:
 182                 if (copy_from_user(&new_rtc_time, (void __user *)arg,
 183                     sizeof(new_rtc_time))) {
 184                         rv = -EFAULT;
 185                         goto err1;
 186                 }
 187                 rtc_time_to_tm(new_rtc_time.tv_sec, &rtc_new_rtc_time);
 188
 189                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_IO,
 190                         "set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
 191                         new_rtc_time.tv_sec, new_rtc_time.tv_nsec,
 192                         rtc_new_rtc_time.tm_hour, rtc_new_rtc_time.tm_min,
 193                         rtc_new_rtc_time.tm_sec, rtc_new_rtc_time.tm_mon + 1,
 194                         rtc_new_rtc_time.tm_mday,
 195                         rtc_new_rtc_time.tm_year + 1900);
 196
 197                 mutex_lock(&alarm_setrtc_mutex);
 198                 spin_lock_irqsave(&alarm_slock, flags);
 199                 for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++)
 200                         hrtimer_try_to_cancel(&alarm_timer[i]);
 201                 getnstimeofday(&tmp_time);
 202                 elapsed_rtc_delta = timespec_sub(elapsed_rtc_delta,
 203                                         timespec_sub(tmp_time, new_rtc_time));
 204                 spin_unlock_irqrestore(&alarm_slock, flags);
 205                 rv = do_settimeofday(&new_rtc_time);
 206                 spin_lock_irqsave(&alarm_slock, flags);
 207                 for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++)
 208                         alarm_start_hrtimer(i);
 209                 spin_unlock_irqrestore(&alarm_slock, flags);
 210                 if (rv < 0) {
 211                         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_ERRORS,
 212                                               "Failed to set time\n");
 213                         mutex_unlock(&alarm_setrtc_mutex);
 214                         goto err1;
 215                 }
 216                 rv = rtc_set_time(alarm_rtc_dev, &rtc_new_rtc_time);
 217                 spin_lock_irqsave(&alarm_slock, flags);
 218                 alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK;
 219                 wake_up(&alarm_wait_queue);
 220                 spin_unlock_irqrestore(&alarm_slock, flags);
 221                 mutex_unlock(&alarm_setrtc_mutex);
 222                 if (rv < 0) {
 223                         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_ERRORS,
 224                             "Failed to set RTC, time will be lost on reboot\n");
 225                         goto err1;
 226                 }
 227                 break;
 228         case ANDROID_ALARM_GET_TIME(0):
 229                 mutex_lock(&alarm_setrtc_mutex);
 230                 spin_lock_irqsave(&alarm_slock, flags);
 231                 if (alarm_type != ANDROID_ALARM_SYSTEMTIME) {
 232                         getnstimeofday(&tmp_time);
 233                         if (alarm_type >= ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP)
 234                                 tmp_time = timespec_sub(tmp_time,
 235                                                         elapsed_rtc_delta);
 236                 } else
 237                         ktime_get_ts(&tmp_time);
 238                 spin_unlock_irqrestore(&alarm_slock, flags);
 239                 mutex_unlock(&alarm_setrtc_mutex);
 240                 if (copy_to_user((void __user *)arg, &tmp_time,
 241                     sizeof(tmp_time))) {
 242                         rv = -EFAULT;
 243                         goto err1;
 244                 }
 245                 break;
 246
 247         default:
 248                 rv = -EINVAL;
 249                 goto err1;
 250         }
 251 err1:
 252         return rv;
 253 }
 254
 255 static int alarm_open(struct inode *inode, struct file *file)
 256 {
 257         file->private_data = NULL;
 258         return 0;
 259 }
 260
 261 static int alarm_release(struct inode *inode, struct file *file)
 262 {
 263         int i;
 264         unsigned long flags;
 265
 266         spin_lock_irqsave(&alarm_slock, flags);
 267         if (file->private_data != 0) {
 268                 for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
 269                         uint32_t alarm_type_mask = 1U << i;
 270                         if (alarm_enabled & alarm_type_mask) {
 271                                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 272                                         "alarm_release: clear alarm, "
 273                                         "pending %d\n",
 274                                         !!(alarm_pending & alarm_type_mask));
 275                                 alarm_enabled &= ~alarm_type_mask;
 276                         }
 277                         spin_unlock_irqrestore(&alarm_slock, flags);
 278                         hrtimer_cancel(&alarm_timer[i]);
 279                         spin_lock_irqsave(&alarm_slock, flags);
 280                 }
 281                 if (alarm_pending | wait_pending) {
 282                         if (alarm_pending)
 283                                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 284                                         "alarm_release: clear pending alarms "
 285                                         "%x\n", alarm_pending);
 286                         wake_unlock(&alarm_wake_lock);
 287                         wait_pending = 0;
 288                         alarm_pending = 0;
 289                 }
 290                 alarm_opened = 0;
 291         }
 292         spin_unlock_irqrestore(&alarm_slock, flags);
 293         return 0;
 294 }
 295
 296 static enum hrtimer_restart alarm_timer_triggered(struct hrtimer *timer)
 297 {
 298         unsigned long flags;
 299         enum android_alarm_type alarm_type = (timer - alarm_timer);
 300         uint32_t alarm_type_mask = 1U << alarm_type;
 301
 302
 303         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INT,
 304                               "alarm_timer_triggered type %d\n", alarm_type);
 305         spin_lock_irqsave(&alarm_slock, flags);
 306         if (alarm_enabled & alarm_type_mask) {
 307                 wake_lock_timeout(&alarm_wake_lock, 5 * HZ);
 308                 alarm_enabled &= ~alarm_type_mask;
 309                 alarm_pending |= alarm_type_mask;
 310                 wake_up(&alarm_wait_queue);
 311         }
 312         spin_unlock_irqrestore(&alarm_slock, flags);
 313         return HRTIMER_NORESTART;
 314 }
 315
 316 static void alarm_triggered_func(void *p)
 317 {
 318         struct rtc_device *rtc = alarm_rtc_dev;
 319         if (!(rtc->irq_data & RTC_AF))
 320                 return;
 321         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INT, "rtc alarm triggered\n");
 322         wake_lock_timeout(&alarm_rtc_wake_lock, 1 * HZ);
 323 }
 324
 325 int alarm_suspend(struct platform_device *pdev, pm_message_t state)
 326 {
 327         int                 err = 0;
 328         unsigned long       flags;
 329         struct rtc_wkalrm   rtc_alarm;
 330         struct rtc_time     rtc_current_rtc_time;
 331         unsigned long       rtc_current_time;
 332         unsigned long       rtc_alarm_time;
 333         struct timespec     rtc_current_timespec;
 334         struct timespec     rtc_delta;
 335         struct timespec     elapsed_realtime_alarm_time;
 336
 337         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_FLOW,
 338                               "alarm_suspend(%p, %d)\n", pdev, state.event);
 339         spin_lock_irqsave(&alarm_slock, flags);
 340         if (alarm_pending && !wake_lock_active(&alarm_wake_lock)) {
 341                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 342                                       "alarm pending\n");
 343                 err = -EBUSY;
 344                 goto err1;
 345         }
 346         if (alarm_enabled & ANDROID_ALARM_WAKEUP_MASK) {
 347                 spin_unlock_irqrestore(&alarm_slock, flags);
 348                 if (alarm_enabled & ANDROID_ALARM_RTC_WAKEUP_MASK)
 349                         hrtimer_cancel(&alarm_timer[ANDROID_ALARM_RTC_WAKEUP]);
 350                 if (alarm_enabled & ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK)
 351                         hrtimer_cancel(&alarm_timer[
 352                                         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP]);
 353
 354                 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
 355                 rtc_current_timespec.tv_nsec = 0;
 356                 rtc_tm_to_time(&rtc_current_rtc_time,
 357                                &rtc_current_timespec.tv_sec);
 358                 save_time_delta(&rtc_delta, &rtc_current_timespec);
 359                 set_normalized_timespec(&elapsed_realtime_alarm_time,
 360                         alarm_time[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP]
 361                         .tv_sec + elapsed_rtc_delta.tv_sec,
 362                         alarm_time[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP]
 363                         .tv_nsec + elapsed_rtc_delta.tv_nsec);
 364                 if ((alarm_enabled & ANDROID_ALARM_RTC_WAKEUP_MASK) &&
 365                     (!(alarm_enabled &
 366                        ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK) ||
 367                      timespec_compare(&alarm_time[ANDROID_ALARM_RTC_WAKEUP],
 368                                       &elapsed_realtime_alarm_time) < 0))
 369                         rtc_alarm_time = timespec_sub(
 370                                         alarm_time[ANDROID_ALARM_RTC_WAKEUP],
 371                                         rtc_delta).tv_sec;
 372                 else
 373                         rtc_alarm_time = timespec_sub(
 374                                 elapsed_realtime_alarm_time, rtc_delta).tv_sec;
 375                 rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
 376                 rtc_alarm.enabled = 1;
 377                 rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
 378                 rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
 379                 rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
 380                 ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 381                         "rtc alarm set at %ld, now %ld, rtc delta %ld.%09ld\n",
 382                         rtc_alarm_time, rtc_current_time,
 383                         rtc_delta.tv_sec, rtc_delta.tv_nsec);
 384                 if (rtc_current_time + 1 >= rtc_alarm_time) {
 385                         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 386                                               "alarm about to go off\n");
 387                         memset(&rtc_alarm, 0, sizeof(rtc_alarm));
 388                         rtc_alarm.enabled = 0;
 389                         rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
 390
 391                         spin_lock_irqsave(&alarm_slock, flags);
 392                         wake_lock_timeout(&alarm_rtc_wake_lock, 2 * HZ);
 393                         alarm_start_hrtimer(ANDROID_ALARM_RTC_WAKEUP);
 394                         alarm_start_hrtimer(
 395                                 ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP);
 396                         err = -EBUSY;
 397                         spin_unlock_irqrestore(&alarm_slock, flags);
 398                 }
 399         } else {
 400 err1:
 401                 spin_unlock_irqrestore(&alarm_slock, flags);
 402         }
 403         return err;
 404 }
 405
 406 int alarm_resume(struct platform_device *pdev)
 407 {
 408         struct rtc_wkalrm alarm;
 409         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_FLOW,
 410                               "alarm_resume(%p)\n", pdev);
 411         if (alarm_enabled & ANDROID_ALARM_WAKEUP_MASK) {
 412                 memset(&alarm, 0, sizeof(alarm));
 413                 alarm.enabled = 0;
 414                 rtc_set_alarm(alarm_rtc_dev, &alarm);
 415                 alarm_start_hrtimer(ANDROID_ALARM_RTC_WAKEUP);
 416                 alarm_start_hrtimer(ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP);
 417         }
 418         return 0;
 419 }
 420
 421 static struct rtc_task alarm_rtc_task = {
 422         .func = alarm_triggered_func
 423 };
 424
 425 static struct file_operations alarm_fops = {
 426         .owner = THIS_MODULE,
 427         .unlocked_ioctl = alarm_ioctl,
 428         .open = alarm_open,
 429         .release = alarm_release,
 430 };
 431
 432 static struct miscdevice alarm_device = {
 433         .minor = MISC_DYNAMIC_MINOR,
 434         .name = "alarm",
 435         .fops = &alarm_fops,
 436 };
 437
 438 static int rtc_alarm_add_device(struct device *dev,
 439                                 struct class_interface *class_intf)
 440 {
 441         int err;
 442         struct rtc_device *rtc = to_rtc_device(dev);
 443
 444         mutex_lock(&alarm_setrtc_mutex);
 445
 446         if (alarm_rtc_dev) {
 447                 err = -EBUSY;
 448                 goto err1;
 449         }
 450
 451         err = misc_register(&alarm_device);
 452         if (err)
 453                 goto err1;
 454         alarm_platform_dev =
 455                 platform_device_register_simple("alarm", -1, NULL, 0);
 456         if (IS_ERR(alarm_platform_dev)) {
 457                 err = PTR_ERR(alarm_platform_dev);
 458                 goto err2;
 459         }
 460         err = rtc_irq_register(rtc, &alarm_rtc_task);
 461         if (err)
 462                 goto err3;
 463         alarm_rtc_dev = rtc;
 464         mutex_unlock(&alarm_setrtc_mutex);
 465
 466         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO, "alarm: parent %p\n",
 467                               alarm_platform_dev->dev.power.pm_parent);
 468         return 0;
 469
 470 err3:
 471         platform_device_unregister(alarm_platform_dev);
 472 err2:
 473         misc_deregister(&alarm_device);
 474 err1:
 475         mutex_unlock(&alarm_setrtc_mutex);
 476         return err;
 477 }
 478
 479 static void rtc_alarm_remove_device(struct device *dev,
 480                                     struct class_interface *class_intf)
 481 {
 482         if (dev == &alarm_rtc_dev->dev) {
 483                 rtc_irq_unregister(alarm_rtc_dev, &alarm_rtc_task);
 484                 platform_device_unregister(alarm_platform_dev);
 485                 misc_deregister(&alarm_device);
 486                 alarm_rtc_dev = NULL;
 487         }
 488 }
 489
 490 static struct class_interface rtc_alarm_interface = {
 491         .add_dev = &rtc_alarm_add_device,
 492         .remove_dev = &rtc_alarm_remove_device,
 493 };
 494
 495 static struct platform_driver alarm_driver = {
 496         .suspend = alarm_suspend,
 497         .resume = alarm_resume,
 498         .driver = {
 499                 .name = "alarm"
 500         }
 501 };
 502
 503 static int __init alarm_late_init(void)
 504 {
 505         unsigned long   flags;
 506         struct timespec system_time;
 507
 508         /* this needs to run after the rtc is read at boot */
 509         spin_lock_irqsave(&alarm_slock, flags);
 510         /* We read the current rtc and system time so we can later calulate
 511          * elasped realtime to be (boot_systemtime + rtc - boot_rtc) ==
 512          * (rtc - (boot_rtc - boot_systemtime))
 513          */
 514         getnstimeofday(&elapsed_rtc_delta);
 515         ktime_get_ts(&system_time);
 516         elapsed_rtc_delta = timespec_sub(elapsed_rtc_delta, system_time);
 517         spin_unlock_irqrestore(&alarm_slock, flags);
 518
 519         ANDROID_ALARM_DPRINTF(ANDROID_ALARM_PRINT_INFO,
 520                 "alarm_late_init: rtc to elapsed realtime delta %ld.%09ld\n",
 521                 elapsed_rtc_delta.tv_sec, elapsed_rtc_delta.tv_nsec);
 522         return 0;
 523 }
 524
 525 static int __init alarm_init(void)
 526 {
 527         int err;
 528         int i;
 529
 530         for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
 531                 hrtimer_init(&alarm_timer[i], CLOCK_REALTIME, HRTIMER_MODE_ABS);
 532                 alarm_timer[i].function = alarm_timer_triggered;
 533         }
 534         hrtimer_init(&alarm_timer[ANDROID_ALARM_SYSTEMTIME],
 535                      CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
 536         alarm_timer[ANDROID_ALARM_SYSTEMTIME].function = alarm_timer_triggered;
 537         err = platform_driver_register(&alarm_driver);
 538         if (err < 0)
 539                 goto err1;
 540         wake_lock_init(&alarm_wake_lock, WAKE_LOCK_SUSPEND, "alarm");
 541         wake_lock_init(&alarm_rtc_wake_lock, WAKE_LOCK_SUSPEND, "alarm_rtc");
 542         rtc_alarm_interface.class = rtc_class;
 543         err = class_interface_register(&rtc_alarm_interface);
 544         if (err < 0)
 545                 goto err2;
 546
 547         return 0;
 548
 549 err2:
 550         wake_lock_destroy(&alarm_rtc_wake_lock);
 551         wake_lock_destroy(&alarm_wake_lock);
 552         platform_driver_unregister(&alarm_driver);
 553 err1:
 554         return err;
 555 }
 556
 557 static void  __exit alarm_exit(void)
 558 {
 559         class_interface_unregister(&rtc_alarm_interface);
 560         wake_lock_destroy(&alarm_rtc_wake_lock);
 561         wake_lock_destroy(&alarm_wake_lock);
 562         platform_driver_unregister(&alarm_driver);
 563 }
 564
 565 late_initcall(alarm_late_init);
 566 module_init(alarm_init);
 567 module_exit(alarm_exit);
 568