[PATCH] rtc framework handles periodic irqs
[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
16 int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
17 {
18         int err;
19         struct rtc_device *rtc = to_rtc_device(class_dev);
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(class_dev->dev, 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 class_device *class_dev, struct rtc_time *tm)
40 {
41         int err;
42         struct rtc_device *rtc = to_rtc_device(class_dev);
43
44         err = rtc_valid_tm(tm);
45         if (err != 0)
46                 return err;
47
48         err = mutex_lock_interruptible(&rtc->ops_lock);
49         if (err)
50                 return -EBUSY;
51
52         if (!rtc->ops)
53                 err = -ENODEV;
54         else if (!rtc->ops->set_time)
55                 err = -EINVAL;
56         else
57                 err = rtc->ops->set_time(class_dev->dev, tm);
58
59         mutex_unlock(&rtc->ops_lock);
60         return err;
61 }
62 EXPORT_SYMBOL_GPL(rtc_set_time);
63
64 int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
65 {
66         int err;
67         struct rtc_device *rtc = to_rtc_device(class_dev);
68
69         err = mutex_lock_interruptible(&rtc->ops_lock);
70         if (err)
71                 return -EBUSY;
72
73         if (!rtc->ops)
74                 err = -ENODEV;
75         else if (rtc->ops->set_mmss)
76                 err = rtc->ops->set_mmss(class_dev->dev, secs);
77         else if (rtc->ops->read_time && rtc->ops->set_time) {
78                 struct rtc_time new, old;
79
80                 err = rtc->ops->read_time(class_dev->dev, &old);
81                 if (err == 0) {
82                         rtc_time_to_tm(secs, &new);
83
84                         /*
85                          * avoid writing when we're going to change the day of
86                          * the month. We will retry in the next minute. This
87                          * basically means that if the RTC must not drift
88                          * by more than 1 minute in 11 minutes.
89                          */
90                         if (!((old.tm_hour == 23 && old.tm_min == 59) ||
91                                 (new.tm_hour == 23 && new.tm_min == 59)))
92                                 err = rtc->ops->set_time(class_dev->dev, &new);
93                 }
94         }
95         else
96                 err = -EINVAL;
97
98         mutex_unlock(&rtc->ops_lock);
99
100         return err;
101 }
102 EXPORT_SYMBOL_GPL(rtc_set_mmss);
103
104 int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
105 {
106         int err;
107         struct rtc_device *rtc = to_rtc_device(class_dev);
108
109         err = mutex_lock_interruptible(&rtc->ops_lock);
110         if (err)
111                 return -EBUSY;
112
113         if (rtc->ops == NULL)
114                 err = -ENODEV;
115         else if (!rtc->ops->read_alarm)
116                 err = -EINVAL;
117         else {
118                 memset(alarm, 0, sizeof(struct rtc_wkalrm));
119                 err = rtc->ops->read_alarm(class_dev->dev, alarm);
120         }
121
122         mutex_unlock(&rtc->ops_lock);
123         return err;
124 }
125 EXPORT_SYMBOL_GPL(rtc_read_alarm);
126
127 int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
128 {
129         int err;
130         struct rtc_device *rtc = to_rtc_device(class_dev);
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(class_dev->dev, alarm);
142
143         mutex_unlock(&rtc->ops_lock);
144         return err;
145 }
146 EXPORT_SYMBOL_GPL(rtc_set_alarm);
147
148 void rtc_update_irq(struct class_device *class_dev,
149                 unsigned long num, unsigned long events)
150 {
151         struct rtc_device *rtc = to_rtc_device(class_dev);
152
153         spin_lock(&rtc->irq_lock);
154         rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
155         spin_unlock(&rtc->irq_lock);
156
157         spin_lock(&rtc->irq_task_lock);
158         if (rtc->irq_task)
159                 rtc->irq_task->func(rtc->irq_task->private_data);
160         spin_unlock(&rtc->irq_task_lock);
161
162         wake_up_interruptible(&rtc->irq_queue);
163         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
164 }
165 EXPORT_SYMBOL_GPL(rtc_update_irq);
166
167 struct class_device *rtc_class_open(char *name)
168 {
169         struct class_device *class_dev = NULL,
170                                 *class_dev_tmp;
171
172         down(&rtc_class->sem);
173         list_for_each_entry(class_dev_tmp, &rtc_class->children, node) {
174                 if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) {
175                         class_dev = class_dev_tmp;
176                         break;
177                 }
178         }
179
180         if (class_dev) {
181                 if (!try_module_get(to_rtc_device(class_dev)->owner))
182                         class_dev = NULL;
183         }
184         up(&rtc_class->sem);
185
186         return class_dev;
187 }
188 EXPORT_SYMBOL_GPL(rtc_class_open);
189
190 void rtc_class_close(struct class_device *class_dev)
191 {
192         module_put(to_rtc_device(class_dev)->owner);
193 }
194 EXPORT_SYMBOL_GPL(rtc_class_close);
195
196 int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
197 {
198         int retval = -EBUSY;
199         struct rtc_device *rtc = to_rtc_device(class_dev);
200
201         if (task == NULL || task->func == NULL)
202                 return -EINVAL;
203
204         spin_lock(&rtc->irq_task_lock);
205         if (rtc->irq_task == NULL) {
206                 rtc->irq_task = task;
207                 retval = 0;
208         }
209         spin_unlock(&rtc->irq_task_lock);
210
211         return retval;
212 }
213 EXPORT_SYMBOL_GPL(rtc_irq_register);
214
215 void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
216 {
217         struct rtc_device *rtc = to_rtc_device(class_dev);
218
219         spin_lock(&rtc->irq_task_lock);
220         if (rtc->irq_task == task)
221                 rtc->irq_task = NULL;
222         spin_unlock(&rtc->irq_task_lock);
223 }
224 EXPORT_SYMBOL_GPL(rtc_irq_unregister);
225
226 int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled)
227 {
228         int err = 0;
229         unsigned long flags;
230         struct rtc_device *rtc = to_rtc_device(class_dev);
231
232         if (rtc->ops->irq_set_state == NULL)
233                 return -ENXIO;
234
235         spin_lock_irqsave(&rtc->irq_task_lock, flags);
236         if (rtc->irq_task != task)
237                 err = -ENXIO;
238         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
239
240         if (err == 0)
241                 err = rtc->ops->irq_set_state(class_dev->dev, enabled);
242
243         return err;
244 }
245 EXPORT_SYMBOL_GPL(rtc_irq_set_state);
246
247 int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq)
248 {
249         int err = 0;
250         unsigned long flags;
251         struct rtc_device *rtc = to_rtc_device(class_dev);
252
253         if (rtc->ops->irq_set_freq == NULL)
254                 return -ENXIO;
255
256         spin_lock_irqsave(&rtc->irq_task_lock, flags);
257         if (rtc->irq_task != task)
258                 err = -ENXIO;
259         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
260
261         if (err == 0) {
262                 err = rtc->ops->irq_set_freq(class_dev->dev, freq);
263                 if (err == 0)
264                         rtc->irq_freq = freq;
265         }
266         return err;
267 }
268 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);