drivers/rtc/rtc-mxc.c: make alarm work

Fix alarm IRQ handling, make the alarm one-shot.  Cleanup black magick
with a validation of already validated time data.

Add ability to wake the system with alarm.

[akpm@linux-foundation.org: fix CONFIG_PM=n build]
Signed-off-by: Yauhen Kharuzhy <jekhor@gmail.com>
Cc: Daniel Mack <daniel@caiaq.de>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 11b7b614fc8d6ecde83222dd95d0649fa723b688..5e1d64ee52289b9e7a47990f8c7de0b41c7fccaf 100644 (file)
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -155,7 +155,6 @@ static int rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
 {
        struct rtc_time alarm_tm, now_tm;
        unsigned long now, time;
-       int ret;
        struct platform_device *pdev = to_platform_device(dev);
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        void __iomem *ioaddr = pdata->ioaddr;
@@ -168,21 +167,33 @@ static int rtc_update_alarm(struct device *dev, struct rtc_time *alrm)
        alarm_tm.tm_hour = alrm->tm_hour;
        alarm_tm.tm_min = alrm->tm_min;
        alarm_tm.tm_sec = alrm->tm_sec;
-       rtc_tm_to_time(&now_tm, &now);
        rtc_tm_to_time(&alarm_tm, &time);
 
-       if (time < now) {
-               time += 60 * 60 * 24;
-               rtc_time_to_tm(time, &alarm_tm);
-       }
-
-       ret = rtc_tm_to_time(&alarm_tm, &time);
-
        /* clear all the interrupt status bits */
        writew(readw(ioaddr + RTC_RTCISR), ioaddr + RTC_RTCISR);
        set_alarm_or_time(dev, MXC_RTC_ALARM, time);
 
-       return ret;
+       return 0;
+}
+
+static void mxc_rtc_irq_enable(struct device *dev, unsigned int bit,
+                               unsigned int enabled)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+       void __iomem *ioaddr = pdata->ioaddr;
+       u32 reg;
+
+       spin_lock_irq(&pdata->rtc->irq_lock);
+       reg = readw(ioaddr + RTC_RTCIENR);
+
+       if (enabled)
+               reg |= bit;
+       else
+               reg &= ~bit;
+
+       writew(reg, ioaddr + RTC_RTCIENR);
+       spin_unlock_irq(&pdata->rtc->irq_lock);
 }
 
 /* This function is the RTC interrupt service routine. */
@@ -199,13 +210,12 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
        /* clear interrupt sources */
        writew(status, ioaddr + RTC_RTCISR);
 
-       /* clear alarm interrupt if it has occurred */
-       if (status & RTC_ALM_BIT)
-               status &= ~RTC_ALM_BIT;
-
        /* update irq data & counter */
-       if (status & RTC_ALM_BIT)
+       if (status & RTC_ALM_BIT) {
                events |= (RTC_AF | RTC_IRQF);
+               /* RTC alarm should be one-shot */
+               mxc_rtc_irq_enable(&pdev->dev, RTC_ALM_BIT, 0);
+       }
 
        if (status & RTC_1HZ_BIT)
                events |= (RTC_UF | RTC_IRQF);
@@ -213,9 +223,6 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
        if (status & PIT_ALL_ON)
                events |= (RTC_PF | RTC_IRQF);
 
-       if ((status & RTC_ALM_BIT) && rtc_valid_tm(&pdata->g_rtc_alarm))
-               rtc_update_alarm(&pdev->dev, &pdata->g_rtc_alarm);
-
        rtc_update_irq(pdata->rtc, 1, events);
        spin_unlock_irq(&pdata->rtc->irq_lock);
 
@@ -242,26 +249,6 @@ static void mxc_rtc_release(struct device *dev)
        spin_unlock_irq(&pdata->rtc->irq_lock);
 }
 
-static void mxc_rtc_irq_enable(struct device *dev, unsigned int bit,
-                               unsigned int enabled)
-{
-       struct platform_device *pdev = to_platform_device(dev);
-       struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-       void __iomem *ioaddr = pdata->ioaddr;
-       u32 reg;
-
-       spin_lock_irq(&pdata->rtc->irq_lock);
-       reg = readw(ioaddr + RTC_RTCIENR);
-
-       if (enabled)
-               reg |= bit;
-       else
-               reg &= ~bit;
-
-       writew(reg, ioaddr + RTC_RTCIENR);
-       spin_unlock_irq(&pdata->rtc->irq_lock);
-}
-
 static int mxc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
        mxc_rtc_irq_enable(dev, RTC_ALM_BIT, enabled);
@@ -335,21 +322,7 @@ static int mxc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
        int ret;
 
-       if (rtc_valid_tm(&alrm->time)) {
-               if (alrm->time.tm_sec > 59 ||
-                   alrm->time.tm_hour > 23 ||
-                   alrm->time.tm_min > 59)
-                       return -EINVAL;
-
-               ret = rtc_update_alarm(dev, &alrm->time);
-       } else {
-               ret = rtc_valid_tm(&alrm->time);
-               if (ret)
-                       return ret;
-
-               ret = rtc_update_alarm(dev, &alrm->time);
-       }
-
+       ret = rtc_update_alarm(dev, &alrm->time);
        if (ret)
                return ret;
 
@@ -435,6 +408,9 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
                pdata->irq = -1;
        }
 
+       if (pdata->irq >=0)
+               device_init_wakeup(&pdev->dev, 1);
+
        rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
                                  THIS_MODULE);
        if (IS_ERR(rtc)) {
@@ -470,9 +446,39 @@ static int __exit mxc_rtc_remove(struct platform_device *pdev)
        return 0;
 }
 
+#ifdef CONFIG_PM
+static int mxc_rtc_suspend(struct device *dev)
+{
+       struct rtc_plat_data *pdata = dev_get_drvdata(dev);
+
+       if (device_may_wakeup(dev))
+               enable_irq_wake(pdata->irq);
+
+       return 0;
+}
+
+static int mxc_rtc_resume(struct device *dev)
+{
+       struct rtc_plat_data *pdata = dev_get_drvdata(dev);
+
+       if (device_may_wakeup(dev))
+               disable_irq_wake(pdata->irq);
+
+       return 0;
+}
+
+static struct dev_pm_ops mxc_rtc_pm_ops = {
+       .suspend        = mxc_rtc_suspend,
+       .resume         = mxc_rtc_resume,
+};
+#endif
+
 static struct platform_driver mxc_rtc_driver = {
        .driver = {
                   .name        = "mxc_rtc",
+#ifdef CONFIG_PM
+                  .pm          = &mxc_rtc_pm_ops,
+#endif
                   .owner       = THIS_MODULE,
        },
        .remove         = __exit_p(mxc_rtc_remove),