blob: de0da545c7a107c0c967e35b9a4eb3daa4cf1c5b [file] [log] [blame]
Alessandro Zummo0c86edc2006-03-27 01:16:37 -08001/*
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>
David Brownell97144c62007-10-16 01:28:16 -070015#include <linux/log2.h>
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080016
David Brownellab6a2d72007-05-08 00:33:30 -070017int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080018{
19 int err;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080020
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));
David Brownellcd966202007-05-08 00:33:40 -070031 err = rtc->ops->read_time(rtc->dev.parent, tm);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080032 }
33
34 mutex_unlock(&rtc->ops_lock);
35 return err;
36}
37EXPORT_SYMBOL_GPL(rtc_read_time);
38
David Brownellab6a2d72007-05-08 00:33:30 -070039int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080040{
41 int err;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080042
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
David Brownellcd966202007-05-08 00:33:40 -070056 err = rtc->ops->set_time(rtc->dev.parent, tm);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080057
58 mutex_unlock(&rtc->ops_lock);
59 return err;
60}
61EXPORT_SYMBOL_GPL(rtc_set_time);
62
David Brownellab6a2d72007-05-08 00:33:30 -070063int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080064{
65 int err;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080066
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)
David Brownellcd966202007-05-08 00:33:40 -070074 err = rtc->ops->set_mmss(rtc->dev.parent, secs);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080075 else if (rtc->ops->read_time && rtc->ops->set_time) {
76 struct rtc_time new, old;
77
David Brownellcd966202007-05-08 00:33:40 -070078 err = rtc->ops->read_time(rtc->dev.parent, &old);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080079 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)))
David Brownellcd966202007-05-08 00:33:40 -070090 err = rtc->ops->set_time(rtc->dev.parent,
David Brownellab6a2d72007-05-08 00:33:30 -070091 &new);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -080092 }
93 }
94 else
95 err = -EINVAL;
96
97 mutex_unlock(&rtc->ops_lock);
98
99 return err;
100}
101EXPORT_SYMBOL_GPL(rtc_set_mmss);
102
Mark Lord0e36a9a2007-10-16 01:28:21 -0700103static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800104{
105 int err;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800106
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));
David Brownellcd966202007-05-08 00:33:40 -0700117 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800118 }
119
120 mutex_unlock(&rtc->ops_lock);
121 return err;
122}
Mark Lord0e36a9a2007-10-16 01:28:21 -0700123
124int 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}
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800204EXPORT_SYMBOL_GPL(rtc_read_alarm);
205
David Brownellab6a2d72007-05-08 00:33:30 -0700206int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800207{
208 int err;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800209
David Brownellf8245c22007-05-08 00:34:07 -0700210 err = rtc_valid_tm(&alarm->time);
211 if (err != 0)
212 return err;
213
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800214 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
David Brownellcd966202007-05-08 00:33:40 -0700223 err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800224
225 mutex_unlock(&rtc->ops_lock);
226 return err;
227}
228EXPORT_SYMBOL_GPL(rtc_set_alarm);
229
David Brownelld728b1e2006-11-25 11:09:28 -0800230/**
231 * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
David Brownellab6a2d72007-05-08 00:33:30 -0700232 * @rtc: the rtc device
David Brownelld728b1e2006-11-25 11:09:28 -0800233 * @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 */
David Brownellab6a2d72007-05-08 00:33:30 -0700237void rtc_update_irq(struct rtc_device *rtc,
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800238 unsigned long num, unsigned long events)
239{
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800240 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}
252EXPORT_SYMBOL_GPL(rtc_update_irq);
253
David Brownellab6a2d72007-05-08 00:33:30 -0700254struct rtc_device *rtc_class_open(char *name)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800255{
David Brownellcd966202007-05-08 00:33:40 -0700256 struct device *dev;
David Brownellab6a2d72007-05-08 00:33:30 -0700257 struct rtc_device *rtc = NULL;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800258
259 down(&rtc_class->sem);
David Brownellcd966202007-05-08 00:33:40 -0700260 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);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800265 break;
266 }
267 }
268
David Brownellab6a2d72007-05-08 00:33:30 -0700269 if (rtc) {
270 if (!try_module_get(rtc->owner)) {
David Brownellcd966202007-05-08 00:33:40 -0700271 put_device(dev);
David Brownellab6a2d72007-05-08 00:33:30 -0700272 rtc = NULL;
273 }
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800274 }
275 up(&rtc_class->sem);
276
David Brownellab6a2d72007-05-08 00:33:30 -0700277 return rtc;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800278}
279EXPORT_SYMBOL_GPL(rtc_class_open);
280
David Brownellab6a2d72007-05-08 00:33:30 -0700281void rtc_class_close(struct rtc_device *rtc)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800282{
David Brownellab6a2d72007-05-08 00:33:30 -0700283 module_put(rtc->owner);
David Brownellcd966202007-05-08 00:33:40 -0700284 put_device(&rtc->dev);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800285}
286EXPORT_SYMBOL_GPL(rtc_class_close);
287
David Brownellab6a2d72007-05-08 00:33:30 -0700288int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800289{
290 int retval = -EBUSY;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800291
292 if (task == NULL || task->func == NULL)
293 return -EINVAL;
294
Alessandro Zummod691eb92007-10-16 01:28:15 -0700295 /* Cannot register while the char dev is in use */
296 if (!(mutex_trylock(&rtc->char_lock)))
297 return -EBUSY;
298
David Brownelld728b1e2006-11-25 11:09:28 -0800299 spin_lock_irq(&rtc->irq_task_lock);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800300 if (rtc->irq_task == NULL) {
301 rtc->irq_task = task;
302 retval = 0;
303 }
David Brownelld728b1e2006-11-25 11:09:28 -0800304 spin_unlock_irq(&rtc->irq_task_lock);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800305
Alessandro Zummod691eb92007-10-16 01:28:15 -0700306 mutex_unlock(&rtc->char_lock);
307
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800308 return retval;
309}
310EXPORT_SYMBOL_GPL(rtc_irq_register);
311
David Brownellab6a2d72007-05-08 00:33:30 -0700312void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800313{
David Brownelld728b1e2006-11-25 11:09:28 -0800314 spin_lock_irq(&rtc->irq_task_lock);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800315 if (rtc->irq_task == task)
316 rtc->irq_task = NULL;
David Brownelld728b1e2006-11-25 11:09:28 -0800317 spin_unlock_irq(&rtc->irq_task_lock);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800318}
319EXPORT_SYMBOL_GPL(rtc_irq_unregister);
320
David Brownell97144c62007-10-16 01:28:16 -0700321/**
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 */
David Brownellab6a2d72007-05-08 00:33:30 -0700331int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800332{
333 int err = 0;
334 unsigned long flags;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800335
Alessandro Zummo56f10c62006-06-25 05:48:20 -0700336 if (rtc->ops->irq_set_state == NULL)
337 return -ENXIO;
338
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800339 spin_lock_irqsave(&rtc->irq_task_lock, flags);
Alessandro Zummod691eb92007-10-16 01:28:15 -0700340 if (rtc->irq_task != NULL && task == NULL)
341 err = -EBUSY;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800342 if (rtc->irq_task != task)
Alessandro Zummod691eb92007-10-16 01:28:15 -0700343 err = -EACCES;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800344 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
345
346 if (err == 0)
David Brownellcd966202007-05-08 00:33:40 -0700347 err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800348
349 return err;
350}
351EXPORT_SYMBOL_GPL(rtc_irq_set_state);
352
David Brownell97144c62007-10-16 01:28:16 -0700353/**
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 */
David Brownellab6a2d72007-05-08 00:33:30 -0700363int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800364{
Alessandro Zummo56f10c62006-06-25 05:48:20 -0700365 int err = 0;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800366 unsigned long flags;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800367
Alessandro Zummo56f10c62006-06-25 05:48:20 -0700368 if (rtc->ops->irq_set_freq == NULL)
369 return -ENXIO;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800370
David Brownell97144c62007-10-16 01:28:16 -0700371 if (!is_power_of_2(freq))
372 return -EINVAL;
373
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800374 spin_lock_irqsave(&rtc->irq_task_lock, flags);
Alessandro Zummod691eb92007-10-16 01:28:15 -0700375 if (rtc->irq_task != NULL && task == NULL)
376 err = -EBUSY;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800377 if (rtc->irq_task != task)
Alessandro Zummod691eb92007-10-16 01:28:15 -0700378 err = -EACCES;
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800379 spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
380
381 if (err == 0) {
David Brownellcd966202007-05-08 00:33:40 -0700382 err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
Alessandro Zummo0c86edc2006-03-27 01:16:37 -0800383 if (err == 0)
384 rtc->irq_freq = freq;
385 }
386 return err;
387}
David Brownell2601a462006-11-25 11:09:27 -0800388EXPORT_SYMBOL_GPL(rtc_irq_set_freq);