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