[mirror_ubuntu-bionic-kernel.git] / drivers / rtc / rtc-mc13783.c

/*
 * Real Time Clock driver for Freescale MC13783 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/mc13783.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 "mc13783-rtc"

#define MC13783_RTCTOD	20
#define MC13783_RTCTODA	21
#define MC13783_RTCDAY	22
#define MC13783_RTCDAYA	23

struct mc13783_rtc {
	struct rtc_device *rtc;
	struct mc13783 *mc13783;
	int valid;
};

static int mc13783_rtc_irq_enable_unlocked(struct device *dev,
		unsigned int enabled, int irq)
{
	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	int (*func)(struct mc13783 *mc13783, int irq);

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

	func = enabled ? mc13783_irq_unmask : mc13783_irq_mask;
	return func(priv->mc13783, irq);
}

static int mc13783_rtc_irq_enable(struct device *dev,
		unsigned int enabled, int irq)
{
	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	int ret;

	mc13783_lock(priv->mc13783);

	ret = mc13783_rtc_irq_enable_unlocked(dev, enabled, irq);

	mc13783_unlock(priv->mc13783);

	return ret;
}

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

	mc13783_lock(priv->mc13783);

	if (!priv->valid) {
		ret = -ENODATA;
		goto out;
	}

	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days1);
	if (unlikely(ret))
		goto out;

	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTOD, &seconds);
	if (unlikely(ret))
		goto out;

	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days2);
out:
	mc13783_unlock(priv->mc13783);

	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 mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
{
	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	unsigned int seconds, days;
	unsigned int alarmseconds;
	int ret;

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

	mc13783_lock(priv->mc13783);

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

	if (alarmseconds < 86400) {
		ret = mc13783_reg_write(priv->mc13783,
				MC13783_RTCTODA, 0x1ffff);
		if (unlikely(ret))
			goto out;
	}

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

	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAY, days);
	if (unlikely(ret))
		goto out;

	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, seconds);
	if (unlikely(ret))
		goto out;

	/* restore alarm */
	if (alarmseconds < 86400) {
		ret = mc13783_reg_write(priv->mc13783,
				MC13783_RTCTODA, alarmseconds);
		if (unlikely(ret))
			goto out;
	}

	ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_RTCRST);
	if (unlikely(ret))
		goto out;

	ret = mc13783_irq_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
out:
	priv->valid = !ret;

	mc13783_unlock(priv->mc13783);

	return ret;
}

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

	mc13783_lock(priv->mc13783);

	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &seconds);
	if (unlikely(ret))
		goto out;
	if (seconds >= 86400) {
		ret = -ENODATA;
		goto out;
	}

	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days);
	if (unlikely(ret))
		goto out;

	ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_TODA,
			&enabled, &pending);

out:
	mc13783_unlock(priv->mc13783);

	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 mc13783_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	unsigned long s1970;
	unsigned seconds, days;
	int ret;

	mc13783_lock(priv->mc13783);

	/* disable alarm to prevent false triggering */
	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, 0x1ffff);
	if (unlikely(ret))
		goto out;

	ret = mc13783_irq_ack(priv->mc13783, MC13783_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 = mc13783_rtc_irq_enable_unlocked(dev, alarm->enabled,
			MC13783_IRQ_TODA);
	if (unlikely(ret))
		goto out;

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

	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAYA, days);
	if (unlikely(ret))
		goto out;

	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, seconds);

out:
	mc13783_unlock(priv->mc13783);

	return ret;
}

static irqreturn_t mc13783_rtc_alarm_handler(int irq, void *dev)
{
	struct mc13783_rtc *priv = dev;
	struct mc13783 *mc13783 = priv->mc13783;

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

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

	mc13783_irq_ack(mc13783, irq);

	return IRQ_HANDLED;
}

static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
{
	struct mc13783_rtc *priv = dev;
	struct mc13783 *mc13783 = priv->mc13783;

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

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

	mc13783_irq_ack(mc13783, irq);

	return IRQ_HANDLED;
}

static int mc13783_rtc_update_irq_enable(struct device *dev,
		unsigned int enabled)
{
	return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_1HZ);
}

static int mc13783_rtc_alarm_irq_enable(struct device *dev,
		unsigned int enabled)
{
	return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_TODA);
}

static const struct rtc_class_ops mc13783_rtc_ops = {
	.read_time = mc13783_rtc_read_time,
	.set_mmss = mc13783_rtc_set_mmss,
	.read_alarm = mc13783_rtc_read_alarm,
	.set_alarm = mc13783_rtc_set_alarm,
	.alarm_irq_enable = mc13783_rtc_alarm_irq_enable,
	.update_irq_enable = mc13783_rtc_update_irq_enable,
};

static irqreturn_t mc13783_rtc_reset_handler(int irq, void *dev)
{
	struct mc13783_rtc *priv = dev;
	struct mc13783 *mc13783 = priv->mc13783;

	dev_dbg(&priv->rtc->dev, "RTCRST\n");
	priv->valid = 0;

	mc13783_irq_mask(mc13783, irq);

	return IRQ_HANDLED;
}

static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
{
	int ret;
	struct mc13783_rtc *priv;
	struct mc13783 *mc13783;
	int rtcrst_pending;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	mc13783 = dev_get_drvdata(pdev->dev.parent);
	priv->mc13783 = mc13783;

	platform_set_drvdata(pdev, priv);

	mc13783_lock(mc13783);

	ret = mc13783_irq_request(mc13783, MC13783_IRQ_RTCRST,
			mc13783_rtc_reset_handler, DRIVER_NAME, priv);
	if (ret)
		goto err_reset_irq_request;

	ret = mc13783_irq_status(mc13783, MC13783_IRQ_RTCRST,
			NULL, &rtcrst_pending);
	if (ret)
		goto err_reset_irq_status;

	priv->valid = !rtcrst_pending;

	ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_1HZ,
			mc13783_rtc_update_handler, DRIVER_NAME, priv);
	if (ret)
		goto err_update_irq_request;

	ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_TODA,
			mc13783_rtc_alarm_handler, DRIVER_NAME, priv);
	if (ret)
		goto err_alarm_irq_request;

	priv->rtc = rtc_device_register(pdev->name,
			&pdev->dev, &mc13783_rtc_ops, THIS_MODULE);
	if (IS_ERR(priv->rtc)) {
		ret = PTR_ERR(priv->rtc);

		mc13783_irq_free(mc13783, MC13783_IRQ_TODA, priv);
err_alarm_irq_request:

		mc13783_irq_free(mc13783, MC13783_IRQ_1HZ, priv);
err_update_irq_request:

err_reset_irq_status:

		mc13783_irq_free(mc13783, MC13783_IRQ_RTCRST, priv);
err_reset_irq_request:

		platform_set_drvdata(pdev, NULL);
		kfree(priv);
	}

	mc13783_unlock(mc13783);

	return ret;
}

static int __devexit mc13783_rtc_remove(struct platform_device *pdev)
{
	struct mc13783_rtc *priv = platform_get_drvdata(pdev);

	mc13783_lock(priv->mc13783);

	rtc_device_unregister(priv->rtc);

	mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
	mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
	mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);

	mc13783_unlock(priv->mc13783);

	platform_set_drvdata(pdev, NULL);

	kfree(priv);

	return 0;
}

static struct platform_driver mc13783_rtc_driver = {
	.remove = __devexit_p(mc13783_rtc_remove),
	.driver = {
		.name = DRIVER_NAME,
		.owner = THIS_MODULE,
	},
};

static int __init mc13783_rtc_init(void)
{
	return platform_driver_probe(&mc13783_rtc_driver, &mc13783_rtc_probe);
}
module_init(mc13783_rtc_init);

static void __exit mc13783_rtc_exit(void)
{
	platform_driver_unregister(&mc13783_rtc_driver);
}
module_exit(mc13783_rtc_exit);

MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
MODULE_DESCRIPTION("RTC driver for Freescale MC13783 PMIC");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);
Commit	Line	Data
43299f28 UKK	1	/*
	2	* Real Time Clock driver for Freescale MC13783 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/mc13783.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
5a0e3ad6	16	#include <linux/slab.h>
43299f28 UKK	17	#include <linux/rtc.h>
	18
	19	#define DRIVER_NAME "mc13783-rtc"
	20
	21	#define MC13783_RTCTOD 20
	22	#define MC13783_RTCTODA 21
	23	#define MC13783_RTCDAY 22
	24	#define MC13783_RTCDAYA 23
	25
	26	struct mc13783_rtc {
	27	struct rtc_device *rtc;
	28	struct mc13783 *mc13783;
	29	int valid;
	30	};
	31
9407351d UKK	32	static int mc13783_rtc_irq_enable_unlocked(struct device *dev,
	33	unsigned int enabled, int irq)
	34	{
	35	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	36	int (func)(struct mc13783 mc13783, int irq);
	37
	38	if (!priv->valid)
	39	return -ENODATA;
	40
	41	func = enabled ? mc13783_irq_unmask : mc13783_irq_mask;
	42	return func(priv->mc13783, irq);
	43	}
	44
	45	static int mc13783_rtc_irq_enable(struct device *dev,
	46	unsigned int enabled, int irq)
	47	{
	48	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	49	int ret;
	50
	51	mc13783_lock(priv->mc13783);
	52
	53	ret = mc13783_rtc_irq_enable_unlocked(dev, enabled, irq);
	54
	55	mc13783_unlock(priv->mc13783);
	56
	57	return ret;
	58	}
	59
43299f28 UKK	60	static int mc13783_rtc_read_time(struct device dev, struct rtc_time tm)
	61	{
	62	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	63	unsigned int seconds, days1, days2;
	64	unsigned long s1970;
	65	int ret;
	66
	67	mc13783_lock(priv->mc13783);
	68
	69	if (!priv->valid) {
	70	ret = -ENODATA;
	71	goto out;
	72	}
	73
	74	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days1);
	75	if (unlikely(ret))
	76	goto out;
	77
	78	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTOD, &seconds);
	79	if (unlikely(ret))
	80	goto out;
	81
	82	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days2);
	83	out:
	84	mc13783_unlock(priv->mc13783);
	85
	86	if (ret)
	87	return ret;
	88
	89	if (days2 == days1 + 1) {
	90	if (seconds >= 86400 / 2)
	91	days2 = days1;
	92	else
	93	days1 = days2;
	94	}
	95
	96	if (days1 != days2)
	97	return -EIO;
	98
	99	s1970 = days1 * 86400 + seconds;
	100
	101	rtc_time_to_tm(s1970, tm);
	102
	103	return rtc_valid_tm(tm);
	104	}
	105
	106	static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
	107	{
	108	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	109	unsigned int seconds, days;
9407351d	110	unsigned int alarmseconds;
43299f28 UKK	111	int ret;
	112
	113	seconds = secs % 86400;
	114	days = secs / 86400;
	115
	116	mc13783_lock(priv->mc13783);
	117
	118	/*
9407351d UKK	119	* temporarily invalidate alarm to prevent triggering it when the day is
	120	* already updated while the time isn't yet.
	121	*/
	122	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &alarmseconds);
	123	if (unlikely(ret))
	124	goto out;
	125
	126	if (alarmseconds < 86400) {
	127	ret = mc13783_reg_write(priv->mc13783,
	128	MC13783_RTCTODA, 0x1ffff);
	129	if (unlikely(ret))
	130	goto out;
	131	}
	132
	133	/*
	134	* write seconds=0 to prevent a day switch between writing days
43299f28 UKK	135	* and seconds below
	136	*/
	137	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, 0);
	138	if (unlikely(ret))
	139	goto out;
	140
	141	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAY, days);
	142	if (unlikely(ret))
	143	goto out;
	144
	145	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, seconds);
	146	if (unlikely(ret))
	147	goto out;
	148
9407351d UKK	149	/* restore alarm */
	150	if (alarmseconds < 86400) {
	151	ret = mc13783_reg_write(priv->mc13783,
	152	MC13783_RTCTODA, alarmseconds);
	153	if (unlikely(ret))
	154	goto out;
	155	}
	156
4dd4dd65	157	ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_RTCRST);
43299f28 UKK	158	if (unlikely(ret))
	159	goto out;
	160
4dd4dd65	161	ret = mc13783_irq_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
43299f28 UKK	162	out:
	163	priv->valid = !ret;
	164
	165	mc13783_unlock(priv->mc13783);
	166
	167	return ret;
	168	}
	169
9407351d UKK	170	static int mc13783_rtc_read_alarm(struct device dev, struct rtc_wkalrm alarm)
	171	{
	172	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	173	unsigned seconds, days;
	174	unsigned long s1970;
	175	int enabled, pending;
	176	int ret;
	177
	178	mc13783_lock(priv->mc13783);
	179
	180	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &seconds);
	181	if (unlikely(ret))
	182	goto out;
	183	if (seconds >= 86400) {
	184	ret = -ENODATA;
	185	goto out;
	186	}
	187
	188	ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days);
	189	if (unlikely(ret))
	190	goto out;
	191
	192	ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_TODA,
	193	&enabled, &pending);
	194
	195	out:
	196	mc13783_unlock(priv->mc13783);
	197
	198	if (ret)
	199	return ret;
	200
	201	alarm->enabled = enabled;
	202	alarm->pending = pending;
	203
	204	s1970 = days * 86400 + seconds;
	205
	206	rtc_time_to_tm(s1970, &alarm->time);
	207	dev_dbg(dev, "%s: %lu\n", __func__, s1970);
	208
	209	return 0;
	210	}
	211
	212	static int mc13783_rtc_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	213	{
	214	struct mc13783_rtc *priv = dev_get_drvdata(dev);
	215	unsigned long s1970;
	216	unsigned seconds, days;
	217	int ret;
	218
	219	mc13783_lock(priv->mc13783);
	220
	221	/* disable alarm to prevent false triggering */
	222	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, 0x1ffff);
	223	if (unlikely(ret))
	224	goto out;
	225
	226	ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TODA);
	227	if (unlikely(ret))
	228	goto out;
	229
	230	ret = rtc_tm_to_time(&alarm->time, &s1970);
	231	if (unlikely(ret))
	232	goto out;
	233
234	dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
235	s1970);
236
237	ret = mc13783_rtc_irq_enable_unlocked(dev, alarm->enabled,
238	MC13783_IRQ_TODA);
239	if (unlikely(ret))
240	goto out;
241
242	seconds = s1970 % 86400;
243	days = s1970 / 86400;
244
245	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAYA, days);
246	if (unlikely(ret))
247	goto out;
248
249	ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, seconds);
250
251	out:
252	mc13783_unlock(priv->mc13783);
253
254	return ret;
255	}
256
257	static irqreturn_t mc13783_rtc_alarm_handler(int irq, void *dev)
258	{
259	struct mc13783_rtc *priv = dev;
260	struct mc13783 *mc13783 = priv->mc13783;
261
262	dev_dbg(&priv->rtc->dev, "Alarm\n");
263
264	rtc_update_irq(priv->rtc, 1, RTC_IRQF \| RTC_AF);
265
266	mc13783_irq_ack(mc13783, irq);
267
268	return IRQ_HANDLED;
269	}
270
43299f28 UKK	271	static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
	272	{
	273	struct mc13783_rtc *priv = dev;
	274	struct mc13783 *mc13783 = priv->mc13783;
	275
	276	dev_dbg(&priv->rtc->dev, "1HZ\n");
	277
	278	rtc_update_irq(priv->rtc, 1, RTC_IRQF \| RTC_UF);
	279
4dd4dd65	280	mc13783_irq_ack(mc13783, irq);
43299f28 UKK	281
	282	return IRQ_HANDLED;
	283	}
	284
	285	static int mc13783_rtc_update_irq_enable(struct device *dev,
	286	unsigned int enabled)
	287	{
9407351d UKK	288	return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_1HZ);
9407351d UKK	289	}
43299f28	290
9407351d UKK	291	static int mc13783_rtc_alarm_irq_enable(struct device *dev,
	292	unsigned int enabled)
	293	{
	294	return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_TODA);
43299f28 UKK	295	}
	296
	297	static const struct rtc_class_ops mc13783_rtc_ops = {
	298	.read_time = mc13783_rtc_read_time,
	299	.set_mmss = mc13783_rtc_set_mmss,
9407351d UKK	300	.read_alarm = mc13783_rtc_read_alarm,
	301	.set_alarm = mc13783_rtc_set_alarm,
	302	.alarm_irq_enable = mc13783_rtc_alarm_irq_enable,
43299f28 UKK	303	.update_irq_enable = mc13783_rtc_update_irq_enable,
	304	};
	305
	306	static irqreturn_t mc13783_rtc_reset_handler(int irq, void *dev)
	307	{
	308	struct mc13783_rtc *priv = dev;
	309	struct mc13783 *mc13783 = priv->mc13783;
	310
	311	dev_dbg(&priv->rtc->dev, "RTCRST\n");
	312	priv->valid = 0;
	313
4dd4dd65	314	mc13783_irq_mask(mc13783, irq);
43299f28 UKK	315
	316	return IRQ_HANDLED;
	317	}
	318
	319	static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
	320	{
	321	int ret;
	322	struct mc13783_rtc *priv;
05731b97	323	struct mc13783 *mc13783;
4c014e87	324	int rtcrst_pending;
43299f28 UKK	325
	326	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	327	if (!priv)
	328	return -ENOMEM;
	329
05731b97 UKK	330	mc13783 = dev_get_drvdata(pdev->dev.parent);
	331	priv->mc13783 = mc13783;
	332
43299f28 UKK	333	platform_set_drvdata(pdev, priv);
43299f28 UKK	334
05731b97	335	mc13783_lock(mc13783);
43299f28	336
05731b97	337	ret = mc13783_irq_request(mc13783, MC13783_IRQ_RTCRST,
43299f28 UKK	338	mc13783_rtc_reset_handler, DRIVER_NAME, priv);
	339	if (ret)
	340	goto err_reset_irq_request;
	341
05731b97	342	ret = mc13783_irq_status(mc13783, MC13783_IRQ_RTCRST,
4c014e87 UKK	343	NULL, &rtcrst_pending);
	344	if (ret)
	345	goto err_reset_irq_status;
	346
	347	priv->valid = !rtcrst_pending;
	348
05731b97	349	ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_1HZ,
43299f28 UKK	350	mc13783_rtc_update_handler, DRIVER_NAME, priv);
	351	if (ret)
	352	goto err_update_irq_request;
	353
05731b97	354	ret = mc13783_irq_request_nounmask(mc13783, MC13783_IRQ_TODA,
9407351d UKK	355	mc13783_rtc_alarm_handler, DRIVER_NAME, priv);
	356	if (ret)
	357	goto err_alarm_irq_request;
	358
43299f28 UKK	359	priv->rtc = rtc_device_register(pdev->name,
43299f28 UKK	360	&pdev->dev, &mc13783_rtc_ops, THIS_MODULE);
43299f28 UKK	361	if (IS_ERR(priv->rtc)) {
	362	ret = PTR_ERR(priv->rtc);
	363
05731b97	364	mc13783_irq_free(mc13783, MC13783_IRQ_TODA, priv);
9407351d UKK	365	err_alarm_irq_request:
9407351d UKK	366
05731b97	367	mc13783_irq_free(mc13783, MC13783_IRQ_1HZ, priv);
43299f28 UKK	368	err_update_irq_request:
43299f28 UKK	369
4c014e87 UKK	370	err_reset_irq_status:
4c014e87 UKK	371
05731b97	372	mc13783_irq_free(mc13783, MC13783_IRQ_RTCRST, priv);
43299f28 UKK	373	err_reset_irq_request:
43299f28 UKK	374
43299f28 UKK	375	platform_set_drvdata(pdev, NULL);
	376	kfree(priv);
	377	}
	378
05731b97	379	mc13783_unlock(mc13783);
4c014e87	380
43299f28 UKK	381	return ret;
	382	}
	383
	384	static int __devexit mc13783_rtc_remove(struct platform_device *pdev)
	385	{
	386	struct mc13783_rtc *priv = platform_get_drvdata(pdev);
	387
43299f28 UKK	388	mc13783_lock(priv->mc13783);
43299f28 UKK	389
4c014e87 UKK	390	rtc_device_unregister(priv->rtc);
4c014e87 UKK	391
9407351d	392	mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
43299f28 UKK	393	mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
	394	mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
	395
	396	mc13783_unlock(priv->mc13783);
	397
	398	platform_set_drvdata(pdev, NULL);
	399
	400	kfree(priv);
	401
	402	return 0;
	403	}
	404
	405	static struct platform_driver mc13783_rtc_driver = {
	406	.remove = __devexit_p(mc13783_rtc_remove),
	407	.driver = {
	408	.name = DRIVER_NAME,
	409	.owner = THIS_MODULE,
	410	},
	411	};
	412
	413	static int __init mc13783_rtc_init(void)
	414	{
	415	return platform_driver_probe(&mc13783_rtc_driver, &mc13783_rtc_probe);
	416	}
	417	module_init(mc13783_rtc_init);
	418
	419	static void __exit mc13783_rtc_exit(void)
	420	{
	421	platform_driver_unregister(&mc13783_rtc_driver);
	422	}
	423	module_exit(mc13783_rtc_exit);
	424
	425	MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
	426	MODULE_DESCRIPTION("RTC driver for Freescale MC13783 PMIC");
	427	MODULE_LICENSE("GPL v2");
	428	MODULE_ALIAS("platform:" DRIVER_NAME);