[linux-2.6-block.git] / drivers / rtc / rtc-mc13xxx.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Real Time Clock driver for Freescale MC13XXX PMIC
 *
 * (C) 2009 Sascha Hauer, Pengutronix
 * (C) 2009 Uwe Kleine-Koenig, Pengutronix
 */

#include <linux/mfd/mc13xxx.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.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 0;
}

static int mc13xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	unsigned int seconds, days;
	unsigned int alarmseconds;
	int ret;

	days = div_s64_rem(rtc_tm_to_time64(tm), 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 int 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_time = mc13xxx_rtc_set_time,
	.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;

	priv->rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(priv->rtc))
		return PTR_ERR(priv->rtc);
	platform_set_drvdata(pdev, priv);

	priv->rtc->ops = &mc13xxx_rtc_ops;
	/* 15bit days + hours, minutes, seconds */
	priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1;

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

	ret = rtc_register_device(priv->rtc);
	if (ret)
		goto err_irq_request;

	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
edd6d79e	1	// SPDX-License-Identifier: GPL-2.0
1c97872b UKK	2	/*
	3	* Real Time Clock driver for Freescale MC13XXX PMIC
	4	*
	5	* (C) 2009 Sascha Hauer, Pengutronix
	6	* (C) 2009 Uwe Kleine-Koenig, Pengutronix
1c97872b UKK	7	*/
	8
	9	#include <linux/mfd/mc13xxx.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
ac316725	13	#include <linux/mod_devicetable.h>
1c97872b UKK	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
6a2b3422 AS	24	#define SEC_PER_DAY (24 * 60 * 60)
6a2b3422 AS	25
1c97872b UKK	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;
1c97872b	64
12de3621 AS	65	if (!priv->valid)
12de3621 AS	66	return -ENODATA;
1c97872b	67
6a2b3422 AS	68	do {
6a2b3422 AS	69	int ret;
1c97872b	70
6a2b3422 AS	71	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
	72	if (ret)
	73	return ret;
1c97872b	74
6a2b3422 AS	75	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
	76	if (ret)
	77	return ret;
1c97872b	78
6a2b3422 AS	79	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
	80	if (ret)
	81	return ret;
	82	} while (days1 != days2);
1c97872b	83
0307b0d7	84	rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);
1c97872b	85
146d21bd	86	return 0;
1c97872b UKK	87	}
1c97872b UKK	88
eee86dea	89	static int mc13xxx_rtc_set_time(struct device dev, struct rtc_time tm)
1c97872b UKK	90	{
	91	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
	92	unsigned int seconds, days;
	93	unsigned int alarmseconds;
	94	int ret;
	95
eee86dea	96	days = div_s64_rem(rtc_tm_to_time64(tm), SEC_PER_DAY, &seconds);
1c97872b UKK	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
6a2b3422	108	if (alarmseconds < SEC_PER_DAY) {
1c97872b UKK	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 */
6a2b3422	132	if (alarmseconds < SEC_PER_DAY) {
1c97872b UKK	133	ret = mc13xxx_reg_write(priv->mc13xxx,
	134	MC13XXX_RTCTODA, alarmseconds);
	135	if (unlikely(ret))
	136	goto out;
	137	}
	138
12de3621 AS	139	if (!priv->valid) {
	140	ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
	141	if (unlikely(ret))
	142	goto out;
	143
	144	ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
	145	}
1c97872b	146
1c97872b UKK	147	out:
	148	priv->valid = !ret;
	149
	150	mc13xxx_unlock(priv->mc13xxx);
	151
	152	return ret;
	153	}
	154
	155	static int mc13xxx_rtc_read_alarm(struct device dev, struct rtc_wkalrm alarm)
	156	{
	157	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
9fc0fd50	158	unsigned int seconds, days;
0307b0d7	159	time64_t s1970;
1c97872b UKK	160	int enabled, pending;
	161	int ret;
	162
	163	mc13xxx_lock(priv->mc13xxx);
	164
	165	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
	166	if (unlikely(ret))
	167	goto out;
6a2b3422	168	if (seconds >= SEC_PER_DAY) {
1c97872b UKK	169	ret = -ENODATA;
	170	goto out;
	171	}
	172
	173	ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
	174	if (unlikely(ret))
	175	goto out;
	176
	177	ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
	178	&enabled, &pending);
	179
	180	out:
	181	mc13xxx_unlock(priv->mc13xxx);
	182
	183	if (ret)
	184	return ret;
	185
	186	alarm->enabled = enabled;
	187	alarm->pending = pending;
	188
0307b0d7	189	s1970 = (time64_t)days * SEC_PER_DAY + seconds;
1c97872b	190
0307b0d7 XP	191	rtc_time64_to_tm(s1970, &alarm->time);
0307b0d7 XP	192	dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);
1c97872b UKK	193
	194	return 0;
	195	}
	196
	197	static int mc13xxx_rtc_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	198	{
	199	struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
0307b0d7 XP	200	time64_t s1970;
0307b0d7 XP	201	u32 seconds, days;
1c97872b UKK	202	int ret;
	203
	204	mc13xxx_lock(priv->mc13xxx);
	205
	206	/* disable alarm to prevent false triggering */
	207	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
	208	if (unlikely(ret))
	209	goto out;
	210
	211	ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
	212	if (unlikely(ret))
	213	goto out;
	214
0307b0d7	215	s1970 = rtc_tm_to_time64(&alarm->time);
1c97872b	216
99c14e4d	217	dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off",
0307b0d7	218	(long long)s1970);
1c97872b UKK	219
	220	ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
	221	MC13XXX_IRQ_TODA);
	222	if (unlikely(ret))
	223	goto out;
	224
0307b0d7	225	days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);
1c97872b UKK	226
	227	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
	228	if (unlikely(ret))
	229	goto out;
	230
	231	ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
	232
	233	out:
	234	mc13xxx_unlock(priv->mc13xxx);
	235
	236	return ret;
	237	}
	238
	239	static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
	240	{
	241	struct mc13xxx_rtc *priv = dev;
	242	struct mc13xxx *mc13xxx = priv->mc13xxx;
	243
1c97872b UKK	244	rtc_update_irq(priv->rtc, 1, RTC_IRQF \| RTC_AF);
	245
	246	mc13xxx_irq_ack(mc13xxx, irq);
	247
	248	return IRQ_HANDLED;
	249	}
	250
1c97872b UKK	251	static const struct rtc_class_ops mc13xxx_rtc_ops = {
1c97872b UKK	252	.read_time = mc13xxx_rtc_read_time,
eee86dea	253	.set_time = mc13xxx_rtc_set_time,
1c97872b UKK	254	.read_alarm = mc13xxx_rtc_read_alarm,
	255	.set_alarm = mc13xxx_rtc_set_alarm,
	256	.alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
1c97872b UKK	257	};
	258
	259	static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
	260	{
	261	struct mc13xxx_rtc *priv = dev;
	262	struct mc13xxx *mc13xxx = priv->mc13xxx;
	263
1c97872b UKK	264	priv->valid = 0;
	265
	266	mc13xxx_irq_mask(mc13xxx, irq);
	267
	268	return IRQ_HANDLED;
	269	}
	270
db5cf8d1	271	static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
1c97872b UKK	272	{
	273	int ret;
	274	struct mc13xxx_rtc *priv;
	275	struct mc13xxx *mc13xxx;
1c97872b	276
a379fd24	277	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
1c97872b UKK	278	if (!priv)
	279	return -ENOMEM;
	280
	281	mc13xxx = dev_get_drvdata(pdev->dev.parent);
	282	priv->mc13xxx = mc13xxx;
12de3621	283	priv->valid = 1;
1c97872b	284
e4ae7023 AB	285	priv->rtc = devm_rtc_allocate_device(&pdev->dev);
	286	if (IS_ERR(priv->rtc))
	287	return PTR_ERR(priv->rtc);
1c97872b UKK	288	platform_set_drvdata(pdev, priv);
1c97872b UKK	289
e4ae7023 AB	290	priv->rtc->ops = &mc13xxx_rtc_ops;
	291	/* 15bit days + hours, minutes, seconds */
	292	priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1;
	293
1c97872b UKK	294	mc13xxx_lock(mc13xxx);
1c97872b UKK	295
12de3621 AS	296	mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);
12de3621 AS	297
1c97872b UKK	298	ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
	299	mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
	300	if (ret)
5ab9a52a	301	goto err_irq_request;
1c97872b	302
1c97872b UKK	303	ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
1c97872b UKK	304	mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
5ab9a52a AS	305	if (ret)
5ab9a52a AS	306	goto err_irq_request;
1c97872b	307
5ab9a52a AS	308	mc13xxx_unlock(mc13xxx);
5ab9a52a AS	309
e4ae7023 AB	310	ret = rtc_register_device(priv->rtc);
	311	if (ret)
	312	goto err_irq_request;
1c97872b	313
5ab9a52a AS	314	return 0;
	315
	316	err_irq_request:
	317	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
589e5014	318	mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
1c97872b	319
589e5014	320	mc13xxx_unlock(mc13xxx);
1c97872b	321
1c97872b UKK	322	return ret;
	323	}
	324
77bf2ea8	325	static int mc13xxx_rtc_remove(struct platform_device *pdev)
1c97872b UKK	326	{
	327	struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
	328
	329	mc13xxx_lock(priv->mc13xxx);
	330
1c97872b	331	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
1c97872b UKK	332	mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
	333
	334	mc13xxx_unlock(priv->mc13xxx);
	335
1c97872b UKK	336	return 0;
	337	}
	338
a46481d7	339	static const struct platform_device_id mc13xxx_rtc_idtable[] = {
1c97872b UKK	340	{
	341	.name = "mc13783-rtc",
	342	}, {
	343	.name = "mc13892-rtc",
19a1ac50 UKK	344	}, {
19a1ac50 UKK	345	.name = "mc34708-rtc",
1c97872b	346	},
0f636fc1	347	{ /* sentinel */ }
1c97872b	348	};
0f636fc1	349	MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
1c97872b UKK	350
	351	static struct platform_driver mc13xxx_rtc_driver = {
	352	.id_table = mc13xxx_rtc_idtable,
77bf2ea8	353	.remove = mc13xxx_rtc_remove,
1c97872b UKK	354	.driver = {
1c97872b UKK	355	.name = DRIVER_NAME,
1c97872b UKK	356	},
	357	};
	358
09fb7ad1	359	module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
1c97872b UKK	360
	361	MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
	362	MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
	363	MODULE_LICENSE("GPL v2");