1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
32#define LPC_LPT_LSB_OFF 0x400
33#define LPC_LPT_MSB_OFF 0x404
34#define LPC_LPT_START_OFF 0x408
35
36
37#define LPC_LPA_LSB_OFF 0x410
38#define LPC_LPA_MSB_OFF 0x414
39#define LPC_LPA_START_OFF 0x418
40
41
42#define LPC_WDT_OFF 0x510
43#define LPC_WDT_FLAG_OFF 0x514
44
45struct 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
57static 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
75static 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
84static 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);
102 rtc_time64_to_tm(lpt, tm);
103
104 return 0;
105}
106
107static int st_rtc_set_time(struct device *dev, struct rtc_time *tm)
108{
109 struct st_rtc *rtc = dev_get_drvdata(dev);
110 unsigned long long lpt, secs;
111 unsigned long flags;
112
113 secs = rtc_tm_to_time64(tm);
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
128static 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
142static 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
157static 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;
161 unsigned long long now_secs;
162 unsigned long long alarm_secs;
163 unsigned long long lpa;
164
165 st_rtc_read_time(dev, &now);
166 now_secs = rtc_tm_to_time64(&now);
167 alarm_secs = rtc_tm_to_time64(&t->time);
168
169
170 if (now_secs > alarm_secs)
171 return -EINVAL;
172
173 memcpy(&rtc->alarm, t, sizeof(struct rtc_wkalrm));
174
175
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
185static 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
193static 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
208
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
259
260
261
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
282static 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
293static 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
307static 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
315
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
329static SIMPLE_DEV_PM_OPS(st_rtc_pm_ops, st_rtc_suspend, st_rtc_resume);
330
331static const struct of_device_id st_rtc_match[] = {
332 { .compatible = "st,stih407-lpc" },
333 {}
334};
335MODULE_DEVICE_TABLE(of, st_rtc_match);
336
337static 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
347module_platform_driver(st_rtc_platform_driver);
348
349MODULE_DESCRIPTION("STMicroelectronics LPC RTC driver");
350MODULE_AUTHOR("David Paris <david.paris@st.com>");
351MODULE_LICENSE("GPL");
352
