mmc: atmel-mci: add runtime pm support

Add runtime pm support to atmel mci controller.
Use runtime pm APIs to enable/disable atmel mci's clock.
Use runtime autosuspend APIs to enable auto suspend delay.

Signed-off-by: Wenyou Yang <wenyou.yang@atmel.com>
Acked-by: Ludovic Desroches <ludovic.desroches@atmel.com>
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
[Ulf: Fixed compile error]

diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index d9646e5..4df1599 100644 (file)
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -37,6 +37,8 @@
 
 #include <linux/atmel-mci.h>
 #include <linux/atmel_pdc.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
 
 #include <asm/cacheflush.h>
 #include <asm/io.h>
@@ -44,6 +46,8 @@
 
 #include "atmel-mci-regs.h"
 
+#define AUTOSUSPEND_DELAY      50
+
 #define ATMCI_DATA_ERROR_FLAGS (ATMCI_DCRCE | ATMCI_DTOE | ATMCI_OVRE | ATMCI_UNRE)
 #define ATMCI_DMA_THRESHOLD    16
 
@@ -386,20 +390,19 @@ static int atmci_regs_show(struct seq_file *s, void *v)
        if (!buf)
                return -ENOMEM;
 
+       pm_runtime_get_sync(&host->pdev->dev);
+
        /*
         * Grab a more or less consistent snapshot. Note that we're
         * not disabling interrupts, so IMR and SR may not be
         * consistent.
         */
-       ret = clk_prepare_enable(host->mck);
-       if (ret)
-               goto out;
-
        spin_lock_bh(&host->lock);
        memcpy_fromio(buf, host->regs, ATMCI_REGS_SIZE);
        spin_unlock_bh(&host->lock);
 
-       clk_disable_unprepare(host->mck);
+       pm_runtime_mark_last_busy(&host->pdev->dev);
+       pm_runtime_put_autosuspend(&host->pdev->dev);
 
        seq_printf(s, "MR:\t0x%08x%s%s ",
                        buf[ATMCI_MR / 4],
@@ -449,7 +452,6 @@ static int atmci_regs_show(struct seq_file *s, void *v)
                                val & ATMCI_CFG_LSYNC ? " LSYNC" : "");
        }
 
-out:
        kfree(buf);
 
        return ret;
@@ -1255,6 +1257,8 @@ static void atmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
        WARN_ON(slot->mrq);
        dev_dbg(&host->pdev->dev, "MRQ: cmd %u\n", mrq->cmd->opcode);
 
+       pm_runtime_get_sync(&host->pdev->dev);
+
        /*
         * We may "know" the card is gone even though there's still an
         * electrical connection. If so, we really need to communicate
@@ -1284,7 +1288,8 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
        struct atmel_mci_slot   *slot = mmc_priv(mmc);
        struct atmel_mci        *host = slot->host;
        unsigned int            i;
-       bool                    unprepare_clk;
+
+       pm_runtime_get_sync(&host->pdev->dev);
 
        slot->sdc_reg &= ~ATMCI_SDCBUS_MASK;
        switch (ios->bus_width) {
@@ -1300,13 +1305,8 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                unsigned int clock_min = ~0U;
                u32 clkdiv;
 
-               clk_prepare(host->mck);
-               unprepare_clk = true;
-
                spin_lock_bh(&host->lock);
                if (!host->mode_reg) {
-                       clk_enable(host->mck);
-                       unprepare_clk = false;
                        atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST);
                        atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIEN);
                        if (host->caps.has_cfg_reg)
@@ -1374,8 +1374,6 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
        } else {
                bool any_slot_active = false;
 
-               unprepare_clk = false;
-
                spin_lock_bh(&host->lock);
                slot->clock = 0;
                for (i = 0; i < ATMCI_MAX_NR_SLOTS; i++) {
@@ -1388,17 +1386,12 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                        atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIDIS);
                        if (host->mode_reg) {
                                atmci_readl(host, ATMCI_MR);
-                               clk_disable(host->mck);
-                               unprepare_clk = true;
                        }
                        host->mode_reg = 0;
                }
                spin_unlock_bh(&host->lock);
        }
 
-       if (unprepare_clk)
-               clk_unprepare(host->mck);
-
        switch (ios->power_mode) {
        case MMC_POWER_OFF:
                if (!IS_ERR(mmc->supply.vmmc))
@@ -1424,6 +1417,9 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 */
                break;
        }
+
+       pm_runtime_mark_last_busy(&host->pdev->dev);
+       pm_runtime_put_autosuspend(&host->pdev->dev);
 }
 
 static int atmci_get_ro(struct mmc_host *mmc)
@@ -1515,6 +1511,9 @@ static void atmci_request_end(struct atmel_mci *host, struct mmc_request *mrq)
        spin_unlock(&host->lock);
        mmc_request_done(prev_mmc, mrq);
        spin_lock(&host->lock);
+
+       pm_runtime_mark_last_busy(&host->pdev->dev);
+       pm_runtime_put_autosuspend(&host->pdev->dev);
 }
 
 static void atmci_command_complete(struct atmel_mci *host,
@@ -2424,15 +2423,16 @@ static int __init atmci_probe(struct platform_device *pdev)
 
        atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST);
        host->bus_hz = clk_get_rate(host->mck);
-       clk_disable_unprepare(host->mck);
 
        host->mapbase = regs->start;
 
        tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)host);
 
        ret = request_irq(irq, atmci_interrupt, 0, dev_name(&pdev->dev), host);
-       if (ret)
+       if (ret) {
+               clk_disable_unprepare(host->mck);
                return ret;
+       }
 
        /* Get MCI capabilities and set operations according to it */
        atmci_get_cap(host);
@@ -2456,6 +2456,12 @@ static int __init atmci_probe(struct platform_device *pdev)
 
        setup_timer(&host->timer, atmci_timeout_timer, (unsigned long)host);
 
+       pm_runtime_get_noresume(&pdev->dev);
+       pm_runtime_set_active(&pdev->dev);
+       pm_runtime_set_autosuspend_delay(&pdev->dev, AUTOSUSPEND_DELAY);
+       pm_runtime_use_autosuspend(&pdev->dev);
+       pm_runtime_enable(&pdev->dev);
+
        /* We need at least one slot to succeed */
        nr_slots = 0;
        ret = -ENODEV;
@@ -2498,6 +2504,9 @@ static int __init atmci_probe(struct platform_device *pdev)
                        "Atmel MCI controller at 0x%08lx irq %d, %u slots\n",
                        host->mapbase, irq, nr_slots);
 
+       pm_runtime_mark_last_busy(&host->pdev->dev);
+       pm_runtime_put_autosuspend(&pdev->dev);
+
        return 0;
 
 err_dma_alloc:
@@ -2506,6 +2515,11 @@ err_dma_alloc:
                        atmci_cleanup_slot(host->slot[i], i);
        }
 err_init_slot:
+       clk_disable_unprepare(host->mck);
+
+       pm_runtime_disable(&pdev->dev);
+       pm_runtime_put_noidle(&pdev->dev);
+
        del_timer_sync(&host->timer);
        if (host->dma.chan)
                dma_release_channel(host->dma.chan);
@@ -2518,6 +2532,8 @@ static int __exit atmci_remove(struct platform_device *pdev)
        struct atmel_mci        *host = platform_get_drvdata(pdev);
        unsigned int            i;
 
+       pm_runtime_get_sync(&pdev->dev);
+
        if (host->buffer)
                dma_free_coherent(&pdev->dev, host->buf_size,
                                  host->buffer, host->buf_phys_addr);
@@ -2527,11 +2543,9 @@ static int __exit atmci_remove(struct platform_device *pdev)
                        atmci_cleanup_slot(host->slot[i], i);
        }
 
-       clk_prepare_enable(host->mck);
        atmci_writel(host, ATMCI_IDR, ~0UL);
        atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIDIS);
        atmci_readl(host, ATMCI_SR);
-       clk_disable_unprepare(host->mck);
 
        del_timer_sync(&host->timer);
        if (host->dma.chan)
@@ -2539,14 +2553,44 @@ static int __exit atmci_remove(struct platform_device *pdev)
 
        free_irq(platform_get_irq(pdev, 0), host);
 
+       clk_disable_unprepare(host->mck);
+
+       pm_runtime_disable(&pdev->dev);
+       pm_runtime_put_noidle(&pdev->dev);
+
+       return 0;
+}
+
+#ifdef CONFIG_PM
+static int atmci_runtime_suspend(struct device *dev)
+{
+       struct atmel_mci *host = dev_get_drvdata(dev);
+
+       clk_disable_unprepare(host->mck);
+
        return 0;
 }
 
+static int atmci_runtime_resume(struct device *dev)
+{
+       struct atmel_mci *host = dev_get_drvdata(dev);
+
+       return clk_prepare_enable(host->mck);
+}
+#endif
+
+static const struct dev_pm_ops atmci_dev_pm_ops = {
+       SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+                               pm_runtime_force_resume)
+       SET_PM_RUNTIME_PM_OPS(atmci_runtime_suspend, atmci_runtime_resume, NULL)
+};
+
 static struct platform_driver atmci_driver = {
        .remove         = __exit_p(atmci_remove),
        .driver         = {
                .name           = "atmel_mci",
                .of_match_table = of_match_ptr(atmci_dt_ids),
+               .pm             = &atmci_dev_pm_ops,
        },
 };