[linux.git] / drivers / rtc / rtc-stmp3xxx.c

/*
 * Freescale STMP37XX/STMP378X Real Time Clock driver
 *
 * Copyright (c) 2007 Sigmatel, Inc.
 * Peter Hartley, <[email protected]>
 *
 * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
 * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
 * Copyright 2011 Wolfram Sang, Pengutronix e.K.
 */

/*
 * The code contained herein is licensed under the GNU General Public
 * License. You may obtain a copy of the GNU General Public License
 * Version 2 or later at the following locations:
 *
 * http://www.opensource.org/licenses/gpl-license.html
 * http://www.gnu.org/copyleft/gpl.html
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/of_device.h>

#include <mach/common.h>

#define STMP3XXX_RTC_CTRL			0x0
#define STMP3XXX_RTC_CTRL_SET			0x4
#define STMP3XXX_RTC_CTRL_CLR			0x8
#define STMP3XXX_RTC_CTRL_ALARM_IRQ_EN		0x00000001
#define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN	0x00000002
#define STMP3XXX_RTC_CTRL_ALARM_IRQ		0x00000004

#define STMP3XXX_RTC_STAT			0x10
#define STMP3XXX_RTC_STAT_STALE_SHIFT		16
#define STMP3XXX_RTC_STAT_RTC_PRESENT		0x80000000

#define STMP3XXX_RTC_SECONDS			0x30

#define STMP3XXX_RTC_ALARM			0x40

#define STMP3XXX_RTC_PERSISTENT0		0x60
#define STMP3XXX_RTC_PERSISTENT0_SET		0x64
#define STMP3XXX_RTC_PERSISTENT0_CLR		0x68
#define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN	0x00000002
#define STMP3XXX_RTC_PERSISTENT0_ALARM_EN	0x00000004
#define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE	0x00000080

struct stmp3xxx_rtc_data {
	struct rtc_device *rtc;
	void __iomem *io;
	int irq_alarm;
};

static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
{
	/*
	 * The datasheet doesn't say which way round the
	 * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
	 * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
	 */
	while (readl(rtc_data->io + STMP3XXX_RTC_STAT) &
			(0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT))
		cpu_relax();
}

/* Time read/write */
static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
{
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

	stmp3xxx_wait_time(rtc_data);
	rtc_time_to_tm(readl(rtc_data->io + STMP3XXX_RTC_SECONDS), rtc_tm);
	return 0;
}

static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t)
{
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

	writel(t, rtc_data->io + STMP3XXX_RTC_SECONDS);
	stmp3xxx_wait_time(rtc_data);
	return 0;
}

/* interrupt(s) handler */
static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id)
{
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id);
	u32 status = readl(rtc_data->io + STMP3XXX_RTC_CTRL);

	if (status & STMP3XXX_RTC_CTRL_ALARM_IRQ) {
		writel(STMP3XXX_RTC_CTRL_ALARM_IRQ,
				rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
		rtc_update_irq(rtc_data->rtc, 1, RTC_AF | RTC_IRQF);
		return IRQ_HANDLED;
	}

	return IRQ_NONE;
}

static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

	if (enabled) {
		writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
				STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN,
				rtc_data->io + STMP3XXX_RTC_PERSISTENT0_SET);
		writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
				rtc_data->io + STMP3XXX_RTC_CTRL_SET);
	} else {
		writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
				STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN,
				rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
		writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
				rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
	}
	return 0;
}

static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

	rtc_time_to_tm(readl(rtc_data->io + STMP3XXX_RTC_ALARM), &alm->time);
	return 0;
}

static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	unsigned long t;
	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

	rtc_tm_to_time(&alm->time, &t);
	writel(t, rtc_data->io + STMP3XXX_RTC_ALARM);

	stmp3xxx_alarm_irq_enable(dev, alm->enabled);

	return 0;
}

static struct rtc_class_ops stmp3xxx_rtc_ops = {
	.alarm_irq_enable =
			  stmp3xxx_alarm_irq_enable,
	.read_time	= stmp3xxx_rtc_gettime,
	.set_mmss	= stmp3xxx_rtc_set_mmss,
	.read_alarm	= stmp3xxx_rtc_read_alarm,
	.set_alarm	= stmp3xxx_rtc_set_alarm,
};

static int stmp3xxx_rtc_remove(struct platform_device *pdev)
{
	struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);

	if (!rtc_data)
		return 0;

	writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
			rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
	free_irq(rtc_data->irq_alarm, &pdev->dev);
	rtc_device_unregister(rtc_data->rtc);
	platform_set_drvdata(pdev, NULL);
	iounmap(rtc_data->io);
	kfree(rtc_data);

	return 0;
}

static int stmp3xxx_rtc_probe(struct platform_device *pdev)
{
	struct stmp3xxx_rtc_data *rtc_data;
	struct resource *r;
	int err;

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

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r) {
		dev_err(&pdev->dev, "failed to get resource\n");
		err = -ENXIO;
		goto out_free;
	}

	rtc_data->io = ioremap(r->start, resource_size(r));
	if (!rtc_data->io) {
		dev_err(&pdev->dev, "ioremap failed\n");
		err = -EIO;
		goto out_free;
	}

	rtc_data->irq_alarm = platform_get_irq(pdev, 0);

	if (!(readl(STMP3XXX_RTC_STAT + rtc_data->io) &
			STMP3XXX_RTC_STAT_RTC_PRESENT)) {
		dev_err(&pdev->dev, "no device onboard\n");
		err = -ENODEV;
		goto out_remap;
	}

	platform_set_drvdata(pdev, rtc_data);

	mxs_reset_block(rtc_data->io);
	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
			STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
			STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
			rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);

	writel(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN |
			STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
			rtc_data->io + STMP3XXX_RTC_CTRL_CLR);

	rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
				&stmp3xxx_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc_data->rtc)) {
		err = PTR_ERR(rtc_data->rtc);
		goto out_remap;
	}

	err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt, 0,
			"RTC alarm", &pdev->dev);
	if (err) {
		dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
			rtc_data->irq_alarm);
		goto out_irq_alarm;
	}

	return 0;

out_irq_alarm:
	rtc_device_unregister(rtc_data->rtc);
out_remap:
	platform_set_drvdata(pdev, NULL);
	iounmap(rtc_data->io);
out_free:
	kfree(rtc_data);
	return err;
}

#ifdef CONFIG_PM
static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
{
	return 0;
}

static int stmp3xxx_rtc_resume(struct platform_device *dev)
{
	struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);

	mxs_reset_block(rtc_data->io);
	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
			STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
			STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
			rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
	return 0;
}
#else
#define stmp3xxx_rtc_suspend	NULL
#define stmp3xxx_rtc_resume	NULL
#endif

static const struct of_device_id rtc_dt_ids[] = {
	{ .compatible = "fsl,stmp3xxx-rtc", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, rtc_dt_ids);

static struct platform_driver stmp3xxx_rtcdrv = {
	.probe		= stmp3xxx_rtc_probe,
	.remove		= stmp3xxx_rtc_remove,
	.suspend	= stmp3xxx_rtc_suspend,
	.resume		= stmp3xxx_rtc_resume,
	.driver		= {
		.name	= "stmp3xxx-rtc",
		.owner	= THIS_MODULE,
		.of_match_table = rtc_dt_ids,
	},
};

module_platform_driver(stmp3xxx_rtcdrv);

MODULE_DESCRIPTION("STMP3xxx RTC Driver");
MODULE_AUTHOR("dmitry pervushin <[email protected]> and "
		"Wolfram Sang <[email protected]>");
MODULE_LICENSE("GPL");
Commit	Line	Data
df17f631	1	/*
	2	* Freescale STMP37XX/STMP378X Real Time Clock driver
	3	*
	4	* Copyright (c) 2007 Sigmatel, Inc.
	5	* Peter Hartley, <[email protected]>
	6	*
	7	* Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
	8	* Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
7e794cb7	9	* Copyright 2011 Wolfram Sang, Pengutronix e.K.
df17f631	10	*/
	11
	12	/*
	13	* The code contained herein is licensed under the GNU General Public
	14	* License. You may obtain a copy of the GNU General Public License
	15	* Version 2 or later at the following locations:
	16	*
	17	* http://www.opensource.org/licenses/gpl-license.html
	18	* http://www.gnu.org/copyleft/gpl.html
	19	*/
	20	#include <linux/kernel.h>
	21	#include <linux/module.h>
b5167159	22	#include <linux/io.h>
df17f631	23	#include <linux/init.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/rtc.h>
5a0e3ad6	27	#include <linux/slab.h>
dd8d20a3	28	#include <linux/of_device.h>
df17f631	29
46b21218	30	#include <mach/common.h>
47eac337 WS	31
47eac337 WS	32	#define STMP3XXX_RTC_CTRL 0x0
b5167159 WS	33	#define STMP3XXX_RTC_CTRL_SET 0x4
b5167159 WS	34	#define STMP3XXX_RTC_CTRL_CLR 0x8
47eac337 WS	35	#define STMP3XXX_RTC_CTRL_ALARM_IRQ_EN 0x00000001
	36	#define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN 0x00000002
	37	#define STMP3XXX_RTC_CTRL_ALARM_IRQ 0x00000004
47eac337 WS	38
	39	#define STMP3XXX_RTC_STAT 0x10
	40	#define STMP3XXX_RTC_STAT_STALE_SHIFT 16
	41	#define STMP3XXX_RTC_STAT_RTC_PRESENT 0x80000000
	42
	43	#define STMP3XXX_RTC_SECONDS 0x30
	44
	45	#define STMP3XXX_RTC_ALARM 0x40
	46
	47	#define STMP3XXX_RTC_PERSISTENT0 0x60
b5167159 WS	48	#define STMP3XXX_RTC_PERSISTENT0_SET 0x64
b5167159 WS	49	#define STMP3XXX_RTC_PERSISTENT0_CLR 0x68
47eac337 WS	50	#define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN 0x00000002
	51	#define STMP3XXX_RTC_PERSISTENT0_ALARM_EN 0x00000004
	52	#define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE 0x00000080
df17f631	53
	54	struct stmp3xxx_rtc_data {
	55	struct rtc_device *rtc;
df17f631	56	void __iomem *io;
7e794cb7	57	int irq_alarm;
df17f631	58	};
	59
	60	static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
	61	{
	62	/*
	63	* The datasheet doesn't say which way round the
	64	* NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0,
	65	* 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS
	66	*/
b5167159	67	while (readl(rtc_data->io + STMP3XXX_RTC_STAT) &
47eac337	68	(0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT))
df17f631	69	cpu_relax();
	70	}
	71
	72	/* Time read/write */
	73	static int stmp3xxx_rtc_gettime(struct device dev, struct rtc_time rtc_tm)
	74	{
	75	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
	76
	77	stmp3xxx_wait_time(rtc_data);
b5167159	78	rtc_time_to_tm(readl(rtc_data->io + STMP3XXX_RTC_SECONDS), rtc_tm);
df17f631	79	return 0;
	80	}
	81
	82	static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t)
	83	{
	84	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
	85
b5167159	86	writel(t, rtc_data->io + STMP3XXX_RTC_SECONDS);
df17f631	87	stmp3xxx_wait_time(rtc_data);
	88	return 0;
	89	}
	90
	91	/* interrupt(s) handler */
	92	static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id)
	93	{
	94	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id);
7e794cb7	95	u32 status = readl(rtc_data->io + STMP3XXX_RTC_CTRL);
df17f631	96
47eac337	97	if (status & STMP3XXX_RTC_CTRL_ALARM_IRQ) {
b5167159 WS	98	writel(STMP3XXX_RTC_CTRL_ALARM_IRQ,
b5167159 WS	99	rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
7e794cb7 WS	100	rtc_update_irq(rtc_data->rtc, 1, RTC_AF \| RTC_IRQF);
7e794cb7 WS	101	return IRQ_HANDLED;
df17f631	102	}
df17f631	103
7e794cb7	104	return IRQ_NONE;
df17f631	105	}
	106
	107	static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled)
	108	{
	109	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
df17f631	110
df17f631	111	if (enabled) {
b5167159 WS	112	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN \|
	113	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN,
	114	rtc_data->io + STMP3XXX_RTC_PERSISTENT0_SET);
	115	writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
	116	rtc_data->io + STMP3XXX_RTC_CTRL_SET);
df17f631	117	} else {
b5167159 WS	118	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN \|
	119	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN,
	120	rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
	121	writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
	122	rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
df17f631	123	}
	124	return 0;
	125	}
	126
df17f631	127	static int stmp3xxx_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	128	{
	129	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
	130
b5167159	131	rtc_time_to_tm(readl(rtc_data->io + STMP3XXX_RTC_ALARM), &alm->time);
df17f631	132	return 0;
	133	}
	134
	135	static int stmp3xxx_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	136	{
	137	unsigned long t;
	138	struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);
	139
	140	rtc_tm_to_time(&alm->time, &t);
b5167159	141	writel(t, rtc_data->io + STMP3XXX_RTC_ALARM);
7e794cb7 WS	142
	143	stmp3xxx_alarm_irq_enable(dev, alm->enabled);
	144
df17f631	145	return 0;
	146	}
	147
	148	static struct rtc_class_ops stmp3xxx_rtc_ops = {
	149	.alarm_irq_enable =
	150	stmp3xxx_alarm_irq_enable,
df17f631	151	.read_time = stmp3xxx_rtc_gettime,
	152	.set_mmss = stmp3xxx_rtc_set_mmss,
	153	.read_alarm = stmp3xxx_rtc_read_alarm,
	154	.set_alarm = stmp3xxx_rtc_set_alarm,
	155	};
	156
	157	static int stmp3xxx_rtc_remove(struct platform_device *pdev)
	158	{
	159	struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);
	160
	161	if (!rtc_data)
	162	return 0;
	163
7e794cb7	164	writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
b5167159	165	rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
df17f631	166	free_irq(rtc_data->irq_alarm, &pdev->dev);
df17f631	167	rtc_device_unregister(rtc_data->rtc);
a91d2bab	168	platform_set_drvdata(pdev, NULL);
df17f631	169	iounmap(rtc_data->io);
	170	kfree(rtc_data);
	171
	172	return 0;
	173	}
	174
	175	static int stmp3xxx_rtc_probe(struct platform_device *pdev)
	176	{
	177	struct stmp3xxx_rtc_data *rtc_data;
	178	struct resource *r;
	179	int err;
	180
	181	rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL);
	182	if (!rtc_data)
	183	return -ENOMEM;
	184
	185	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	186	if (!r) {
	187	dev_err(&pdev->dev, "failed to get resource\n");
	188	err = -ENXIO;
	189	goto out_free;
	190	}
	191
	192	rtc_data->io = ioremap(r->start, resource_size(r));
	193	if (!rtc_data->io) {
	194	dev_err(&pdev->dev, "ioremap failed\n");
	195	err = -EIO;
	196	goto out_free;
	197	}
	198
	199	rtc_data->irq_alarm = platform_get_irq(pdev, 0);
df17f631	200
b5167159	201	if (!(readl(STMP3XXX_RTC_STAT + rtc_data->io) &
47eac337	202	STMP3XXX_RTC_STAT_RTC_PRESENT)) {
df17f631	203	dev_err(&pdev->dev, "no device onboard\n");
	204	err = -ENODEV;
	205	goto out_remap;
	206	}
	207
a91d2bab WS	208	platform_set_drvdata(pdev, rtc_data);
a91d2bab WS	209
46b21218	210	mxs_reset_block(rtc_data->io);
b5167159	211	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN \|
47eac337 WS	212	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN \|
47eac337 WS	213	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
b5167159	214	rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
a91d2bab	215
7e794cb7 WS	216	writel(STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN \|
	217	STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
	218	rtc_data->io + STMP3XXX_RTC_CTRL_CLR);
	219
df17f631	220	rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev,
	221	&stmp3xxx_rtc_ops, THIS_MODULE);
	222	if (IS_ERR(rtc_data->rtc)) {
	223	err = PTR_ERR(rtc_data->rtc);
	224	goto out_remap;
	225	}
	226
7e794cb7 WS	227	err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt, 0,
7e794cb7 WS	228	"RTC alarm", &pdev->dev);
df17f631	229	if (err) {
	230	dev_err(&pdev->dev, "Cannot claim IRQ%d\n",
	231	rtc_data->irq_alarm);
	232	goto out_irq_alarm;
	233	}
df17f631	234
df17f631	235	return 0;
df17f631	236
df17f631	237	out_irq_alarm:
df17f631	238	rtc_device_unregister(rtc_data->rtc);
df17f631	239	out_remap:
a91d2bab	240	platform_set_drvdata(pdev, NULL);
df17f631	241	iounmap(rtc_data->io);
	242	out_free:
	243	kfree(rtc_data);
	244	return err;
	245	}
	246
	247	#ifdef CONFIG_PM
	248	static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state)
	249	{
	250	return 0;
	251	}
	252
	253	static int stmp3xxx_rtc_resume(struct platform_device *dev)
	254	{
	255	struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev);
	256
46b21218	257	mxs_reset_block(rtc_data->io);
b5167159	258	writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN \|
47eac337 WS	259	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN \|
47eac337 WS	260	STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
b5167159	261	rtc_data->io + STMP3XXX_RTC_PERSISTENT0_CLR);
df17f631	262	return 0;
	263	}
	264	#else
	265	#define stmp3xxx_rtc_suspend NULL
	266	#define stmp3xxx_rtc_resume NULL
	267	#endif
	268
dd8d20a3 MV	269	static const struct of_device_id rtc_dt_ids[] = {
	270	{ .compatible = "fsl,stmp3xxx-rtc", },
	271	{ /* sentinel */ }
	272	};
	273	MODULE_DEVICE_TABLE(of, rtc_dt_ids);
	274
df17f631	275	static struct platform_driver stmp3xxx_rtcdrv = {
	276	.probe = stmp3xxx_rtc_probe,
	277	.remove = stmp3xxx_rtc_remove,
	278	.suspend = stmp3xxx_rtc_suspend,
	279	.resume = stmp3xxx_rtc_resume,
	280	.driver = {
	281	.name = "stmp3xxx-rtc",
	282	.owner = THIS_MODULE,
dd8d20a3	283	.of_match_table = rtc_dt_ids,
df17f631	284	},
	285	};
	286
0c4eae66	287	module_platform_driver(stmp3xxx_rtcdrv);
df17f631	288
df17f631	289	MODULE_DESCRIPTION("STMP3xxx RTC Driver");
7e794cb7 WS	290	MODULE_AUTHOR("dmitry pervushin <[email protected]> and "
7e794cb7 WS	291	"Wolfram Sang <[email protected]>");
df17f631	292	MODULE_LICENSE("GPL");