1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Real Time Clock driver for Wolfson Microelectronics WM8350 |
4 | * |
5 | * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC. |
6 | * |
7 | * Author: Liam Girdwood |
8 | * linux@wolfsonmicro.com |
9 | */ |
10 | |
11 | #include <linux/module.h> |
12 | #include <linux/kernel.h> |
13 | #include <linux/time.h> |
14 | #include <linux/rtc.h> |
15 | #include <linux/bcd.h> |
16 | #include <linux/interrupt.h> |
17 | #include <linux/ioctl.h> |
18 | #include <linux/completion.h> |
19 | #include <linux/mfd/wm8350/rtc.h> |
20 | #include <linux/mfd/wm8350/core.h> |
21 | #include <linux/delay.h> |
22 | #include <linux/platform_device.h> |
23 | |
24 | #define WM8350_SET_ALM_RETRIES 5 |
25 | #define WM8350_SET_TIME_RETRIES 5 |
26 | #define WM8350_GET_TIME_RETRIES 5 |
27 | |
28 | /* |
29 | * Read current time and date in RTC |
30 | */ |
31 | static int wm8350_rtc_readtime(struct device *dev, struct rtc_time *tm) |
32 | { |
33 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
34 | u16 time1[4], time2[4]; |
35 | int retries = WM8350_GET_TIME_RETRIES, ret; |
36 | |
37 | /* |
38 | * Read the time twice and compare. |
39 | * If time1 == time2, then time is valid else retry. |
40 | */ |
41 | do { |
42 | ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, |
43 | size: 4, dest: time1); |
44 | if (ret < 0) |
45 | return ret; |
46 | ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, |
47 | size: 4, dest: time2); |
48 | if (ret < 0) |
49 | return ret; |
50 | |
51 | if (memcmp(p: time1, q: time2, size: sizeof(time1)) == 0) { |
52 | tm->tm_sec = time1[0] & WM8350_RTC_SECS_MASK; |
53 | |
54 | tm->tm_min = (time1[0] & WM8350_RTC_MINS_MASK) |
55 | >> WM8350_RTC_MINS_SHIFT; |
56 | |
57 | tm->tm_hour = time1[1] & WM8350_RTC_HRS_MASK; |
58 | |
59 | tm->tm_wday = ((time1[1] >> WM8350_RTC_DAY_SHIFT) |
60 | & 0x7) - 1; |
61 | |
62 | tm->tm_mon = ((time1[2] & WM8350_RTC_MTH_MASK) |
63 | >> WM8350_RTC_MTH_SHIFT) - 1; |
64 | |
65 | tm->tm_mday = (time1[2] & WM8350_RTC_DATE_MASK); |
66 | |
67 | tm->tm_year = ((time1[3] & WM8350_RTC_YHUNDREDS_MASK) |
68 | >> WM8350_RTC_YHUNDREDS_SHIFT) * 100; |
69 | tm->tm_year += time1[3] & WM8350_RTC_YUNITS_MASK; |
70 | |
71 | tm->tm_yday = rtc_year_days(day: tm->tm_mday, month: tm->tm_mon, |
72 | year: tm->tm_year); |
73 | tm->tm_year -= 1900; |
74 | |
75 | dev_dbg(dev, "Read (%d left): %04x %04x %04x %04x\n" , |
76 | retries, |
77 | time1[0], time1[1], time1[2], time1[3]); |
78 | |
79 | return 0; |
80 | } |
81 | } while (retries--); |
82 | |
83 | dev_err(dev, "timed out reading RTC time\n" ); |
84 | return -EIO; |
85 | } |
86 | |
87 | /* |
88 | * Set current time and date in RTC |
89 | */ |
90 | static int wm8350_rtc_settime(struct device *dev, struct rtc_time *tm) |
91 | { |
92 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
93 | u16 time[4]; |
94 | u16 rtc_ctrl; |
95 | int ret, retries = WM8350_SET_TIME_RETRIES; |
96 | |
97 | time[0] = tm->tm_sec; |
98 | time[0] |= tm->tm_min << WM8350_RTC_MINS_SHIFT; |
99 | time[1] = tm->tm_hour; |
100 | time[1] |= (tm->tm_wday + 1) << WM8350_RTC_DAY_SHIFT; |
101 | time[2] = tm->tm_mday; |
102 | time[2] |= (tm->tm_mon + 1) << WM8350_RTC_MTH_SHIFT; |
103 | time[3] = ((tm->tm_year + 1900) / 100) << WM8350_RTC_YHUNDREDS_SHIFT; |
104 | time[3] |= (tm->tm_year + 1900) % 100; |
105 | |
106 | dev_dbg(dev, "Setting: %04x %04x %04x %04x\n" , |
107 | time[0], time[1], time[2], time[3]); |
108 | |
109 | /* Set RTC_SET to stop the clock */ |
110 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, WM8350_RTC_SET); |
111 | if (ret < 0) |
112 | return ret; |
113 | |
114 | /* Wait until confirmation of stopping */ |
115 | do { |
116 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
117 | schedule_timeout_uninterruptible(timeout: msecs_to_jiffies(m: 1)); |
118 | } while (--retries && !(rtc_ctrl & WM8350_RTC_STS)); |
119 | |
120 | if (!retries) { |
121 | dev_err(dev, "timed out on set confirmation\n" ); |
122 | return -EIO; |
123 | } |
124 | |
125 | /* Write time to RTC */ |
126 | ret = wm8350_block_write(wm8350, WM8350_RTC_SECONDS_MINUTES, size: 4, src: time); |
127 | if (ret < 0) |
128 | return ret; |
129 | |
130 | /* Clear RTC_SET to start the clock */ |
131 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
132 | WM8350_RTC_SET); |
133 | return ret; |
134 | } |
135 | |
136 | /* |
137 | * Read alarm time and date in RTC |
138 | */ |
139 | static int wm8350_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) |
140 | { |
141 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
142 | struct rtc_time *tm = &alrm->time; |
143 | u16 time[4]; |
144 | int ret; |
145 | |
146 | ret = wm8350_block_read(wm8350, WM8350_ALARM_SECONDS_MINUTES, size: 4, dest: time); |
147 | if (ret < 0) |
148 | return ret; |
149 | |
150 | tm->tm_sec = time[0] & WM8350_RTC_ALMSECS_MASK; |
151 | if (tm->tm_sec == WM8350_RTC_ALMSECS_MASK) |
152 | tm->tm_sec = -1; |
153 | |
154 | tm->tm_min = time[0] & WM8350_RTC_ALMMINS_MASK; |
155 | if (tm->tm_min == WM8350_RTC_ALMMINS_MASK) |
156 | tm->tm_min = -1; |
157 | else |
158 | tm->tm_min >>= WM8350_RTC_ALMMINS_SHIFT; |
159 | |
160 | tm->tm_hour = time[1] & WM8350_RTC_ALMHRS_MASK; |
161 | if (tm->tm_hour == WM8350_RTC_ALMHRS_MASK) |
162 | tm->tm_hour = -1; |
163 | |
164 | tm->tm_wday = ((time[1] >> WM8350_RTC_ALMDAY_SHIFT) & 0x7) - 1; |
165 | if (tm->tm_wday > 7) |
166 | tm->tm_wday = -1; |
167 | |
168 | tm->tm_mon = time[2] & WM8350_RTC_ALMMTH_MASK; |
169 | if (tm->tm_mon == WM8350_RTC_ALMMTH_MASK) |
170 | tm->tm_mon = -1; |
171 | else |
172 | tm->tm_mon = (tm->tm_mon >> WM8350_RTC_ALMMTH_SHIFT) - 1; |
173 | |
174 | tm->tm_mday = (time[2] & WM8350_RTC_ALMDATE_MASK); |
175 | if (tm->tm_mday == WM8350_RTC_ALMDATE_MASK) |
176 | tm->tm_mday = -1; |
177 | |
178 | tm->tm_year = -1; |
179 | |
180 | alrm->enabled = !(time[3] & WM8350_RTC_ALMSTS); |
181 | |
182 | return 0; |
183 | } |
184 | |
185 | static int wm8350_rtc_stop_alarm(struct wm8350 *wm8350) |
186 | { |
187 | int retries = WM8350_SET_ALM_RETRIES; |
188 | u16 rtc_ctrl; |
189 | int ret; |
190 | |
191 | /* Set RTC_SET to stop the clock */ |
192 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
193 | WM8350_RTC_ALMSET); |
194 | if (ret < 0) |
195 | return ret; |
196 | |
197 | /* Wait until confirmation of stopping */ |
198 | do { |
199 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
200 | schedule_timeout_uninterruptible(timeout: msecs_to_jiffies(m: 1)); |
201 | } while (retries-- && !(rtc_ctrl & WM8350_RTC_ALMSTS)); |
202 | |
203 | if (!(rtc_ctrl & WM8350_RTC_ALMSTS)) |
204 | return -ETIMEDOUT; |
205 | |
206 | return 0; |
207 | } |
208 | |
209 | static int wm8350_rtc_start_alarm(struct wm8350 *wm8350) |
210 | { |
211 | int ret; |
212 | int retries = WM8350_SET_ALM_RETRIES; |
213 | u16 rtc_ctrl; |
214 | |
215 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
216 | WM8350_RTC_ALMSET); |
217 | if (ret < 0) |
218 | return ret; |
219 | |
220 | /* Wait until confirmation */ |
221 | do { |
222 | rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
223 | schedule_timeout_uninterruptible(timeout: msecs_to_jiffies(m: 1)); |
224 | } while (retries-- && rtc_ctrl & WM8350_RTC_ALMSTS); |
225 | |
226 | if (rtc_ctrl & WM8350_RTC_ALMSTS) |
227 | return -ETIMEDOUT; |
228 | |
229 | return 0; |
230 | } |
231 | |
232 | static int wm8350_rtc_alarm_irq_enable(struct device *dev, |
233 | unsigned int enabled) |
234 | { |
235 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
236 | |
237 | if (enabled) |
238 | return wm8350_rtc_start_alarm(wm8350); |
239 | else |
240 | return wm8350_rtc_stop_alarm(wm8350); |
241 | } |
242 | |
243 | static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) |
244 | { |
245 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
246 | struct rtc_time *tm = &alrm->time; |
247 | u16 time[3]; |
248 | int ret; |
249 | |
250 | memset(time, 0, sizeof(time)); |
251 | |
252 | if (tm->tm_sec != -1) |
253 | time[0] |= tm->tm_sec; |
254 | else |
255 | time[0] |= WM8350_RTC_ALMSECS_MASK; |
256 | |
257 | if (tm->tm_min != -1) |
258 | time[0] |= tm->tm_min << WM8350_RTC_ALMMINS_SHIFT; |
259 | else |
260 | time[0] |= WM8350_RTC_ALMMINS_MASK; |
261 | |
262 | if (tm->tm_hour != -1) |
263 | time[1] |= tm->tm_hour; |
264 | else |
265 | time[1] |= WM8350_RTC_ALMHRS_MASK; |
266 | |
267 | if (tm->tm_wday != -1) |
268 | time[1] |= (tm->tm_wday + 1) << WM8350_RTC_ALMDAY_SHIFT; |
269 | else |
270 | time[1] |= WM8350_RTC_ALMDAY_MASK; |
271 | |
272 | if (tm->tm_mday != -1) |
273 | time[2] |= tm->tm_mday; |
274 | else |
275 | time[2] |= WM8350_RTC_ALMDATE_MASK; |
276 | |
277 | if (tm->tm_mon != -1) |
278 | time[2] |= (tm->tm_mon + 1) << WM8350_RTC_ALMMTH_SHIFT; |
279 | else |
280 | time[2] |= WM8350_RTC_ALMMTH_MASK; |
281 | |
282 | ret = wm8350_rtc_stop_alarm(wm8350); |
283 | if (ret < 0) |
284 | return ret; |
285 | |
286 | /* Write time to RTC */ |
287 | ret = wm8350_block_write(wm8350, WM8350_ALARM_SECONDS_MINUTES, |
288 | size: 3, src: time); |
289 | if (ret < 0) |
290 | return ret; |
291 | |
292 | if (alrm->enabled) |
293 | ret = wm8350_rtc_start_alarm(wm8350); |
294 | |
295 | return ret; |
296 | } |
297 | |
298 | static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data) |
299 | { |
300 | struct wm8350 *wm8350 = data; |
301 | struct rtc_device *rtc = wm8350->rtc.rtc; |
302 | int ret; |
303 | |
304 | rtc_update_irq(rtc, num: 1, RTC_IRQF | RTC_AF); |
305 | |
306 | /* Make it one shot */ |
307 | ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
308 | WM8350_RTC_ALMSET); |
309 | if (ret != 0) { |
310 | dev_err(&(wm8350->rtc.pdev->dev), |
311 | "Failed to disable alarm: %d\n" , ret); |
312 | } |
313 | |
314 | return IRQ_HANDLED; |
315 | } |
316 | |
317 | static irqreturn_t wm8350_rtc_update_handler(int irq, void *data) |
318 | { |
319 | struct wm8350 *wm8350 = data; |
320 | struct rtc_device *rtc = wm8350->rtc.rtc; |
321 | |
322 | rtc_update_irq(rtc, num: 1, RTC_IRQF | RTC_UF); |
323 | |
324 | return IRQ_HANDLED; |
325 | } |
326 | |
327 | static const struct rtc_class_ops wm8350_rtc_ops = { |
328 | .read_time = wm8350_rtc_readtime, |
329 | .set_time = wm8350_rtc_settime, |
330 | .read_alarm = wm8350_rtc_readalarm, |
331 | .set_alarm = wm8350_rtc_setalarm, |
332 | .alarm_irq_enable = wm8350_rtc_alarm_irq_enable, |
333 | }; |
334 | |
335 | #ifdef CONFIG_PM_SLEEP |
336 | static int wm8350_rtc_suspend(struct device *dev) |
337 | { |
338 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
339 | int ret = 0; |
340 | u16 reg; |
341 | |
342 | reg = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
343 | |
344 | if (device_may_wakeup(dev: &wm8350->rtc.pdev->dev) && |
345 | reg & WM8350_RTC_ALMSTS) { |
346 | ret = wm8350_rtc_stop_alarm(wm8350); |
347 | if (ret != 0) |
348 | dev_err(dev, "Failed to stop RTC alarm: %d\n" , ret); |
349 | } |
350 | |
351 | return ret; |
352 | } |
353 | |
354 | static int wm8350_rtc_resume(struct device *dev) |
355 | { |
356 | struct wm8350 *wm8350 = dev_get_drvdata(dev); |
357 | int ret; |
358 | |
359 | if (wm8350->rtc.alarm_enabled) { |
360 | ret = wm8350_rtc_start_alarm(wm8350); |
361 | if (ret != 0) |
362 | dev_err(dev, "Failed to restart RTC alarm: %d\n" , ret); |
363 | } |
364 | |
365 | return 0; |
366 | } |
367 | #endif |
368 | |
369 | static int wm8350_rtc_probe(struct platform_device *pdev) |
370 | { |
371 | struct wm8350 *wm8350 = platform_get_drvdata(pdev); |
372 | struct wm8350_rtc *wm_rtc = &wm8350->rtc; |
373 | int ret = 0; |
374 | u16 timectl, power5; |
375 | |
376 | timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); |
377 | if (timectl & WM8350_RTC_BCD) { |
378 | dev_err(&pdev->dev, "RTC BCD mode not supported\n" ); |
379 | return -EINVAL; |
380 | } |
381 | if (timectl & WM8350_RTC_12HR) { |
382 | dev_err(&pdev->dev, "RTC 12 hour mode not supported\n" ); |
383 | return -EINVAL; |
384 | } |
385 | |
386 | /* enable the RTC if it's not already enabled */ |
387 | power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5); |
388 | if (!(power5 & WM8350_RTC_TICK_ENA)) { |
389 | wm8350_reg_unlock(wm8350); |
390 | |
391 | ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, |
392 | WM8350_RTC_TICK_ENA); |
393 | if (ret < 0) { |
394 | dev_err(&pdev->dev, "failed to enable RTC: %d\n" , ret); |
395 | return ret; |
396 | } |
397 | |
398 | wm8350_reg_lock(wm8350); |
399 | } |
400 | |
401 | if (timectl & WM8350_RTC_STS) { |
402 | int retries; |
403 | |
404 | ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, |
405 | WM8350_RTC_SET); |
406 | if (ret < 0) { |
407 | dev_err(&pdev->dev, "failed to start: %d\n" , ret); |
408 | return ret; |
409 | } |
410 | |
411 | retries = WM8350_SET_TIME_RETRIES; |
412 | do { |
413 | timectl = wm8350_reg_read(wm8350, |
414 | WM8350_RTC_TIME_CONTROL); |
415 | } while (timectl & WM8350_RTC_STS && --retries); |
416 | |
417 | if (retries == 0) { |
418 | dev_err(&pdev->dev, "failed to start: timeout\n" ); |
419 | return -ENODEV; |
420 | } |
421 | } |
422 | |
423 | device_init_wakeup(dev: &pdev->dev, enable: 1); |
424 | |
425 | wm_rtc->rtc = devm_rtc_device_register(dev: &pdev->dev, name: "wm8350" , |
426 | ops: &wm8350_rtc_ops, THIS_MODULE); |
427 | if (IS_ERR(ptr: wm_rtc->rtc)) |
428 | return PTR_ERR(ptr: wm_rtc->rtc); |
429 | |
430 | ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC, |
431 | handler: wm8350_rtc_update_handler, flags: 0, |
432 | name: "RTC Seconds" , data: wm8350); |
433 | if (ret) |
434 | return ret; |
435 | |
436 | wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC); |
437 | |
438 | ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM, |
439 | handler: wm8350_rtc_alarm_handler, flags: 0, |
440 | name: "RTC Alarm" , data: wm8350); |
441 | if (ret) { |
442 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, data: wm8350); |
443 | return ret; |
444 | } |
445 | |
446 | return 0; |
447 | } |
448 | |
449 | static void wm8350_rtc_remove(struct platform_device *pdev) |
450 | { |
451 | struct wm8350 *wm8350 = platform_get_drvdata(pdev); |
452 | |
453 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, data: wm8350); |
454 | wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, data: wm8350); |
455 | } |
456 | |
457 | static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend, |
458 | wm8350_rtc_resume); |
459 | |
460 | static struct platform_driver wm8350_rtc_driver = { |
461 | .probe = wm8350_rtc_probe, |
462 | .remove_new = wm8350_rtc_remove, |
463 | .driver = { |
464 | .name = "wm8350-rtc" , |
465 | .pm = &wm8350_rtc_pm_ops, |
466 | }, |
467 | }; |
468 | |
469 | module_platform_driver(wm8350_rtc_driver); |
470 | |
471 | MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>" ); |
472 | MODULE_DESCRIPTION("RTC driver for the WM8350" ); |
473 | MODULE_LICENSE("GPL" ); |
474 | MODULE_ALIAS("platform:wm8350-rtc" ); |
475 | |