]>
Commit | Line | Data |
---|---|---|
b5b2bdfc LJ |
1 | /* |
2 | * rtc-st-lpc.c - ST's LPC RTC, powered by the Low Power Timer | |
3 | * | |
4 | * Copyright (C) 2014 STMicroelectronics Limited | |
5 | * | |
6 | * Author: David Paris <david.paris@st.com> for STMicroelectronics | |
7 | * Lee Jones <lee.jones@linaro.org> for STMicroelectronics | |
8 | * | |
9 | * Based on the original driver written by Stuart Menefy. | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU General Public Licence | |
13 | * as published by the Free Software Foundation; either version | |
14 | * 2 of the Licence, or (at your option) any later version. | |
15 | */ | |
16 | ||
17 | #include <linux/clk.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/io.h> | |
21 | #include <linux/irq.h> | |
22 | #include <linux/kernel.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/of.h> | |
25 | #include <linux/of_irq.h> | |
26 | #include <linux/platform_device.h> | |
27 | #include <linux/rtc.h> | |
28 | ||
29 | #include <dt-bindings/mfd/st-lpc.h> | |
30 | ||
31 | /* Low Power Timer */ | |
32 | #define LPC_LPT_LSB_OFF 0x400 | |
33 | #define LPC_LPT_MSB_OFF 0x404 | |
34 | #define LPC_LPT_START_OFF 0x408 | |
35 | ||
36 | /* Low Power Alarm */ | |
37 | #define LPC_LPA_LSB_OFF 0x410 | |
38 | #define LPC_LPA_MSB_OFF 0x414 | |
39 | #define LPC_LPA_START_OFF 0x418 | |
40 | ||
41 | /* LPC as WDT */ | |
42 | #define LPC_WDT_OFF 0x510 | |
43 | #define LPC_WDT_FLAG_OFF 0x514 | |
44 | ||
45 | struct st_rtc { | |
46 | struct rtc_device *rtc_dev; | |
47 | struct rtc_wkalrm alarm; | |
48 | struct resource *res; | |
49 | struct clk *clk; | |
50 | unsigned long clkrate; | |
51 | void __iomem *ioaddr; | |
52 | bool irq_enabled:1; | |
53 | spinlock_t lock; | |
54 | short irq; | |
55 | }; | |
56 | ||
57 | static void st_rtc_set_hw_alarm(struct st_rtc *rtc, | |
58 | unsigned long msb, unsigned long lsb) | |
59 | { | |
60 | unsigned long flags; | |
61 | ||
62 | spin_lock_irqsave(&rtc->lock, flags); | |
63 | ||
64 | writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF); | |
65 | ||
66 | writel_relaxed(msb, rtc->ioaddr + LPC_LPA_MSB_OFF); | |
67 | writel_relaxed(lsb, rtc->ioaddr + LPC_LPA_LSB_OFF); | |
68 | writel_relaxed(1, rtc->ioaddr + LPC_LPA_START_OFF); | |
69 | ||
70 | writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF); | |
71 | ||
72 | spin_unlock_irqrestore(&rtc->lock, flags); | |
73 | } | |
74 | ||
75 | static irqreturn_t st_rtc_handler(int this_irq, void *data) | |
76 | { | |
77 | struct st_rtc *rtc = (struct st_rtc *)data; | |
78 | ||
79 | rtc_update_irq(rtc->rtc_dev, 1, RTC_AF); | |
80 | ||
81 | return IRQ_HANDLED; | |
82 | } | |
83 | ||
84 | static int st_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
85 | { | |
86 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
87 | unsigned long lpt_lsb, lpt_msb; | |
88 | unsigned long long lpt; | |
89 | unsigned long flags; | |
90 | ||
91 | spin_lock_irqsave(&rtc->lock, flags); | |
92 | ||
93 | do { | |
94 | lpt_msb = readl_relaxed(rtc->ioaddr + LPC_LPT_MSB_OFF); | |
95 | lpt_lsb = readl_relaxed(rtc->ioaddr + LPC_LPT_LSB_OFF); | |
96 | } while (readl_relaxed(rtc->ioaddr + LPC_LPT_MSB_OFF) != lpt_msb); | |
97 | ||
98 | spin_unlock_irqrestore(&rtc->lock, flags); | |
99 | ||
100 | lpt = ((unsigned long long)lpt_msb << 32) | lpt_lsb; | |
101 | do_div(lpt, rtc->clkrate); | |
f4b82d39 | 102 | rtc_time64_to_tm(lpt, tm); |
b5b2bdfc LJ |
103 | |
104 | return 0; | |
105 | } | |
106 | ||
107 | static int st_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
108 | { | |
109 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
f4b82d39 BG |
110 | unsigned long long lpt, secs; |
111 | unsigned long flags; | |
b5b2bdfc | 112 | |
f4b82d39 | 113 | secs = rtc_tm_to_time64(tm); |
b5b2bdfc LJ |
114 | |
115 | lpt = (unsigned long long)secs * rtc->clkrate; | |
116 | ||
117 | spin_lock_irqsave(&rtc->lock, flags); | |
118 | ||
119 | writel_relaxed(lpt >> 32, rtc->ioaddr + LPC_LPT_MSB_OFF); | |
120 | writel_relaxed(lpt, rtc->ioaddr + LPC_LPT_LSB_OFF); | |
121 | writel_relaxed(1, rtc->ioaddr + LPC_LPT_START_OFF); | |
122 | ||
123 | spin_unlock_irqrestore(&rtc->lock, flags); | |
124 | ||
125 | return 0; | |
126 | } | |
127 | ||
128 | static int st_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm) | |
129 | { | |
130 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
131 | unsigned long flags; | |
132 | ||
133 | spin_lock_irqsave(&rtc->lock, flags); | |
134 | ||
135 | memcpy(wkalrm, &rtc->alarm, sizeof(struct rtc_wkalrm)); | |
136 | ||
137 | spin_unlock_irqrestore(&rtc->lock, flags); | |
138 | ||
139 | return 0; | |
140 | } | |
141 | ||
142 | static int st_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) | |
143 | { | |
144 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
145 | ||
146 | if (enabled && !rtc->irq_enabled) { | |
147 | enable_irq(rtc->irq); | |
148 | rtc->irq_enabled = true; | |
149 | } else if (!enabled && rtc->irq_enabled) { | |
150 | disable_irq(rtc->irq); | |
151 | rtc->irq_enabled = false; | |
152 | } | |
153 | ||
154 | return 0; | |
155 | } | |
156 | ||
157 | static int st_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t) | |
158 | { | |
159 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
160 | struct rtc_time now; | |
f4b82d39 BG |
161 | unsigned long long now_secs; |
162 | unsigned long long alarm_secs; | |
b5b2bdfc LJ |
163 | unsigned long long lpa; |
164 | ||
165 | st_rtc_read_time(dev, &now); | |
f4b82d39 BG |
166 | now_secs = rtc_tm_to_time64(&now); |
167 | alarm_secs = rtc_tm_to_time64(&t->time); | |
b5b2bdfc LJ |
168 | |
169 | /* Invalid alarm time */ | |
170 | if (now_secs > alarm_secs) | |
171 | return -EINVAL; | |
172 | ||
173 | memcpy(&rtc->alarm, t, sizeof(struct rtc_wkalrm)); | |
174 | ||
175 | /* Now many secs to fire */ | |
176 | alarm_secs -= now_secs; | |
177 | lpa = (unsigned long long)alarm_secs * rtc->clkrate; | |
178 | ||
179 | st_rtc_set_hw_alarm(rtc, lpa >> 32, lpa); | |
180 | st_rtc_alarm_irq_enable(dev, t->enabled); | |
181 | ||
182 | return 0; | |
183 | } | |
184 | ||
185 | static struct rtc_class_ops st_rtc_ops = { | |
186 | .read_time = st_rtc_read_time, | |
187 | .set_time = st_rtc_set_time, | |
188 | .read_alarm = st_rtc_read_alarm, | |
189 | .set_alarm = st_rtc_set_alarm, | |
190 | .alarm_irq_enable = st_rtc_alarm_irq_enable, | |
191 | }; | |
192 | ||
193 | static int st_rtc_probe(struct platform_device *pdev) | |
194 | { | |
195 | struct device_node *np = pdev->dev.of_node; | |
196 | struct st_rtc *rtc; | |
197 | struct resource *res; | |
198 | struct rtc_time tm_check; | |
199 | uint32_t mode; | |
200 | int ret = 0; | |
201 | ||
202 | ret = of_property_read_u32(np, "st,lpc-mode", &mode); | |
203 | if (ret) { | |
204 | dev_err(&pdev->dev, "An LPC mode must be provided\n"); | |
205 | return -EINVAL; | |
206 | } | |
207 | ||
742e4097 | 208 | /* LPC can either run as a Clocksource or in RTC or WDT mode */ |
b5b2bdfc LJ |
209 | if (mode != ST_LPC_MODE_RTC) |
210 | return -ENODEV; | |
211 | ||
212 | rtc = devm_kzalloc(&pdev->dev, sizeof(struct st_rtc), GFP_KERNEL); | |
213 | if (!rtc) | |
214 | return -ENOMEM; | |
215 | ||
216 | spin_lock_init(&rtc->lock); | |
217 | ||
218 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
219 | rtc->ioaddr = devm_ioremap_resource(&pdev->dev, res); | |
220 | if (IS_ERR(rtc->ioaddr)) | |
221 | return PTR_ERR(rtc->ioaddr); | |
222 | ||
223 | rtc->irq = irq_of_parse_and_map(np, 0); | |
224 | if (!rtc->irq) { | |
225 | dev_err(&pdev->dev, "IRQ missing or invalid\n"); | |
226 | return -EINVAL; | |
227 | } | |
228 | ||
229 | ret = devm_request_irq(&pdev->dev, rtc->irq, st_rtc_handler, 0, | |
230 | pdev->name, rtc); | |
231 | if (ret) { | |
232 | dev_err(&pdev->dev, "Failed to request irq %i\n", rtc->irq); | |
233 | return ret; | |
234 | } | |
235 | ||
236 | enable_irq_wake(rtc->irq); | |
237 | disable_irq(rtc->irq); | |
238 | ||
239 | rtc->clk = clk_get(&pdev->dev, NULL); | |
240 | if (IS_ERR(rtc->clk)) { | |
241 | dev_err(&pdev->dev, "Unable to request clock\n"); | |
242 | return PTR_ERR(rtc->clk); | |
243 | } | |
244 | ||
245 | clk_prepare_enable(rtc->clk); | |
246 | ||
247 | rtc->clkrate = clk_get_rate(rtc->clk); | |
248 | if (!rtc->clkrate) { | |
249 | dev_err(&pdev->dev, "Unable to fetch clock rate\n"); | |
250 | return -EINVAL; | |
251 | } | |
252 | ||
253 | device_set_wakeup_capable(&pdev->dev, 1); | |
254 | ||
255 | platform_set_drvdata(pdev, rtc); | |
256 | ||
257 | /* | |
258 | * The RTC-LPC is able to manage date.year > 2038 | |
259 | * but currently the kernel can not manage this date! | |
260 | * If the RTC-LPC has a date.year > 2038 then | |
261 | * it's set to the epoch "Jan 1st 2000" | |
262 | */ | |
263 | st_rtc_read_time(&pdev->dev, &tm_check); | |
264 | ||
265 | if (tm_check.tm_year >= (2038 - 1900)) { | |
266 | memset(&tm_check, 0, sizeof(tm_check)); | |
267 | tm_check.tm_year = 100; | |
268 | tm_check.tm_mday = 1; | |
269 | st_rtc_set_time(&pdev->dev, &tm_check); | |
270 | } | |
271 | ||
272 | rtc->rtc_dev = rtc_device_register("st-lpc-rtc", &pdev->dev, | |
273 | &st_rtc_ops, THIS_MODULE); | |
274 | if (IS_ERR(rtc->rtc_dev)) { | |
275 | clk_disable_unprepare(rtc->clk); | |
276 | return PTR_ERR(rtc->rtc_dev); | |
277 | } | |
278 | ||
279 | return 0; | |
280 | } | |
281 | ||
282 | static int st_rtc_remove(struct platform_device *pdev) | |
283 | { | |
284 | struct st_rtc *rtc = platform_get_drvdata(pdev); | |
285 | ||
286 | if (likely(rtc->rtc_dev)) | |
287 | rtc_device_unregister(rtc->rtc_dev); | |
288 | ||
289 | return 0; | |
290 | } | |
291 | ||
292 | #ifdef CONFIG_PM_SLEEP | |
293 | static int st_rtc_suspend(struct device *dev) | |
294 | { | |
295 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
296 | ||
297 | if (device_may_wakeup(dev)) | |
298 | return 0; | |
299 | ||
300 | writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF); | |
301 | writel_relaxed(0, rtc->ioaddr + LPC_LPA_START_OFF); | |
302 | writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF); | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | static int st_rtc_resume(struct device *dev) | |
308 | { | |
309 | struct st_rtc *rtc = dev_get_drvdata(dev); | |
310 | ||
311 | rtc_alarm_irq_enable(rtc->rtc_dev, 0); | |
312 | ||
313 | /* | |
314 | * clean 'rtc->alarm' to allow a new | |
315 | * .set_alarm to the upper RTC layer | |
316 | */ | |
317 | memset(&rtc->alarm, 0, sizeof(struct rtc_wkalrm)); | |
318 | ||
319 | writel_relaxed(0, rtc->ioaddr + LPC_LPA_MSB_OFF); | |
320 | writel_relaxed(0, rtc->ioaddr + LPC_LPA_LSB_OFF); | |
321 | writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF); | |
322 | writel_relaxed(1, rtc->ioaddr + LPC_LPA_START_OFF); | |
323 | writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF); | |
324 | ||
325 | return 0; | |
326 | } | |
327 | #endif | |
328 | ||
329 | static SIMPLE_DEV_PM_OPS(st_rtc_pm_ops, st_rtc_suspend, st_rtc_resume); | |
330 | ||
331 | static const struct of_device_id st_rtc_match[] = { | |
332 | { .compatible = "st,stih407-lpc" }, | |
333 | {} | |
334 | }; | |
335 | MODULE_DEVICE_TABLE(of, st_rtc_match); | |
336 | ||
337 | static struct platform_driver st_rtc_platform_driver = { | |
338 | .driver = { | |
339 | .name = "st-lpc-rtc", | |
340 | .pm = &st_rtc_pm_ops, | |
341 | .of_match_table = st_rtc_match, | |
342 | }, | |
343 | .probe = st_rtc_probe, | |
344 | .remove = st_rtc_remove, | |
345 | }; | |
346 | ||
347 | module_platform_driver(st_rtc_platform_driver); | |
348 | ||
349 | MODULE_DESCRIPTION("STMicroelectronics LPC RTC driver"); | |
350 | MODULE_AUTHOR("David Paris <david.paris@st.com>"); | |
351 | MODULE_LICENSE("GPL"); |