rtc: rtc interfaces don't use class_device
[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 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->class_dev.dev, 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->class_dev.dev, 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->class_dev.dev, 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->class_dev.dev, &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->class_dev.dev,
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->class_dev.dev, 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 = mutex_lock_interruptible(&rtc->ops_lock);
129         if (err)
130                 return -EBUSY;
131
132         if (!rtc->ops)
133                 err = -ENODEV;
134         else if (!rtc->ops->set_alarm)
135                 err = -EINVAL;
136         else
137                 err = rtc->ops->set_alarm(rtc->class_dev.dev, alarm);
138
139         mutex_unlock(&rtc->ops_lock);
140         return err;
141 }
142 EXPORT_SYMBOL_GPL(rtc_set_alarm);
143
144 /**
145  * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
146  * @rtc: the rtc device
147  * @num: how many irqs are being reported (usually one)
148  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
149  * Context: in_interrupt(), irqs blocked
150  */
151 void rtc_update_irq(struct rtc_device *rtc,
152                 unsigned long num, unsigned long events)
153 {
154         spin_lock(&rtc->irq_lock);
155         rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
156         spin_unlock(&rtc->irq_lock);
157
158         spin_lock(&rtc->irq_task_lock);
159         if (rtc->irq_task)
160                 rtc->irq_task->func(rtc->irq_task->private_data);
161         spin_unlock(&rtc->irq_task_lock);
162
163         wake_up_interruptible(&rtc->irq_queue);
164         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
165 }
166 EXPORT_SYMBOL_GPL(rtc_update_irq);
167
168 struct rtc_device *rtc_class_open(char *name)
169 {
170         struct class_device *class_dev_tmp;
171         struct rtc_device *rtc = NULL;
172
173         down(&rtc_class->sem);
174         list_for_each_entry(class_dev_tmp, &rtc_class->children, node) {
175                 if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) {
176                         class_dev_tmp = class_device_get(class_dev_tmp);
177                         if (class_dev_tmp)
178                                 rtc = to_rtc_device(class_dev_tmp);
179                         break;
180                 }
181         }
182
183         if (rtc) {
184                 if (!try_module_get(rtc->owner)) {
185                         class_device_put(class_dev_tmp);
186                         rtc = NULL;
187                 }
188         }
189         up(&rtc_class->sem);
190
191         return rtc;
192 }
193 EXPORT_SYMBOL_GPL(rtc_class_open);
194
195 void rtc_class_close(struct rtc_device *rtc)
196 {
197         module_put(rtc->owner);
198         class_device_put(&rtc->class_dev);
199 }
200 EXPORT_SYMBOL_GPL(rtc_class_close);
201
202 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
203 {
204         int retval = -EBUSY;
205
206         if (task == NULL || task->func == NULL)
207                 return -EINVAL;
208
209         spin_lock_irq(&rtc->irq_task_lock);
210         if (rtc->irq_task == NULL) {
211                 rtc->irq_task = task;
212                 retval = 0;
213         }
214         spin_unlock_irq(&rtc->irq_task_lock);
215
216         return retval;
217 }
218 EXPORT_SYMBOL_GPL(rtc_irq_register);
219
220 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
221 {
222
223         spin_lock_irq(&rtc->irq_task_lock);
224         if (rtc->irq_task == task)
225                 rtc->irq_task = NULL;
226         spin_unlock_irq(&rtc->irq_task_lock);
227 }
228 EXPORT_SYMBOL_GPL(rtc_irq_unregister);
229
230 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
231 {
232         int err = 0;
233         unsigned long flags;
234
235         if (rtc->ops->irq_set_state == NULL)
236                 return -ENXIO;
237
238         spin_lock_irqsave(&rtc->irq_task_lock, flags);
239         if (rtc->irq_task != task)
240                 err = -ENXIO;
241         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
242
243         if (err == 0)
244                 err = rtc->ops->irq_set_state(rtc->class_dev.dev, enabled);
245
246         return err;
247 }
248 EXPORT_SYMBOL_GPL(rtc_irq_set_state);
249
250 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
251 {
252         int err = 0;
253         unsigned long flags;
254
255         if (rtc->ops->irq_set_freq == NULL)
256                 return -ENXIO;
257
258         spin_lock_irqsave(&rtc->irq_task_lock, flags);
259         if (rtc->irq_task != task)
260                 err = -ENXIO;
261         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
262
263         if (err == 0) {
264                 err = rtc->ops->irq_set_freq(rtc->class_dev.dev, freq);
265                 if (err == 0)
266                         rtc->irq_freq = freq;
267         }
268         return err;
269 }
270 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);