git.oblomov.eu Git - linux-2.6/blob - arch/arm/common/rtctime.c

   1 /*
   2  *  linux/arch/arm/common/rtctime.c
   3  *
   4  *  Copyright (C) 2003 Deep Blue Solutions Ltd.
   5  *  Based on sa1100-rtc.c, Nils Faerber, CIH, Nicolas Pitre.
   6  *  Based on rtc.c by Paul Gortmaker
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/time.h>
  15 #include <linux/rtc.h>
  16 #include <linux/poll.h>
  17 #include <linux/proc_fs.h>
  18 #include <linux/miscdevice.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/capability.h>
  21 #include <linux/device.h>
  22 #include <linux/mutex.h>
  23
  24 #include <asm/rtc.h>
  25
  26 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
  27 static struct fasync_struct *rtc_async_queue;
  28
  29 /*
  30  * rtc_lock protects rtc_irq_data
  31  */
  32 static DEFINE_SPINLOCK(rtc_lock);
  33 static unsigned long rtc_irq_data;
  34
  35 /*
  36  * rtc_sem protects rtc_inuse and rtc_ops
  37  */
  38 static DEFINE_MUTEX(rtc_mutex);
  39 static unsigned long rtc_inuse;
  40 static struct rtc_ops *rtc_ops;
  41
  42 #define rtc_epoch 1900UL
  43
  44 /*
  45  * Calculate the next alarm time given the requested alarm time mask
  46  * and the current time.
  47  */
  48 void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, struct rtc_time *alrm)
  49 {
  50         unsigned long next_time;
  51         unsigned long now_time;
  52
  53         next->tm_year = now->tm_year;
  54         next->tm_mon = now->tm_mon;
  55         next->tm_mday = now->tm_mday;
  56         next->tm_hour = alrm->tm_hour;
  57         next->tm_min = alrm->tm_min;
  58         next->tm_sec = alrm->tm_sec;
  59
  60         rtc_tm_to_time(now, &now_time);
  61         rtc_tm_to_time(next, &next_time);
  62
  63         if (next_time < now_time) {
  64                 /* Advance one day */
  65                 next_time += 60 * 60 * 24;
  66                 rtc_time_to_tm(next_time, next);
  67         }
  68 }
  69 EXPORT_SYMBOL(rtc_next_alarm_time);
  70
  71 static inline int rtc_arm_read_time(struct rtc_ops *ops, struct rtc_time *tm)
  72 {
  73         memset(tm, 0, sizeof(struct rtc_time));
  74         return ops->read_time(tm);
  75 }
  76
  77 static inline int rtc_arm_set_time(struct rtc_ops *ops, struct rtc_time *tm)
  78 {
  79         int ret;
  80
  81         ret = rtc_valid_tm(tm);
  82         if (ret == 0)
  83                 ret = ops->set_time(tm);
  84
  85         return ret;
  86 }
  87
  88 static inline int rtc_arm_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
  89 {
  90         int ret = -EINVAL;
  91         if (ops->read_alarm) {
  92                 memset(alrm, 0, sizeof(struct rtc_wkalrm));
  93                 ret = ops->read_alarm(alrm);
  94         }
  95         return ret;
  96 }
  97
  98 static inline int rtc_arm_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
  99 {
 100         int ret = -EINVAL;
 101         if (ops->set_alarm)
 102                 ret = ops->set_alarm(alrm);
 103         return ret;
 104 }
 105
 106 void rtc_update(unsigned long num, unsigned long events)
 107 {
 108         spin_lock(&rtc_lock);
 109         rtc_irq_data = (rtc_irq_data + (num << 8)) | events;
 110         spin_unlock(&rtc_lock);
 111
 112         wake_up_interruptible(&rtc_wait);
 113         kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
 114 }
 115 EXPORT_SYMBOL(rtc_update);
 116
 117
 118 static ssize_t
 119 rtc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 120 {
 121         DECLARE_WAITQUEUE(wait, current);
 122         unsigned long data;
 123         ssize_t ret;
 124
 125         if (count < sizeof(unsigned long))
 126                 return -EINVAL;
 127
 128         add_wait_queue(&rtc_wait, &wait);
 129         do {
 130                 __set_current_state(TASK_INTERRUPTIBLE);
 131
 132                 spin_lock_irq(&rtc_lock);
 133                 data = rtc_irq_data;
 134                 rtc_irq_data = 0;
 135                 spin_unlock_irq(&rtc_lock);
 136
 137                 if (data != 0) {
 138                         ret = 0;
 139                         break;
 140                 }
 141                 if (file->f_flags & O_NONBLOCK) {
 142                         ret = -EAGAIN;
 143                         break;
 144                 }
 145                 if (signal_pending(current)) {
 146                         ret = -ERESTARTSYS;
 147                         break;
 148                 }
 149                 schedule();
 150         } while (1);
 151         set_current_state(TASK_RUNNING);
 152         remove_wait_queue(&rtc_wait, &wait);
 153
 154         if (ret == 0) {
 155                 ret = put_user(data, (unsigned long __user *)buf);
 156                 if (ret == 0)
 157                         ret = sizeof(unsigned long);
 158         }
 159         return ret;
 160 }
 161
 162 static unsigned int rtc_poll(struct file *file, poll_table *wait)
 163 {
 164         unsigned long data;
 165
 166         poll_wait(file, &rtc_wait, wait);
 167
 168         spin_lock_irq(&rtc_lock);
 169         data = rtc_irq_data;
 170         spin_unlock_irq(&rtc_lock);
 171
 172         return data != 0 ? POLLIN | POLLRDNORM : 0;
 173 }
 174
 175 static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 176                      unsigned long arg)
 177 {
 178         struct rtc_ops *ops = file->private_data;
 179         struct rtc_time tm;
 180         struct rtc_wkalrm alrm;
 181         void __user *uarg = (void __user *)arg;
 182         int ret = -EINVAL;
 183
 184         switch (cmd) {
 185         case RTC_ALM_READ:
 186                 ret = rtc_arm_read_alarm(ops, &alrm);
 187                 if (ret)
 188                         break;
 189                 ret = copy_to_user(uarg, &alrm.time, sizeof(tm));
 190                 if (ret)
 191                         ret = -EFAULT;
 192                 break;
 193
 194         case RTC_ALM_SET:
 195                 ret = copy_from_user(&alrm.time, uarg, sizeof(tm));
 196                 if (ret) {
 197                         ret = -EFAULT;
 198                         break;
 199                 }
 200                 alrm.enabled = 0;
 201                 alrm.pending = 0;
 202                 alrm.time.tm_mday = -1;
 203                 alrm.time.tm_mon = -1;
 204                 alrm.time.tm_year = -1;
 205                 alrm.time.tm_wday = -1;
 206                 alrm.time.tm_yday = -1;
 207                 alrm.time.tm_isdst = -1;
 208                 ret = rtc_arm_set_alarm(ops, &alrm);
 209                 break;
 210
 211         case RTC_RD_TIME:
 212                 ret = rtc_arm_read_time(ops, &tm);
 213                 if (ret)
 214                         break;
 215                 ret = copy_to_user(uarg, &tm, sizeof(tm));
 216                 if (ret)
 217                         ret = -EFAULT;
 218                 break;
 219
 220         case RTC_SET_TIME:
 221                 if (!capable(CAP_SYS_TIME)) {
 222                         ret = -EACCES;
 223                         break;
 224                 }
 225                 ret = copy_from_user(&tm, uarg, sizeof(tm));
 226                 if (ret) {
 227                         ret = -EFAULT;
 228                         break;
 229                 }
 230                 ret = rtc_arm_set_time(ops, &tm);
 231                 break;
 232
 233         case RTC_EPOCH_SET:
 234 #ifndef rtc_epoch
 235                 /*
 236                  * There were no RTC clocks before 1900.
 237                  */
 238                 if (arg < 1900) {
 239                         ret = -EINVAL;
 240                         break;
 241                 }
 242                 if (!capable(CAP_SYS_TIME)) {
 243                         ret = -EACCES;
 244                         break;
 245                 }
 246                 rtc_epoch = arg;
 247                 ret = 0;
 248 #endif
 249                 break;
 250
 251         case RTC_EPOCH_READ:
 252                 ret = put_user(rtc_epoch, (unsigned long __user *)uarg);
 253                 break;
 254
 255         case RTC_WKALM_SET:
 256                 ret = copy_from_user(&alrm, uarg, sizeof(alrm));
 257                 if (ret) {
 258                         ret = -EFAULT;
 259                         break;
 260                 }
 261                 ret = rtc_arm_set_alarm(ops, &alrm);
 262                 break;
 263
 264         case RTC_WKALM_RD:
 265                 ret = rtc_arm_read_alarm(ops, &alrm);
 266                 if (ret)
 267                         break;
 268                 ret = copy_to_user(uarg, &alrm, sizeof(alrm));
 269                 if (ret)
 270                         ret = -EFAULT;
 271                 break;
 272
 273         default:
 274                 if (ops->ioctl)
 275                         ret = ops->ioctl(cmd, arg);
 276                 break;
 277         }
 278         return ret;
 279 }
 280
 281 static int rtc_open(struct inode *inode, struct file *file)
 282 {
 283         int ret;
 284
 285         mutex_lock(&rtc_mutex);
 286
 287         if (rtc_inuse) {
 288                 ret = -EBUSY;
 289         } else if (!rtc_ops || !try_module_get(rtc_ops->owner)) {
 290                 ret = -ENODEV;
 291         } else {
 292                 file->private_data = rtc_ops;
 293
 294                 ret = rtc_ops->open ? rtc_ops->open() : 0;
 295                 if (ret == 0) {
 296                         spin_lock_irq(&rtc_lock);
 297                         rtc_irq_data = 0;
 298                         spin_unlock_irq(&rtc_lock);
 299
 300                         rtc_inuse = 1;
 301                 }
 302         }
 303         mutex_unlock(&rtc_mutex);
 304
 305         return ret;
 306 }
 307
 308 static int rtc_release(struct inode *inode, struct file *file)
 309 {
 310         struct rtc_ops *ops = file->private_data;
 311
 312         if (ops->release)
 313                 ops->release();
 314
 315         spin_lock_irq(&rtc_lock);
 316         rtc_irq_data = 0;
 317         spin_unlock_irq(&rtc_lock);
 318
 319         module_put(rtc_ops->owner);
 320         rtc_inuse = 0;
 321
 322         return 0;
 323 }
 324
 325 static int rtc_fasync(int fd, struct file *file, int on)
 326 {
 327         return fasync_helper(fd, file, on, &rtc_async_queue);
 328 }
 329
 330 static const struct file_operations rtc_fops = {
 331         .owner          = THIS_MODULE,
 332         .llseek         = no_llseek,
 333         .read           = rtc_read,
 334         .poll           = rtc_poll,
 335         .ioctl          = rtc_ioctl,
 336         .open           = rtc_open,
 337         .release        = rtc_release,
 338         .fasync         = rtc_fasync,
 339 };
 340
 341 static struct miscdevice rtc_miscdev = {
 342         .minor          = RTC_MINOR,
 343         .name           = "rtc",
 344         .fops           = &rtc_fops,
 345 };
 346
 347
 348 static int rtc_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
 349 {
 350         struct rtc_ops *ops = data;
 351         struct rtc_wkalrm alrm;
 352         struct rtc_time tm;
 353         char *p = page;
 354
 355         if (rtc_arm_read_time(ops, &tm) == 0) {
 356                 p += sprintf(p,
 357                         "rtc_time\t: %02d:%02d:%02d\n"
 358                         "rtc_date\t: %04d-%02d-%02d\n"
 359                         "rtc_epoch\t: %04lu\n",
 360                         tm.tm_hour, tm.tm_min, tm.tm_sec,
 361                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 362                         rtc_epoch);
 363         }
 364
 365         if (rtc_arm_read_alarm(ops, &alrm) == 0) {
 366                 p += sprintf(p, "alrm_time\t: ");
 367                 if ((unsigned int)alrm.time.tm_hour <= 24)
 368                         p += sprintf(p, "%02d:", alrm.time.tm_hour);
 369                 else
 370                         p += sprintf(p, "**:");
 371                 if ((unsigned int)alrm.time.tm_min <= 59)
 372                         p += sprintf(p, "%02d:", alrm.time.tm_min);
 373                 else
 374                         p += sprintf(p, "**:");
 375                 if ((unsigned int)alrm.time.tm_sec <= 59)
 376                         p += sprintf(p, "%02d\n", alrm.time.tm_sec);
 377                 else
 378                         p += sprintf(p, "**\n");
 379
 380                 p += sprintf(p, "alrm_date\t: ");
 381                 if ((unsigned int)alrm.time.tm_year <= 200)
 382                         p += sprintf(p, "%04d-", alrm.time.tm_year + 1900);
 383                 else
 384                         p += sprintf(p, "****-");
 385                 if ((unsigned int)alrm.time.tm_mon <= 11)
 386                         p += sprintf(p, "%02d-", alrm.time.tm_mon + 1);
 387                 else
 388                         p += sprintf(p, "**-");
 389                 if ((unsigned int)alrm.time.tm_mday <= 31)
 390                         p += sprintf(p, "%02d\n", alrm.time.tm_mday);
 391                 else
 392                         p += sprintf(p, "**\n");
 393                 p += sprintf(p, "alrm_wakeup\t: %s\n",
 394                              alrm.enabled ? "yes" : "no");
 395                 p += sprintf(p, "alrm_pending\t: %s\n",
 396                              alrm.pending ? "yes" : "no");
 397         }
 398
 399         if (ops->proc)
 400                 p += ops->proc(p);
 401
 402         return p - page;
 403 }
 404
 405 int register_rtc(struct rtc_ops *ops)
 406 {
 407         int ret = -EBUSY;
 408
 409         mutex_lock(&rtc_mutex);
 410         if (rtc_ops == NULL) {
 411                 rtc_ops = ops;
 412
 413                 ret = misc_register(&rtc_miscdev);
 414                 if (ret == 0)
 415                         create_proc_read_entry("driver/rtc", 0, NULL,
 416                                                rtc_read_proc, ops);
 417         }
 418         mutex_unlock(&rtc_mutex);
 419
 420         return ret;
 421 }
 422 EXPORT_SYMBOL(register_rtc);
 423
 424 void unregister_rtc(struct rtc_ops *rtc)
 425 {
 426         mutex_lock(&rtc_mutex);
 427         if (rtc == rtc_ops) {
 428                 remove_proc_entry("driver/rtc", NULL);
 429                 misc_deregister(&rtc_miscdev);
 430                 rtc_ops = NULL;
 431         }
 432         mutex_unlock(&rtc_mutex);
 433 }
 434 EXPORT_SYMBOL(unregister_rtc);