[linux-2.6-block.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

#define SEC_PER_DAY	(24 * 60 * 60)

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;

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

	do {
		int ret;

		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
		if (ret)
			return ret;

		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
		if (ret)
			return ret;

		ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
		if (ret)
			return ret;
	} while (days1 != days2);

	rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);

	return rtc_valid_tm(tm);
}

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

	days = div_s64_rem(secs, SEC_PER_DAY, &seconds);

	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 < SEC_PER_DAY) {
		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 < SEC_PER_DAY) {
		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;
	time64_t 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 >= SEC_PER_DAY) {
		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 = (time64_t)days * SEC_PER_DAY + seconds;

	rtc_time64_to_tm(s1970, &alarm->time);
	dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);

	return 0;
}

static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	time64_t s1970;
	u32 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;

	s1970 = rtc_tm_to_time64(&alarm->time);

	dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off",
			(long long)s1970);

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

	days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);

	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;

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

	mc13xxx_irq_ack(mc13xxx, irq);

	return IRQ_HANDLED;
}

static const struct rtc_class_ops mc13xxx_rtc_ops = {
	.read_time = mc13xxx_rtc_read_time,
	.set_mmss64 = 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;

	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);

	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_irq_request;

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

	mc13xxx_unlock(mc13xxx);

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

	return 0;

err_irq_request:
	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);

	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_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,
	},
};

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