1/*
2 * RTC driver for Maxim MAX77686
3 *
4 * Copyright (C) 2012 Samsung Electronics Co.Ltd
5 *
6 *  based on rtc-max8997.c
7 *
8 *  This program is free software; you can redistribute  it and/or modify it
9 *  under  the terms of  the GNU General  Public License as published by the
10 *  Free Software Foundation;  either version 2 of the  License, or (at your
11 *  option) any later version.
12 *
13 */
14
15#include <linux/slab.h>
16#include <linux/rtc.h>
17#include <linux/delay.h>
18#include <linux/mutex.h>
19#include <linux/module.h>
20#include <linux/platform_device.h>
21#include <linux/mfd/max77686-private.h>
22#include <linux/irqdomain.h>
23#include <linux/regmap.h>
24
25/* RTC Control Register */
26#define BCD_EN_SHIFT			0
27#define BCD_EN_MASK			(1 << BCD_EN_SHIFT)
28#define MODEL24_SHIFT			1
29#define MODEL24_MASK			(1 << MODEL24_SHIFT)
30/* RTC Update Register1 */
31#define RTC_UDR_SHIFT			0
32#define RTC_UDR_MASK			(1 << RTC_UDR_SHIFT)
33#define RTC_RBUDR_SHIFT			4
34#define RTC_RBUDR_MASK			(1 << RTC_RBUDR_SHIFT)
35/* RTC Hour register */
36#define HOUR_PM_SHIFT			6
37#define HOUR_PM_MASK			(1 << HOUR_PM_SHIFT)
38/* RTC Alarm Enable */
39#define ALARM_ENABLE_SHIFT		7
40#define ALARM_ENABLE_MASK		(1 << ALARM_ENABLE_SHIFT)
41
42#define MAX77686_RTC_UPDATE_DELAY	16
43
44enum {
45	RTC_SEC = 0,
46	RTC_MIN,
47	RTC_HOUR,
48	RTC_WEEKDAY,
49	RTC_MONTH,
50	RTC_YEAR,
51	RTC_DATE,
52	RTC_NR_TIME
53};
54
55struct max77686_rtc_info {
56	struct device		*dev;
57	struct max77686_dev	*max77686;
58	struct i2c_client	*rtc;
59	struct rtc_device	*rtc_dev;
60	struct mutex		lock;
61
62	struct regmap		*regmap;
63
64	int virq;
65	int rtc_24hr_mode;
66};
67
68enum MAX77686_RTC_OP {
69	MAX77686_RTC_WRITE,
70	MAX77686_RTC_READ,
71};
72
73static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
74				   int rtc_24hr_mode)
75{
76	tm->tm_sec = data[RTC_SEC] & 0x7f;
77	tm->tm_min = data[RTC_MIN] & 0x7f;
78	if (rtc_24hr_mode)
79		tm->tm_hour = data[RTC_HOUR] & 0x1f;
80	else {
81		tm->tm_hour = data[RTC_HOUR] & 0x0f;
82		if (data[RTC_HOUR] & HOUR_PM_MASK)
83			tm->tm_hour += 12;
84	}
85
86	/* Only a single bit is set in data[], so fls() would be equivalent */
87	tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f) - 1;
88	tm->tm_mday = data[RTC_DATE] & 0x1f;
89	tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
90	tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
91	tm->tm_yday = 0;
92	tm->tm_isdst = 0;
93}
94
95static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
96{
97	data[RTC_SEC] = tm->tm_sec;
98	data[RTC_MIN] = tm->tm_min;
99	data[RTC_HOUR] = tm->tm_hour;
100	data[RTC_WEEKDAY] = 1 << tm->tm_wday;
101	data[RTC_DATE] = tm->tm_mday;
102	data[RTC_MONTH] = tm->tm_mon + 1;
103	data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
104
105	if (tm->tm_year < 100) {
106		pr_warn("%s: MAX77686 RTC cannot handle the year %d."
107			"Assume it's 2000.\n", __func__, 1900 + tm->tm_year);
108		return -EINVAL;
109	}
110	return 0;
111}
112
113static int max77686_rtc_update(struct max77686_rtc_info *info,
114	enum MAX77686_RTC_OP op)
115{
116	int ret;
117	unsigned int data;
118
119	if (op == MAX77686_RTC_WRITE)
120		data = 1 << RTC_UDR_SHIFT;
121	else
122		data = 1 << RTC_RBUDR_SHIFT;
123
124	ret = regmap_update_bits(info->max77686->rtc_regmap,
125				 MAX77686_RTC_UPDATE0, data, data);
126	if (ret < 0)
127		dev_err(info->dev, "%s: fail to write update reg(ret=%d, data=0x%x)\n",
128				__func__, ret, data);
129	else {
130		/* Minimum 16ms delay required before RTC update. */
131		msleep(MAX77686_RTC_UPDATE_DELAY);
132	}
133
134	return ret;
135}
136
137static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm)
138{
139	struct max77686_rtc_info *info = dev_get_drvdata(dev);
140	u8 data[RTC_NR_TIME];
141	int ret;
142
143	mutex_lock(&info->lock);
144
145	ret = max77686_rtc_update(info, MAX77686_RTC_READ);
146	if (ret < 0)
147		goto out;
148
149	ret = regmap_bulk_read(info->max77686->rtc_regmap,
150				MAX77686_RTC_SEC, data, RTC_NR_TIME);
151	if (ret < 0) {
152		dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,	ret);
153		goto out;
154	}
155
156	max77686_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
157
158	ret = rtc_valid_tm(tm);
159
160out:
161	mutex_unlock(&info->lock);
162	return ret;
163}
164
165static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm)
166{
167	struct max77686_rtc_info *info = dev_get_drvdata(dev);
168	u8 data[RTC_NR_TIME];
169	int ret;
170
171	ret = max77686_rtc_tm_to_data(tm, data);
172	if (ret < 0)
173		return ret;
174
175	mutex_lock(&info->lock);
176
177	ret = regmap_bulk_write(info->max77686->rtc_regmap,
178				 MAX77686_RTC_SEC, data, RTC_NR_TIME);
179	if (ret < 0) {
180		dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
181				ret);
182		goto out;
183	}
184
185	ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
186
187out:
188	mutex_unlock(&info->lock);
189	return ret;
190}
191
192static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
193{
194	struct max77686_rtc_info *info = dev_get_drvdata(dev);
195	u8 data[RTC_NR_TIME];
196	unsigned int val;
197	int i, ret;
198
199	mutex_lock(&info->lock);
200
201	ret = max77686_rtc_update(info, MAX77686_RTC_READ);
202	if (ret < 0)
203		goto out;
204
205	ret = regmap_bulk_read(info->max77686->rtc_regmap,
206				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
207	if (ret < 0) {
208		dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
209				__func__, __LINE__, ret);
210		goto out;
211	}
212
213	max77686_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
214
215	alrm->enabled = 0;
216	for (i = 0; i < RTC_NR_TIME; i++) {
217		if (data[i] & ALARM_ENABLE_MASK) {
218			alrm->enabled = 1;
219			break;
220		}
221	}
222
223	alrm->pending = 0;
224	ret = regmap_read(info->max77686->regmap, MAX77686_REG_STATUS2, &val);
225	if (ret < 0) {
226		dev_err(info->dev, "%s:%d fail to read status2 reg(%d)\n",
227				__func__, __LINE__, ret);
228		goto out;
229	}
230
231	if (val & (1 << 4)) /* RTCA1 */
232		alrm->pending = 1;
233
234out:
235	mutex_unlock(&info->lock);
236	return 0;
237}
238
239static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info)
240{
241	u8 data[RTC_NR_TIME];
242	int ret, i;
243	struct rtc_time tm;
244
245	if (!mutex_is_locked(&info->lock))
246		dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
247
248	ret = max77686_rtc_update(info, MAX77686_RTC_READ);
249	if (ret < 0)
250		goto out;
251
252	ret = regmap_bulk_read(info->max77686->rtc_regmap,
253				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
254	if (ret < 0) {
255		dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
256				__func__, ret);
257		goto out;
258	}
259
260	max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode);
261
262	for (i = 0; i < RTC_NR_TIME; i++)
263		data[i] &= ~ALARM_ENABLE_MASK;
264
265	ret = regmap_bulk_write(info->max77686->rtc_regmap,
266				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
267	if (ret < 0) {
268		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
269				__func__, ret);
270		goto out;
271	}
272
273	ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
274out:
275	return ret;
276}
277
278static int max77686_rtc_start_alarm(struct max77686_rtc_info *info)
279{
280	u8 data[RTC_NR_TIME];
281	int ret;
282	struct rtc_time tm;
283
284	if (!mutex_is_locked(&info->lock))
285		dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
286
287	ret = max77686_rtc_update(info, MAX77686_RTC_READ);
288	if (ret < 0)
289		goto out;
290
291	ret = regmap_bulk_read(info->max77686->rtc_regmap,
292				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
293	if (ret < 0) {
294		dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
295				__func__, ret);
296		goto out;
297	}
298
299	max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode);
300
301	data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
302	data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
303	data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
304	data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
305	if (data[RTC_MONTH] & 0xf)
306		data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
307	if (data[RTC_YEAR] & 0x7f)
308		data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
309	if (data[RTC_DATE] & 0x1f)
310		data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
311
312	ret = regmap_bulk_write(info->max77686->rtc_regmap,
313				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
314	if (ret < 0) {
315		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
316				__func__, ret);
317		goto out;
318	}
319
320	ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
321out:
322	return ret;
323}
324
325static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
326{
327	struct max77686_rtc_info *info = dev_get_drvdata(dev);
328	u8 data[RTC_NR_TIME];
329	int ret;
330
331	ret = max77686_rtc_tm_to_data(&alrm->time, data);
332	if (ret < 0)
333		return ret;
334
335	mutex_lock(&info->lock);
336
337	ret = max77686_rtc_stop_alarm(info);
338	if (ret < 0)
339		goto out;
340
341	ret = regmap_bulk_write(info->max77686->rtc_regmap,
342				 MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
343
344	if (ret < 0) {
345		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
346				__func__, ret);
347		goto out;
348	}
349
350	ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
351	if (ret < 0)
352		goto out;
353
354	if (alrm->enabled)
355		ret = max77686_rtc_start_alarm(info);
356out:
357	mutex_unlock(&info->lock);
358	return ret;
359}
360
361static int max77686_rtc_alarm_irq_enable(struct device *dev,
362					unsigned int enabled)
363{
364	struct max77686_rtc_info *info = dev_get_drvdata(dev);
365	int ret;
366
367	mutex_lock(&info->lock);
368	if (enabled)
369		ret = max77686_rtc_start_alarm(info);
370	else
371		ret = max77686_rtc_stop_alarm(info);
372	mutex_unlock(&info->lock);
373
374	return ret;
375}
376
377static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data)
378{
379	struct max77686_rtc_info *info = data;
380
381	dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
382
383	rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
384
385	return IRQ_HANDLED;
386}
387
388static const struct rtc_class_ops max77686_rtc_ops = {
389	.read_time = max77686_rtc_read_time,
390	.set_time = max77686_rtc_set_time,
391	.read_alarm = max77686_rtc_read_alarm,
392	.set_alarm = max77686_rtc_set_alarm,
393	.alarm_irq_enable = max77686_rtc_alarm_irq_enable,
394};
395
396static int max77686_rtc_init_reg(struct max77686_rtc_info *info)
397{
398	u8 data[2];
399	int ret;
400
401	/* Set RTC control register : Binary mode, 24hour mdoe */
402	data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
403	data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
404
405	info->rtc_24hr_mode = 1;
406
407	ret = regmap_bulk_write(info->max77686->rtc_regmap, MAX77686_RTC_CONTROLM, data, 2);
408	if (ret < 0) {
409		dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
410				__func__, ret);
411		return ret;
412	}
413
414	ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
415	return ret;
416}
417
418static int max77686_rtc_probe(struct platform_device *pdev)
419{
420	struct max77686_dev *max77686 = dev_get_drvdata(pdev->dev.parent);
421	struct max77686_rtc_info *info;
422	int ret;
423
424	dev_info(&pdev->dev, "%s\n", __func__);
425
426	info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
427				GFP_KERNEL);
428	if (!info)
429		return -ENOMEM;
430
431	mutex_init(&info->lock);
432	info->dev = &pdev->dev;
433	info->max77686 = max77686;
434	info->rtc = max77686->rtc;
435
436	platform_set_drvdata(pdev, info);
437
438	ret = max77686_rtc_init_reg(info);
439
440	if (ret < 0) {
441		dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
442		goto err_rtc;
443	}
444
445	device_init_wakeup(&pdev->dev, 1);
446
447	info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc",
448					&max77686_rtc_ops, THIS_MODULE);
449
450	if (IS_ERR(info->rtc_dev)) {
451		ret = PTR_ERR(info->rtc_dev);
452		dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
453		if (ret == 0)
454			ret = -EINVAL;
455		goto err_rtc;
456	}
457
458	if (!max77686->rtc_irq_data) {
459		ret = -EINVAL;
460		dev_err(&pdev->dev, "%s: no RTC regmap IRQ chip\n", __func__);
461		goto err_rtc;
462	}
463
464	info->virq = regmap_irq_get_virq(max77686->rtc_irq_data,
465					 MAX77686_RTCIRQ_RTCA1);
466	if (!info->virq) {
467		ret = -ENXIO;
468		goto err_rtc;
469	}
470
471	ret = devm_request_threaded_irq(&pdev->dev, info->virq, NULL,
472				max77686_rtc_alarm_irq, 0, "rtc-alarm1", info);
473	if (ret < 0)
474		dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
475			info->virq, ret);
476
477err_rtc:
478	return ret;
479}
480
481#ifdef CONFIG_PM_SLEEP
482static int max77686_rtc_suspend(struct device *dev)
483{
484	if (device_may_wakeup(dev)) {
485		struct max77686_rtc_info *info = dev_get_drvdata(dev);
486
487		return enable_irq_wake(info->virq);
488	}
489
490	return 0;
491}
492
493static int max77686_rtc_resume(struct device *dev)
494{
495	if (device_may_wakeup(dev)) {
496		struct max77686_rtc_info *info = dev_get_drvdata(dev);
497
498		return disable_irq_wake(info->virq);
499	}
500
501	return 0;
502}
503#endif
504
505static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops,
506			 max77686_rtc_suspend, max77686_rtc_resume);
507
508static const struct platform_device_id rtc_id[] = {
509	{ "max77686-rtc", 0 },
510	{},
511};
512
513static struct platform_driver max77686_rtc_driver = {
514	.driver		= {
515		.name	= "max77686-rtc",
516		.owner	= THIS_MODULE,
517		.pm	= &max77686_rtc_pm_ops,
518	},
519	.probe		= max77686_rtc_probe,
520	.id_table	= rtc_id,
521};
522
523module_platform_driver(max77686_rtc_driver);
524
525MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
526MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
527MODULE_LICENSE("GPL");
528