Merge tag 'dt' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[linux-2.6.git] / drivers / rtc / rtc-mc13xxx.c
1 /*
2  * Real Time Clock driver for Freescale MC13XXX PMIC
3  *
4  * (C) 2009 Sascha Hauer, Pengutronix
5  * (C) 2009 Uwe Kleine-Koenig, Pengutronix
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/mfd/mc13xxx.h>
13 #include <linux/platform_device.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/rtc.h>
18
19 #define DRIVER_NAME "mc13xxx-rtc"
20
21 #define MC13XXX_RTCTOD  20
22 #define MC13XXX_RTCTODA 21
23 #define MC13XXX_RTCDAY  22
24 #define MC13XXX_RTCDAYA 23
25
26 struct mc13xxx_rtc {
27         struct rtc_device *rtc;
28         struct mc13xxx *mc13xxx;
29         int valid;
30 };
31
32 static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
33                 unsigned int enabled, int irq)
34 {
35         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
36         int (*func)(struct mc13xxx *mc13xxx, int irq);
37
38         if (!priv->valid)
39                 return -ENODATA;
40
41         func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
42         return func(priv->mc13xxx, irq);
43 }
44
45 static int mc13xxx_rtc_irq_enable(struct device *dev,
46                 unsigned int enabled, int irq)
47 {
48         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
49         int ret;
50
51         mc13xxx_lock(priv->mc13xxx);
52
53         ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, irq);
54
55         mc13xxx_unlock(priv->mc13xxx);
56
57         return ret;
58 }
59
60 static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
61 {
62         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
63         unsigned int seconds, days1, days2;
64         unsigned long s1970;
65         int ret;
66
67         mc13xxx_lock(priv->mc13xxx);
68
69         if (!priv->valid) {
70                 ret = -ENODATA;
71                 goto out;
72         }
73
74         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
75         if (unlikely(ret))
76                 goto out;
77
78         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
79         if (unlikely(ret))
80                 goto out;
81
82         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
83 out:
84         mc13xxx_unlock(priv->mc13xxx);
85
86         if (ret)
87                 return ret;
88
89         if (days2 == days1 + 1) {
90                 if (seconds >= 86400 / 2)
91                         days2 = days1;
92                 else
93                         days1 = days2;
94         }
95
96         if (days1 != days2)
97                 return -EIO;
98
99         s1970 = days1 * 86400 + seconds;
100
101         rtc_time_to_tm(s1970, tm);
102
103         return rtc_valid_tm(tm);
104 }
105
106 static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
107 {
108         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
109         unsigned int seconds, days;
110         unsigned int alarmseconds;
111         int ret;
112
113         seconds = secs % 86400;
114         days = secs / 86400;
115
116         mc13xxx_lock(priv->mc13xxx);
117
118         /*
119          * temporarily invalidate alarm to prevent triggering it when the day is
120          * already updated while the time isn't yet.
121          */
122         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
123         if (unlikely(ret))
124                 goto out;
125
126         if (alarmseconds < 86400) {
127                 ret = mc13xxx_reg_write(priv->mc13xxx,
128                                 MC13XXX_RTCTODA, 0x1ffff);
129                 if (unlikely(ret))
130                         goto out;
131         }
132
133         /*
134          * write seconds=0 to prevent a day switch between writing days
135          * and seconds below
136          */
137         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
138         if (unlikely(ret))
139                 goto out;
140
141         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
142         if (unlikely(ret))
143                 goto out;
144
145         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
146         if (unlikely(ret))
147                 goto out;
148
149         /* restore alarm */
150         if (alarmseconds < 86400) {
151                 ret = mc13xxx_reg_write(priv->mc13xxx,
152                                 MC13XXX_RTCTODA, alarmseconds);
153                 if (unlikely(ret))
154                         goto out;
155         }
156
157         ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
158         if (unlikely(ret))
159                 goto out;
160
161         ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
162 out:
163         priv->valid = !ret;
164
165         mc13xxx_unlock(priv->mc13xxx);
166
167         return ret;
168 }
169
170 static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
171 {
172         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
173         unsigned seconds, days;
174         unsigned long s1970;
175         int enabled, pending;
176         int ret;
177
178         mc13xxx_lock(priv->mc13xxx);
179
180         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
181         if (unlikely(ret))
182                 goto out;
183         if (seconds >= 86400) {
184                 ret = -ENODATA;
185                 goto out;
186         }
187
188         ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
189         if (unlikely(ret))
190                 goto out;
191
192         ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
193                         &enabled, &pending);
194
195 out:
196         mc13xxx_unlock(priv->mc13xxx);
197
198         if (ret)
199                 return ret;
200
201         alarm->enabled = enabled;
202         alarm->pending = pending;
203
204         s1970 = days * 86400 + seconds;
205
206         rtc_time_to_tm(s1970, &alarm->time);
207         dev_dbg(dev, "%s: %lu\n", __func__, s1970);
208
209         return 0;
210 }
211
212 static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
213 {
214         struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
215         unsigned long s1970;
216         unsigned seconds, days;
217         int ret;
218
219         mc13xxx_lock(priv->mc13xxx);
220
221         /* disable alarm to prevent false triggering */
222         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
223         if (unlikely(ret))
224                 goto out;
225
226         ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
227         if (unlikely(ret))
228                 goto out;
229
230         ret = rtc_tm_to_time(&alarm->time, &s1970);
231         if (unlikely(ret))
232                 goto out;
233
234         dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
235                         s1970);
236
237         ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
238                         MC13XXX_IRQ_TODA);
239         if (unlikely(ret))
240                 goto out;
241
242         seconds = s1970 % 86400;
243         days = s1970 / 86400;
244
245         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
246         if (unlikely(ret))
247                 goto out;
248
249         ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
250
251 out:
252         mc13xxx_unlock(priv->mc13xxx);
253
254         return ret;
255 }
256
257 static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
258 {
259         struct mc13xxx_rtc *priv = dev;
260         struct mc13xxx *mc13xxx = priv->mc13xxx;
261
262         dev_dbg(&priv->rtc->dev, "Alarm\n");
263
264         rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
265
266         mc13xxx_irq_ack(mc13xxx, irq);
267
268         return IRQ_HANDLED;
269 }
270
271 static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
272 {
273         struct mc13xxx_rtc *priv = dev;
274         struct mc13xxx *mc13xxx = priv->mc13xxx;
275
276         dev_dbg(&priv->rtc->dev, "1HZ\n");
277
278         rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
279
280         mc13xxx_irq_ack(mc13xxx, irq);
281
282         return IRQ_HANDLED;
283 }
284
285 static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
286                 unsigned int enabled)
287 {
288         return mc13xxx_rtc_irq_enable(dev, enabled, MC13XXX_IRQ_TODA);
289 }
290
291 static const struct rtc_class_ops mc13xxx_rtc_ops = {
292         .read_time = mc13xxx_rtc_read_time,
293         .set_mmss = mc13xxx_rtc_set_mmss,
294         .read_alarm = mc13xxx_rtc_read_alarm,
295         .set_alarm = mc13xxx_rtc_set_alarm,
296         .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
297 };
298
299 static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
300 {
301         struct mc13xxx_rtc *priv = dev;
302         struct mc13xxx *mc13xxx = priv->mc13xxx;
303
304         dev_dbg(&priv->rtc->dev, "RTCRST\n");
305         priv->valid = 0;
306
307         mc13xxx_irq_mask(mc13xxx, irq);
308
309         return IRQ_HANDLED;
310 }
311
312 static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
313 {
314         int ret;
315         struct mc13xxx_rtc *priv;
316         struct mc13xxx *mc13xxx;
317         int rtcrst_pending;
318
319         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
320         if (!priv)
321                 return -ENOMEM;
322
323         mc13xxx = dev_get_drvdata(pdev->dev.parent);
324         priv->mc13xxx = mc13xxx;
325
326         platform_set_drvdata(pdev, priv);
327
328         mc13xxx_lock(mc13xxx);
329
330         ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
331                         mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
332         if (ret)
333                 goto err_reset_irq_request;
334
335         ret = mc13xxx_irq_status(mc13xxx, MC13XXX_IRQ_RTCRST,
336                         NULL, &rtcrst_pending);
337         if (ret)
338                 goto err_reset_irq_status;
339
340         priv->valid = !rtcrst_pending;
341
342         ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_1HZ,
343                         mc13xxx_rtc_update_handler, DRIVER_NAME, priv);
344         if (ret)
345                 goto err_update_irq_request;
346
347         ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
348                         mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
349         if (ret)
350                 goto err_alarm_irq_request;
351
352         mc13xxx_unlock(mc13xxx);
353
354         priv->rtc = rtc_device_register(pdev->name,
355                         &pdev->dev, &mc13xxx_rtc_ops, THIS_MODULE);
356         if (IS_ERR(priv->rtc)) {
357                 ret = PTR_ERR(priv->rtc);
358
359                 mc13xxx_lock(mc13xxx);
360
361                 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
362 err_alarm_irq_request:
363
364                 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv);
365 err_update_irq_request:
366
367 err_reset_irq_status:
368
369                 mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
370 err_reset_irq_request:
371
372                 mc13xxx_unlock(mc13xxx);
373
374                 platform_set_drvdata(pdev, NULL);
375                 kfree(priv);
376         }
377
378         return ret;
379 }
380
381 static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
382 {
383         struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
384
385         mc13xxx_lock(priv->mc13xxx);
386
387         rtc_device_unregister(priv->rtc);
388
389         mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
390         mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
391         mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
392
393         mc13xxx_unlock(priv->mc13xxx);
394
395         platform_set_drvdata(pdev, NULL);
396
397         kfree(priv);
398
399         return 0;
400 }
401
402 const struct platform_device_id mc13xxx_rtc_idtable[] = {
403         {
404                 .name = "mc13783-rtc",
405         }, {
406                 .name = "mc13892-rtc",
407         },
408         { }
409 };
410
411 static struct platform_driver mc13xxx_rtc_driver = {
412         .id_table = mc13xxx_rtc_idtable,
413         .remove = __exit_p(mc13xxx_rtc_remove),
414         .driver = {
415                 .name = DRIVER_NAME,
416                 .owner = THIS_MODULE,
417         },
418 };
419
420 static int __init mc13xxx_rtc_init(void)
421 {
422         return platform_driver_probe(&mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
423 }
424 module_init(mc13xxx_rtc_init);
425
426 static void __exit mc13xxx_rtc_exit(void)
427 {
428         platform_driver_unregister(&mc13xxx_rtc_driver);
429 }
430 module_exit(mc13xxx_rtc_exit);
431
432 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
433 MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
434 MODULE_LICENSE("GPL v2");
435 MODULE_ALIAS("platform:" DRIVER_NAME);