[deliverable/linux.git] / drivers / rtc / rtc-mc13xxx.c

/*
 * Real Time Clock driver for Freescale MC13XXX PMIC
 *
 * (C) 2009 Sascha Hauer, Pengutronix
 * (C) 2009 Uwe Kleine-Koenig, Pengutronix
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/mfd/mc13xxx.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/rtc.h>

#define DRIVER_NAME "mc13xxx-rtc"

#define MC13XXX_RTCTOD	20
#define MC13XXX_RTCTODA	21
#define MC13XXX_RTCDAY	22
#define MC13XXX_RTCDAYA	23

struct mc13xxx_rtc {
	struct rtc_device *rtc;
	struct mc13xxx *mc13xxx;
	int valid;
};

static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
		unsigned int enabled, int irq)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	int (*func)(struct mc13xxx *mc13xxx, int irq);

	if (!priv->valid)
		return -ENODATA;

	func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
	return func(priv->mc13xxx, irq);
}

static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
					unsigned int enabled)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	int ret;

	mc13xxx_lock(priv->mc13xxx);

	ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);

	mc13xxx_unlock(priv->mc13xxx);

	return ret;
}

static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	unsigned int seconds, days1, days2;
	unsigned long s1970;
	int ret;

	if (!priv->valid)
		return -ENODATA;

	mc13xxx_lock(priv->mc13xxx);

	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
out:
	mc13xxx_unlock(priv->mc13xxx);

	if (ret)
		return ret;

	if (days2 == days1 + 1) {
		if (seconds >= 86400 / 2)
			days2 = days1;
		else
			days1 = days2;
	}

	if (days1 != days2)
		return -EIO;

	s1970 = days1 * 86400 + seconds;

	rtc_time_to_tm(s1970, tm);

	return rtc_valid_tm(tm);
}

static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	unsigned int seconds, days;
	unsigned int alarmseconds;
	int ret;

	seconds = secs % 86400;
	days = secs / 86400;

	mc13xxx_lock(priv->mc13xxx);

	/*
	 * temporarily invalidate alarm to prevent triggering it when the day is
	 * already updated while the time isn't yet.
	 */
	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
	if (unlikely(ret))
		goto out;

	if (alarmseconds < 86400) {
		ret = mc13xxx_reg_write(priv->mc13xxx,
				MC13XXX_RTCTODA, 0x1ffff);
		if (unlikely(ret))
			goto out;
	}

	/*
	 * write seconds=0 to prevent a day switch between writing days
	 * and seconds below
	 */
	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
	if (unlikely(ret))
		goto out;

	/* restore alarm */
	if (alarmseconds < 86400) {
		ret = mc13xxx_reg_write(priv->mc13xxx,
				MC13XXX_RTCTODA, alarmseconds);
		if (unlikely(ret))
			goto out;
	}

	if (!priv->valid) {
		ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
		if (unlikely(ret))
			goto out;

		ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
	}

out:
	priv->valid = !ret;

	mc13xxx_unlock(priv->mc13xxx);

	return ret;
}

static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	unsigned seconds, days;
	unsigned long s1970;
	int enabled, pending;
	int ret;

	mc13xxx_lock(priv->mc13xxx);

	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
	if (unlikely(ret))
		goto out;
	if (seconds >= 86400) {
		ret = -ENODATA;
		goto out;
	}

	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
			&enabled, &pending);

out:
	mc13xxx_unlock(priv->mc13xxx);

	if (ret)
		return ret;

	alarm->enabled = enabled;
	alarm->pending = pending;

	s1970 = days * 86400 + seconds;

	rtc_time_to_tm(s1970, &alarm->time);
	dev_dbg(dev, "%s: %lu\n", __func__, s1970);

	return 0;
}

static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	unsigned long s1970;
	unsigned seconds, days;
	int ret;

	mc13xxx_lock(priv->mc13xxx);

	/* disable alarm to prevent false triggering */
	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
	if (unlikely(ret))
		goto out;

	ret = rtc_tm_to_time(&alarm->time, &s1970);
	if (unlikely(ret))
		goto out;

	dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
			s1970);

	ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
			MC13XXX_IRQ_TODA);
	if (unlikely(ret))
		goto out;

	seconds = s1970 % 86400;
	days = s1970 / 86400;

	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
	if (unlikely(ret))
		goto out;

	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);

out:
	mc13xxx_unlock(priv->mc13xxx);

	return ret;
}

static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
{
	struct mc13xxx_rtc *priv = dev;
	struct mc13xxx *mc13xxx = priv->mc13xxx;

	dev_dbg(&priv->rtc->dev, "Alarm\n");

	rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);

	mc13xxx_irq_ack(mc13xxx, irq);

	return IRQ_HANDLED;
}

static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
{
	struct mc13xxx_rtc *priv = dev;
	struct mc13xxx *mc13xxx = priv->mc13xxx;

	dev_dbg(&priv->rtc->dev, "1HZ\n");

	rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);

	mc13xxx_irq_ack(mc13xxx, irq);

	return IRQ_HANDLED;
}

static const struct rtc_class_ops mc13xxx_rtc_ops = {
	.read_time = mc13xxx_rtc_read_time,
	.set_mmss = mc13xxx_rtc_set_mmss,
	.read_alarm = mc13xxx_rtc_read_alarm,
	.set_alarm = mc13xxx_rtc_set_alarm,
	.alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
};

static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
{
	struct mc13xxx_rtc *priv = dev;
	struct mc13xxx *mc13xxx = priv->mc13xxx;

	dev_warn(&priv->rtc->dev, "Contents of the RTC are no longer valid\n");
	priv->valid = 0;

	mc13xxx_irq_mask(mc13xxx, irq);

	return IRQ_HANDLED;
}

static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
{
	int ret;
	struct mc13xxx_rtc *priv;
	struct mc13xxx *mc13xxx;

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	mc13xxx = dev_get_drvdata(pdev->dev.parent);
	priv->mc13xxx = mc13xxx;
	priv->valid = 1;

	platform_set_drvdata(pdev, priv);

	priv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
					     &mc13xxx_rtc_ops, THIS_MODULE);
	if (IS_ERR(priv->rtc))
		return PTR_ERR(priv->rtc);

	mc13xxx_lock(mc13xxx);

	mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);

	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
			mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
	if (ret)
		goto err_reset_irq_request;

	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_1HZ,
			mc13xxx_rtc_update_handler, DRIVER_NAME, priv);
	if (ret)
		goto err_reset_irq_status;

	ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
			mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
	if (!ret)
		goto err_reset_irq_request;

	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv);

err_reset_irq_status:
	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);

err_reset_irq_request:
	mc13xxx_unlock(mc13xxx);

	return ret;
}

static int mc13xxx_rtc_remove(struct platform_device *pdev)
{
	struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);

	mc13xxx_lock(priv->mc13xxx);

	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);

	mc13xxx_unlock(priv->mc13xxx);

	return 0;
}

static const struct platform_device_id mc13xxx_rtc_idtable[] = {
	{
		.name = "mc13783-rtc",
	}, {
		.name = "mc13892-rtc",
	}, {
		.name = "mc34708-rtc",
	},
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);

static struct platform_driver mc13xxx_rtc_driver = {
	.id_table = mc13xxx_rtc_idtable,
	.remove = mc13xxx_rtc_remove,
	.driver = {
		.name = DRIVER_NAME,
		.owner = THIS_MODULE,
	},
};

module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);

MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1c97872b UKK	1	/*
	2	* Real Time Clock driver for Freescale MC13XXX PMIC
	3	*
	4	* (C) 2009 Sascha Hauer, Pengutronix
	5	* (C) 2009 Uwe Kleine-Koenig, Pengutronix
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/mfd/mc13xxx.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/slab.h>
	17	#include <linux/rtc.h>
	18
	19	#define DRIVER_NAME "mc13xxx-rtc"
	20
	21	#define MC13XXX_RTCTOD 20
	22	#define MC13XXX_RTCTODA 21
	23	#define MC13XXX_RTCDAY 22
	24	#define MC13XXX_RTCDAYA 23
	25
	26	struct mc13xxx_rtc {
	27	struct rtc_device *rtc;
	28	struct mc13xxx *mc13xxx;
	29	int valid;
	30	};
	31
	32	static 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
2fb004a9 AS	45	static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
2fb004a9 AS	46	unsigned int enabled)
1c97872b UKK	47	{
	48	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	49	int ret;
	50
	51	mc13xxx_lock(priv->mc13xxx);
	52
2fb004a9	53	ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);
1c97872b UKK	54
	55	mc13xxx_unlock(priv->mc13xxx);
	56
	57	return ret;
	58	}
	59
	60	static 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	unsigned long s1970;
	65	int ret;
	66
12de3621 AS	67	if (!priv->valid)
12de3621 AS	68	return -ENODATA;
1c97872b	69
12de3621	70	mc13xxx_lock(priv->mc13xxx);
1c97872b UKK	71
	72	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
	73	if (unlikely(ret))
	74	goto out;
	75
	76	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
	77	if (unlikely(ret))
	78	goto out;
	79
	80	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
	81	out:
	82	mc13xxx_unlock(priv->mc13xxx);
	83
	84	if (ret)
	85	return ret;
	86
	87	if (days2 == days1 + 1) {
	88	if (seconds >= 86400 / 2)
	89	days2 = days1;
	90	else
	91	days1 = days2;
	92	}
	93
	94	if (days1 != days2)
	95	return -EIO;
	96
	97	s1970 = days1 * 86400 + seconds;
	98
	99	rtc_time_to_tm(s1970, tm);
	100
	101	return rtc_valid_tm(tm);
	102	}
	103
	104	static int mc13xxx_rtc_set_mmss(struct device *dev, unsigned long secs)
	105	{
	106	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	107	unsigned int seconds, days;
	108	unsigned int alarmseconds;
	109	int ret;
	110
	111	seconds = secs % 86400;
	112	days = secs / 86400;
	113
	114	mc13xxx_lock(priv->mc13xxx);
	115
	116	/*
	117	* temporarily invalidate alarm to prevent triggering it when the day is
	118	* already updated while the time isn't yet.
	119	*/
	120	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
	121	if (unlikely(ret))
	122	goto out;
	123
	124	if (alarmseconds < 86400) {
	125	ret = mc13xxx_reg_write(priv->mc13xxx,
	126	MC13XXX_RTCTODA, 0x1ffff);
	127	if (unlikely(ret))
	128	goto out;
	129	}
	130
	131	/*
	132	* write seconds=0 to prevent a day switch between writing days
	133	* and seconds below
	134	*/
135	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
136	if (unlikely(ret))
137	goto out;
138
139	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
140	if (unlikely(ret))
141	goto out;
142
143	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
144	if (unlikely(ret))
145	goto out;
146
147	/* restore alarm */
148	if (alarmseconds < 86400) {
149	ret = mc13xxx_reg_write(priv->mc13xxx,
150	MC13XXX_RTCTODA, alarmseconds);
151	if (unlikely(ret))
152	goto out;
153	}
154
12de3621 AS	155	if (!priv->valid) {
	156	ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
	157	if (unlikely(ret))
	158	goto out;
	159
	160	ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
	161	}
1c97872b	162
1c97872b UKK	163	out:
	164	priv->valid = !ret;
	165
	166	mc13xxx_unlock(priv->mc13xxx);
	167
	168	return ret;
	169	}
	170
	171	static int mc13xxx_rtc_read_alarm(struct device dev, struct rtc_wkalrm alarm)
	172	{
	173	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	174	unsigned seconds, days;
	175	unsigned long s1970;
	176	int enabled, pending;
	177	int ret;
	178
	179	mc13xxx_lock(priv->mc13xxx);
	180
	181	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
	182	if (unlikely(ret))
	183	goto out;
	184	if (seconds >= 86400) {
	185	ret = -ENODATA;
	186	goto out;
	187	}
	188
	189	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
	190	if (unlikely(ret))
	191	goto out;
	192
	193	ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
	194	&enabled, &pending);
	195
	196	out:
	197	mc13xxx_unlock(priv->mc13xxx);
	198
	199	if (ret)
	200	return ret;
	201
	202	alarm->enabled = enabled;
	203	alarm->pending = pending;
	204
	205	s1970 = days * 86400 + seconds;
	206
	207	rtc_time_to_tm(s1970, &alarm->time);
	208	dev_dbg(dev, "%s: %lu\n", __func__, s1970);
	209
	210	return 0;
	211	}
	212
	213	static int mc13xxx_rtc_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	214	{
	215	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	216	unsigned long s1970;
	217	unsigned seconds, days;
	218	int ret;
	219
	220	mc13xxx_lock(priv->mc13xxx);
	221
	222	/* disable alarm to prevent false triggering */
	223	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
	224	if (unlikely(ret))
	225	goto out;
	226
227	ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
228	if (unlikely(ret))
229	goto out;
230
231	ret = rtc_tm_to_time(&alarm->time, &s1970);
232	if (unlikely(ret))
233	goto out;
234
235	dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
236	s1970);
237
238	ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
239	MC13XXX_IRQ_TODA);
240	if (unlikely(ret))
241	goto out;
242
243	seconds = s1970 % 86400;
244	days = s1970 / 86400;
245
246	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
247	if (unlikely(ret))
248	goto out;
249
250	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
251
252	out:
253	mc13xxx_unlock(priv->mc13xxx);
254
255	return ret;
256	}
257
258	static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
259	{
260	struct mc13xxx_rtc *priv = dev;
261	struct mc13xxx *mc13xxx = priv->mc13xxx;
262
263	dev_dbg(&priv->rtc->dev, "Alarm\n");
264
265	rtc_update_irq(priv->rtc, 1, RTC_IRQF \| RTC_AF);
266
267	mc13xxx_irq_ack(mc13xxx, irq);
268
269	return IRQ_HANDLED;
270	}
271
272	static irqreturn_t mc13xxx_rtc_update_handler(int irq, void *dev)
273	{
274	struct mc13xxx_rtc *priv = dev;
275	struct mc13xxx *mc13xxx = priv->mc13xxx;
276
277	dev_dbg(&priv->rtc->dev, "1HZ\n");
278
279	rtc_update_irq(priv->rtc, 1, RTC_IRQF \| RTC_UF);
280
281	mc13xxx_irq_ack(mc13xxx, irq);
282
283	return IRQ_HANDLED;
284	}
285
1c97872b UKK	286	static const struct rtc_class_ops mc13xxx_rtc_ops = {
	287	.read_time = mc13xxx_rtc_read_time,
	288	.set_mmss = mc13xxx_rtc_set_mmss,
	289	.read_alarm = mc13xxx_rtc_read_alarm,
	290	.set_alarm = mc13xxx_rtc_set_alarm,
	291	.alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
1c97872b UKK	292	};
	293
	294	static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
	295	{
	296	struct mc13xxx_rtc *priv = dev;
	297	struct mc13xxx *mc13xxx = priv->mc13xxx;
	298
12de3621	299	dev_warn(&priv->rtc->dev, "Contents of the RTC are no longer valid\n");
1c97872b UKK	300	priv->valid = 0;
	301
	302	mc13xxx_irq_mask(mc13xxx, irq);
	303
	304	return IRQ_HANDLED;
	305	}
	306
db5cf8d1	307	static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
1c97872b UKK	308	{
	309	int ret;
	310	struct mc13xxx_rtc *priv;
	311	struct mc13xxx *mc13xxx;
1c97872b	312
a379fd24	313	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
1c97872b UKK	314	if (!priv)
	315	return -ENOMEM;
	316
	317	mc13xxx = dev_get_drvdata(pdev->dev.parent);
	318	priv->mc13xxx = mc13xxx;
12de3621	319	priv->valid = 1;
1c97872b UKK	320
	321	platform_set_drvdata(pdev, priv);
	322
589e5014 AS	323	priv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
	324	&mc13xxx_rtc_ops, THIS_MODULE);
	325	if (IS_ERR(priv->rtc))
	326	return PTR_ERR(priv->rtc);
	327
1c97872b UKK	328	mc13xxx_lock(mc13xxx);
1c97872b UKK	329
12de3621 AS	330	mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);
12de3621 AS	331
1c97872b UKK	332	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
	333	mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
	334	if (ret)
	335	goto err_reset_irq_request;
	336
fb1bd9a2	337	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_1HZ,
1c97872b UKK	338	mc13xxx_rtc_update_handler, DRIVER_NAME, priv);
1c97872b UKK	339	if (ret)
589e5014	340	goto err_reset_irq_status;
1c97872b UKK	341
	342	ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
	343	mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
589e5014 AS	344	if (!ret)
589e5014 AS	345	goto err_reset_irq_request;
1c97872b	346
589e5014	347	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_1HZ, priv);
1c97872b UKK	348
1c97872b UKK	349	err_reset_irq_status:
589e5014	350	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
1c97872b	351
1c97872b	352	err_reset_irq_request:
589e5014	353	mc13xxx_unlock(mc13xxx);
1c97872b	354
1c97872b UKK	355	return ret;
	356	}
	357
77bf2ea8	358	static int mc13xxx_rtc_remove(struct platform_device *pdev)
1c97872b UKK	359	{
	360	struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
	361
	362	mc13xxx_lock(priv->mc13xxx);
	363
1c97872b UKK	364	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
	365	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
	366	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
	367
	368	mc13xxx_unlock(priv->mc13xxx);
	369
1c97872b UKK	370	return 0;
	371	}
	372
a46481d7	373	static const struct platform_device_id mc13xxx_rtc_idtable[] = {
1c97872b UKK	374	{
	375	.name = "mc13783-rtc",
	376	}, {
	377	.name = "mc13892-rtc",
19a1ac50 UKK	378	}, {
19a1ac50 UKK	379	.name = "mc34708-rtc",
1c97872b	380	},
0f636fc1	381	{ /* sentinel */ }
1c97872b	382	};
0f636fc1	383	MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
1c97872b UKK	384
	385	static struct platform_driver mc13xxx_rtc_driver = {
	386	.id_table = mc13xxx_rtc_idtable,
77bf2ea8	387	.remove = mc13xxx_rtc_remove,
1c97872b UKK	388	.driver = {
	389	.name = DRIVER_NAME,
	390	.owner = THIS_MODULE,
	391	},
	392	};
	393
09fb7ad1	394	module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
1c97872b UKK	395
	396	MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
	397	MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
	398	MODULE_LICENSE("GPL v2");