rtc-mc13xxx.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Real Time Clock driver for Freescale MC13XXX PMIC
  4 *
  5 * (C) 2009 Sascha Hauer, Pengutronix
  6 * (C) 2009 Uwe Kleine-Koenig, Pengutronix
  7 */
  8
  9#include <linux/mfd/mc13xxx.h>
 10#include <linux/platform_device.h>
 11#include <linux/kernel.h>
 12#include <linux/module.h>
 13#include <linux/mod_devicetable.h>
 14#include <linux/slab.h>
 15#include <linux/rtc.h>
 16
 17#define DRIVER_NAME "mc13xxx-rtc"
 18
 19#define MC13XXX_RTCTOD	20
 20#define MC13XXX_RTCTODA	21
 21#define MC13XXX_RTCDAY	22
 22#define MC13XXX_RTCDAYA	23
 23
 24#define SEC_PER_DAY	(24 * 60 * 60)
 25
 26struct mc13xxx_rtc {
 27	struct rtc_device *rtc;
 28	struct mc13xxx *mc13xxx;
 29	int valid;
 30};
 31
 32static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
 33		unsigned int enabled, int irq)
 34{
 35	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
 36	int (*func)(struct mc13xxx *mc13xxx, int irq);
 37
 38	if (!priv->valid)
 39		return -ENODATA;
 40
 41	func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
 42	return func(priv->mc13xxx, irq);
 43}
 44
 45static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
 46					unsigned int enabled)
 47{
 48	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
 49	int ret;
 50
 51	mc13xxx_lock(priv->mc13xxx);
 52
 53	ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);
 54
 55	mc13xxx_unlock(priv->mc13xxx);
 56
 57	return ret;
 58}
 59
 60static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
 61{
 62	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
 63	unsigned int seconds, days1, days2;
 64
 65	if (!priv->valid)
 66		return -ENODATA;
 67
 68	do {
 69		int ret;
 70
 71		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
 72		if (ret)
 73			return ret;
 74
 75		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
 76		if (ret)
 77			return ret;
 78
 79		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
 80		if (ret)
 81			return ret;
 82	} while (days1 != days2);
 83
 84	rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);
 85
 86	return 0;
 87}
 88
 89static int mc13xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
 90{
 91	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
 92	unsigned int seconds, days;
 93	unsigned int alarmseconds;
 94	int ret;
 95
 96	days = div_s64_rem(rtc_tm_to_time64(tm), SEC_PER_DAY, &seconds);
 97
 98	mc13xxx_lock(priv->mc13xxx);
 99
100	/*
101	 * temporarily invalidate alarm to prevent triggering it when the day is
102	 * already updated while the time isn't yet.
103	 */
104	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
105	if (unlikely(ret))
106		goto out;
107
108	if (alarmseconds < SEC_PER_DAY) {
109		ret = mc13xxx_reg_write(priv->mc13xxx,
110				MC13XXX_RTCTODA, 0x1ffff);
111		if (unlikely(ret))
112			goto out;
113	}
114
115	/*
116	 * write seconds=0 to prevent a day switch between writing days
117	 * and seconds below
118	 */
119	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
120	if (unlikely(ret))
121		goto out;
122
123	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
124	if (unlikely(ret))
125		goto out;
126
127	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
128	if (unlikely(ret))
129		goto out;
130
131	/* restore alarm */
132	if (alarmseconds < SEC_PER_DAY) {
133		ret = mc13xxx_reg_write(priv->mc13xxx,
134				MC13XXX_RTCTODA, alarmseconds);
135		if (unlikely(ret))
136			goto out;
137	}
138
139	if (!priv->valid) {
140		ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
141	}
142
143out:
144	priv->valid = !ret;
145
146	mc13xxx_unlock(priv->mc13xxx);
147
148	return ret;
149}
150
151static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
152{
153	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
154	unsigned int seconds, days;
155	time64_t s1970;
156	int enabled, pending;
157	int ret;
158
159	mc13xxx_lock(priv->mc13xxx);
160
161	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
162	if (unlikely(ret))
163		goto out;
164	if (seconds >= SEC_PER_DAY) {
165		ret = -ENODATA;
166		goto out;
167	}
168
169	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
170	if (unlikely(ret))
171		goto out;
172
173	ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
174			&enabled, &pending);
175
176out:
177	mc13xxx_unlock(priv->mc13xxx);
178
179	if (ret)
180		return ret;
181
182	alarm->enabled = enabled;
183	alarm->pending = pending;
184
185	s1970 = (time64_t)days * SEC_PER_DAY + seconds;
186
187	rtc_time64_to_tm(s1970, &alarm->time);
188	dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);
189
190	return 0;
191}
192
193static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
194{
195	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
196	time64_t s1970;
197	u32 seconds, days;
198	int ret;
199
200	mc13xxx_lock(priv->mc13xxx);
201
202	/* disable alarm to prevent false triggering */
203	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
204	if (unlikely(ret))
205		goto out;
206
207	s1970 = rtc_tm_to_time64(&alarm->time);
208
209	dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off",
210			(long long)s1970);
211
212	ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
213			MC13XXX_IRQ_TODA);
214	if (unlikely(ret))
215		goto out;
216
217	days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);
218
219	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
220	if (unlikely(ret))
221		goto out;
222
223	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
224
225out:
226	mc13xxx_unlock(priv->mc13xxx);
227
228	return ret;
229}
230
231static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
232{
233	struct mc13xxx_rtc *priv = dev;
234
235	rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
236
237	return IRQ_HANDLED;
238}
239
240static const struct rtc_class_ops mc13xxx_rtc_ops = {
241	.read_time = mc13xxx_rtc_read_time,
242	.set_time = mc13xxx_rtc_set_time,
243	.read_alarm = mc13xxx_rtc_read_alarm,
244	.set_alarm = mc13xxx_rtc_set_alarm,
245	.alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
246};
247
248static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
249{
250	struct mc13xxx_rtc *priv = dev;
251	struct mc13xxx *mc13xxx = priv->mc13xxx;
252
253	priv->valid = 0;
254
255	mc13xxx_irq_mask(mc13xxx, irq);
256
257	return IRQ_HANDLED;
258}
259
260static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
261{
262	int ret;
263	struct mc13xxx_rtc *priv;
264	struct mc13xxx *mc13xxx;
265
266	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
267	if (!priv)
268		return -ENOMEM;
269
270	mc13xxx = dev_get_drvdata(pdev->dev.parent);
271	priv->mc13xxx = mc13xxx;
272	priv->valid = 1;
273
274	priv->rtc = devm_rtc_allocate_device(&pdev->dev);
275	if (IS_ERR(priv->rtc))
276		return PTR_ERR(priv->rtc);
277	platform_set_drvdata(pdev, priv);
278
279	priv->rtc->ops = &mc13xxx_rtc_ops;
280	/* 15bit days + hours, minutes, seconds */
281	priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1;
282
283	mc13xxx_lock(mc13xxx);
284
285	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
286			mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
287	if (ret)
288		goto err_irq_request;
289
290	ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
291			mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
292	if (ret)
293		goto err_irq_request;
294
295	mc13xxx_unlock(mc13xxx);
296
297	ret = devm_rtc_register_device(priv->rtc);
298	if (ret) {
299		mc13xxx_lock(mc13xxx);
300		goto err_irq_request;
301	}
302
303	return 0;
304
305err_irq_request:
306	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
307	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
308
309	mc13xxx_unlock(mc13xxx);
310
311	return ret;
312}
313
314static void mc13xxx_rtc_remove(struct platform_device *pdev)
315{
316	struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
317
318	mc13xxx_lock(priv->mc13xxx);
319
320	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
321	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
322
323	mc13xxx_unlock(priv->mc13xxx);
324}
325
326static const struct platform_device_id mc13xxx_rtc_idtable[] = {
327	{
328		.name = "mc13783-rtc",
329	}, {
330		.name = "mc13892-rtc",
331	}, {
332		.name = "mc34708-rtc",
333	},
334	{ /* sentinel */ }
335};
336MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
337
338static struct platform_driver mc13xxx_rtc_driver = {
339	.id_table = mc13xxx_rtc_idtable,
340	.remove = mc13xxx_rtc_remove,
341	.driver = {
342		.name = DRIVER_NAME,
343	},
344};
345
346module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
347
348MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
349MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
350MODULE_LICENSE("GPL v2");