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