mmc: sdhci-pci: add runtime pm support

Ths patch allows runtime PM for sdhci-pci, runtime suspending after
inactivity of 50ms and ensuring runtime resume before SDHC registers
are accessed.  During runtime suspend, interrupts are masked.
The host controller state is restored at runtime resume.

For Medfield, the host controller's card detect mechanism is
supplanted by an always-on GPIO which provides for card detect wake-up.

Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Signed-off-by: Chris Ball <cjb@laptop.org>

1 files changed, 211 insertions, 44 deletions

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 9394860602fe..155deb8629af 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/leds.h>
 
@@ -42,6 +43,7 @@
 #define MAX_TUNING_LOOP 40
 
 static unsigned int debug_quirks = 0;
+static unsigned int debug_quirks2;
 
 static void sdhci_finish_data(struct sdhci_host *);
 
@@ -50,6 +52,20 @@ static void sdhci_finish_command(struct sdhci_host *);
 static int sdhci_execute_tuning(struct mmc_host *mmc);
 static void sdhci_tuning_timer(unsigned long data);
 
+#ifdef CONFIG_PM_RUNTIME
+static int sdhci_runtime_pm_get(struct sdhci_host *host);
+static int sdhci_runtime_pm_put(struct sdhci_host *host);
+#else
+static inline int sdhci_runtime_pm_get(struct sdhci_host *host)
+{
+        return 0;
+}
+static inline int sdhci_runtime_pm_put(struct sdhci_host *host)
+{
+        return 0;
+}
+#endif
+
 static void sdhci_dumpregs(struct sdhci_host *host)
 {
         printk(KERN_DEBUG DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
@@ -133,6 +149,9 @@ static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
         if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
                 return;
 
+        if (host->quirks2 & SDHCI_QUIRK2_OWN_CARD_DETECTION)
+                return;
+
         present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
                               SDHCI_CARD_PRESENT;
         irqs = present ? SDHCI_INT_CARD_REMOVE : SDHCI_INT_CARD_INSERT;
@@ -252,11 +271,14 @@ static void sdhci_led_control(struct led_classdev *led,
 
         spin_lock_irqsave(&host->lock, flags);
 
+        if (host->runtime_suspended)
+                goto out;
+
         if (brightness == LED_OFF)
                 sdhci_deactivate_led(host);
         else
                 sdhci_activate_led(host);
-
+out:
         spin_unlock_irqrestore(&host->lock, flags);
 }
 #endif
@@ -1210,6 +1232,8 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         host = mmc_priv(mmc);
 
+        sdhci_runtime_pm_get(host);
+
         spin_lock_irqsave(&host->lock, flags);
 
         WARN_ON(host->mrq != NULL);
@@ -1270,14 +1294,11 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
 {
-        struct sdhci_host *host;
         unsigned long flags;
         u8 ctrl;
 
-        host = mmc_priv(mmc);
-
         spin_lock_irqsave(&host->lock, flags);
 
         if (host->flags & SDHCI_DEVICE_DEAD)
@@ -1427,7 +1448,16 @@ out:
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int check_ro(struct sdhci_host *host)
+static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+
+        sdhci_runtime_pm_get(host);
+        sdhci_do_set_ios(host, ios);
+        sdhci_runtime_pm_put(host);
+}
+
+static int sdhci_check_ro(struct sdhci_host *host)
 {
         unsigned long flags;
         int is_readonly;
@@ -1451,19 +1481,16 @@ static int check_ro(struct sdhci_host *host)
 
 #define SAMPLE_COUNT    5
 
-static int sdhci_get_ro(struct mmc_host *mmc)
+static int sdhci_do_get_ro(struct sdhci_host *host)
 {
-        struct sdhci_host *host;
         int i, ro_count;
 
-        host = mmc_priv(mmc);
-
         if (!(host->quirks & SDHCI_QUIRK_UNSTABLE_RO_DETECT))
-                return check_ro(host);
+                return sdhci_check_ro(host);
 
         ro_count = 0;
         for (i = 0; i < SAMPLE_COUNT; i++) {
-                if (check_ro(host)) {
+                if (sdhci_check_ro(host)) {
                         if (++ro_count > SAMPLE_COUNT / 2)
                                 return 1;
                 }
@@ -1480,38 +1507,56 @@ static void sdhci_hw_reset(struct mmc_host *mmc)
                 host->ops->hw_reset(host);
 }
 
-static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
+static int sdhci_get_ro(struct mmc_host *mmc)
 {
-        struct sdhci_host *host;
-        unsigned long flags;
-
-        host = mmc_priv(mmc);
+        struct sdhci_host *host = mmc_priv(mmc);
+        int ret;
 
-        spin_lock_irqsave(&host->lock, flags);
+        sdhci_runtime_pm_get(host);
+        ret = sdhci_do_get_ro(host);
+        sdhci_runtime_pm_put(host);
+        return ret;
+}
 
+static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable)
+{
         if (host->flags & SDHCI_DEVICE_DEAD)
                 goto out;
 
         if (enable)
+                host->flags |= SDHCI_SDIO_IRQ_ENABLED;
+        else
+                host->flags &= ~SDHCI_SDIO_IRQ_ENABLED;
+
+        /* SDIO IRQ will be enabled as appropriate in runtime resume */
+        if (host->runtime_suspended)
+                goto out;
+
+        if (enable)
                 sdhci_unmask_irqs(host, SDHCI_INT_CARD_INT);
         else
                 sdhci_mask_irqs(host, SDHCI_INT_CARD_INT);
 out:
         mmiowb();
+}
+
+static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+        unsigned long flags;
 
+        spin_lock_irqsave(&host->lock, flags);
+        sdhci_enable_sdio_irq_nolock(host, enable);
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
-        struct mmc_ios *ios)
+static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
+                                                struct mmc_ios *ios)
 {
-        struct sdhci_host *host;
         u8 pwr;
         u16 clk, ctrl;
         u32 present_state;
 
-        host = mmc_priv(mmc);
-
         /*
          * Signal Voltage Switching is only applicable for Host Controllers
          * v3.00 and above.
@@ -1604,6 +1649,20 @@ static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
                 return 0;
 }
 
+static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
+        struct mmc_ios *ios)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+        int err;
+
+        if (host->version < SDHCI_SPEC_300)
+                return 0;
+        sdhci_runtime_pm_get(host);
+        err = sdhci_do_start_signal_voltage_switch(host, ios);
+        sdhci_runtime_pm_put(host);
+        return err;
+}
+
 static int sdhci_execute_tuning(struct mmc_host *mmc)
 {
         struct sdhci_host *host;
@@ -1615,6 +1674,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
 
         host = mmc_priv(mmc);
 
+        sdhci_runtime_pm_get(host);
         disable_irq(host->irq);
         spin_lock(&host->lock);
 
@@ -1632,6 +1692,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
         else {
                 spin_unlock(&host->lock);
                 enable_irq(host->irq);
+                sdhci_runtime_pm_put(host);
                 return 0;
         }
 
@@ -1657,7 +1718,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
         timeout = 150;
         do {
                 struct mmc_command cmd = {0};
-                struct mmc_request mrq = {0};
+                struct mmc_request mrq = {NULL};
 
                 if (!tuning_loop_counter && !timeout)
                         break;
@@ -1775,18 +1836,16 @@ out:
         sdhci_clear_set_irqs(host, SDHCI_INT_DATA_AVAIL, ier);
         spin_unlock(&host->lock);
         enable_irq(host->irq);
+        sdhci_runtime_pm_put(host);
 
         return err;
 }
 
-static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
+static void sdhci_do_enable_preset_value(struct sdhci_host *host, bool enable)
 {
-        struct sdhci_host *host;
         u16 ctrl;
         unsigned long flags;
 
-        host = mmc_priv(mmc);
-
         /* Host Controller v3.00 defines preset value registers */
         if (host->version < SDHCI_SPEC_300)
                 return;
@@ -1802,14 +1861,25 @@ static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
         if (enable && !(ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
                 ctrl |= SDHCI_CTRL_PRESET_VAL_ENABLE;
                 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+                host->flags |= SDHCI_PV_ENABLED;
         } else if (!enable && (ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
                 ctrl &= ~SDHCI_CTRL_PRESET_VAL_ENABLE;
                 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+                host->flags &= ~SDHCI_PV_ENABLED;
         }
 
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+
+        sdhci_runtime_pm_get(host);
+        sdhci_do_enable_preset_value(host, enable);
+        sdhci_runtime_pm_put(host);
+}
+
 static const struct mmc_host_ops sdhci_ops = {
         .request        = sdhci_request,
         .set_ios        = sdhci_set_ios,
@@ -1836,19 +1906,19 @@ static void sdhci_tasklet_card(unsigned long param)
 
         spin_lock_irqsave(&host->lock, flags);
 
-        if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
-                if (host->mrq) {
-                        printk(KERN_ERR "%s: Card removed during transfer!\n",
-                                mmc_hostname(host->mmc));
-                        printk(KERN_ERR "%s: Resetting controller.\n",
-                                mmc_hostname(host->mmc));
+        /* Check host->mrq first in case we are runtime suspended */
+        if (host->mrq &&
+            !(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
+                printk(KERN_ERR "%s: Card removed during transfer!\n",
+                        mmc_hostname(host->mmc));
+                printk(KERN_ERR "%s: Resetting controller.\n",
+                        mmc_hostname(host->mmc));
 
-                        sdhci_reset(host, SDHCI_RESET_CMD);
-                        sdhci_reset(host, SDHCI_RESET_DATA);
+                sdhci_reset(host, SDHCI_RESET_CMD);
+                sdhci_reset(host, SDHCI_RESET_DATA);
 
-                        host->mrq->cmd->error = -ENOMEDIUM;
-                        tasklet_schedule(&host->finish_tasklet);
-                }
+                host->mrq->cmd->error = -ENOMEDIUM;
+                tasklet_schedule(&host->finish_tasklet);
         }
 
         spin_unlock_irqrestore(&host->lock, flags);
@@ -1864,14 +1934,16 @@ static void sdhci_tasklet_finish(unsigned long param)
 
         host = (struct sdhci_host*)param;
 
+        spin_lock_irqsave(&host->lock, flags);
+
         /*
          * If this tasklet gets rescheduled while running, it will
          * be run again afterwards but without any active request.
          */
-        if (!host->mrq)
+        if (!host->mrq) {
+                spin_unlock_irqrestore(&host->lock, flags);
                 return;
-
-        spin_lock_irqsave(&host->lock, flags);
+        }
 
         del_timer(&host->timer);
 
@@ -1915,6 +1987,7 @@ static void sdhci_tasklet_finish(unsigned long param)
         spin_unlock_irqrestore(&host->lock, flags);
 
         mmc_request_done(host->mmc, mrq);
+        sdhci_runtime_pm_put(host);
 }
 
 static void sdhci_timeout_timer(unsigned long data)
@@ -2146,12 +2219,19 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
 static irqreturn_t sdhci_irq(int irq, void *dev_id)
 {
         irqreturn_t result;
-        struct sdhci_host* host = dev_id;
+        struct sdhci_host *host = dev_id;
         u32 intmask;
         int cardint = 0;
 
         spin_lock(&host->lock);
 
+        if (host->runtime_suspended) {
+                spin_unlock(&host->lock);
+                printk(KERN_WARNING "%s: got irq while runtime suspended\n",
+                       mmc_hostname(host->mmc));
+                return IRQ_HANDLED;
+        }
+
         intmask = sdhci_readl(host, SDHCI_INT_STATUS);
 
         if (!intmask || intmask == 0xffffffff) {
@@ -2285,7 +2365,6 @@ int sdhci_resume_host(struct sdhci_host *host)
                         return ret;
         }
 
-
         if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
                 if (host->ops->enable_dma)
                         host->ops->enable_dma(host);
@@ -2324,6 +2403,90 @@ EXPORT_SYMBOL_GPL(sdhci_enable_irq_wakeups);
 
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_PM_RUNTIME
+
+static int sdhci_runtime_pm_get(struct sdhci_host *host)
+{
+        return pm_runtime_get_sync(host->mmc->parent);
+}
+
+static int sdhci_runtime_pm_put(struct sdhci_host *host)
+{
+        pm_runtime_mark_last_busy(host->mmc->parent);
+        return pm_runtime_put_autosuspend(host->mmc->parent);
+}
+
+int sdhci_runtime_suspend_host(struct sdhci_host *host)
+{
+        unsigned long flags;
+        int ret = 0;
+
+        /* Disable tuning since we are suspending */
+        if (host->version >= SDHCI_SPEC_300 &&
+            host->tuning_mode == SDHCI_TUNING_MODE_1) {
+                del_timer_sync(&host->tuning_timer);
+                host->flags &= ~SDHCI_NEEDS_RETUNING;
+        }
+
+        spin_lock_irqsave(&host->lock, flags);
+        sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        synchronize_irq(host->irq);
+
+        spin_lock_irqsave(&host->lock, flags);
+        host->runtime_suspended = true;
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(sdhci_runtime_suspend_host);
+
+int sdhci_runtime_resume_host(struct sdhci_host *host)
+{
+        unsigned long flags;
+        int ret = 0, host_flags = host->flags;
+
+        if (host_flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
+                if (host->ops->enable_dma)
+                        host->ops->enable_dma(host);
+        }
+
+        sdhci_init(host, 0);
+
+        /* Force clock and power re-program */
+        host->pwr = 0;
+        host->clock = 0;
+        sdhci_do_set_ios(host, &host->mmc->ios);
+
+        sdhci_do_start_signal_voltage_switch(host, &host->mmc->ios);
+        if (host_flags & SDHCI_PV_ENABLED)
+                sdhci_do_enable_preset_value(host, true);
+
+        /* Set the re-tuning expiration flag */
+        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
+            (host->tuning_mode == SDHCI_TUNING_MODE_1))
+                host->flags |= SDHCI_NEEDS_RETUNING;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        host->runtime_suspended = false;
+
+        /* Enable SDIO IRQ */
+        if ((host->flags & SDHCI_SDIO_IRQ_ENABLED))
+                sdhci_enable_sdio_irq_nolock(host, true);
+
+        /* Enable Card Detection */
+        sdhci_enable_card_detection(host);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(sdhci_runtime_resume_host);
+
+#endif
+
 /*****************************************************************************\
  *                                                                           *
  * Device allocation/registration                                            *
@@ -2366,6 +2529,8 @@ int sdhci_add_host(struct sdhci_host *host)
 
         if (debug_quirks)
                 host->quirks = debug_quirks;
+        if (debug_quirks2)
+                host->quirks2 = debug_quirks2;
 
         sdhci_reset(host, SDHCI_RESET_ALL);
 
@@ -2888,9 +3053,11 @@ module_init(sdhci_drv_init);
 module_exit(sdhci_drv_exit);
 
 module_param(debug_quirks, uint, 0444);
+module_param(debug_quirks2, uint, 0444);
 
 MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
 MODULE_DESCRIPTION("Secure Digital Host Controller Interface core driver");
 MODULE_LICENSE("GPL");
 
 MODULE_PARM_DESC(debug_quirks, "Force certain quirks.");
+MODULE_PARM_DESC(debug_quirks2, "Force certain other quirks.");