RTC: assure proper memory ordering with respect to RTC_DEV_BUSY flag
[linux-2.6.git] / 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 #include <linux/log2.h>
16
17 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
18 {
19         int err;
20
21         err = mutex_lock_interruptible(&rtc->ops_lock);
22         if (err)
23                 return -EBUSY;
24
25         if (!rtc->ops)
26                 err = -ENODEV;
27         else if (!rtc->ops->read_time)
28                 err = -EINVAL;
29         else {
30                 memset(tm, 0, sizeof(struct rtc_time));
31                 err = rtc->ops->read_time(rtc->dev.parent, tm);
32         }
33
34         mutex_unlock(&rtc->ops_lock);
35         return err;
36 }
37 EXPORT_SYMBOL_GPL(rtc_read_time);
38
39 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
40 {
41         int err;
42
43         err = rtc_valid_tm(tm);
44         if (err != 0)
45                 return err;
46
47         err = mutex_lock_interruptible(&rtc->ops_lock);
48         if (err)
49                 return -EBUSY;
50
51         if (!rtc->ops)
52                 err = -ENODEV;
53         else if (!rtc->ops->set_time)
54                 err = -EINVAL;
55         else
56                 err = rtc->ops->set_time(rtc->dev.parent, tm);
57
58         mutex_unlock(&rtc->ops_lock);
59         return err;
60 }
61 EXPORT_SYMBOL_GPL(rtc_set_time);
62
63 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
64 {
65         int err;
66
67         err = mutex_lock_interruptible(&rtc->ops_lock);
68         if (err)
69                 return -EBUSY;
70
71         if (!rtc->ops)
72                 err = -ENODEV;
73         else if (rtc->ops->set_mmss)
74                 err = rtc->ops->set_mmss(rtc->dev.parent, secs);
75         else if (rtc->ops->read_time && rtc->ops->set_time) {
76                 struct rtc_time new, old;
77
78                 err = rtc->ops->read_time(rtc->dev.parent, &old);
79                 if (err == 0) {
80                         rtc_time_to_tm(secs, &new);
81
82                         /*
83                          * avoid writing when we're going to change the day of
84                          * the month. We will retry in the next minute. This
85                          * basically means that if the RTC must not drift
86                          * by more than 1 minute in 11 minutes.
87                          */
88                         if (!((old.tm_hour == 23 && old.tm_min == 59) ||
89                                 (new.tm_hour == 23 && new.tm_min == 59)))
90                                 err = rtc->ops->set_time(rtc->dev.parent,
91                                                 &new);
92                 }
93         }
94         else
95                 err = -EINVAL;
96
97         mutex_unlock(&rtc->ops_lock);
98
99         return err;
100 }
101 EXPORT_SYMBOL_GPL(rtc_set_mmss);
102
103 static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
104 {
105         int err;
106
107         err = mutex_lock_interruptible(&rtc->ops_lock);
108         if (err)
109                 return -EBUSY;
110
111         if (rtc->ops == NULL)
112                 err = -ENODEV;
113         else if (!rtc->ops->read_alarm)
114                 err = -EINVAL;
115         else {
116                 memset(alarm, 0, sizeof(struct rtc_wkalrm));
117                 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
118         }
119
120         mutex_unlock(&rtc->ops_lock);
121         return err;
122 }
123
124 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
125 {
126         int err;
127         struct rtc_time before, now;
128         int first_time = 1;
129
130         /* The lower level RTC driver may not be capable of filling
131          * in all fields of the rtc_time struct (eg. rtc-cmos),
132          * and so might instead return -1 in some fields.
133          * We deal with that here by grabbing a current RTC timestamp
134          * and using values from that for any missing (-1) values.
135          *
136          * But this can be racey, because some fields of the RTC timestamp
137          * may have wrapped in the interval since we read the RTC alarm,
138          * which would lead to us inserting inconsistent values in place
139          * of the -1 fields.
140          *
141          * Reading the alarm and timestamp in the reverse sequence
142          * would have the same race condition, and not solve the issue.
143          *
144          * So, we must first read the RTC timestamp,
145          * then read the RTC alarm value,
146          * and then read a second RTC timestamp.
147          *
148          * If any fields of the second timestamp have changed
149          * when compared with the first timestamp, then we know
150          * our timestamp may be inconsistent with that used by
151          * the low-level rtc_read_alarm_internal() function.
152          *
153          * So, when the two timestamps disagree, we just loop and do
154          * the process again to get a fully consistent set of values.
155          *
156          * This could all instead be done in the lower level driver,
157          * but since more than one lower level RTC implementation needs it,
158          * then it's probably best best to do it here instead of there..
159          */
160
161         /* Get the "before" timestamp */
162         err = rtc_read_time(rtc, &before);
163         if (err < 0)
164                 return err;
165         do {
166                 if (!first_time)
167                         memcpy(&before, &now, sizeof(struct rtc_time));
168                 first_time = 0;
169
170                 /* get the RTC alarm values, which may be incomplete */
171                 err = rtc_read_alarm_internal(rtc, alarm);
172                 if (err)
173                         return err;
174                 if (!alarm->enabled)
175                         return 0;
176
177                 /* get the "after" timestamp, to detect wrapped fields */
178                 err = rtc_read_time(rtc, &now);
179                 if (err < 0)
180                         return err;
181
182                 /* note that tm_sec is a "don't care" value here: */
183         } while (   before.tm_min   != now.tm_min
184                  || before.tm_hour  != now.tm_hour
185                  || before.tm_mon   != now.tm_mon
186                  || before.tm_year  != now.tm_year
187                  || before.tm_isdst != now.tm_isdst);
188
189         /* Fill in any missing alarm fields using the timestamp */
190         if (alarm->time.tm_sec == -1)
191                 alarm->time.tm_sec = now.tm_sec;
192         if (alarm->time.tm_min == -1)
193                 alarm->time.tm_min = now.tm_min;
194         if (alarm->time.tm_hour == -1)
195                 alarm->time.tm_hour = now.tm_hour;
196         if (alarm->time.tm_mday == -1)
197                 alarm->time.tm_mday = now.tm_mday;
198         if (alarm->time.tm_mon == -1)
199                 alarm->time.tm_mon = now.tm_mon;
200         if (alarm->time.tm_year == -1)
201                 alarm->time.tm_year = now.tm_year;
202         return 0;
203 }
204 EXPORT_SYMBOL_GPL(rtc_read_alarm);
205
206 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
207 {
208         int err;
209
210         err = rtc_valid_tm(&alarm->time);
211         if (err != 0)
212                 return err;
213
214         err = mutex_lock_interruptible(&rtc->ops_lock);
215         if (err)
216                 return -EBUSY;
217
218         if (!rtc->ops)
219                 err = -ENODEV;
220         else if (!rtc->ops->set_alarm)
221                 err = -EINVAL;
222         else
223                 err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
224
225         mutex_unlock(&rtc->ops_lock);
226         return err;
227 }
228 EXPORT_SYMBOL_GPL(rtc_set_alarm);
229
230 /**
231  * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
232  * @rtc: the rtc device
233  * @num: how many irqs are being reported (usually one)
234  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
235  * Context: in_interrupt(), irqs blocked
236  */
237 void rtc_update_irq(struct rtc_device *rtc,
238                 unsigned long num, unsigned long events)
239 {
240         spin_lock(&rtc->irq_lock);
241         rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
242         spin_unlock(&rtc->irq_lock);
243
244         spin_lock(&rtc->irq_task_lock);
245         if (rtc->irq_task)
246                 rtc->irq_task->func(rtc->irq_task->private_data);
247         spin_unlock(&rtc->irq_task_lock);
248
249         wake_up_interruptible(&rtc->irq_queue);
250         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
251 }
252 EXPORT_SYMBOL_GPL(rtc_update_irq);
253
254 struct rtc_device *rtc_class_open(char *name)
255 {
256         struct device *dev;
257         struct rtc_device *rtc = NULL;
258
259         down(&rtc_class->sem);
260         list_for_each_entry(dev, &rtc_class->devices, node) {
261                 if (strncmp(dev->bus_id, name, BUS_ID_SIZE) == 0) {
262                         dev = get_device(dev);
263                         if (dev)
264                                 rtc = to_rtc_device(dev);
265                         break;
266                 }
267         }
268
269         if (rtc) {
270                 if (!try_module_get(rtc->owner)) {
271                         put_device(dev);
272                         rtc = NULL;
273                 }
274         }
275         up(&rtc_class->sem);
276
277         return rtc;
278 }
279 EXPORT_SYMBOL_GPL(rtc_class_open);
280
281 void rtc_class_close(struct rtc_device *rtc)
282 {
283         module_put(rtc->owner);
284         put_device(&rtc->dev);
285 }
286 EXPORT_SYMBOL_GPL(rtc_class_close);
287
288 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
289 {
290         int retval = -EBUSY;
291
292         if (task == NULL || task->func == NULL)
293                 return -EINVAL;
294
295         /* Cannot register while the char dev is in use */
296         if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
297                 return -EBUSY;
298
299         spin_lock_irq(&rtc->irq_task_lock);
300         if (rtc->irq_task == NULL) {
301                 rtc->irq_task = task;
302                 retval = 0;
303         }
304         spin_unlock_irq(&rtc->irq_task_lock);
305
306         clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
307
308         return retval;
309 }
310 EXPORT_SYMBOL_GPL(rtc_irq_register);
311
312 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
313 {
314         spin_lock_irq(&rtc->irq_task_lock);
315         if (rtc->irq_task == task)
316                 rtc->irq_task = NULL;
317         spin_unlock_irq(&rtc->irq_task_lock);
318 }
319 EXPORT_SYMBOL_GPL(rtc_irq_unregister);
320
321 /**
322  * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
323  * @rtc: the rtc device
324  * @task: currently registered with rtc_irq_register()
325  * @enabled: true to enable periodic IRQs
326  * Context: any
327  *
328  * Note that rtc_irq_set_freq() should previously have been used to
329  * specify the desired frequency of periodic IRQ task->func() callbacks.
330  */
331 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
332 {
333         int err = 0;
334         unsigned long flags;
335
336         if (rtc->ops->irq_set_state == NULL)
337                 return -ENXIO;
338
339         spin_lock_irqsave(&rtc->irq_task_lock, flags);
340         if (rtc->irq_task != NULL && task == NULL)
341                 err = -EBUSY;
342         if (rtc->irq_task != task)
343                 err = -EACCES;
344         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
345
346         if (err == 0)
347                 err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
348
349         return err;
350 }
351 EXPORT_SYMBOL_GPL(rtc_irq_set_state);
352
353 /**
354  * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
355  * @rtc: the rtc device
356  * @task: currently registered with rtc_irq_register()
357  * @freq: positive frequency with which task->func() will be called
358  * Context: any
359  *
360  * Note that rtc_irq_set_state() is used to enable or disable the
361  * periodic IRQs.
362  */
363 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
364 {
365         int err = 0;
366         unsigned long flags;
367
368         if (rtc->ops->irq_set_freq == NULL)
369                 return -ENXIO;
370
371         if (!is_power_of_2(freq))
372                 return -EINVAL;
373
374         spin_lock_irqsave(&rtc->irq_task_lock, flags);
375         if (rtc->irq_task != NULL && task == NULL)
376                 err = -EBUSY;
377         if (rtc->irq_task != task)
378                 err = -EACCES;
379         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
380
381         if (err == 0) {
382                 err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
383                 if (err == 0)
384                         rtc->irq_freq = freq;
385         }
386         return err;
387 }
388 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);