Merge branch 'omap-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6.git] / drivers / rtc / rtc-stmp3xxx.c
1 /*
2  * Freescale STMP37XX/STMP378X Real Time Clock driver
3  *
4  * Copyright (c) 2007 Sigmatel, Inc.
5  * Peter Hartley, <peter.hartley@sigmatel.com>
6  *
7  * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
8  * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
9  */
10
11 /*
12  * The code contained herein is licensed under the GNU General Public
13  * License. You may obtain a copy of the GNU General Public License
14  * Version 2 or later at the following locations:
15  *
16  * http://www.opensource.org/licenses/gpl-license.html
17  * http://www.gnu.org/copyleft/gpl.html
18  */
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/platform_device.h>
23 #include <linux/interrupt.h>
24 #include <linux/rtc.h>
25
26 #include <mach/platform.h>
27 #include <mach/stmp3xxx.h>
28 #include <mach/regs-rtc.h>
29
30 struct stmp3xxx_rtc_data {
31         struct rtc_device *rtc;
32         unsigned irq_count;
33         void __iomem *io;
34         int irq_alarm, irq_1msec;
35 };
36
37 static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
38 {
39         /*
40          * The datasheet doesn't say which way round the
41          * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
42          * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
43          */
44         while (__raw_readl(rtc_data->io + HW_RTC_STAT) &
45                         BF(0x80, RTC_STAT_STALE_REGS))
46                 cpu_relax();
47 }
48
49 /* Time read/write */
50 static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
51 {
52         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
53
54         stmp3xxx_wait_time(rtc_data);
55         rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_SECONDS), rtc_tm);
56         return 0;
57 }
58
59 static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t)
60 {
61         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
62
63         __raw_writel(t, rtc_data->io + HW_RTC_SECONDS);
64         stmp3xxx_wait_time(rtc_data);
65         return 0;
66 }
67
68 /* interrupt(s) handler */
69 static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id)
70 {
71         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id);
72         u32 status;
73         u32 events = 0;
74
75         status = __raw_readl(rtc_data->io + HW_RTC_CTRL) &
76                         (BM_RTC_CTRL_ALARM_IRQ | BM_RTC_CTRL_ONEMSEC_IRQ);
77
78         if (status & BM_RTC_CTRL_ALARM_IRQ) {
79                 stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ,
80                                 rtc_data->io + HW_RTC_CTRL);
81                 events |= RTC_AF | RTC_IRQF;
82         }
83
84         if (status & BM_RTC_CTRL_ONEMSEC_IRQ) {
85                 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ,
86                                 rtc_data->io + HW_RTC_CTRL);
87                 if (++rtc_data->irq_count % 1000 == 0) {
88                         events |= RTC_UF | RTC_IRQF;
89                         rtc_data->irq_count = 0;
90                 }
91         }
92
93         if (events)
94                 rtc_update_irq(rtc_data->rtc, 1, events);
95
96         return IRQ_HANDLED;
97 }
98
99 static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
100 {
101         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
102         void __iomem *p = rtc_data->io + HW_RTC_PERSISTENT0,
103                      *ctl = rtc_data->io + HW_RTC_CTRL;
104
105         if (enabled) {
106                 stmp3xxx_setl(BM_RTC_PERSISTENT0_ALARM_EN |
107                               BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
108                 stmp3xxx_setl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl);
109         } else {
110                 stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
111                               BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p);
112                 stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl);
113         }
114         return 0;
115 }
116
117 static int stmp3xxx_update_irq_enable(struct device *dev, unsigned int enabled)
118 {
119         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
120
121         if (enabled)
122                 stmp3xxx_setl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
123                                 rtc_data->io + HW_RTC_CTRL);
124         else
125                 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN,
126                                 rtc_data->io + HW_RTC_CTRL);
127         return 0;
128 }
129
130 static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
131 {
132         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
133
134         rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_ALARM), &alm->time);
135         return 0;
136 }
137
138 static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
139 {
140         unsigned long t;
141         struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
142
143         rtc_tm_to_time(&alm->time, &t);
144         __raw_writel(t, rtc_data->io + HW_RTC_ALARM);
145         return 0;
146 }
147
148 static struct rtc_class_ops stmp3xxx_rtc_ops = {
149         .alarm_irq_enable =
150                           stmp3xxx_alarm_irq_enable,
151         .update_irq_enable =
152                           stmp3xxx_update_irq_enable,
153         .read_time      = stmp3xxx_rtc_gettime,
154         .set_mmss       = stmp3xxx_rtc_set_mmss,
155         .read_alarm     = stmp3xxx_rtc_read_alarm,
156         .set_alarm      = stmp3xxx_rtc_set_alarm,
157 };
158
159 static int stmp3xxx_rtc_remove(struct platform_device *pdev)
160 {
161         struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);
162
163         if (!rtc_data)
164                 return 0;
165
166         stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN,
167                         rtc_data->io + HW_RTC_CTRL);
168         free_irq(rtc_data->irq_alarm, &pdev->dev);
169         free_irq(rtc_data->irq_1msec, &pdev->dev);
170         rtc_device_unregister(rtc_data->rtc);
171         iounmap(rtc_data->io);
172         kfree(rtc_data);
173
174         return 0;
175 }
176
177 static int stmp3xxx_rtc_probe(struct platform_device *pdev)
178 {
179         struct stmp3xxx_rtc_data *rtc_data;
180         struct resource *r;
181         int err;
182
183         rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL);
184         if (!rtc_data)
185                 return -ENOMEM;
186
187         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
188         if (!r) {
189                 dev_err(&pdev->dev, "failed to get resource\n");
190                 err = -ENXIO;
191                 goto out_free;
192         }
193
194         rtc_data->io = ioremap(r->start, resource_size(r));
195         if (!rtc_data->io) {
196                 dev_err(&pdev->dev, "ioremap failed\n");
197                 err = -EIO;
198                 goto out_free;
199         }
200
201         rtc_data->irq_alarm = platform_get_irq(pdev, 0);
202         rtc_data->irq_1msec = platform_get_irq(pdev, 1);
203
204         if (!(__raw_readl(HW_RTC_STAT + rtc_data->io) &
205                         BM_RTC_STAT_RTC_PRESENT)) {
206                 dev_err(&pdev->dev, "no device onboard\n");
207                 err = -ENODEV;
208                 goto out_remap;
209         }
210
211         stmp3xxx_reset_block(rtc_data->io, true);
212         stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
213                         BM_RTC_PERSISTENT0_ALARM_WAKE_EN |
214                         BM_RTC_PERSISTENT0_ALARM_WAKE,
215                         rtc_data->io + HW_RTC_PERSISTENT0);
216         rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
217                                 &stmp3xxx_rtc_ops, THIS_MODULE);
218         if (IS_ERR(rtc_data->rtc)) {
219                 err = PTR_ERR(rtc_data->rtc);
220                 goto out_remap;
221         }
222
223         rtc_data->irq_count = 0;
224         err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt,
225                         IRQF_DISABLED, "RTC alarm", &pdev->dev);
226         if (err) {
227                 dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
228                         rtc_data->irq_alarm);
229                 goto out_irq_alarm;
230         }
231         err = request_irq(rtc_data->irq_1msec, stmp3xxx_rtc_interrupt,
232                         IRQF_DISABLED, "RTC tick", &pdev->dev);
233         if (err) {
234                 dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
235                         rtc_data->irq_1msec);
236                 goto out_irq1;
237         }
238
239         platform_set_drvdata(pdev, rtc_data);
240
241         return 0;
242
243 out_irq1:
244         free_irq(rtc_data->irq_alarm, &pdev->dev);
245 out_irq_alarm:
246         stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN,
247                         rtc_data->io + HW_RTC_CTRL);
248         rtc_device_unregister(rtc_data->rtc);
249 out_remap:
250         iounmap(rtc_data->io);
251 out_free:
252         kfree(rtc_data);
253         return err;
254 }
255
256 #ifdef CONFIG_PM
257 static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
258 {
259         return 0;
260 }
261
262 static int stmp3xxx_rtc_resume(struct platform_device *dev)
263 {
264         struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);
265
266         stmp3xxx_reset_block(rtc_data->io, true);
267         stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN |
268                         BM_RTC_PERSISTENT0_ALARM_WAKE_EN |
269                         BM_RTC_PERSISTENT0_ALARM_WAKE,
270                         rtc_data->io + HW_RTC_PERSISTENT0);
271         return 0;
272 }
273 #else
274 #define stmp3xxx_rtc_suspend    NULL
275 #define stmp3xxx_rtc_resume     NULL
276 #endif
277
278 static struct platform_driver stmp3xxx_rtcdrv = {
279         .probe          = stmp3xxx_rtc_probe,
280         .remove         = stmp3xxx_rtc_remove,
281         .suspend        = stmp3xxx_rtc_suspend,
282         .resume         = stmp3xxx_rtc_resume,
283         .driver         = {
284                 .name   = "stmp3xxx-rtc",
285                 .owner  = THIS_MODULE,
286         },
287 };
288
289 static int __init stmp3xxx_rtc_init(void)
290 {
291         return platform_driver_register(&stmp3xxx_rtcdrv);
292 }
293
294 static void __exit stmp3xxx_rtc_exit(void)
295 {
296         platform_driver_unregister(&stmp3xxx_rtcdrv);
297 }
298
299 module_init(stmp3xxx_rtc_init);
300 module_exit(stmp3xxx_rtc_exit);
301
302 MODULE_DESCRIPTION("STMP3xxx RTC Driver");
303 MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>");
304 MODULE_LICENSE("GPL");