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