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

/*
 * TX4939 internal RTC driver
 * Based on RBTX49xx patch from CELF patch archive.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * (C) Copyright TOSHIBA CORPORATION 2005-2007
 */
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/gfp.h>
#include <asm/txx9/tx4939.h>

struct tx4939rtc_plat_data {
	struct rtc_device *rtc;
	struct tx4939_rtc_reg __iomem *rtcreg;
	spinlock_t lock;
};

static struct tx4939rtc_plat_data *get_tx4939rtc_plat_data(struct device *dev)
{
	return platform_get_drvdata(to_platform_device(dev));
}

static int tx4939_rtc_cmd(struct tx4939_rtc_reg __iomem *rtcreg, int cmd)
{
	int i = 0;

	__raw_writel(cmd, &rtcreg->ctl);
	/* This might take 30us (next 32.768KHz clock) */
	while (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_BUSY) {
		/* timeout on approx. 100us (@ GBUS200MHz) */
		if (i++ > 200 * 100)
			return -EBUSY;
		cpu_relax();
	}
	return 0;
}

static int tx4939_rtc_set_mmss(struct device *dev, unsigned long secs)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	int i, ret;
	unsigned char buf[6];

	buf[0] = 0;
	buf[1] = 0;
	buf[2] = secs;
	buf[3] = secs >> 8;
	buf[4] = secs >> 16;
	buf[5] = secs >> 24;
	spin_lock_irq(&pdata->lock);
	__raw_writel(0, &rtcreg->adr);
	for (i = 0; i < 6; i++)
		__raw_writel(buf[i], &rtcreg->dat);
	ret = tx4939_rtc_cmd(rtcreg,
			     TX4939_RTCCTL_COMMAND_SETTIME |
			     (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
	spin_unlock_irq(&pdata->lock);
	return ret;
}

static int tx4939_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	int i, ret;
	unsigned long sec;
	unsigned char buf[6];

	spin_lock_irq(&pdata->lock);
	ret = tx4939_rtc_cmd(rtcreg,
			     TX4939_RTCCTL_COMMAND_GETTIME |
			     (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
	if (ret) {
		spin_unlock_irq(&pdata->lock);
		return ret;
	}
	__raw_writel(2, &rtcreg->adr);
	for (i = 2; i < 6; i++)
		buf[i] = __raw_readl(&rtcreg->dat);
	spin_unlock_irq(&pdata->lock);
	sec = ((unsigned long)buf[5] << 24) | (buf[4] << 16) |
		(buf[3] << 8) | buf[2];
	rtc_time_to_tm(sec, tm);
	return rtc_valid_tm(tm);
}

static int tx4939_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	int i, ret;
	unsigned long sec;
	unsigned char buf[6];

	if (alrm->time.tm_sec < 0 ||
	    alrm->time.tm_min < 0 ||
	    alrm->time.tm_hour < 0 ||
	    alrm->time.tm_mday < 0 ||
	    alrm->time.tm_mon < 0 ||
	    alrm->time.tm_year < 0)
		return -EINVAL;
	rtc_tm_to_time(&alrm->time, &sec);
	buf[0] = 0;
	buf[1] = 0;
	buf[2] = sec;
	buf[3] = sec >> 8;
	buf[4] = sec >> 16;
	buf[5] = sec >> 24;
	spin_lock_irq(&pdata->lock);
	__raw_writel(0, &rtcreg->adr);
	for (i = 0; i < 6; i++)
		__raw_writel(buf[i], &rtcreg->dat);
	ret = tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_SETALARM |
			     (alrm->enabled ? TX4939_RTCCTL_ALME : 0));
	spin_unlock_irq(&pdata->lock);
	return ret;
}

static int tx4939_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	int i, ret;
	unsigned long sec;
	unsigned char buf[6];
	u32 ctl;

	spin_lock_irq(&pdata->lock);
	ret = tx4939_rtc_cmd(rtcreg,
			     TX4939_RTCCTL_COMMAND_GETALARM |
			     (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
	if (ret) {
		spin_unlock_irq(&pdata->lock);
		return ret;
	}
	__raw_writel(2, &rtcreg->adr);
	for (i = 2; i < 6; i++)
		buf[i] = __raw_readl(&rtcreg->dat);
	ctl = __raw_readl(&rtcreg->ctl);
	alrm->enabled = (ctl & TX4939_RTCCTL_ALME) ? 1 : 0;
	alrm->pending = (ctl & TX4939_RTCCTL_ALMD) ? 1 : 0;
	spin_unlock_irq(&pdata->lock);
	sec = ((unsigned long)buf[5] << 24) | (buf[4] << 16) |
		(buf[3] << 8) | buf[2];
	rtc_time_to_tm(sec, &alrm->time);
	return rtc_valid_tm(&alrm->time);
}

static int tx4939_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);

	spin_lock_irq(&pdata->lock);
	tx4939_rtc_cmd(pdata->rtcreg,
		       TX4939_RTCCTL_COMMAND_NOP |
		       (enabled ? TX4939_RTCCTL_ALME : 0));
	spin_unlock_irq(&pdata->lock);
	return 0;
}

static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id)
{
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev_id);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	unsigned long events = RTC_IRQF;

	spin_lock(&pdata->lock);
	if (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALMD) {
		events |= RTC_AF;
		tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_NOP);
	}
	spin_unlock(&pdata->lock);
	rtc_update_irq(pdata->rtc, 1, events);

	return IRQ_HANDLED;
}

static const struct rtc_class_ops tx4939_rtc_ops = {
	.read_time		= tx4939_rtc_read_time,
	.read_alarm		= tx4939_rtc_read_alarm,
	.set_alarm		= tx4939_rtc_set_alarm,
	.set_mmss		= tx4939_rtc_set_mmss,
	.alarm_irq_enable	= tx4939_rtc_alarm_irq_enable,
};

static ssize_t tx4939_rtc_nvram_read(struct file *filp, struct kobject *kobj,
				     struct bin_attribute *bin_attr,
				     char *buf, loff_t pos, size_t size)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	ssize_t count;

	spin_lock_irq(&pdata->lock);
	for (count = 0; count < size; count++) {
		__raw_writel(pos++, &rtcreg->adr);
		*buf++ = __raw_readl(&rtcreg->dat);
	}
	spin_unlock_irq(&pdata->lock);
	return count;
}

static ssize_t tx4939_rtc_nvram_write(struct file *filp, struct kobject *kobj,
				      struct bin_attribute *bin_attr,
				      char *buf, loff_t pos, size_t size)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	ssize_t count;

	spin_lock_irq(&pdata->lock);
	for (count = 0; count < size; count++) {
		__raw_writel(pos++, &rtcreg->adr);
		__raw_writel(*buf++, &rtcreg->dat);
	}
	spin_unlock_irq(&pdata->lock);
	return count;
}

static struct bin_attribute tx4939_rtc_nvram_attr = {
	.attr = {
		.name = "nvram",
		.mode = S_IRUGO | S_IWUSR,
	},
	.size = TX4939_RTC_REG_RAMSIZE,
	.read = tx4939_rtc_nvram_read,
	.write = tx4939_rtc_nvram_write,
};

static int __init tx4939_rtc_probe(struct platform_device *pdev)
{
	struct rtc_device *rtc;
	struct tx4939rtc_plat_data *pdata;
	struct resource *res;
	int irq, ret;

	irq = platform_get_irq(pdev, 0);
	if (irq < 0)
		return -ENODEV;
	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return -ENOMEM;
	platform_set_drvdata(pdev, pdata);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	pdata->rtcreg = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(pdata->rtcreg))
		return PTR_ERR(pdata->rtcreg);

	spin_lock_init(&pdata->lock);
	tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
	if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
			     0, pdev->name, &pdev->dev) < 0)
		return -EBUSY;
	rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
				  &tx4939_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc))
		return PTR_ERR(rtc);
	pdata->rtc = rtc;
	ret = sysfs_create_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);

	return ret;
}

static int __exit tx4939_rtc_remove(struct platform_device *pdev)
{
	struct tx4939rtc_plat_data *pdata = platform_get_drvdata(pdev);

	sysfs_remove_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
	spin_lock_irq(&pdata->lock);
	tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
	spin_unlock_irq(&pdata->lock);
	return 0;
}

static struct platform_driver tx4939_rtc_driver = {
	.remove		= __exit_p(tx4939_rtc_remove),
	.driver		= {
		.name	= "tx4939rtc",
	},
};

module_platform_driver_probe(tx4939_rtc_driver, tx4939_rtc_probe);

MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
MODULE_DESCRIPTION("TX4939 internal RTC driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:tx4939rtc");
Commit	Line	Data
0e149233 AN	1	/*
	2	* TX4939 internal RTC driver
	3	* Based on RBTX49xx patch from CELF patch archive.
	4	*
	5	* This file is subject to the terms and conditions of the GNU General Public
	6	* License. See the file "COPYING" in the main directory of this archive
	7	* for more details.
	8	*
	9	* (C) Copyright TOSHIBA CORPORATION 2005-2007
	10	*/
	11	#include <linux/rtc.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/interrupt.h>
2113852b	14	#include <linux/module.h>
0e149233	15	#include <linux/io.h>
5a0e3ad6	16	#include <linux/gfp.h>
0e149233 AN	17	#include <asm/txx9/tx4939.h>
	18
	19	struct tx4939rtc_plat_data {
	20	struct rtc_device *rtc;
	21	struct tx4939_rtc_reg __iomem *rtcreg;
af69a180	22	spinlock_t lock;
0e149233 AN	23	};
	24
	25	static struct tx4939rtc_plat_data get_tx4939rtc_plat_data(struct device dev)
	26	{
	27	return platform_get_drvdata(to_platform_device(dev));
	28	}
	29
	30	static int tx4939_rtc_cmd(struct tx4939_rtc_reg __iomem *rtcreg, int cmd)
	31	{
	32	int i = 0;
	33
	34	__raw_writel(cmd, &rtcreg->ctl);
	35	/* This might take 30us (next 32.768KHz clock) */
	36	while (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_BUSY) {
	37	/* timeout on approx. 100us (@ GBUS200MHz) */
	38	if (i++ > 200 * 100)
	39	return -EBUSY;
	40	cpu_relax();
	41	}
	42	return 0;
	43	}
	44
	45	static int tx4939_rtc_set_mmss(struct device *dev, unsigned long secs)
	46	{
	47	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	48	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	49	int i, ret;
	50	unsigned char buf[6];
	51
	52	buf[0] = 0;
	53	buf[1] = 0;
	54	buf[2] = secs;
	55	buf[3] = secs >> 8;
	56	buf[4] = secs >> 16;
	57	buf[5] = secs >> 24;
af69a180	58	spin_lock_irq(&pdata->lock);
0e149233 AN	59	__raw_writel(0, &rtcreg->adr);
	60	for (i = 0; i < 6; i++)
	61	__raw_writel(buf[i], &rtcreg->dat);
	62	ret = tx4939_rtc_cmd(rtcreg,
	63	TX4939_RTCCTL_COMMAND_SETTIME \|
	64	(__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
af69a180	65	spin_unlock_irq(&pdata->lock);
0e149233 AN	66	return ret;
	67	}
	68
	69	static int tx4939_rtc_read_time(struct device dev, struct rtc_time tm)
	70	{
	71	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	72	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	73	int i, ret;
	74	unsigned long sec;
	75	unsigned char buf[6];
	76
af69a180	77	spin_lock_irq(&pdata->lock);
0e149233 AN	78	ret = tx4939_rtc_cmd(rtcreg,
	79	TX4939_RTCCTL_COMMAND_GETTIME \|
	80	(__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
	81	if (ret) {
af69a180	82	spin_unlock_irq(&pdata->lock);
0e149233 AN	83	return ret;
	84	}
	85	__raw_writel(2, &rtcreg->adr);
	86	for (i = 2; i < 6; i++)
	87	buf[i] = __raw_readl(&rtcreg->dat);
af69a180	88	spin_unlock_irq(&pdata->lock);
974dbda8 CIK	89	sec = ((unsigned long)buf[5] << 24) \| (buf[4] << 16) \|
974dbda8 CIK	90	(buf[3] << 8) \| buf[2];
0e149233 AN	91	rtc_time_to_tm(sec, tm);
	92	return rtc_valid_tm(tm);
	93	}
	94
	95	static int tx4939_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
	96	{
	97	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	98	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	99	int i, ret;
	100	unsigned long sec;
	101	unsigned char buf[6];
	102
	103	if (alrm->time.tm_sec < 0 \|\|
	104	alrm->time.tm_min < 0 \|\|
	105	alrm->time.tm_hour < 0 \|\|
	106	alrm->time.tm_mday < 0 \|\|
	107	alrm->time.tm_mon < 0 \|\|
	108	alrm->time.tm_year < 0)
	109	return -EINVAL;
	110	rtc_tm_to_time(&alrm->time, &sec);
	111	buf[0] = 0;
	112	buf[1] = 0;
	113	buf[2] = sec;
	114	buf[3] = sec >> 8;
	115	buf[4] = sec >> 16;
	116	buf[5] = sec >> 24;
af69a180	117	spin_lock_irq(&pdata->lock);
0e149233 AN	118	__raw_writel(0, &rtcreg->adr);
	119	for (i = 0; i < 6; i++)
	120	__raw_writel(buf[i], &rtcreg->dat);
	121	ret = tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_SETALARM \|
	122	(alrm->enabled ? TX4939_RTCCTL_ALME : 0));
af69a180	123	spin_unlock_irq(&pdata->lock);
0e149233 AN	124	return ret;
	125	}
	126
	127	static int tx4939_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
	128	{
	129	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	130	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	131	int i, ret;
	132	unsigned long sec;
	133	unsigned char buf[6];
	134	u32 ctl;
	135
af69a180	136	spin_lock_irq(&pdata->lock);
0e149233 AN	137	ret = tx4939_rtc_cmd(rtcreg,
	138	TX4939_RTCCTL_COMMAND_GETALARM \|
	139	(__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
	140	if (ret) {
af69a180	141	spin_unlock_irq(&pdata->lock);
0e149233 AN	142	return ret;
	143	}
	144	__raw_writel(2, &rtcreg->adr);
	145	for (i = 2; i < 6; i++)
	146	buf[i] = __raw_readl(&rtcreg->dat);
	147	ctl = __raw_readl(&rtcreg->ctl);
	148	alrm->enabled = (ctl & TX4939_RTCCTL_ALME) ? 1 : 0;
	149	alrm->pending = (ctl & TX4939_RTCCTL_ALMD) ? 1 : 0;
af69a180	150	spin_unlock_irq(&pdata->lock);
974dbda8 CIK	151	sec = ((unsigned long)buf[5] << 24) \| (buf[4] << 16) \|
974dbda8 CIK	152	(buf[3] << 8) \| buf[2];
0e149233 AN	153	rtc_time_to_tm(sec, &alrm->time);
	154	return rtc_valid_tm(&alrm->time);
	155	}
	156
	157	static int tx4939_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
	158	{
	159	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	160
af69a180	161	spin_lock_irq(&pdata->lock);
0e149233 AN	162	tx4939_rtc_cmd(pdata->rtcreg,
	163	TX4939_RTCCTL_COMMAND_NOP \|
	164	(enabled ? TX4939_RTCCTL_ALME : 0));
af69a180	165	spin_unlock_irq(&pdata->lock);
0e149233 AN	166	return 0;
	167	}
	168
	169	static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id)
	170	{
	171	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev_id);
	172	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	173	unsigned long events = RTC_IRQF;
	174
af69a180	175	spin_lock(&pdata->lock);
0e149233 AN	176	if (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALMD) {
	177	events \|= RTC_AF;
	178	tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_NOP);
	179	}
af69a180	180	spin_unlock(&pdata->lock);
0d71915d AS	181	rtc_update_irq(pdata->rtc, 1, events);
0d71915d AS	182
0e149233 AN	183	return IRQ_HANDLED;
	184	}
	185
	186	static const struct rtc_class_ops tx4939_rtc_ops = {
	187	.read_time = tx4939_rtc_read_time,
	188	.read_alarm = tx4939_rtc_read_alarm,
	189	.set_alarm = tx4939_rtc_set_alarm,
	190	.set_mmss = tx4939_rtc_set_mmss,
	191	.alarm_irq_enable = tx4939_rtc_alarm_irq_enable,
	192	};
	193
2c3c8bea	194	static ssize_t tx4939_rtc_nvram_read(struct file filp, struct kobject kobj,
0e149233 AN	195	struct bin_attribute *bin_attr,
	196	char *buf, loff_t pos, size_t size)
	197	{
	198	struct device *dev = container_of(kobj, struct device, kobj);
	199	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	200	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	201	ssize_t count;
	202
af69a180	203	spin_lock_irq(&pdata->lock);
824625d3	204	for (count = 0; count < size; count++) {
0e149233 AN	205	__raw_writel(pos++, &rtcreg->adr);
	206	*buf++ = __raw_readl(&rtcreg->dat);
	207	}
af69a180	208	spin_unlock_irq(&pdata->lock);
0e149233 AN	209	return count;
	210	}
	211
2c3c8bea	212	static ssize_t tx4939_rtc_nvram_write(struct file filp, struct kobject kobj,
0e149233 AN	213	struct bin_attribute *bin_attr,
	214	char *buf, loff_t pos, size_t size)
	215	{
	216	struct device *dev = container_of(kobj, struct device, kobj);
	217	struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
	218	struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
	219	ssize_t count;
	220
af69a180	221	spin_lock_irq(&pdata->lock);
824625d3	222	for (count = 0; count < size; count++) {
0e149233 AN	223	__raw_writel(pos++, &rtcreg->adr);
	224	__raw_writel(*buf++, &rtcreg->dat);
	225	}
af69a180	226	spin_unlock_irq(&pdata->lock);
0e149233 AN	227	return count;
	228	}
	229
	230	static struct bin_attribute tx4939_rtc_nvram_attr = {
	231	.attr = {
	232	.name = "nvram",
	233	.mode = S_IRUGO \| S_IWUSR,
	234	},
	235	.size = TX4939_RTC_REG_RAMSIZE,
	236	.read = tx4939_rtc_nvram_read,
	237	.write = tx4939_rtc_nvram_write,
	238	};
	239
	240	static int __init tx4939_rtc_probe(struct platform_device *pdev)
	241	{
	242	struct rtc_device *rtc;
	243	struct tx4939rtc_plat_data *pdata;
	244	struct resource *res;
	245	int irq, ret;
	246
0e149233 AN	247	irq = platform_get_irq(pdev, 0);
	248	if (irq < 0)
	249	return -ENODEV;
	250	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	251	if (!pdata)
	252	return -ENOMEM;
	253	platform_set_drvdata(pdev, pdata);
	254
7c1d69ee JL	255	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	256	pdata->rtcreg = devm_ioremap_resource(&pdev->dev, res);
	257	if (IS_ERR(pdata->rtcreg))
	258	return PTR_ERR(pdata->rtcreg);
0e149233	259
af69a180	260	spin_lock_init(&pdata->lock);
0e149233 AN	261	tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
0e149233 AN	262	if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
2f6e5f94	263	0, pdev->name, &pdev->dev) < 0)
0e149233	264	return -EBUSY;
e38fc305	265	rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
0e149233 AN	266	&tx4939_rtc_ops, THIS_MODULE);
	267	if (IS_ERR(rtc))
	268	return PTR_ERR(rtc);
	269	pdata->rtc = rtc;
	270	ret = sysfs_create_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
e38fc305	271
0e149233 AN	272	return ret;
	273	}
	274
	275	static int __exit tx4939_rtc_remove(struct platform_device *pdev)
	276	{
	277	struct tx4939rtc_plat_data *pdata = platform_get_drvdata(pdev);
0e149233	278
0e149233	279	sysfs_remove_bin_file(&pdev->dev.kobj, &tx4939_rtc_nvram_attr);
af69a180 AN	280	spin_lock_irq(&pdata->lock);
	281	tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
	282	spin_unlock_irq(&pdata->lock);
0e149233 AN	283	return 0;
	284	}
	285
	286	static struct platform_driver tx4939_rtc_driver = {
	287	.remove = __exit_p(tx4939_rtc_remove),
	288	.driver = {
	289	.name = "tx4939rtc",
0e149233 AN	290	},
	291	};
	292
80f1def4	293	module_platform_driver_probe(tx4939_rtc_driver, tx4939_rtc_probe);
0e149233 AN	294
	295	MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
	296	MODULE_DESCRIPTION("TX4939 internal RTC driver");
	297	MODULE_LICENSE("GPL");
	298	MODULE_ALIAS("platform:tx4939rtc");