Pileus Git - ~andy/linux/blob - drivers/staging/android/alarm-dev.c

   1 /* drivers/rtc/alarm-dev.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 <linux/time.h>
  17 #include <linux/module.h>
  18 #include <linux/device.h>
  19 #include <linux/miscdevice.h>
  20 #include <linux/fs.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/sched.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/alarmtimer.h>
  26 #include "android_alarm.h"
  27
  28 #define ANDROID_ALARM_PRINT_INFO (1U << 0)
  29 #define ANDROID_ALARM_PRINT_IO (1U << 1)
  30 #define ANDROID_ALARM_PRINT_INT (1U << 2)
  31
  32 static int debug_mask = ANDROID_ALARM_PRINT_INFO;
  33 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
  34
  35 #define alarm_dbg(debug_level_mask, fmt, ...)                           \
  36 do {                                                                    \
  37         if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask)        \
  38                 pr_info(fmt, ##__VA_ARGS__);                            \
  39 } while (0)
  40
  41 #define ANDROID_ALARM_WAKEUP_MASK ( \
  42         ANDROID_ALARM_RTC_WAKEUP_MASK | \
  43         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK)
  44
  45 static int alarm_opened;
  46 static DEFINE_SPINLOCK(alarm_slock);
  47 static struct wakeup_source alarm_wake_lock;
  48 static DECLARE_WAIT_QUEUE_HEAD(alarm_wait_queue);
  49 static uint32_t alarm_pending;
  50 static uint32_t alarm_enabled;
  51 static uint32_t wait_pending;
  52
  53 struct devalarm {
  54         union {
  55                 struct hrtimer hrt;
  56                 struct alarm alrm;
  57         } u;
  58         enum android_alarm_type type;
  59 };
  60
  61 static struct devalarm alarms[ANDROID_ALARM_TYPE_COUNT];
  62
  63
  64 static int is_wakeup(enum android_alarm_type type)
  65 {
  66         return (type == ANDROID_ALARM_RTC_WAKEUP ||
  67                 type == ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP);
  68 }
  69
  70
  71 static void devalarm_start(struct devalarm *alrm, ktime_t exp)
  72 {
  73         if (is_wakeup(alrm->type))
  74                 alarm_start(&alrm->u.alrm, exp);
  75         else
  76                 hrtimer_start(&alrm->u.hrt, exp, HRTIMER_MODE_ABS);
  77 }
  78
  79
  80 static int devalarm_try_to_cancel(struct devalarm *alrm)
  81 {
  82         if (is_wakeup(alrm->type))
  83                 return alarm_try_to_cancel(&alrm->u.alrm);
  84         return hrtimer_try_to_cancel(&alrm->u.hrt);
  85 }
  86
  87 static void devalarm_cancel(struct devalarm *alrm)
  88 {
  89         if (is_wakeup(alrm->type))
  90                 alarm_cancel(&alrm->u.alrm);
  91         else
  92                 hrtimer_cancel(&alrm->u.hrt);
  93 }
  94
  95
  96 static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  97 {
  98         int rv = 0;
  99         unsigned long flags;
 100         struct timespec new_alarm_time;
 101         struct timespec new_rtc_time;
 102         struct timespec tmp_time;
 103         struct rtc_time new_rtc_tm;
 104         struct rtc_device *rtc_dev;
 105         enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd);
 106         uint32_t alarm_type_mask = 1U << alarm_type;
 107
 108         if (alarm_type >= ANDROID_ALARM_TYPE_COUNT)
 109                 return -EINVAL;
 110
 111         if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) {
 112                 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 113                         return -EPERM;
 114                 if (file->private_data == NULL &&
 115                     cmd != ANDROID_ALARM_SET_RTC) {
 116                         spin_lock_irqsave(&alarm_slock, flags);
 117                         if (alarm_opened) {
 118                                 spin_unlock_irqrestore(&alarm_slock, flags);
 119                                 return -EBUSY;
 120                         }
 121                         alarm_opened = 1;
 122                         file->private_data = (void *)1;
 123                         spin_unlock_irqrestore(&alarm_slock, flags);
 124                 }
 125         }
 126
 127         switch (ANDROID_ALARM_BASE_CMD(cmd)) {
 128         case ANDROID_ALARM_CLEAR(0):
 129                 spin_lock_irqsave(&alarm_slock, flags);
 130                 alarm_dbg(IO, "alarm %d clear\n", alarm_type);
 131                 devalarm_try_to_cancel(&alarms[alarm_type]);
 132                 if (alarm_pending) {
 133                         alarm_pending &= ~alarm_type_mask;
 134                         if (!alarm_pending && !wait_pending)
 135                                 __pm_relax(&alarm_wake_lock);
 136                 }
 137                 alarm_enabled &= ~alarm_type_mask;
 138                 spin_unlock_irqrestore(&alarm_slock, flags);
 139                 break;
 140
 141         case ANDROID_ALARM_SET_AND_WAIT(0):
 142         case ANDROID_ALARM_SET(0):
 143                 if (copy_from_user(&new_alarm_time, (void __user *)arg,
 144                     sizeof(new_alarm_time))) {
 145                         rv = -EFAULT;
 146                         goto err1;
 147                 }
 148                 spin_lock_irqsave(&alarm_slock, flags);
 149                 alarm_dbg(IO, "alarm %d set %ld.%09ld\n",
 150                           alarm_type,
 151                           new_alarm_time.tv_sec, new_alarm_time.tv_nsec);
 152                 alarm_enabled |= alarm_type_mask;
 153                 devalarm_start(&alarms[alarm_type],
 154                         timespec_to_ktime(new_alarm_time));
 155                 spin_unlock_irqrestore(&alarm_slock, flags);
 156                 if (ANDROID_ALARM_BASE_CMD(cmd) !=
 157                                                 ANDROID_ALARM_SET_AND_WAIT(0))
 158                         break;
 159                 /* fall though */
 160         case ANDROID_ALARM_WAIT:
 161                 spin_lock_irqsave(&alarm_slock, flags);
 162                 alarm_dbg(IO, "alarm wait\n");
 163                 if (!alarm_pending && wait_pending) {
 164                         __pm_relax(&alarm_wake_lock);
 165                         wait_pending = 0;
 166                 }
 167                 spin_unlock_irqrestore(&alarm_slock, flags);
 168                 rv = wait_event_interruptible(alarm_wait_queue, alarm_pending);
 169                 if (rv)
 170                         goto err1;
 171                 spin_lock_irqsave(&alarm_slock, flags);
 172                 rv = alarm_pending;
 173                 wait_pending = 1;
 174                 alarm_pending = 0;
 175                 spin_unlock_irqrestore(&alarm_slock, flags);
 176                 break;
 177         case ANDROID_ALARM_SET_RTC:
 178                 if (copy_from_user(&new_rtc_time, (void __user *)arg,
 179                     sizeof(new_rtc_time))) {
 180                         rv = -EFAULT;
 181                         goto err1;
 182                 }
 183                 rtc_time_to_tm(new_rtc_time.tv_sec, &new_rtc_tm);
 184                 rtc_dev = alarmtimer_get_rtcdev();
 185                 rv = do_settimeofday(&new_rtc_time);
 186                 if (rv < 0)
 187                         goto err1;
 188                 if (rtc_dev)
 189                         rv = rtc_set_time(rtc_dev, &new_rtc_tm);
 190                 spin_lock_irqsave(&alarm_slock, flags);
 191                 alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK;
 192                 wake_up(&alarm_wait_queue);
 193                 spin_unlock_irqrestore(&alarm_slock, flags);
 194                 if (rv < 0)
 195                         goto err1;
 196                 break;
 197         case ANDROID_ALARM_GET_TIME(0):
 198                 switch (alarm_type) {
 199                 case ANDROID_ALARM_RTC_WAKEUP:
 200                 case ANDROID_ALARM_RTC:
 201                         getnstimeofday(&tmp_time);
 202                         break;
 203                 case ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP:
 204                 case ANDROID_ALARM_ELAPSED_REALTIME:
 205                         get_monotonic_boottime(&tmp_time);
 206                         break;
 207                 case ANDROID_ALARM_SYSTEMTIME:
 208                         ktime_get_ts(&tmp_time);
 209                         break;
 210                 default:
 211                         rv = -EINVAL;
 212                         goto err1;
 213                 }
 214                 if (copy_to_user((void __user *)arg, &tmp_time,
 215                     sizeof(tmp_time))) {
 216                         rv = -EFAULT;
 217                         goto err1;
 218                 }
 219                 break;
 220
 221         default:
 222                 rv = -EINVAL;
 223         }
 224 err1:
 225         return rv;
 226 }
 227
 228 static int alarm_open(struct inode *inode, struct file *file)
 229 {
 230         file->private_data = NULL;
 231         return 0;
 232 }
 233
 234 static int alarm_release(struct inode *inode, struct file *file)
 235 {
 236         int i;
 237         unsigned long flags;
 238
 239         spin_lock_irqsave(&alarm_slock, flags);
 240         if (file->private_data) {
 241                 for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
 242                         uint32_t alarm_type_mask = 1U << i;
 243                         if (alarm_enabled & alarm_type_mask) {
 244                                 alarm_dbg(INFO,
 245                                           "%s: clear alarm, pending %d\n",
 246                                           __func__,
 247                                           !!(alarm_pending & alarm_type_mask));
 248                                 alarm_enabled &= ~alarm_type_mask;
 249                         }
 250                         spin_unlock_irqrestore(&alarm_slock, flags);
 251                         devalarm_cancel(&alarms[i]);
 252                         spin_lock_irqsave(&alarm_slock, flags);
 253                 }
 254                 if (alarm_pending | wait_pending) {
 255                         if (alarm_pending)
 256                                 alarm_dbg(INFO, "%s: clear pending alarms %x\n",
 257                                           __func__, alarm_pending);
 258                         __pm_relax(&alarm_wake_lock);
 259                         wait_pending = 0;
 260                         alarm_pending = 0;
 261                 }
 262                 alarm_opened = 0;
 263         }
 264         spin_unlock_irqrestore(&alarm_slock, flags);
 265         return 0;
 266 }
 267
 268 static void devalarm_triggered(struct devalarm *alarm)
 269 {
 270         unsigned long flags;
 271         uint32_t alarm_type_mask = 1U << alarm->type;
 272
 273         alarm_dbg(INT, "%s: type %d\n", __func__, alarm->type);
 274         spin_lock_irqsave(&alarm_slock, flags);
 275         if (alarm_enabled & alarm_type_mask) {
 276                 __pm_wakeup_event(&alarm_wake_lock, 5000); /* 5secs */
 277                 alarm_enabled &= ~alarm_type_mask;
 278                 alarm_pending |= alarm_type_mask;
 279                 wake_up(&alarm_wait_queue);
 280         }
 281         spin_unlock_irqrestore(&alarm_slock, flags);
 282 }
 283
 284
 285 static enum hrtimer_restart devalarm_hrthandler(struct hrtimer *hrt)
 286 {
 287         struct devalarm *devalrm = container_of(hrt, struct devalarm, u.hrt);
 288
 289         devalarm_triggered(devalrm);
 290         return HRTIMER_NORESTART;
 291 }
 292
 293 static enum alarmtimer_restart devalarm_alarmhandler(struct alarm *alrm,
 294                                                         ktime_t now)
 295 {
 296         struct devalarm *devalrm = container_of(alrm, struct devalarm, u.alrm);
 297
 298         devalarm_triggered(devalrm);
 299         return ALARMTIMER_NORESTART;
 300 }
 301
 302
 303 static const struct file_operations alarm_fops = {
 304         .owner = THIS_MODULE,
 305         .unlocked_ioctl = alarm_ioctl,
 306         .open = alarm_open,
 307         .release = alarm_release,
 308 };
 309
 310 static struct miscdevice alarm_device = {
 311         .minor = MISC_DYNAMIC_MINOR,
 312         .name = "alarm",
 313         .fops = &alarm_fops,
 314 };
 315
 316 static int __init alarm_dev_init(void)
 317 {
 318         int err;
 319         int i;
 320
 321         err = misc_register(&alarm_device);
 322         if (err)
 323                 return err;
 324
 325         alarm_init(&alarms[ANDROID_ALARM_RTC_WAKEUP].u.alrm,
 326                         ALARM_REALTIME, devalarm_alarmhandler);
 327         hrtimer_init(&alarms[ANDROID_ALARM_RTC].u.hrt,
 328                         CLOCK_REALTIME, HRTIMER_MODE_ABS);
 329         alarm_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].u.alrm,
 330                         ALARM_BOOTTIME, devalarm_alarmhandler);
 331         hrtimer_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME].u.hrt,
 332                         CLOCK_BOOTTIME, HRTIMER_MODE_ABS);
 333         hrtimer_init(&alarms[ANDROID_ALARM_SYSTEMTIME].u.hrt,
 334                         CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
 335
 336         for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
 337                 alarms[i].type = i;
 338                 if (!is_wakeup(i))
 339                         alarms[i].u.hrt.function = devalarm_hrthandler;
 340         }
 341
 342         wakeup_source_init(&alarm_wake_lock, "alarm");
 343         return 0;
 344 }
 345
 346 static void  __exit alarm_dev_exit(void)
 347 {
 348         misc_deregister(&alarm_device);
 349         wakeup_source_trash(&alarm_wake_lock);
 350 }
 351
 352 module_init(alarm_dev_init);
 353 module_exit(alarm_dev_exit);
 354