2 * Real Time Clock interface for StrongARM SA1x00 and XScale PXA2xx
4 * Copyright (c) 2000 Nils Faerber
6 * Based on rtc.c by Paul Gortmaker
8 * Original Driver by Nils Faerber <nils@kernelconcepts.de>
11 * CIH <cih@coventive.com>
12 * Nicolas Pitre <nico@fluxnic.net>
13 * Andrew Christian <andrew.christian@hp.com>
15 * Converted to the RTC subsystem and Driver Model
16 * by Richard Purdie <rpurdie@rpsys.net>
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.
24 #include <linux/platform_device.h>
25 #include <linux/module.h>
26 #include <linux/clk.h>
27 #include <linux/rtc.h>
28 #include <linux/init.h>
30 #include <linux/interrupt.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
35 #include <linux/bitops.h>
38 #include <mach/hardware.h>
39 #include <mach/irqs.h>
41 #if defined(CONFIG_ARCH_PXA) || defined(CONFIG_ARCH_MMP)
42 #include <mach/regs-rtc.h>
45 #define RTC_DEF_DIVIDER (32768 - 1)
46 #define RTC_DEF_TRIM 0
53 struct rtc_device
*rtc
;
57 static irqreturn_t
sa1100_rtc_interrupt(int irq
, void *dev_id
)
59 struct sa1100_rtc
*info
= dev_get_drvdata(dev_id
);
60 struct rtc_device
*rtc
= info
->rtc
;
62 unsigned long events
= 0;
64 spin_lock(&info
->lock
);
67 /* clear interrupt sources */
69 /* Fix for a nasty initialization problem the in SA11xx RTSR register.
70 * See also the comments in sa1100_rtc_probe(). */
71 if (rtsr
& (RTSR_ALE
| RTSR_HZE
)) {
72 /* This is the original code, before there was the if test
73 * above. This code does not clear interrupts that were not
75 RTSR
= (RTSR_AL
| RTSR_HZ
) & (rtsr
>> 2);
77 /* For some reason, it is possible to enter this routine
78 * without interruptions enabled, it has been tested with
79 * several units (Bug in SA11xx chip?).
81 * This situation leads to an infinite "loop" of interrupt
82 * routine calling and as a result the processor seems to
83 * lock on its first call to open(). */
84 RTSR
= RTSR_AL
| RTSR_HZ
;
87 /* clear alarm interrupt if it has occurred */
90 RTSR
= rtsr
& (RTSR_ALE
| RTSR_HZE
);
92 /* update irq data & counter */
94 events
|= RTC_AF
| RTC_IRQF
;
96 events
|= RTC_UF
| RTC_IRQF
;
98 rtc_update_irq(rtc
, 1, events
);
100 spin_unlock(&info
->lock
);
105 static int sa1100_rtc_open(struct device
*dev
)
107 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
108 struct rtc_device
*rtc
= info
->rtc
;
111 ret
= request_irq(info
->irq_1hz
, sa1100_rtc_interrupt
, 0, "rtc 1Hz", dev
);
113 dev_err(dev
, "IRQ %d already in use.\n", info
->irq_1hz
);
116 ret
= request_irq(info
->irq_alarm
, sa1100_rtc_interrupt
, 0, "rtc Alrm", dev
);
118 dev_err(dev
, "IRQ %d already in use.\n", info
->irq_alarm
);
121 rtc
->max_user_freq
= RTC_FREQ
;
122 rtc_irq_set_freq(rtc
, NULL
, RTC_FREQ
);
127 free_irq(info
->irq_1hz
, dev
);
129 clk_disable_unprepare(info
->clk
);
133 static void sa1100_rtc_release(struct device
*dev
)
135 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
137 spin_lock_irq(&info
->lock
);
139 spin_unlock_irq(&info
->lock
);
141 free_irq(info
->irq_alarm
, dev
);
142 free_irq(info
->irq_1hz
, dev
);
145 static int sa1100_rtc_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
147 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
149 spin_lock_irq(&info
->lock
);
154 spin_unlock_irq(&info
->lock
);
158 static int sa1100_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
160 rtc_time_to_tm(RCNR
, tm
);
164 static int sa1100_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
169 ret
= rtc_tm_to_time(tm
, &time
);
175 static int sa1100_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
180 alrm
->enabled
= (rtsr
& RTSR_ALE
) ? 1 : 0;
181 alrm
->pending
= (rtsr
& RTSR_AL
) ? 1 : 0;
185 static int sa1100_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
187 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
191 spin_lock_irq(&info
->lock
);
192 ret
= rtc_tm_to_time(&alrm
->time
, &time
);
195 RTSR
= RTSR
& (RTSR_HZE
|RTSR_ALE
|RTSR_AL
);
202 spin_unlock_irq(&info
->lock
);
207 static int sa1100_rtc_proc(struct device
*dev
, struct seq_file
*seq
)
209 seq_printf(seq
, "trim/divider\t\t: 0x%08x\n", (u32
) RTTR
);
210 seq_printf(seq
, "RTSR\t\t\t: 0x%08x\n", (u32
)RTSR
);
215 static const struct rtc_class_ops sa1100_rtc_ops
= {
216 .open
= sa1100_rtc_open
,
217 .release
= sa1100_rtc_release
,
218 .read_time
= sa1100_rtc_read_time
,
219 .set_time
= sa1100_rtc_set_time
,
220 .read_alarm
= sa1100_rtc_read_alarm
,
221 .set_alarm
= sa1100_rtc_set_alarm
,
222 .proc
= sa1100_rtc_proc
,
223 .alarm_irq_enable
= sa1100_rtc_alarm_irq_enable
,
226 static int sa1100_rtc_probe(struct platform_device
*pdev
)
228 struct rtc_device
*rtc
;
229 struct sa1100_rtc
*info
;
230 int irq_1hz
, irq_alarm
, ret
= 0;
232 irq_1hz
= platform_get_irq_byname(pdev
, "rtc 1Hz");
233 irq_alarm
= platform_get_irq_byname(pdev
, "rtc alarm");
234 if (irq_1hz
< 0 || irq_alarm
< 0)
237 info
= kzalloc(sizeof(struct sa1100_rtc
), GFP_KERNEL
);
240 info
->clk
= clk_get(&pdev
->dev
, NULL
);
241 if (IS_ERR(info
->clk
)) {
242 dev_err(&pdev
->dev
, "failed to find rtc clock source\n");
243 ret
= PTR_ERR(info
->clk
);
246 info
->irq_1hz
= irq_1hz
;
247 info
->irq_alarm
= irq_alarm
;
248 spin_lock_init(&info
->lock
);
249 platform_set_drvdata(pdev
, info
);
251 ret
= clk_prepare_enable(info
->clk
);
255 * According to the manual we should be able to let RTTR be zero
256 * and then a default diviser for a 32.768KHz clock is used.
257 * Apparently this doesn't work, at least for my SA1110 rev 5.
258 * If the clock divider is uninitialized then reset it to the
259 * default value to get the 1Hz clock.
262 RTTR
= RTC_DEF_DIVIDER
+ (RTC_DEF_TRIM
<< 16);
263 dev_warn(&pdev
->dev
, "warning: "
264 "initializing default clock divider/trim value\n");
265 /* The current RTC value probably doesn't make sense either */
269 device_init_wakeup(&pdev
->dev
, 1);
271 rtc
= rtc_device_register(pdev
->name
, &pdev
->dev
, &sa1100_rtc_ops
,
280 /* Fix for a nasty initialization problem the in SA11xx RTSR register.
281 * See also the comments in sa1100_rtc_interrupt().
283 * Sometimes bit 1 of the RTSR (RTSR_HZ) will wake up 1, which means an
284 * interrupt pending, even though interrupts were never enabled.
285 * In this case, this bit it must be reset before enabling
286 * interruptions to avoid a nonexistent interrupt to occur.
288 * In principle, the same problem would apply to bit 0, although it has
289 * never been observed to happen.
291 * This issue is addressed both here and in sa1100_rtc_interrupt().
292 * If the issue is not addressed here, in the times when the processor
293 * wakes up with the bit set there will be one spurious interrupt.
295 * The issue is also dealt with in sa1100_rtc_interrupt() to be on the
296 * safe side, once the condition that lead to this strange
297 * initialization is unknown and could in principle happen during
300 * Notice that clearing bit 1 and 0 is accomplished by writting ONES to
301 * the corresponding bits in RTSR. */
302 RTSR
= RTSR_AL
| RTSR_HZ
;
306 clk_disable_unprepare(info
->clk
);
308 platform_set_drvdata(pdev
, NULL
);
315 static int sa1100_rtc_remove(struct platform_device
*pdev
)
317 struct sa1100_rtc
*info
= platform_get_drvdata(pdev
);
320 rtc_device_unregister(info
->rtc
);
321 clk_disable_unprepare(info
->clk
);
323 platform_set_drvdata(pdev
, NULL
);
331 static int sa1100_rtc_suspend(struct device
*dev
)
333 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
334 if (device_may_wakeup(dev
))
335 enable_irq_wake(info
->irq_alarm
);
339 static int sa1100_rtc_resume(struct device
*dev
)
341 struct sa1100_rtc
*info
= dev_get_drvdata(dev
);
342 if (device_may_wakeup(dev
))
343 disable_irq_wake(info
->irq_alarm
);
347 static const struct dev_pm_ops sa1100_rtc_pm_ops
= {
348 .suspend
= sa1100_rtc_suspend
,
349 .resume
= sa1100_rtc_resume
,
354 static struct of_device_id sa1100_rtc_dt_ids
[] = {
355 { .compatible
= "mrvl,sa1100-rtc", },
356 { .compatible
= "mrvl,mmp-rtc", },
359 MODULE_DEVICE_TABLE(of
, sa1100_rtc_dt_ids
);
362 static struct platform_driver sa1100_rtc_driver
= {
363 .probe
= sa1100_rtc_probe
,
364 .remove
= sa1100_rtc_remove
,
366 .name
= "sa1100-rtc",
368 .pm
= &sa1100_rtc_pm_ops
,
370 .of_match_table
= of_match_ptr(sa1100_rtc_dt_ids
),
374 module_platform_driver(sa1100_rtc_driver
);
376 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
377 MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)");
378 MODULE_LICENSE("GPL");
379 MODULE_ALIAS("platform:sa1100-rtc");