SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/rtc/interface.c

   1 /*
   2  * RTC subsystem, interface functions
   3  *
   4  * Copyright (C) 2005 Tower Technologies
   5  * Author: Alessandro Zummo <a.zummo@towertech.it>
   6  *
   7  * based on arch/arm/common/rtctime.c
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12 */
  13
  14 #include <linux/rtc.h>
  15
  16 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
  17 {
  18         int err;
  19
  20         err = mutex_lock_interruptible(&rtc->ops_lock);
  21         if (err)
  22                 return -EBUSY;
  23
  24         if (!rtc->ops)
  25                 err = -ENODEV;
  26         else if (!rtc->ops->read_time)
  27                 err = -EINVAL;
  28         else {
  29                 memset(tm, 0, sizeof(struct rtc_time));
  30                 err = rtc->ops->read_time(rtc->dev.parent, tm);
  31         }
  32
  33         mutex_unlock(&rtc->ops_lock);
  34         return err;
  35 }
  36 EXPORT_SYMBOL_GPL(rtc_read_time);
  37
  38 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
  39 {
  40         int err;
  41
  42         err = rtc_valid_tm(tm);
  43         if (err != 0)
  44                 return err;
  45
  46         err = mutex_lock_interruptible(&rtc->ops_lock);
  47         if (err)
  48                 return -EBUSY;
  49
  50         if (!rtc->ops)
  51                 err = -ENODEV;
  52         else if (!rtc->ops->set_time)
  53                 err = -EINVAL;
  54         else
  55                 err = rtc->ops->set_time(rtc->dev.parent, tm);
  56
  57         mutex_unlock(&rtc->ops_lock);
  58         return err;
  59 }
  60 EXPORT_SYMBOL_GPL(rtc_set_time);
  61
  62 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
  63 {
  64         int err;
  65
  66         err = mutex_lock_interruptible(&rtc->ops_lock);
  67         if (err)
  68                 return -EBUSY;
  69
  70         if (!rtc->ops)
  71                 err = -ENODEV;
  72         else if (rtc->ops->set_mmss)
  73                 err = rtc->ops->set_mmss(rtc->dev.parent, secs);
  74         else if (rtc->ops->read_time && rtc->ops->set_time) {
  75                 struct rtc_time new, old;
  76
  77                 err = rtc->ops->read_time(rtc->dev.parent, &old);
  78                 if (err == 0) {
  79                         rtc_time_to_tm(secs, &new);
  80
  81                         /*
  82                          * avoid writing when we're going to change the day of
  83                          * the month. We will retry in the next minute. This
  84                          * basically means that if the RTC must not drift
  85                          * by more than 1 minute in 11 minutes.
  86                          */
  87                         if (!((old.tm_hour == 23 && old.tm_min == 59) ||
  88                                 (new.tm_hour == 23 && new.tm_min == 59)))
  89                                 err = rtc->ops->set_time(rtc->dev.parent,
  90                                                 &new);
  91                 }
  92         }
  93         else
  94                 err = -EINVAL;
  95
  96         mutex_unlock(&rtc->ops_lock);
  97
  98         return err;
  99 }
 100 EXPORT_SYMBOL_GPL(rtc_set_mmss);
 101
 102 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 103 {
 104         int err;
 105
 106         err = mutex_lock_interruptible(&rtc->ops_lock);
 107         if (err)
 108                 return -EBUSY;
 109
 110         if (rtc->ops == NULL)
 111                 err = -ENODEV;
 112         else if (!rtc->ops->read_alarm)
 113                 err = -EINVAL;
 114         else {
 115                 memset(alarm, 0, sizeof(struct rtc_wkalrm));
 116                 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
 117         }
 118
 119         mutex_unlock(&rtc->ops_lock);
 120         return err;
 121 }
 122 EXPORT_SYMBOL_GPL(rtc_read_alarm);
 123
 124 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 125 {
 126         int err;
 127
 128         err = rtc_valid_tm(&alarm->time);
 129         if (err != 0)
 130                 return err;
 131
 132         err = mutex_lock_interruptible(&rtc->ops_lock);
 133         if (err)
 134                 return -EBUSY;
 135
 136         if (!rtc->ops)
 137                 err = -ENODEV;
 138         else if (!rtc->ops->set_alarm)
 139                 err = -EINVAL;
 140         else
 141                 err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
 142
 143         mutex_unlock(&rtc->ops_lock);
 144         return err;
 145 }
 146 EXPORT_SYMBOL_GPL(rtc_set_alarm);
 147
 148 /**
 149  * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
 150  * @rtc: the rtc device
 151  * @num: how many irqs are being reported (usually one)
 152  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
 153  * Context: in_interrupt(), irqs blocked
 154  */
 155 void rtc_update_irq(struct rtc_device *rtc,
 156                 unsigned long num, unsigned long events)
 157 {
 158         spin_lock(&rtc->irq_lock);
 159         rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
 160         spin_unlock(&rtc->irq_lock);
 161
 162         spin_lock(&rtc->irq_task_lock);
 163         if (rtc->irq_task)
 164                 rtc->irq_task->func(rtc->irq_task->private_data);
 165         spin_unlock(&rtc->irq_task_lock);
 166
 167         wake_up_interruptible(&rtc->irq_queue);
 168         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
 169 }
 170 EXPORT_SYMBOL_GPL(rtc_update_irq);
 171
 172 struct rtc_device *rtc_class_open(char *name)
 173 {
 174         struct device *dev;
 175         struct rtc_device *rtc = NULL;
 176
 177         down(&rtc_class->sem);
 178         list_for_each_entry(dev, &rtc_class->devices, node) {
 179                 if (strncmp(dev->bus_id, name, BUS_ID_SIZE) == 0) {
 180                         dev = get_device(dev);
 181                         if (dev)
 182                                 rtc = to_rtc_device(dev);
 183                         break;
 184                 }
 185         }
 186
 187         if (rtc) {
 188                 if (!try_module_get(rtc->owner)) {
 189                         put_device(dev);
 190                         rtc = NULL;
 191                 }
 192         }
 193         up(&rtc_class->sem);
 194
 195         return rtc;
 196 }
 197 EXPORT_SYMBOL_GPL(rtc_class_open);
 198
 199 void rtc_class_close(struct rtc_device *rtc)
 200 {
 201         module_put(rtc->owner);
 202         put_device(&rtc->dev);
 203 }
 204 EXPORT_SYMBOL_GPL(rtc_class_close);
 205
 206 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
 207 {
 208         int retval = -EBUSY;
 209
 210         if (task == NULL || task->func == NULL)
 211                 return -EINVAL;
 212
 213         /* Cannot register while the char dev is in use */
 214         if (!(mutex_trylock(&rtc->char_lock)))
 215                 return -EBUSY;
 216
 217         spin_lock_irq(&rtc->irq_task_lock);
 218         if (rtc->irq_task == NULL) {
 219                 rtc->irq_task = task;
 220                 retval = 0;
 221         }
 222         spin_unlock_irq(&rtc->irq_task_lock);
 223
 224         mutex_unlock(&rtc->char_lock);
 225
 226         return retval;
 227 }
 228 EXPORT_SYMBOL_GPL(rtc_irq_register);
 229
 230 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
 231 {
 232         spin_lock_irq(&rtc->irq_task_lock);
 233         if (rtc->irq_task == task)
 234                 rtc->irq_task = NULL;
 235         spin_unlock_irq(&rtc->irq_task_lock);
 236 }
 237 EXPORT_SYMBOL_GPL(rtc_irq_unregister);
 238
 239 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
 240 {
 241         int err = 0;
 242         unsigned long flags;
 243
 244         if (rtc->ops->irq_set_state == NULL)
 245                 return -ENXIO;
 246
 247         spin_lock_irqsave(&rtc->irq_task_lock, flags);
 248         if (rtc->irq_task != NULL && task == NULL)
 249                 err = -EBUSY;
 250         if (rtc->irq_task != task)
 251                 err = -EACCES;
 252         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
 253
 254         if (err == 0)
 255                 err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
 256
 257         return err;
 258 }
 259 EXPORT_SYMBOL_GPL(rtc_irq_set_state);
 260
 261 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
 262 {
 263         int err = 0;
 264         unsigned long flags;
 265
 266         if (rtc->ops->irq_set_freq == NULL)
 267                 return -ENXIO;
 268
 269         spin_lock_irqsave(&rtc->irq_task_lock, flags);
 270         if (rtc->irq_task != NULL && task == NULL)
 271                 err = -EBUSY;
 272         if (rtc->irq_task != task)
 273                 err = -EACCES;
 274         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
 275
 276         if (err == 0) {
 277                 err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
 278                 if (err == 0)
 279                         rtc->irq_freq = freq;
 280         }
 281         return err;
 282 }
 283 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);