rtc: xgene: mark PM functions as __maybe_unused

[linux-block.git] / drivers / rtc / rtc-xgene.c

diff --git a/drivers/rtc/rtc-xgene.c b/drivers/rtc/rtc-xgene.c
index 65b432a096fe22ffc489f876c355f05654315bb4..0c34d3b81279e535bbe027e77bce04443bd5b05a 100644 (file)
--- a/drivers/rtc/rtc-xgene.c
+++ b/drivers/rtc/rtc-xgene.c
@@ -52,6 +52,7 @@ struct xgene_rtc_dev {
        void __iomem *csr_base;
        struct clk *clk;
        unsigned int irq_wake;
+       unsigned int irq_enabled;
 };
 
 static int xgene_rtc_read_time(struct device *dev, struct rtc_time *tm)
@@ -104,15 +105,19 @@ static int xgene_rtc_alarm_irq_enable(struct device *dev, u32 enabled)
        return 0;
 }
 
+static int xgene_rtc_alarm_irq_enabled(struct device *dev)
+{
+       struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+
+       return readl(pdata->csr_base + RTC_CCR) & RTC_CCR_IE ? 1 : 0;
+}
+
 static int xgene_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
-       unsigned long rtc_time;
        unsigned long alarm_time;
 
-       rtc_time = readl(pdata->csr_base + RTC_CCVR);
        rtc_tm_to_time(&alrm->time, &alarm_time);
-
        pdata->alarm_time = alarm_time;
        writel((u32) pdata->alarm_time, pdata->csr_base + RTC_CMR);
 
@@ -180,12 +185,18 @@ static int xgene_rtc_probe(struct platform_device *pdev)
                dev_err(&pdev->dev, "Couldn't get the clock for RTC\n");
                return -ENODEV;
        }
-       clk_prepare_enable(pdata->clk);
+       ret = clk_prepare_enable(pdata->clk);
+       if (ret)
+               return ret;
 
        /* Turn on the clock and the crystal */
        writel(RTC_CCR_EN, pdata->csr_base + RTC_CCR);
 
-       device_init_wakeup(&pdev->dev, 1);
+       ret = device_init_wakeup(&pdev->dev, 1);
+       if (ret) {
+               clk_disable_unprepare(pdata->clk);
+               return ret;
+       }
 
        pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
                                         &xgene_rtc_ops, THIS_MODULE);
@@ -210,45 +221,55 @@ static int xgene_rtc_remove(struct platform_device *pdev)
        return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int xgene_rtc_suspend(struct device *dev)
+static int __maybe_unused xgene_rtc_suspend(struct device *dev)
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
        int irq;
 
        irq = platform_get_irq(pdev, 0);
+
+       /*
+        * If this RTC alarm will be used for waking the system up,
+        * don't disable it of course. Else we just disable the alarm
+        * and await suspension.
+        */
        if (device_may_wakeup(&pdev->dev)) {
                if (!enable_irq_wake(irq))
                        pdata->irq_wake = 1;
        } else {
+               pdata->irq_enabled = xgene_rtc_alarm_irq_enabled(dev);
                xgene_rtc_alarm_irq_enable(dev, 0);
-               clk_disable(pdata->clk);
+               clk_disable_unprepare(pdata->clk);
        }
-
        return 0;
 }
 
-static int xgene_rtc_resume(struct device *dev)
+static int __maybe_unused xgene_rtc_resume(struct device *dev)
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
        int irq;
+       int rc;
 
        irq = platform_get_irq(pdev, 0);
+
        if (device_may_wakeup(&pdev->dev)) {
                if (pdata->irq_wake) {
                        disable_irq_wake(irq);
                        pdata->irq_wake = 0;
                }
        } else {
-               clk_enable(pdata->clk);
-               xgene_rtc_alarm_irq_enable(dev, 1);
+               rc = clk_prepare_enable(pdata->clk);
+               if (rc) {
+                       dev_err(dev, "Unable to enable clock error %d\n", rc);
+                       return rc;
+               }
+               xgene_rtc_alarm_irq_enable(dev, pdata->irq_enabled);
        }
 
        return 0;
 }
-#endif
 
 static SIMPLE_DEV_PM_OPS(xgene_rtc_pm_ops, xgene_rtc_suspend, xgene_rtc_resume);