[deliverable/linux.git] / drivers / rtc / rtc-omap.c

/*
 * TI OMAP1 Real Time Clock interface for Linux
 *
 * Copyright (C) 2003 MontaVista Software, Inc.
 * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
 *
 * Copyright (C) 2006 David Brownell (new RTC framework)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/pm_runtime.h>
#include <linux/io.h>

/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
 * with century-range alarm matching, driven by the 32kHz clock.
 *
 * The main user-visible ways it differs from PC RTCs are by omitting
 * "don't care" alarm fields and sub-second periodic IRQs, and having
 * an autoadjust mechanism to calibrate to the true oscillator rate.
 *
 * Board-specific wiring options include using split power mode with
 * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
 * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
 * low power modes) for OMAP1 boards (OMAP-L138 has this built into
 * the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
 */

#define	DRIVER_NAME			"omap_rtc"

#define OMAP_RTC_BASE			0xfffb4800

/* RTC registers */
#define OMAP_RTC_SECONDS_REG		0x00
#define OMAP_RTC_MINUTES_REG		0x04
#define OMAP_RTC_HOURS_REG		0x08
#define OMAP_RTC_DAYS_REG		0x0C
#define OMAP_RTC_MONTHS_REG		0x10
#define OMAP_RTC_YEARS_REG		0x14
#define OMAP_RTC_WEEKS_REG		0x18

#define OMAP_RTC_ALARM_SECONDS_REG	0x20
#define OMAP_RTC_ALARM_MINUTES_REG	0x24
#define OMAP_RTC_ALARM_HOURS_REG	0x28
#define OMAP_RTC_ALARM_DAYS_REG		0x2c
#define OMAP_RTC_ALARM_MONTHS_REG	0x30
#define OMAP_RTC_ALARM_YEARS_REG	0x34

#define OMAP_RTC_CTRL_REG		0x40
#define OMAP_RTC_STATUS_REG		0x44
#define OMAP_RTC_INTERRUPTS_REG		0x48

#define OMAP_RTC_COMP_LSB_REG		0x4c
#define OMAP_RTC_COMP_MSB_REG		0x50
#define OMAP_RTC_OSC_REG		0x54

#define OMAP_RTC_KICK0_REG		0x6c
#define OMAP_RTC_KICK1_REG		0x70

#define OMAP_RTC_IRQWAKEEN		0x7c

/* OMAP_RTC_CTRL_REG bit fields: */
#define OMAP_RTC_CTRL_SPLIT		BIT(7)
#define OMAP_RTC_CTRL_DISABLE		BIT(6)
#define OMAP_RTC_CTRL_SET_32_COUNTER	BIT(5)
#define OMAP_RTC_CTRL_TEST		BIT(4)
#define OMAP_RTC_CTRL_MODE_12_24	BIT(3)
#define OMAP_RTC_CTRL_AUTO_COMP		BIT(2)
#define OMAP_RTC_CTRL_ROUND_30S		BIT(1)
#define OMAP_RTC_CTRL_STOP		BIT(0)

/* OMAP_RTC_STATUS_REG bit fields: */
#define OMAP_RTC_STATUS_POWER_UP	BIT(7)
#define OMAP_RTC_STATUS_ALARM		BIT(6)
#define OMAP_RTC_STATUS_1D_EVENT	BIT(5)
#define OMAP_RTC_STATUS_1H_EVENT	BIT(4)
#define OMAP_RTC_STATUS_1M_EVENT	BIT(3)
#define OMAP_RTC_STATUS_1S_EVENT	BIT(2)
#define OMAP_RTC_STATUS_RUN		BIT(1)
#define OMAP_RTC_STATUS_BUSY		BIT(0)

/* OMAP_RTC_INTERRUPTS_REG bit fields: */
#define OMAP_RTC_INTERRUPTS_IT_ALARM	BIT(3)
#define OMAP_RTC_INTERRUPTS_IT_TIMER	BIT(2)

/* OMAP_RTC_IRQWAKEEN bit fields: */
#define OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN	BIT(1)

/* OMAP_RTC_KICKER values */
#define	KICK0_VALUE			0x83e70b13
#define	KICK1_VALUE			0x95a4f1e0

#define	OMAP_RTC_HAS_KICKER		BIT(0)

/*
 * Few RTC IP revisions has special WAKE-EN Register to enable Wakeup
 * generation for event Alarm.
 */
#define	OMAP_RTC_HAS_IRQWAKEEN		BIT(1)

static void __iomem	*rtc_base;

#define rtc_read(addr)		readb(rtc_base + (addr))
#define rtc_write(val, addr)	writeb(val, rtc_base + (addr))

#define rtc_writel(val, addr)	writel(val, rtc_base + (addr))


/* we rely on the rtc framework to handle locking (rtc->ops_lock),
 * so the only other requirement is that register accesses which
 * require BUSY to be clear are made with IRQs locally disabled
 */
static void rtc_wait_not_busy(void)
{
	int	count = 0;
	u8	status;

	/* BUSY may stay active for 1/32768 second (~30 usec) */
	for (count = 0; count < 50; count++) {
		status = rtc_read(OMAP_RTC_STATUS_REG);
		if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
			break;
		udelay(1);
	}
	/* now we have ~15 usec to read/write various registers */
}

static irqreturn_t rtc_irq(int irq, void *rtc)
{
	unsigned long		events = 0;
	u8			irq_data;

	irq_data = rtc_read(OMAP_RTC_STATUS_REG);

	/* alarm irq? */
	if (irq_data & OMAP_RTC_STATUS_ALARM) {
		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
		events |= RTC_IRQF | RTC_AF;
	}

	/* 1/sec periodic/update irq? */
	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
		events |= RTC_IRQF | RTC_UF;

	rtc_update_irq(rtc, 1, events);

	return IRQ_HANDLED;
}

static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	u8 reg;

	local_irq_disable();
	rtc_wait_not_busy();
	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
	if (enabled)
		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
	else
		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	rtc_wait_not_busy();
	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
	local_irq_enable();

	return 0;
}

/* this hardware doesn't support "don't care" alarm fields */
static int tm2bcd(struct rtc_time *tm)
{
	if (rtc_valid_tm(tm) != 0)
		return -EINVAL;

	tm->tm_sec = bin2bcd(tm->tm_sec);
	tm->tm_min = bin2bcd(tm->tm_min);
	tm->tm_hour = bin2bcd(tm->tm_hour);
	tm->tm_mday = bin2bcd(tm->tm_mday);

	tm->tm_mon = bin2bcd(tm->tm_mon + 1);

	/* epoch == 1900 */
	if (tm->tm_year < 100 || tm->tm_year > 199)
		return -EINVAL;
	tm->tm_year = bin2bcd(tm->tm_year - 100);

	return 0;
}

static void bcd2tm(struct rtc_time *tm)
{
	tm->tm_sec = bcd2bin(tm->tm_sec);
	tm->tm_min = bcd2bin(tm->tm_min);
	tm->tm_hour = bcd2bin(tm->tm_hour);
	tm->tm_mday = bcd2bin(tm->tm_mday);
	tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
	/* epoch == 1900 */
	tm->tm_year = bcd2bin(tm->tm_year) + 100;
}


static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	/* we don't report wday/yday/isdst ... */
	local_irq_disable();
	rtc_wait_not_busy();

	tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
	tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
	tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
	tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
	tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
	tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);

	local_irq_enable();

	bcd2tm(tm);
	return 0;
}

static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	if (tm2bcd(tm) < 0)
		return -EINVAL;
	local_irq_disable();
	rtc_wait_not_busy();

	rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
	rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
	rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
	rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
	rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
	rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);

	local_irq_enable();

	return 0;
}

static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	local_irq_disable();
	rtc_wait_not_busy();

	alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
	alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
	alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
	alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
	alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
	alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);

	local_irq_enable();

	bcd2tm(&alm->time);
	alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
			& OMAP_RTC_INTERRUPTS_IT_ALARM);

	return 0;
}

static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	u8 reg;

	if (tm2bcd(&alm->time) < 0)
		return -EINVAL;

	local_irq_disable();
	rtc_wait_not_busy();

	rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
	rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
	rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
	rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
	rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
	rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);

	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
	if (alm->enabled)
		reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
	else
		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);

	local_irq_enable();

	return 0;
}

static struct rtc_class_ops omap_rtc_ops = {
	.read_time	= omap_rtc_read_time,
	.set_time	= omap_rtc_set_time,
	.read_alarm	= omap_rtc_read_alarm,
	.set_alarm	= omap_rtc_set_alarm,
	.alarm_irq_enable = omap_rtc_alarm_irq_enable,
};

static int omap_rtc_alarm;
static int omap_rtc_timer;

#define	OMAP_RTC_DATA_AM3352_IDX	1
#define	OMAP_RTC_DATA_DA830_IDX		2

static struct platform_device_id omap_rtc_devtype[] = {
	{
		.name	= DRIVER_NAME,
	},
	[OMAP_RTC_DATA_AM3352_IDX] = {
		.name	= "am3352-rtc",
		.driver_data = OMAP_RTC_HAS_KICKER | OMAP_RTC_HAS_IRQWAKEEN,
	},
	[OMAP_RTC_DATA_DA830_IDX] = {
		.name	= "da830-rtc",
		.driver_data = OMAP_RTC_HAS_KICKER,
	},
	{},
};
MODULE_DEVICE_TABLE(platform, omap_rtc_devtype);

static const struct of_device_id omap_rtc_of_match[] = {
	{	.compatible	= "ti,da830-rtc",
		.data		= &omap_rtc_devtype[OMAP_RTC_DATA_DA830_IDX],
	},
	{	.compatible	= "ti,am3352-rtc",
		.data		= &omap_rtc_devtype[OMAP_RTC_DATA_AM3352_IDX],
	},
	{},
};
MODULE_DEVICE_TABLE(of, omap_rtc_of_match);

static int __init omap_rtc_probe(struct platform_device *pdev)
{
	struct resource		*res;
	struct rtc_device	*rtc;
	u8			reg, new_ctrl;
	const struct platform_device_id *id_entry;
	const struct of_device_id *of_id;

	of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
	if (of_id)
		pdev->id_entry = of_id->data;

	id_entry = platform_get_device_id(pdev);
	if (!id_entry) {
		dev_err(&pdev->dev, "no matching device entry\n");
		return -ENODEV;
	}

	omap_rtc_timer = platform_get_irq(pdev, 0);
	if (omap_rtc_timer <= 0) {
		pr_debug("%s: no update irq?\n", pdev->name);
		return -ENOENT;
	}

	omap_rtc_alarm = platform_get_irq(pdev, 1);
	if (omap_rtc_alarm <= 0) {
		pr_debug("%s: no alarm irq?\n", pdev->name);
		return -ENOENT;
	}

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

	/* Enable the clock/module so that we can access the registers */
	pm_runtime_enable(&pdev->dev);
	pm_runtime_get_sync(&pdev->dev);

	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER) {
		rtc_writel(KICK0_VALUE, OMAP_RTC_KICK0_REG);
		rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
	}

	rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
			&omap_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc)) {
		pr_debug("%s: can't register RTC device, err %ld\n",
			pdev->name, PTR_ERR(rtc));
		goto fail0;
	}
	platform_set_drvdata(pdev, rtc);

	/* clear pending irqs, and set 1/second periodic,
	 * which we'll use instead of update irqs
	 */
	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);

	/* clear old status */
	reg = rtc_read(OMAP_RTC_STATUS_REG);
	if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
		pr_info("%s: RTC power up reset detected\n",
			pdev->name);
		rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
	}
	if (reg & (u8) OMAP_RTC_STATUS_ALARM)
		rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);

	/* handle periodic and alarm irqs */
	if (devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,
			dev_name(&rtc->dev), rtc)) {
		pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
			pdev->name, omap_rtc_timer);
		goto fail0;
	}
	if ((omap_rtc_timer != omap_rtc_alarm) &&
		(devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,
			dev_name(&rtc->dev), rtc))) {
		pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
			pdev->name, omap_rtc_alarm);
		goto fail0;
	}

	/* On boards with split power, RTC_ON_NOFF won't reset the RTC */
	reg = rtc_read(OMAP_RTC_CTRL_REG);
	if (reg & (u8) OMAP_RTC_CTRL_STOP)
		pr_info("%s: already running\n", pdev->name);

	/* force to 24 hour mode */
	new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
	new_ctrl |= OMAP_RTC_CTRL_STOP;

	/* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
	 *
	 *  - Device wake-up capability setting should come through chip
	 *    init logic. OMAP1 boards should initialize the "wakeup capable"
	 *    flag in the platform device if the board is wired right for
	 *    being woken up by RTC alarm. For OMAP-L138, this capability
	 *    is built into the SoC by the "Deep Sleep" capability.
	 *
	 *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
	 *    rather than nPWRON_RESET, should forcibly enable split
	 *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
	 *    is write-only, and always reads as zero...)
	 */

	device_init_wakeup(&pdev->dev, true);

	if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
		pr_info("%s: split power mode\n", pdev->name);

	if (reg != new_ctrl)
		rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);

	return 0;

fail0:
	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
		rtc_writel(0, OMAP_RTC_KICK0_REG);
	pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);
	return -EIO;
}

static int __exit omap_rtc_remove(struct platform_device *pdev)
{
	const struct platform_device_id *id_entry =
				platform_get_device_id(pdev);

	device_init_wakeup(&pdev->dev, 0);

	/* leave rtc running, but disable irqs */
	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);

	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
		rtc_writel(0, OMAP_RTC_KICK0_REG);

	/* Disable the clock/module */
	pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static u8 irqstat;

static int omap_rtc_suspend(struct device *dev)
{
	u8 irqwake_stat;
	struct platform_device *pdev = to_platform_device(dev);
	const struct platform_device_id *id_entry =
					platform_get_device_id(pdev);

	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);

	/* FIXME the RTC alarm is not currently acting as a wakeup event
	 * source on some platforms, and in fact this enable() call is just
	 * saving a flag that's never used...
	 */
	if (device_may_wakeup(dev)) {
		enable_irq_wake(omap_rtc_alarm);

		if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
			irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
			irqwake_stat |= OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
			rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
		}
	} else {
		rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
	}

	/* Disable the clock/module */
	pm_runtime_put_sync(dev);

	return 0;
}

static int omap_rtc_resume(struct device *dev)
{
	u8 irqwake_stat;
	struct platform_device *pdev = to_platform_device(dev);
	const struct platform_device_id *id_entry =
				platform_get_device_id(pdev);

	/* Enable the clock/module so that we can access the registers */
	pm_runtime_get_sync(dev);

	if (device_may_wakeup(dev)) {
		disable_irq_wake(omap_rtc_alarm);

		if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
			irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
			irqwake_stat &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
			rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
		}
	} else {
		rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
	}
	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);

static void omap_rtc_shutdown(struct platform_device *pdev)
{
	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
}

MODULE_ALIAS("platform:omap_rtc");
static struct platform_driver omap_rtc_driver = {
	.remove		= __exit_p(omap_rtc_remove),
	.shutdown	= omap_rtc_shutdown,
	.driver		= {
		.name	= DRIVER_NAME,
		.owner	= THIS_MODULE,
		.pm	= &omap_rtc_pm_ops,
		.of_match_table = omap_rtc_of_match,
	},
	.id_table	= omap_rtc_devtype,
};

module_platform_driver_probe(omap_rtc_driver, omap_rtc_probe);

MODULE_AUTHOR("George G. Davis (and others)");
MODULE_LICENSE("GPL");
Commit	Line	Data
db68b189 DB	1	/*
	2	* TI OMAP1 Real Time Clock interface for Linux
	3	*
	4	* Copyright (C) 2003 MontaVista Software, Inc.
	5	* Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
	6	*
	7	* Copyright (C) 2006 David Brownell (new RTC framework)
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License
	11	* as published by the Free Software Foundation; either version
	12	* 2 of the License, or (at your option) any later version.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/module.h>
	18	#include <linux/ioport.h>
	19	#include <linux/delay.h>
	20	#include <linux/rtc.h>
	21	#include <linux/bcd.h>
	22	#include <linux/platform_device.h>
9e0344dc AM	23	#include <linux/of.h>
9e0344dc AM	24	#include <linux/of_device.h>
fc9bd902	25	#include <linux/pm_runtime.h>
4b30c9fc	26	#include <linux/io.h>
db68b189 DB	27
	28	/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
	29	* with century-range alarm matching, driven by the 32kHz clock.
	30	*
	31	* The main user-visible ways it differs from PC RTCs are by omitting
	32	* "don't care" alarm fields and sub-second periodic IRQs, and having
	33	* an autoadjust mechanism to calibrate to the true oscillator rate.
	34	*
	35	* Board-specific wiring options include using split power mode with
	36	* RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
	37	* and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
fa5b0782 SN	38	* low power modes) for OMAP1 boards (OMAP-L138 has this built into
fa5b0782 SN	39	* the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
db68b189 DB	40	*/
db68b189 DB	41
cab1458c AM	42	#define DRIVER_NAME "omap_rtc"
cab1458c AM	43
db68b189 DB	44	#define OMAP_RTC_BASE 0xfffb4800
	45
	46	/* RTC registers */
	47	#define OMAP_RTC_SECONDS_REG 0x00
	48	#define OMAP_RTC_MINUTES_REG 0x04
	49	#define OMAP_RTC_HOURS_REG 0x08
	50	#define OMAP_RTC_DAYS_REG 0x0C
	51	#define OMAP_RTC_MONTHS_REG 0x10
	52	#define OMAP_RTC_YEARS_REG 0x14
	53	#define OMAP_RTC_WEEKS_REG 0x18
	54
	55	#define OMAP_RTC_ALARM_SECONDS_REG 0x20
	56	#define OMAP_RTC_ALARM_MINUTES_REG 0x24
	57	#define OMAP_RTC_ALARM_HOURS_REG 0x28
	58	#define OMAP_RTC_ALARM_DAYS_REG 0x2c
	59	#define OMAP_RTC_ALARM_MONTHS_REG 0x30
	60	#define OMAP_RTC_ALARM_YEARS_REG 0x34
	61
	62	#define OMAP_RTC_CTRL_REG 0x40
	63	#define OMAP_RTC_STATUS_REG 0x44
	64	#define OMAP_RTC_INTERRUPTS_REG 0x48
	65
	66	#define OMAP_RTC_COMP_LSB_REG 0x4c
	67	#define OMAP_RTC_COMP_MSB_REG 0x50
	68	#define OMAP_RTC_OSC_REG 0x54
	69
cab1458c AM	70	#define OMAP_RTC_KICK0_REG 0x6c
	71	#define OMAP_RTC_KICK1_REG 0x70
	72
8af750e3 HG	73	#define OMAP_RTC_IRQWAKEEN 0x7c
8af750e3 HG	74
db68b189	75	/* OMAP_RTC_CTRL_REG bit fields: */
92adb96a SN	76	#define OMAP_RTC_CTRL_SPLIT BIT(7)
	77	#define OMAP_RTC_CTRL_DISABLE BIT(6)
	78	#define OMAP_RTC_CTRL_SET_32_COUNTER BIT(5)
	79	#define OMAP_RTC_CTRL_TEST BIT(4)
	80	#define OMAP_RTC_CTRL_MODE_12_24 BIT(3)
	81	#define OMAP_RTC_CTRL_AUTO_COMP BIT(2)
	82	#define OMAP_RTC_CTRL_ROUND_30S BIT(1)
	83	#define OMAP_RTC_CTRL_STOP BIT(0)
db68b189 DB	84
db68b189 DB	85	/* OMAP_RTC_STATUS_REG bit fields: */
92adb96a SN	86	#define OMAP_RTC_STATUS_POWER_UP BIT(7)
	87	#define OMAP_RTC_STATUS_ALARM BIT(6)
	88	#define OMAP_RTC_STATUS_1D_EVENT BIT(5)
	89	#define OMAP_RTC_STATUS_1H_EVENT BIT(4)
	90	#define OMAP_RTC_STATUS_1M_EVENT BIT(3)
	91	#define OMAP_RTC_STATUS_1S_EVENT BIT(2)
	92	#define OMAP_RTC_STATUS_RUN BIT(1)
	93	#define OMAP_RTC_STATUS_BUSY BIT(0)
db68b189 DB	94
db68b189 DB	95	/* OMAP_RTC_INTERRUPTS_REG bit fields: */
92adb96a SN	96	#define OMAP_RTC_INTERRUPTS_IT_ALARM BIT(3)
92adb96a SN	97	#define OMAP_RTC_INTERRUPTS_IT_TIMER BIT(2)
db68b189	98
8af750e3	99	/* OMAP_RTC_IRQWAKEEN bit fields: */
92adb96a	100	#define OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN BIT(1)
8af750e3	101
cab1458c AM	102	/* OMAP_RTC_KICKER values */
	103	#define KICK0_VALUE 0x83e70b13
	104	#define KICK1_VALUE 0x95a4f1e0
	105
92adb96a	106	#define OMAP_RTC_HAS_KICKER BIT(0)
cab1458c	107
8af750e3 HG	108	/*
	109	* Few RTC IP revisions has special WAKE-EN Register to enable Wakeup
	110	* generation for event Alarm.
	111	*/
92adb96a	112	#define OMAP_RTC_HAS_IRQWAKEEN BIT(1)
8af750e3	113
8cfde8c1	114	static void __iomem *rtc_base;
db68b189	115
cab1458c AM	116	#define rtc_read(addr) readb(rtc_base + (addr))
	117	#define rtc_write(val, addr) writeb(val, rtc_base + (addr))
	118
	119	#define rtc_writel(val, addr) writel(val, rtc_base + (addr))
db68b189 DB	120
db68b189 DB	121
db68b189 DB	122	/* we rely on the rtc framework to handle locking (rtc->ops_lock),
	123	* so the only other requirement is that register accesses which
	124	* require BUSY to be clear are made with IRQs locally disabled
	125	*/
	126	static void rtc_wait_not_busy(void)
	127	{
	128	int count = 0;
	129	u8 status;
	130
	131	/* BUSY may stay active for 1/32768 second (~30 usec) */
	132	for (count = 0; count < 50; count++) {
	133	status = rtc_read(OMAP_RTC_STATUS_REG);
	134	if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
	135	break;
	136	udelay(1);
	137	}
	138	/* now we have ~15 usec to read/write various registers */
	139	}
	140
ab6a2d70	141	static irqreturn_t rtc_irq(int irq, void *rtc)
db68b189 DB	142	{
	143	unsigned long events = 0;
	144	u8 irq_data;
	145
	146	irq_data = rtc_read(OMAP_RTC_STATUS_REG);
	147
	148	/* alarm irq? */
	149	if (irq_data & OMAP_RTC_STATUS_ALARM) {
	150	rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
	151	events \|= RTC_IRQF \| RTC_AF;
	152	}
	153
	154	/* 1/sec periodic/update irq? */
	155	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
	156	events \|= RTC_IRQF \| RTC_UF;
	157
ab6a2d70	158	rtc_update_irq(rtc, 1, events);
db68b189 DB	159
	160	return IRQ_HANDLED;
	161	}
	162
16380c15 JS	163	static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
	164	{
	165	u8 reg;
	166
	167	local_irq_disable();
	168	rtc_wait_not_busy();
	169	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
	170	if (enabled)
	171	reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;
	172	else
	173	reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	174	rtc_wait_not_busy();
	175	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
	176	local_irq_enable();
	177
	178	return 0;
	179	}
	180
db68b189 DB	181	/* this hardware doesn't support "don't care" alarm fields */
	182	static int tm2bcd(struct rtc_time *tm)
	183	{
	184	if (rtc_valid_tm(tm) != 0)
	185	return -EINVAL;
	186
fe20ba70 AB	187	tm->tm_sec = bin2bcd(tm->tm_sec);
	188	tm->tm_min = bin2bcd(tm->tm_min);
	189	tm->tm_hour = bin2bcd(tm->tm_hour);
	190	tm->tm_mday = bin2bcd(tm->tm_mday);
db68b189	191
fe20ba70	192	tm->tm_mon = bin2bcd(tm->tm_mon + 1);
db68b189 DB	193
	194	/* epoch == 1900 */
	195	if (tm->tm_year < 100 \|\| tm->tm_year > 199)
	196	return -EINVAL;
fe20ba70	197	tm->tm_year = bin2bcd(tm->tm_year - 100);
db68b189 DB	198
	199	return 0;
	200	}
	201
	202	static void bcd2tm(struct rtc_time *tm)
	203	{
fe20ba70 AB	204	tm->tm_sec = bcd2bin(tm->tm_sec);
	205	tm->tm_min = bcd2bin(tm->tm_min);
	206	tm->tm_hour = bcd2bin(tm->tm_hour);
	207	tm->tm_mday = bcd2bin(tm->tm_mday);
	208	tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
db68b189	209	/* epoch == 1900 */
fe20ba70	210	tm->tm_year = bcd2bin(tm->tm_year) + 100;
db68b189 DB	211	}
	212
	213
	214	static int omap_rtc_read_time(struct device dev, struct rtc_time tm)
	215	{
	216	/* we don't report wday/yday/isdst ... */
	217	local_irq_disable();
	218	rtc_wait_not_busy();
	219
	220	tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
	221	tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
	222	tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
	223	tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
	224	tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
	225	tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
	226
	227	local_irq_enable();
	228
	229	bcd2tm(tm);
	230	return 0;
	231	}
	232
	233	static int omap_rtc_set_time(struct device dev, struct rtc_time tm)
	234	{
	235	if (tm2bcd(tm) < 0)
	236	return -EINVAL;
	237	local_irq_disable();
	238	rtc_wait_not_busy();
	239
	240	rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
	241	rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
	242	rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
	243	rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
	244	rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
	245	rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
	246
	247	local_irq_enable();
	248
	249	return 0;
	250	}
	251
	252	static int omap_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	253	{
	254	local_irq_disable();
	255	rtc_wait_not_busy();
	256
	257	alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
	258	alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
	259	alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
	260	alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
	261	alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
	262	alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
	263
	264	local_irq_enable();
	265
	266	bcd2tm(&alm->time);
a2db8dfc	267	alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
db68b189	268	& OMAP_RTC_INTERRUPTS_IT_ALARM);
db68b189 DB	269
	270	return 0;
	271	}
	272
	273	static int omap_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	274	{
	275	u8 reg;
	276
db68b189 DB	277	if (tm2bcd(&alm->time) < 0)
	278	return -EINVAL;
	279
	280	local_irq_disable();
	281	rtc_wait_not_busy();
	282
	283	rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
	284	rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
	285	rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
	286	rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
	287	rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
	288	rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
	289
	290	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
	291	if (alm->enabled)
	292	reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;
	293	else
	294	reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	295	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
	296
	297	local_irq_enable();
	298
	299	return 0;
	300	}
	301
	302	static struct rtc_class_ops omap_rtc_ops = {
db68b189 DB	303	.read_time = omap_rtc_read_time,
	304	.set_time = omap_rtc_set_time,
	305	.read_alarm = omap_rtc_read_alarm,
	306	.set_alarm = omap_rtc_set_alarm,
16380c15	307	.alarm_irq_enable = omap_rtc_alarm_irq_enable,
db68b189 DB	308	};
	309
	310	static int omap_rtc_alarm;
	311	static int omap_rtc_timer;
	312
8af750e3 HG	313	#define OMAP_RTC_DATA_AM3352_IDX 1
8af750e3 HG	314	#define OMAP_RTC_DATA_DA830_IDX 2
9e0344dc	315
cab1458c AM	316	static struct platform_device_id omap_rtc_devtype[] = {
	317	{
	318	.name = DRIVER_NAME,
8af750e3 HG	319	},
	320	[OMAP_RTC_DATA_AM3352_IDX] = {
	321	.name = "am3352-rtc",
	322	.driver_data = OMAP_RTC_HAS_KICKER \| OMAP_RTC_HAS_IRQWAKEEN,
	323	},
	324	[OMAP_RTC_DATA_DA830_IDX] = {
cab1458c AM	325	.name = "da830-rtc",
	326	.driver_data = OMAP_RTC_HAS_KICKER,
	327	},
	328	{},
	329	};
	330	MODULE_DEVICE_TABLE(platform, omap_rtc_devtype);
	331
9e0344dc AM	332	static const struct of_device_id omap_rtc_of_match[] = {
	333	{ .compatible = "ti,da830-rtc",
	334	.data = &omap_rtc_devtype[OMAP_RTC_DATA_DA830_IDX],
	335	},
8af750e3 HG	336	{ .compatible = "ti,am3352-rtc",
	337	.data = &omap_rtc_devtype[OMAP_RTC_DATA_AM3352_IDX],
	338	},
9e0344dc AM	339	{},
	340	};
	341	MODULE_DEVICE_TABLE(of, omap_rtc_of_match);
	342
71fc8224	343	static int __init omap_rtc_probe(struct platform_device *pdev)
db68b189	344	{
3765e8f1	345	struct resource *res;
db68b189 DB	346	struct rtc_device *rtc;
db68b189 DB	347	u8 reg, new_ctrl;
cab1458c	348	const struct platform_device_id *id_entry;
9e0344dc AM	349	const struct of_device_id *of_id;
	350
	351	of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
	352	if (of_id)
	353	pdev->id_entry = of_id->data;
db68b189	354
337b600f SN	355	id_entry = platform_get_device_id(pdev);
	356	if (!id_entry) {
	357	dev_err(&pdev->dev, "no matching device entry\n");
	358	return -ENODEV;
	359	}
	360
db68b189 DB	361	omap_rtc_timer = platform_get_irq(pdev, 0);
	362	if (omap_rtc_timer <= 0) {
	363	pr_debug("%s: no update irq?\n", pdev->name);
	364	return -ENOENT;
	365	}
	366
	367	omap_rtc_alarm = platform_get_irq(pdev, 1);
	368	if (omap_rtc_alarm <= 0) {
	369	pr_debug("%s: no alarm irq?\n", pdev->name);
	370	return -ENOENT;
	371	}
	372
db68b189	373	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3765e8f1 VBM	374	rtc_base = devm_ioremap_resource(&pdev->dev, res);
	375	if (IS_ERR(rtc_base))
	376	return PTR_ERR(rtc_base);
8cfde8c1	377
fc9bd902 VH	378	/* Enable the clock/module so that we can access the registers */
	379	pm_runtime_enable(&pdev->dev);
	380	pm_runtime_get_sync(&pdev->dev);
	381
337b600f	382	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER) {
cab1458c AM	383	rtc_writel(KICK0_VALUE, OMAP_RTC_KICK0_REG);
	384	rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
	385	}
	386
3765e8f1	387	rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
db68b189 DB	388	&omap_rtc_ops, THIS_MODULE);
	389	if (IS_ERR(rtc)) {
	390	pr_debug("%s: can't register RTC device, err %ld\n",
	391	pdev->name, PTR_ERR(rtc));
8cfde8c1	392	goto fail0;
db68b189 DB	393	}
db68b189 DB	394	platform_set_drvdata(pdev, rtc);
db68b189 DB	395
	396	/* clear pending irqs, and set 1/second periodic,
	397	* which we'll use instead of update irqs
	398	*/
	399	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
	400
	401	/* clear old status */
	402	reg = rtc_read(OMAP_RTC_STATUS_REG);
	403	if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
	404	pr_info("%s: RTC power up reset detected\n",
	405	pdev->name);
	406	rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
	407	}
	408	if (reg & (u8) OMAP_RTC_STATUS_ALARM)
	409	rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
	410
	411	/* handle periodic and alarm irqs */
3765e8f1	412	if (devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,
744bcb13	413	dev_name(&rtc->dev), rtc)) {
db68b189 DB	414	pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
db68b189 DB	415	pdev->name, omap_rtc_timer);
3765e8f1	416	goto fail0;
db68b189	417	}
8cfde8c1	418	if ((omap_rtc_timer != omap_rtc_alarm) &&
3765e8f1	419	(devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,
8cfde8c1	420	dev_name(&rtc->dev), rtc))) {
db68b189 DB	421	pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
db68b189 DB	422	pdev->name, omap_rtc_alarm);
3765e8f1	423	goto fail0;
db68b189 DB	424	}
	425
	426	/* On boards with split power, RTC_ON_NOFF won't reset the RTC */
	427	reg = rtc_read(OMAP_RTC_CTRL_REG);
	428	if (reg & (u8) OMAP_RTC_CTRL_STOP)
	429	pr_info("%s: already running\n", pdev->name);
	430
	431	/* force to 24 hour mode */
12b3e038	432	new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT\|OMAP_RTC_CTRL_AUTO_COMP);
db68b189 DB	433	new_ctrl \|= OMAP_RTC_CTRL_STOP;
	434
	435	/* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
	436	*
fa5b0782 SN	437	* - Device wake-up capability setting should come through chip
	438	* init logic. OMAP1 boards should initialize the "wakeup capable"
	439	* flag in the platform device if the board is wired right for
	440	* being woken up by RTC alarm. For OMAP-L138, this capability
	441	* is built into the SoC by the "Deep Sleep" capability.
db68b189 DB	442	*
	443	* - Boards wired so RTC_ON_nOFF is used as the reset signal,
	444	* rather than nPWRON_RESET, should forcibly enable split
	445	* power mode. (Some chip errata report that RTC_CTRL_SPLIT
	446	* is write-only, and always reads as zero...)
	447	*/
db68b189	448
1d2e2b65 HG	449	device_init_wakeup(&pdev->dev, true);
1d2e2b65 HG	450
db68b189 DB	451	if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
	452	pr_info("%s: split power mode\n", pdev->name);
	453
	454	if (reg != new_ctrl)
	455	rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
	456
	457	return 0;
	458
8cfde8c1	459	fail0:
337b600f	460	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
cab1458c	461	rtc_writel(0, OMAP_RTC_KICK0_REG);
fc9bd902 VH	462	pm_runtime_put_sync(&pdev->dev);
fc9bd902 VH	463	pm_runtime_disable(&pdev->dev);
db68b189 DB	464	return -EIO;
	465	}
	466
71fc8224	467	static int __exit omap_rtc_remove(struct platform_device *pdev)
db68b189	468	{
cab1458c AM	469	const struct platform_device_id *id_entry =
cab1458c AM	470	platform_get_device_id(pdev);
db68b189 DB	471
	472	device_init_wakeup(&pdev->dev, 0);
	473
	474	/* leave rtc running, but disable irqs */
	475	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
	476
337b600f	477	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
cab1458c	478	rtc_writel(0, OMAP_RTC_KICK0_REG);
fc9bd902 VH	479
	480	/* Disable the clock/module */
	481	pm_runtime_put_sync(&pdev->dev);
	482	pm_runtime_disable(&pdev->dev);
	483
db68b189 DB	484	return 0;
	485	}
	486
04ebc359	487	#ifdef CONFIG_PM_SLEEP
db68b189 DB	488	static u8 irqstat;
db68b189 DB	489
04ebc359	490	static int omap_rtc_suspend(struct device *dev)
db68b189	491	{
8af750e3 HG	492	u8 irqwake_stat;
	493	struct platform_device *pdev = to_platform_device(dev);
	494	const struct platform_device_id *id_entry =
	495	platform_get_device_id(pdev);
	496
db68b189 DB	497	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
	498
	499	/* FIXME the RTC alarm is not currently acting as a wakeup event
8af750e3 HG	500	* source on some platforms, and in fact this enable() call is just
8af750e3 HG	501	* saving a flag that's never used...
db68b189	502	*/
8af750e3	503	if (device_may_wakeup(dev)) {
db68b189	504	enable_irq_wake(omap_rtc_alarm);
8af750e3 HG	505
	506	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
	507	irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
	508	irqwake_stat \|= OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
	509	rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
	510	}
	511	} else {
db68b189	512	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
8af750e3	513	}
db68b189	514
fc9bd902	515	/* Disable the clock/module */
04ebc359	516	pm_runtime_put_sync(dev);
fc9bd902	517
db68b189 DB	518	return 0;
	519	}
	520
04ebc359	521	static int omap_rtc_resume(struct device *dev)
db68b189	522	{
8af750e3 HG	523	u8 irqwake_stat;
	524	struct platform_device *pdev = to_platform_device(dev);
	525	const struct platform_device_id *id_entry =
	526	platform_get_device_id(pdev);
	527
fc9bd902	528	/* Enable the clock/module so that we can access the registers */
04ebc359	529	pm_runtime_get_sync(dev);
fc9bd902	530
8af750e3	531	if (device_may_wakeup(dev)) {
db68b189	532	disable_irq_wake(omap_rtc_alarm);
8af750e3 HG	533
	534	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
	535	irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
	536	irqwake_stat &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
	537	rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
	538	}
	539	} else {
db68b189	540	rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
8af750e3	541	}
db68b189 DB	542	return 0;
db68b189 DB	543	}
db68b189 DB	544	#endif
db68b189 DB	545
04ebc359 JH	546	static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);
04ebc359 JH	547
db68b189 DB	548	static void omap_rtc_shutdown(struct platform_device *pdev)
	549	{
	550	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
	551	}
	552
ad28a07b	553	MODULE_ALIAS("platform:omap_rtc");
db68b189	554	static struct platform_driver omap_rtc_driver = {
71fc8224	555	.remove = __exit_p(omap_rtc_remove),
db68b189 DB	556	.shutdown = omap_rtc_shutdown,
db68b189 DB	557	.driver = {
cab1458c	558	.name = DRIVER_NAME,
db68b189	559	.owner = THIS_MODULE,
04ebc359	560	.pm = &omap_rtc_pm_ops,
616b7341	561	.of_match_table = omap_rtc_of_match,
db68b189	562	},
cab1458c	563	.id_table = omap_rtc_devtype,
db68b189 DB	564	};
db68b189 DB	565
09c5a36b	566	module_platform_driver_probe(omap_rtc_driver, omap_rtc_probe);
db68b189 DB	567
	568	MODULE_AUTHOR("George G. Davis (and others)");
	569	MODULE_LICENSE("GPL");