Root/drivers/rtc/rtc-wm8350.c

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 */
38static 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 */
97static 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));
125    } while (--retries && !(rtc_ctrl & WM8350_RTC_STS));
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 */
146static 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
192static 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
216static 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
239static 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
250static 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
305static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
306{
307    struct wm8350 *wm8350 = data;
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    }
320
321    return IRQ_HANDLED;
322}
323
324static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
325{
326    struct wm8350 *wm8350 = data;
327    struct rtc_device *rtc = wm8350->rtc.rtc;
328
329    rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);
330
331    return IRQ_HANDLED;
332}
333
334static const struct rtc_class_ops wm8350_rtc_ops = {
335    .read_time = wm8350_rtc_readtime,
336    .set_time = wm8350_rtc_settime,
337    .read_alarm = wm8350_rtc_readalarm,
338    .set_alarm = wm8350_rtc_setalarm,
339    .alarm_irq_enable = wm8350_rtc_alarm_irq_enable,
340};
341
342#ifdef CONFIG_PM
343static int wm8350_rtc_suspend(struct device *dev)
344{
345    struct platform_device *pdev = to_platform_device(dev);
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
363static int wm8350_rtc_resume(struct device *dev)
364{
365    struct platform_device *pdev = to_platform_device(dev);
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
384static 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);
432        } while (timectl & WM8350_RTC_STS && --retries);
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
450    wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
451                wm8350_rtc_update_handler, 0,
452                "RTC Seconds", wm8350);
453    wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
454
455    wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
456                wm8350_rtc_alarm_handler, 0,
457                "RTC Alarm", wm8350);
458
459    return 0;
460}
461
462static 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
467    wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
468    wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
469
470    rtc_device_unregister(wm_rtc->rtc);
471
472    return 0;
473}
474
475static struct dev_pm_ops wm8350_rtc_pm_ops = {
476    .suspend = wm8350_rtc_suspend,
477    .resume = wm8350_rtc_resume,
478};
479
480static struct platform_driver wm8350_rtc_driver = {
481    .probe = wm8350_rtc_probe,
482    .remove = __devexit_p(wm8350_rtc_remove),
483    .driver = {
484        .name = "wm8350-rtc",
485        .pm = &wm8350_rtc_pm_ops,
486    },
487};
488
489module_platform_driver(wm8350_rtc_driver);
490
491MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
492MODULE_DESCRIPTION("RTC driver for the WM8350");
493MODULE_LICENSE("GPL");
494MODULE_ALIAS("platform:wm8350-rtc");
495

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive