rtc: omap: add device abstraction (55ba953a) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/rtc/rtc-omap.c

+133 −106

Original line number	Original line	Diff line number	Diff line
	@@ -118,26 +118,42 @@
	*/		*/
	#define OMAP_RTC_HAS_32KCLK_EN BIT(2)		#define OMAP_RTC_HAS_32KCLK_EN BIT(2)

	static void __iomem *rtc_base;		struct omap_rtc {
			struct rtc_device *rtc;
			void __iomem *base;
			int irq_alarm;
			int irq_timer;
			u8 interrupts_reg;
			unsigned long flags;
			};

	#define rtc_read(addr) readb(rtc_base + (addr))		static inline u8 rtc_read(struct omap_rtc *rtc, unsigned int reg)
	#define rtc_write(val, addr) writeb(val, rtc_base + (addr))		{
			return readb(rtc->base + reg);
			}

	#define rtc_writel(val, addr) writel(val, rtc_base + (addr))		static inline void rtc_write(struct omap_rtc *rtc, unsigned int reg, u8 val)
			{
			writeb(val, rtc->base + reg);
			}

			static inline void rtc_writel(struct omap_rtc *rtc, unsigned int reg, u32 val)
			{
			writel(val, rtc->base + reg);
			}

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

	/* BUSY may stay active for 1/32768 second (~30 usec) */		/* BUSY may stay active for 1/32768 second (~30 usec) */
	for (count = 0; count < 50; count++) {		for (count = 0; count < 50; count++) {
	status = rtc_read(OMAP_RTC_STATUS_REG);		status = rtc_read(rtc, OMAP_RTC_STATUS_REG);
	if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)		if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
	break;		break;
	udelay(1);		udelay(1);
	@@ -145,16 +161,17 @@ static void rtc_wait_not_busy(void)
	/* now we have ~15 usec to read/write various registers */		/* now we have ~15 usec to read/write various registers */
	}		}

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

	irq_data = rtc_read(OMAP_RTC_STATUS_REG);		irq_data = rtc_read(rtc, OMAP_RTC_STATUS_REG);

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

	@@ -162,23 +179,21 @@ static irqreturn_t rtc_irq(int irq, void *rtc)
	if (irq_data & OMAP_RTC_STATUS_1S_EVENT)		if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
	events \|= RTC_IRQF \| RTC_UF;		events \|= RTC_IRQF \| RTC_UF;

	rtc_update_irq(rtc, 1, events);		rtc_update_irq(rtc->rtc, 1, events);

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}

	static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)		static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);
	u8 reg, irqwake_reg = 0;		u8 reg, irqwake_reg = 0;
	struct platform_device *pdev = to_platform_device(dev);
	const struct platform_device_id *id_entry =
	platform_get_device_id(pdev);

	local_irq_disable();		local_irq_disable();
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);
	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);		reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)		if (rtc->flags & OMAP_RTC_HAS_IRQWAKEEN)
	irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);		irqwake_reg = rtc_read(rtc, OMAP_RTC_IRQWAKEEN);

	if (enabled) {		if (enabled) {
	reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;		reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;
	@@ -187,10 +202,10 @@ static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
	reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;		irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
	}		}
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);
	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);		rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, reg);
	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)		if (rtc->flags & OMAP_RTC_HAS_IRQWAKEEN)
	rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);		rtc_write(rtc, OMAP_RTC_IRQWAKEEN, irqwake_reg);
	local_irq_enable();		local_irq_enable();

	return 0;		return 0;
	@@ -231,16 +246,18 @@ static void bcd2tm(struct rtc_time *tm)

	static int omap_rtc_read_time(struct device dev, struct rtc_time tm)		static int omap_rtc_read_time(struct device dev, struct rtc_time tm)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);

	/* we don't report wday/yday/isdst ... */		/* we don't report wday/yday/isdst ... */
	local_irq_disable();		local_irq_disable();
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);

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

	local_irq_enable();		local_irq_enable();

	@@ -250,17 +267,19 @@ static int omap_rtc_read_time(struct device dev, struct rtc_time tm)

	static int omap_rtc_set_time(struct device dev, struct rtc_time tm)		static int omap_rtc_set_time(struct device dev, struct rtc_time tm)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);

	if (tm2bcd(tm) < 0)		if (tm2bcd(tm) < 0)
	return -EINVAL;		return -EINVAL;
	local_irq_disable();		local_irq_disable();
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);

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

	local_irq_enable();		local_irq_enable();

	@@ -269,20 +288,22 @@ static int omap_rtc_set_time(struct device dev, struct rtc_time tm)

	static int omap_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)		static int omap_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);

	local_irq_disable();		local_irq_disable();
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);

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

	local_irq_enable();		local_irq_enable();

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

	return 0;		return 0;
	@@ -290,27 +311,25 @@ static int omap_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)

	static int omap_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)		static int omap_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);
	u8 reg, irqwake_reg = 0;		u8 reg, irqwake_reg = 0;
	struct platform_device *pdev = to_platform_device(dev);
	const struct platform_device_id *id_entry =
	platform_get_device_id(pdev);

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

	local_irq_disable();		local_irq_disable();
	rtc_wait_not_busy();		rtc_wait_not_busy(rtc);

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

	reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);		reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)		if (rtc->flags & OMAP_RTC_HAS_IRQWAKEEN)
	irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);		irqwake_reg = rtc_read(rtc, OMAP_RTC_IRQWAKEEN);

	if (alm->enabled) {		if (alm->enabled) {
	reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;		reg \|= OMAP_RTC_INTERRUPTS_IT_ALARM;
	@@ -319,9 +338,9 @@ static int omap_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;		reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
	irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;		irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
	}		}
	rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);		rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, reg);
	if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)		if (rtc->flags & OMAP_RTC_HAS_IRQWAKEEN)
	rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);		rtc_write(rtc, OMAP_RTC_IRQWAKEEN, irqwake_reg);

	local_irq_enable();		local_irq_enable();

	@@ -336,9 +355,6 @@ static struct rtc_class_ops omap_rtc_ops = {
	.alarm_irq_enable = omap_rtc_alarm_irq_enable,		.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_AM3352_IDX 1
	#define OMAP_RTC_DATA_DA830_IDX 2		#define OMAP_RTC_DATA_DA830_IDX 2

	@@ -372,13 +388,17 @@ MODULE_DEVICE_TABLE(of, omap_rtc_of_match);

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

			rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
			if (!rtc)
			return -ENOMEM;

	of_id = of_match_device(omap_rtc_of_match, &pdev->dev);		of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
	if (of_id)		if (of_id)
	pdev->id_entry = of_id->data;		pdev->id_entry = of_id->data;
	@@ -389,26 +409,30 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
	return -ENODEV;		return -ENODEV;
	}		}

	omap_rtc_timer = platform_get_irq(pdev, 0);		rtc->flags = id_entry->driver_data;
	if (omap_rtc_timer <= 0)
			rtc->irq_timer = platform_get_irq(pdev, 0);
			if (rtc->irq_timer <= 0)
	return -ENOENT;		return -ENOENT;

	omap_rtc_alarm = platform_get_irq(pdev, 1);		rtc->irq_alarm = platform_get_irq(pdev, 1);
	if (omap_rtc_alarm <= 0)		if (rtc->irq_alarm <= 0)
	return -ENOENT;		return -ENOENT;

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

			platform_set_drvdata(pdev, rtc);

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

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

	/*		/*
	@@ -416,25 +440,26 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
	*		*
	* NOTE: ALARM2 is not cleared on AM3352 if rtc_write (writeb) is used		* NOTE: ALARM2 is not cleared on AM3352 if rtc_write (writeb) is used
	*/		*/
	rtc_writel(0, OMAP_RTC_INTERRUPTS_REG);		rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG, 0);

	/* enable RTC functional clock */		/* enable RTC functional clock */
	if (id_entry->driver_data & OMAP_RTC_HAS_32KCLK_EN) {		if (rtc->flags & OMAP_RTC_HAS_32KCLK_EN) {
	reg = rtc_read(OMAP_RTC_OSC_REG);		reg = rtc_read(rtc, OMAP_RTC_OSC_REG);
	rtc_writel(reg \| OMAP_RTC_OSC_32KCLK_EN, OMAP_RTC_OSC_REG);		rtc_writel(rtc, OMAP_RTC_OSC_REG,
			reg \| OMAP_RTC_OSC_32KCLK_EN);
	}		}

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

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

	@@ -460,27 +485,26 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
	dev_info(&pdev->dev, "split power mode\n");		dev_info(&pdev->dev, "split power mode\n");

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

	device_init_wakeup(&pdev->dev, true);		device_init_wakeup(&pdev->dev, true);

	rtc = devm_rtc_device_register(&pdev->dev, pdev->name,		rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
	&omap_rtc_ops, THIS_MODULE);		&omap_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc)) {		if (IS_ERR(rtc->rtc)) {
	ret = PTR_ERR(rtc);		ret = PTR_ERR(rtc->rtc);
	goto err;		goto err;
	}		}
	platform_set_drvdata(pdev, rtc);

	/* handle periodic and alarm irqs */		/* handle periodic and alarm irqs */
	ret = devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,		ret = devm_request_irq(&pdev->dev, rtc->irq_timer, rtc_irq, 0,
	dev_name(&rtc->dev), rtc);		dev_name(&rtc->rtc->dev), rtc);
	if (ret)		if (ret)
	goto err;		goto err;

	if (omap_rtc_timer != omap_rtc_alarm) {		if (rtc->irq_timer != rtc->irq_alarm) {
	ret = devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,		ret = devm_request_irq(&pdev->dev, rtc->irq_alarm, rtc_irq, 0,
	dev_name(&rtc->dev), rtc);		dev_name(&rtc->rtc->dev), rtc);
	if (ret)		if (ret)
	goto err;		goto err;
	}		}
	@@ -489,8 +513,8 @@ static int __init omap_rtc_probe(struct platform_device *pdev)

	err:		err:
	device_init_wakeup(&pdev->dev, false);		device_init_wakeup(&pdev->dev, false);
	if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)		if (rtc->flags & OMAP_RTC_HAS_KICKER)
	rtc_writel(0, OMAP_RTC_KICK0_REG);		rtc_writel(rtc, OMAP_RTC_KICK0_REG, 0);
	pm_runtime_put_sync(&pdev->dev);		pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);		pm_runtime_disable(&pdev->dev);

	@@ -499,16 +523,15 @@ static int __init omap_rtc_probe(struct platform_device *pdev)

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

	device_init_wakeup(&pdev->dev, 0);		device_init_wakeup(&pdev->dev, 0);

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

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

	/* Disable the clock/module */		/* Disable the clock/module */
	pm_runtime_put_sync(&pdev->dev);		pm_runtime_put_sync(&pdev->dev);
	@@ -518,20 +541,20 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
	}		}

	#ifdef CONFIG_PM_SLEEP		#ifdef CONFIG_PM_SLEEP
	static u8 irqstat;

	static int omap_rtc_suspend(struct device *dev)		static int omap_rtc_suspend(struct device *dev)
	{		{
	irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);		struct omap_rtc *rtc = dev_get_drvdata(dev);

			rtc->interrupts_reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);

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

	/* Disable the clock/module */		/* Disable the clock/module */
	pm_runtime_put_sync(dev);		pm_runtime_put_sync(dev);
	@@ -541,13 +564,15 @@ static int omap_rtc_suspend(struct device *dev)

	static int omap_rtc_resume(struct device *dev)		static int omap_rtc_resume(struct device *dev)
	{		{
			struct omap_rtc *rtc = dev_get_drvdata(dev);

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

	if (device_may_wakeup(dev))		if (device_may_wakeup(dev))
	disable_irq_wake(omap_rtc_alarm);		disable_irq_wake(rtc->irq_alarm);
	else		else
	rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);		rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, rtc->interrupts_reg);

	return 0;		return 0;
	}		}
	@@ -557,7 +582,9 @@ static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);

	static void omap_rtc_shutdown(struct platform_device *pdev)		static void omap_rtc_shutdown(struct platform_device *pdev)
	{		{
	rtc_write(0, OMAP_RTC_INTERRUPTS_REG);		struct omap_rtc *rtc = platform_get_drvdata(pdev);

			rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, 0);
	}		}

	MODULE_ALIAS("platform:omap_rtc");		MODULE_ALIAS("platform:omap_rtc");