2 * Freescale STMP37XX/STMP378X Real Time Clock driver
4 * Copyright (c) 2007 Sigmatel, Inc.
5 * Peter Hartley, <peter.hartley@sigmatel.com>
7 * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
8 * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
9 * Copyright 2011 Wolfram Sang, Pengutronix e.K.
13 * The code contained herein is licensed under the GNU General Public
14 * License. You may obtain a copy of the GNU General Public License
15 * Version 2 or later at the following locations:
17 * http://www.opensource.org/licenses/gpl-license.html
18 * http://www.gnu.org/copyleft/gpl.html
20 #include <linux/kernel.h>
21 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/platform_device.h>
25 #include <linux/interrupt.h>
26 #include <linux/delay.h>
27 #include <linux/rtc.h>
28 #include <linux/slab.h>
29 #include <linux/of_device.h>
31 #include <linux/stmp_device.h>
32 #include <linux/stmp3xxx_rtc_wdt.h>
34 #define STMP3XXX_RTC_CTRL 0x0
35 #define STMP3XXX_RTC_CTRL_SET 0x4
36 #define STMP3XXX_RTC_CTRL_CLR 0x8
37 #define STMP3XXX_RTC_CTRL_ALARM_IRQ_EN 0x00000001
38 #define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN 0x00000002
39 #define STMP3XXX_RTC_CTRL_ALARM_IRQ 0x00000004
40 #define STMP3XXX_RTC_CTRL_WATCHDOGEN 0x00000010
42 #define STMP3XXX_RTC_STAT 0x10
43 #define STMP3XXX_RTC_STAT_STALE_SHIFT 16
44 #define STMP3XXX_RTC_STAT_RTC_PRESENT 0x80000000
46 #define STMP3XXX_RTC_SECONDS 0x30
48 #define STMP3XXX_RTC_ALARM 0x40
50 #define STMP3XXX_RTC_WATCHDOG 0x50
52 #define STMP3XXX_RTC_PERSISTENT0 0x60
53 #define STMP3XXX_RTC_PERSISTENT0_SET 0x64
54 #define STMP3XXX_RTC_PERSISTENT0_CLR 0x68
55 #define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN 0x00000002
56 #define STMP3XXX_RTC_PERSISTENT0_ALARM_EN 0x00000004
57 #define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE 0x00000080
59 #define STMP3XXX_RTC_PERSISTENT1 0x70
60 /* missing bitmask in headers */
61 #define STMP3XXX_RTC_PERSISTENT1_FORCE_UPDATER 0x80000000
63 struct stmp3xxx_rtc_data
{
64 struct rtc_device
*rtc
;
69 #if IS_ENABLED(CONFIG_STMP3XXX_RTC_WATCHDOG)
71 * stmp3xxx_wdt_set_timeout - configure the watchdog inside the STMP3xxx RTC
72 * @dev: the parent device of the watchdog (= the RTC)
73 * @timeout: the desired value for the timeout register of the watchdog.
74 * 0 disables the watchdog
76 * The watchdog needs one register and two bits which are in the RTC domain.
77 * To handle the resource conflict, the RTC driver will create another
78 * platform_device for the watchdog driver as a child of the RTC device.
79 * The watchdog driver is passed the below accessor function via platform_data
80 * to configure the watchdog. Locking is not needed because accessing SET/CLR
81 * registers is atomic.
84 static void stmp3xxx_wdt_set_timeout(struct device
*dev
, u32 timeout
)
86 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
89 writel(timeout
, rtc_data
->io
+ STMP3XXX_RTC_WATCHDOG
);
90 writel(STMP3XXX_RTC_CTRL_WATCHDOGEN
,
91 rtc_data
->io
+ STMP3XXX_RTC_CTRL
+ STMP_OFFSET_REG_SET
);
92 writel(STMP3XXX_RTC_PERSISTENT1_FORCE_UPDATER
,
93 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT1
+ STMP_OFFSET_REG_SET
);
95 writel(STMP3XXX_RTC_CTRL_WATCHDOGEN
,
96 rtc_data
->io
+ STMP3XXX_RTC_CTRL
+ STMP_OFFSET_REG_CLR
);
97 writel(STMP3XXX_RTC_PERSISTENT1_FORCE_UPDATER
,
98 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT1
+ STMP_OFFSET_REG_CLR
);
102 static struct stmp3xxx_wdt_pdata wdt_pdata
= {
103 .wdt_set_timeout
= stmp3xxx_wdt_set_timeout
,
106 static void stmp3xxx_wdt_register(struct platform_device
*rtc_pdev
)
108 struct platform_device
*wdt_pdev
=
109 platform_device_alloc("stmp3xxx_rtc_wdt", rtc_pdev
->id
);
112 wdt_pdev
->dev
.parent
= &rtc_pdev
->dev
;
113 wdt_pdev
->dev
.platform_data
= &wdt_pdata
;
114 platform_device_add(wdt_pdev
);
118 static void stmp3xxx_wdt_register(struct platform_device
*rtc_pdev
)
121 #endif /* CONFIG_STMP3XXX_RTC_WATCHDOG */
123 static int stmp3xxx_wait_time(struct stmp3xxx_rtc_data
*rtc_data
)
125 int timeout
= 5000; /* 3ms according to i.MX28 Ref Manual */
127 * The i.MX28 Applications Processor Reference Manual, Rev. 1, 2010
129 * | The order in which registers are updated is
130 * | Persistent 0, 1, 2, 3, 4, 5, Alarm, Seconds.
131 * | (This list is in bitfield order, from LSB to MSB, as they would
132 * | appear in the STALE_REGS and NEW_REGS bitfields of the HW_RTC_STAT
133 * | register. For example, the Seconds register corresponds to
134 * | STALE_REGS or NEW_REGS containing 0x80.)
137 if (!(readl(rtc_data
->io
+ STMP3XXX_RTC_STAT
) &
138 (0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT
)))
141 } while (--timeout
> 0);
142 return (readl(rtc_data
->io
+ STMP3XXX_RTC_STAT
) &
143 (0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT
)) ? -ETIME
: 0;
146 /* Time read/write */
147 static int stmp3xxx_rtc_gettime(struct device
*dev
, struct rtc_time
*rtc_tm
)
150 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
152 ret
= stmp3xxx_wait_time(rtc_data
);
156 rtc_time_to_tm(readl(rtc_data
->io
+ STMP3XXX_RTC_SECONDS
), rtc_tm
);
160 static int stmp3xxx_rtc_set_mmss(struct device
*dev
, unsigned long t
)
162 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
164 writel(t
, rtc_data
->io
+ STMP3XXX_RTC_SECONDS
);
165 return stmp3xxx_wait_time(rtc_data
);
168 /* interrupt(s) handler */
169 static irqreturn_t
stmp3xxx_rtc_interrupt(int irq
, void *dev_id
)
171 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev_id
);
172 u32 status
= readl(rtc_data
->io
+ STMP3XXX_RTC_CTRL
);
174 if (status
& STMP3XXX_RTC_CTRL_ALARM_IRQ
) {
175 writel(STMP3XXX_RTC_CTRL_ALARM_IRQ
,
176 rtc_data
->io
+ STMP3XXX_RTC_CTRL_CLR
);
177 rtc_update_irq(rtc_data
->rtc
, 1, RTC_AF
| RTC_IRQF
);
184 static int stmp3xxx_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
186 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
189 writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
|
190 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
,
191 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT0_SET
);
192 writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN
,
193 rtc_data
->io
+ STMP3XXX_RTC_CTRL_SET
);
195 writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
|
196 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
,
197 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT0_CLR
);
198 writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN
,
199 rtc_data
->io
+ STMP3XXX_RTC_CTRL_CLR
);
204 static int stmp3xxx_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
206 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
208 rtc_time_to_tm(readl(rtc_data
->io
+ STMP3XXX_RTC_ALARM
), &alm
->time
);
212 static int stmp3xxx_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
215 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
217 rtc_tm_to_time(&alm
->time
, &t
);
218 writel(t
, rtc_data
->io
+ STMP3XXX_RTC_ALARM
);
220 stmp3xxx_alarm_irq_enable(dev
, alm
->enabled
);
225 static struct rtc_class_ops stmp3xxx_rtc_ops
= {
227 stmp3xxx_alarm_irq_enable
,
228 .read_time
= stmp3xxx_rtc_gettime
,
229 .set_mmss
= stmp3xxx_rtc_set_mmss
,
230 .read_alarm
= stmp3xxx_rtc_read_alarm
,
231 .set_alarm
= stmp3xxx_rtc_set_alarm
,
234 static int stmp3xxx_rtc_remove(struct platform_device
*pdev
)
236 struct stmp3xxx_rtc_data
*rtc_data
= platform_get_drvdata(pdev
);
241 writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN
,
242 rtc_data
->io
+ STMP3XXX_RTC_CTRL_CLR
);
247 static int stmp3xxx_rtc_probe(struct platform_device
*pdev
)
249 struct stmp3xxx_rtc_data
*rtc_data
;
253 rtc_data
= devm_kzalloc(&pdev
->dev
, sizeof(*rtc_data
), GFP_KERNEL
);
257 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
259 dev_err(&pdev
->dev
, "failed to get resource\n");
263 rtc_data
->io
= devm_ioremap(&pdev
->dev
, r
->start
, resource_size(r
));
265 dev_err(&pdev
->dev
, "ioremap failed\n");
269 rtc_data
->irq_alarm
= platform_get_irq(pdev
, 0);
271 if (!(readl(STMP3XXX_RTC_STAT
+ rtc_data
->io
) &
272 STMP3XXX_RTC_STAT_RTC_PRESENT
)) {
273 dev_err(&pdev
->dev
, "no device onboard\n");
277 platform_set_drvdata(pdev
, rtc_data
);
279 err
= stmp_reset_block(rtc_data
->io
);
281 dev_err(&pdev
->dev
, "stmp_reset_block failed: %d\n", err
);
285 writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
|
286 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
|
287 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE
,
288 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT0_CLR
);
290 writel(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN
|
291 STMP3XXX_RTC_CTRL_ALARM_IRQ_EN
,
292 rtc_data
->io
+ STMP3XXX_RTC_CTRL_CLR
);
294 rtc_data
->rtc
= devm_rtc_device_register(&pdev
->dev
, pdev
->name
,
295 &stmp3xxx_rtc_ops
, THIS_MODULE
);
296 if (IS_ERR(rtc_data
->rtc
))
297 return PTR_ERR(rtc_data
->rtc
);
299 err
= devm_request_irq(&pdev
->dev
, rtc_data
->irq_alarm
,
300 stmp3xxx_rtc_interrupt
, 0, "RTC alarm", &pdev
->dev
);
302 dev_err(&pdev
->dev
, "Cannot claim IRQ%d\n",
303 rtc_data
->irq_alarm
);
307 stmp3xxx_wdt_register(pdev
);
311 #ifdef CONFIG_PM_SLEEP
312 static int stmp3xxx_rtc_suspend(struct device
*dev
)
317 static int stmp3xxx_rtc_resume(struct device
*dev
)
319 struct stmp3xxx_rtc_data
*rtc_data
= dev_get_drvdata(dev
);
321 stmp_reset_block(rtc_data
->io
);
322 writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
|
323 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
|
324 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE
,
325 rtc_data
->io
+ STMP3XXX_RTC_PERSISTENT0_CLR
);
330 static SIMPLE_DEV_PM_OPS(stmp3xxx_rtc_pm_ops
, stmp3xxx_rtc_suspend
,
331 stmp3xxx_rtc_resume
);
333 static const struct of_device_id rtc_dt_ids
[] = {
334 { .compatible
= "fsl,stmp3xxx-rtc", },
337 MODULE_DEVICE_TABLE(of
, rtc_dt_ids
);
339 static struct platform_driver stmp3xxx_rtcdrv
= {
340 .probe
= stmp3xxx_rtc_probe
,
341 .remove
= stmp3xxx_rtc_remove
,
343 .name
= "stmp3xxx-rtc",
344 .owner
= THIS_MODULE
,
345 .pm
= &stmp3xxx_rtc_pm_ops
,
346 .of_match_table
= of_match_ptr(rtc_dt_ids
),
350 module_platform_driver(stmp3xxx_rtcdrv
);
352 MODULE_DESCRIPTION("STMP3xxx RTC Driver");
353 MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com> and "
354 "Wolfram Sang <w.sang@pengutronix.de>");
355 MODULE_LICENSE("GPL");