d268cf11b367eb034298037d3e2baae32acc1d59
[linux-2.6.git] / drivers / rtc / rtc-sa1100.c
1 /*
2  * Real Time Clock interface for StrongARM SA1x00 and XScale PXA2xx
3  *
4  * Copyright (c) 2000 Nils Faerber
5  *
6  * Based on rtc.c by Paul Gortmaker
7  *
8  * Original Driver by Nils Faerber <nils@kernelconcepts.de>
9  *
10  * Modifications from:
11  *   CIH <cih@coventive.com>
12  *   Nicolas Pitre <nico@fluxnic.net>
13  *   Andrew Christian <andrew.christian@hp.com>
14  *
15  * Converted to the RTC subsystem and Driver Model
16  *   by Richard Purdie <rpurdie@rpsys.net>
17  *
18  * This program is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU General Public License
20  * as published by the Free Software Foundation; either version
21  * 2 of the License, or (at your option) any later version.
22  */
23
24 #include <linux/platform_device.h>
25 #include <linux/module.h>
26 #include <linux/rtc.h>
27 #include <linux/init.h>
28 #include <linux/fs.h>
29 #include <linux/interrupt.h>
30 #include <linux/string.h>
31 #include <linux/pm.h>
32 #include <linux/bitops.h>
33
34 #include <mach/hardware.h>
35 #include <asm/irq.h>
36
37 #ifdef CONFIG_ARCH_PXA
38 #include <mach/regs-rtc.h>
39 #endif
40
41 #define RTC_DEF_DIVIDER         (32768 - 1)
42 #define RTC_DEF_TRIM            0
43
44 static const unsigned long RTC_FREQ = 1024;
45 static struct rtc_time rtc_alarm;
46 static DEFINE_SPINLOCK(sa1100_rtc_lock);
47
48 /*
49  * Calculate the next alarm time given the requested alarm time mask
50  * and the current time.
51  */
52 static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
53         struct rtc_time *alrm)
54 {
55         unsigned long next_time;
56         unsigned long now_time;
57
58         next->tm_year = now->tm_year;
59         next->tm_mon = now->tm_mon;
60         next->tm_mday = now->tm_mday;
61         next->tm_hour = alrm->tm_hour;
62         next->tm_min = alrm->tm_min;
63         next->tm_sec = alrm->tm_sec;
64
65         rtc_tm_to_time(now, &now_time);
66         rtc_tm_to_time(next, &next_time);
67
68         if (next_time < now_time) {
69                 /* Advance one day */
70                 next_time += 60 * 60 * 24;
71                 rtc_time_to_tm(next_time, next);
72         }
73 }
74
75 static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
76 {
77         struct platform_device *pdev = to_platform_device(dev_id);
78         struct rtc_device *rtc = platform_get_drvdata(pdev);
79         unsigned int rtsr;
80         unsigned long events = 0;
81
82         spin_lock(&sa1100_rtc_lock);
83
84         rtsr = RTSR;
85         /* clear interrupt sources */
86         RTSR = 0;
87         /* Fix for a nasty initialization problem the in SA11xx RTSR register.
88          * See also the comments in sa1100_rtc_probe(). */
89         if (rtsr & (RTSR_ALE | RTSR_HZE)) {
90                 /* This is the original code, before there was the if test
91                  * above. This code does not clear interrupts that were not
92                  * enabled. */
93                 RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2);
94         } else {
95                 /* For some reason, it is possible to enter this routine
96                  * without interruptions enabled, it has been tested with
97                  * several units (Bug in SA11xx chip?).
98                  *
99                  * This situation leads to an infinite "loop" of interrupt
100                  * routine calling and as a result the processor seems to
101                  * lock on its first call to open(). */
102                 RTSR = RTSR_AL | RTSR_HZ;
103         }
104
105         /* clear alarm interrupt if it has occurred */
106         if (rtsr & RTSR_AL)
107                 rtsr &= ~RTSR_ALE;
108         RTSR = rtsr & (RTSR_ALE | RTSR_HZE);
109
110         /* update irq data & counter */
111         if (rtsr & RTSR_AL)
112                 events |= RTC_AF | RTC_IRQF;
113         if (rtsr & RTSR_HZ)
114                 events |= RTC_UF | RTC_IRQF;
115
116         rtc_update_irq(rtc, 1, events);
117
118         spin_unlock(&sa1100_rtc_lock);
119
120         return IRQ_HANDLED;
121 }
122
123 static int sa1100_rtc_open(struct device *dev)
124 {
125         int ret;
126         struct platform_device *plat_dev = to_platform_device(dev);
127         struct rtc_device *rtc = platform_get_drvdata(plat_dev);
128
129         ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, IRQF_DISABLED,
130                 "rtc 1Hz", dev);
131         if (ret) {
132                 dev_err(dev, "IRQ %d already in use.\n", IRQ_RTC1Hz);
133                 goto fail_ui;
134         }
135         ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, IRQF_DISABLED,
136                 "rtc Alrm", dev);
137         if (ret) {
138                 dev_err(dev, "IRQ %d already in use.\n", IRQ_RTCAlrm);
139                 goto fail_ai;
140         }
141         rtc->max_user_freq = RTC_FREQ;
142         rtc_irq_set_freq(rtc, NULL, RTC_FREQ);
143
144         return 0;
145
146  fail_ai:
147         free_irq(IRQ_RTC1Hz, dev);
148  fail_ui:
149         return ret;
150 }
151
152 static void sa1100_rtc_release(struct device *dev)
153 {
154         spin_lock_irq(&sa1100_rtc_lock);
155         RTSR = 0;
156         spin_unlock_irq(&sa1100_rtc_lock);
157
158         free_irq(IRQ_RTCAlrm, dev);
159         free_irq(IRQ_RTC1Hz, dev);
160 }
161
162 static int sa1100_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
163 {
164         spin_lock_irq(&sa1100_rtc_lock);
165         if (enabled)
166                 RTSR |= RTSR_ALE;
167         else
168                 RTSR &= ~RTSR_ALE;
169         spin_unlock_irq(&sa1100_rtc_lock);
170         return 0;
171 }
172
173 static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm)
174 {
175         rtc_time_to_tm(RCNR, tm);
176         return 0;
177 }
178
179 static int sa1100_rtc_set_time(struct device *dev, struct rtc_time *tm)
180 {
181         unsigned long time;
182         int ret;
183
184         ret = rtc_tm_to_time(tm, &time);
185         if (ret == 0)
186                 RCNR = time;
187         return ret;
188 }
189
190 static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
191 {
192         u32     rtsr;
193
194         memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time));
195         rtsr = RTSR;
196         alrm->enabled = (rtsr & RTSR_ALE) ? 1 : 0;
197         alrm->pending = (rtsr & RTSR_AL) ? 1 : 0;
198         return 0;
199 }
200
201 static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
202 {
203         struct rtc_time now_tm, alarm_tm;
204         int ret;
205
206         spin_lock_irq(&sa1100_rtc_lock);
207
208         now = RCNR;
209         rtc_time_to_tm(now, &now_tm);
210         rtc_next_alarm_time(&alarm_tm, &now_tm, alrm->time);
211         rtc_tm_to_time(&alarm_tm, &time);
212         RTAR = time;
213         if (alrm->enabled)
214                 RTSR |= RTSR_ALE;
215         else
216                 RTSR &= ~RTSR_ALE;
217
218         spin_unlock_irq(&sa1100_rtc_lock);
219
220         return ret;
221 }
222
223 static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq)
224 {
225         seq_printf(seq, "trim/divider\t\t: 0x%08x\n", (u32) RTTR);
226         seq_printf(seq, "RTSR\t\t\t: 0x%08x\n", (u32)RTSR);
227
228         return 0;
229 }
230
231 static const struct rtc_class_ops sa1100_rtc_ops = {
232         .open = sa1100_rtc_open,
233         .release = sa1100_rtc_release,
234         .read_time = sa1100_rtc_read_time,
235         .set_time = sa1100_rtc_set_time,
236         .read_alarm = sa1100_rtc_read_alarm,
237         .set_alarm = sa1100_rtc_set_alarm,
238         .proc = sa1100_rtc_proc,
239         .alarm_irq_enable = sa1100_rtc_alarm_irq_enable,
240 };
241
242 static int sa1100_rtc_probe(struct platform_device *pdev)
243 {
244         struct rtc_device *rtc;
245
246         /*
247          * According to the manual we should be able to let RTTR be zero
248          * and then a default diviser for a 32.768KHz clock is used.
249          * Apparently this doesn't work, at least for my SA1110 rev 5.
250          * If the clock divider is uninitialized then reset it to the
251          * default value to get the 1Hz clock.
252          */
253         if (RTTR == 0) {
254                 RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16);
255                 dev_warn(&pdev->dev, "warning: "
256                         "initializing default clock divider/trim value\n");
257                 /* The current RTC value probably doesn't make sense either */
258                 RCNR = 0;
259         }
260
261         device_init_wakeup(&pdev->dev, 1);
262
263         rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
264                 THIS_MODULE);
265
266         if (IS_ERR(rtc))
267                 return PTR_ERR(rtc);
268
269         platform_set_drvdata(pdev, rtc);
270
271         /* Fix for a nasty initialization problem the in SA11xx RTSR register.
272          * See also the comments in sa1100_rtc_interrupt().
273          *
274          * Sometimes bit 1 of the RTSR (RTSR_HZ) will wake up 1, which means an
275          * interrupt pending, even though interrupts were never enabled.
276          * In this case, this bit it must be reset before enabling
277          * interruptions to avoid a nonexistent interrupt to occur.
278          *
279          * In principle, the same problem would apply to bit 0, although it has
280          * never been observed to happen.
281          *
282          * This issue is addressed both here and in sa1100_rtc_interrupt().
283          * If the issue is not addressed here, in the times when the processor
284          * wakes up with the bit set there will be one spurious interrupt.
285          *
286          * The issue is also dealt with in sa1100_rtc_interrupt() to be on the
287          * safe side, once the condition that lead to this strange
288          * initialization is unknown and could in principle happen during
289          * normal processing.
290          *
291          * Notice that clearing bit 1 and 0 is accomplished by writting ONES to
292          * the corresponding bits in RTSR. */
293         RTSR = RTSR_AL | RTSR_HZ;
294
295         return 0;
296 }
297
298 static int sa1100_rtc_remove(struct platform_device *pdev)
299 {
300         struct rtc_device *rtc = platform_get_drvdata(pdev);
301
302         if (rtc)
303                 rtc_device_unregister(rtc);
304
305         return 0;
306 }
307
308 #ifdef CONFIG_PM
309 static int sa1100_rtc_suspend(struct device *dev)
310 {
311         if (device_may_wakeup(dev))
312                 enable_irq_wake(IRQ_RTCAlrm);
313         return 0;
314 }
315
316 static int sa1100_rtc_resume(struct device *dev)
317 {
318         if (device_may_wakeup(dev))
319                 disable_irq_wake(IRQ_RTCAlrm);
320         return 0;
321 }
322
323 static const struct dev_pm_ops sa1100_rtc_pm_ops = {
324         .suspend        = sa1100_rtc_suspend,
325         .resume         = sa1100_rtc_resume,
326 };
327 #endif
328
329 static struct platform_driver sa1100_rtc_driver = {
330         .probe          = sa1100_rtc_probe,
331         .remove         = sa1100_rtc_remove,
332         .driver         = {
333                 .name   = "sa1100-rtc",
334 #ifdef CONFIG_PM
335                 .pm     = &sa1100_rtc_pm_ops,
336 #endif
337         },
338 };
339
340 static int __init sa1100_rtc_init(void)
341 {
342         return platform_driver_register(&sa1100_rtc_driver);
343 }
344
345 static void __exit sa1100_rtc_exit(void)
346 {
347         platform_driver_unregister(&sa1100_rtc_driver);
348 }
349
350 module_init(sa1100_rtc_init);
351 module_exit(sa1100_rtc_exit);
352
353 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
354 MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)");
355 MODULE_LICENSE("GPL");
356 MODULE_ALIAS("platform:sa1100-rtc");