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_SLEEP
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#endif
379
380static int wm8350_rtc_probe(struct platform_device *pdev)
381{
382	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
383	struct wm8350_rtc *wm_rtc = &wm8350->rtc;
384	int ret = 0;
385	u16 timectl, power5;
386
387	timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL);
388	if (timectl & WM8350_RTC_BCD) {
389		dev_err(&pdev->dev, "RTC BCD mode not supported\n");
390		return -EINVAL;
391	}
392	if (timectl & WM8350_RTC_12HR) {
393		dev_err(&pdev->dev, "RTC 12 hour mode not supported\n");
394		return -EINVAL;
395	}
396
397	/* enable the RTC if it's not already enabled */
398	power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
399	if (!(power5 &  WM8350_RTC_TICK_ENA)) {
400		dev_info(wm8350->dev, "Starting RTC\n");
401
402		wm8350_reg_unlock(wm8350);
403
404		ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5,
405				      WM8350_RTC_TICK_ENA);
406		if (ret < 0) {
407			dev_err(&pdev->dev, "failed to enable RTC: %d\n", ret);
408			return ret;
409		}
410
411		wm8350_reg_lock(wm8350);
412	}
413
414	if (timectl & WM8350_RTC_STS) {
415		int retries;
416
417		ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL,
418					WM8350_RTC_SET);
419		if (ret < 0) {
420			dev_err(&pdev->dev, "failed to start: %d\n", ret);
421			return ret;
422		}
423
424		retries = WM8350_SET_TIME_RETRIES;
425		do {
426			timectl = wm8350_reg_read(wm8350,
427						  WM8350_RTC_TIME_CONTROL);
428		} while (timectl & WM8350_RTC_STS && --retries);
429
430		if (retries == 0) {
431			dev_err(&pdev->dev, "failed to start: timeout\n");
432			return -ENODEV;
433		}
434	}
435
436	device_init_wakeup(&pdev->dev, 1);
437
438	wm_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm8350",
439					&wm8350_rtc_ops, THIS_MODULE);
440	if (IS_ERR(wm_rtc->rtc)) {
441		ret = PTR_ERR(wm_rtc->rtc);
442		dev_err(&pdev->dev, "failed to register RTC: %d\n", ret);
443		return ret;
444	}
445
446	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
447			    wm8350_rtc_update_handler, 0,
448			    "RTC Seconds", wm8350);
449	wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC);
450
451	wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
452			    wm8350_rtc_alarm_handler, 0,
453			    "RTC Alarm", wm8350);
454
455	return 0;
456}
457
458static int wm8350_rtc_remove(struct platform_device *pdev)
459{
460	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
461
462	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350);
463	wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350);
464
465	return 0;
466}
467
468static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend,
469			wm8350_rtc_resume);
470
471static struct platform_driver wm8350_rtc_driver = {
472	.probe = wm8350_rtc_probe,
473	.remove = wm8350_rtc_remove,
474	.driver = {
475		.name = "wm8350-rtc",
476		.pm = &wm8350_rtc_pm_ops,
477	},
478};
479
480module_platform_driver(wm8350_rtc_driver);
481
482MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
483MODULE_DESCRIPTION("RTC driver for the WM8350");
484MODULE_LICENSE("GPL");
485MODULE_ALIAS("platform:wm8350-rtc");
486