6 files changed, 137 insertions, 71 deletions

diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index bdfd05517dd5..983e244eca76 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -53,6 +53,8 @@ static unsigned int fmax = 515633;
  * @sdio: variant supports SDIO
  * @st_clkdiv: true if using a ST-specific clock divider algorithm
  * @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
+ * @pwrreg_powerup: power up value for MMCIPOWER register
+ * @signal_direction: input/out direction of bus signals can be indicated
  */
 struct variant_data {
         unsigned int            clkreg;
@@ -63,18 +65,22 @@ struct variant_data {
         bool                    sdio;
         bool                    st_clkdiv;
         bool                    blksz_datactrl16;
+        u32                     pwrreg_powerup;
+        bool                    signal_direction;
 };
 
 static struct variant_data variant_arm = {
         .fifosize               = 16 * 4,
         .fifohalfsize           = 8 * 4,
         .datalength_bits        = 16,
+        .pwrreg_powerup         = MCI_PWR_UP,
 };
 
 static struct variant_data variant_arm_extended_fifo = {
         .fifosize               = 128 * 4,
         .fifohalfsize           = 64 * 4,
         .datalength_bits        = 16,
+        .pwrreg_powerup         = MCI_PWR_UP,
 };
 
 static struct variant_data variant_u300 = {
@@ -83,6 +89,8 @@ static struct variant_data variant_u300 = {
         .clkreg_enable          = MCI_ST_U300_HWFCEN,
         .datalength_bits        = 16,
         .sdio                   = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 static struct variant_data variant_ux500 = {
@@ -93,6 +101,8 @@ static struct variant_data variant_ux500 = {
         .datalength_bits        = 24,
         .sdio                   = true,
         .st_clkdiv              = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 static struct variant_data variant_ux500v2 = {
@@ -104,11 +114,35 @@ static struct variant_data variant_ux500v2 = {
         .sdio                   = true,
         .st_clkdiv              = true,
         .blksz_datactrl16       = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 /*
  * This must be called with host->lock held
  */
+static void mmci_write_clkreg(struct mmci_host *host, u32 clk)
+{
+        if (host->clk_reg != clk) {
+                host->clk_reg = clk;
+                writel(clk, host->base + MMCICLOCK);
+        }
+}
+
+/*
+ * This must be called with host->lock held
+ */
+static void mmci_write_pwrreg(struct mmci_host *host, u32 pwr)
+{
+        if (host->pwr_reg != pwr) {
+                host->pwr_reg = pwr;
+                writel(pwr, host->base + MMCIPOWER);
+        }
+}
+
+/*
+ * This must be called with host->lock held
+ */
 static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
 {
         struct variant_data *variant = host->variant;
@@ -153,7 +187,7 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
         if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
                 clk |= MCI_ST_8BIT_BUS;
 
-        writel(clk, host->base + MMCICLOCK);
+        mmci_write_clkreg(host, clk);
 }
 
 static void
@@ -166,14 +200,10 @@ mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
         host->mrq = NULL;
         host->cmd = NULL;
 
-        /*
-         * Need to drop the host lock here; mmc_request_done may call
-         * back into the driver...
-         */
-        spin_unlock(&host->lock);
-        pm_runtime_put(mmc_dev(host->mmc));
         mmc_request_done(host->mmc, mrq);
-        spin_lock(&host->lock);
+
+        pm_runtime_mark_last_busy(mmc_dev(host->mmc));
+        pm_runtime_put_autosuspend(mmc_dev(host->mmc));
 }
 
 static void mmci_set_mask1(struct mmci_host *host, unsigned int mask)
@@ -607,6 +637,11 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         if (data->flags & MMC_DATA_READ)
                 datactrl |= MCI_DPSM_DIRECTION;
 
+        /* The ST Micro variants has a special bit to enable SDIO */
+        if (variant->sdio && host->mmc->card)
+                if (mmc_card_sdio(host->mmc->card))
+                        datactrl |= MCI_ST_DPSM_SDIOEN;
+
         /*
          * Attempt to use DMA operation mode, if this
          * should fail, fall back to PIO mode
@@ -635,11 +670,6 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                 irqmask = MCI_TXFIFOHALFEMPTYMASK;
         }
 
-        /* The ST Micro variants has a special bit to enable SDIO */
-        if (variant->sdio && host->mmc->card)
-                if (mmc_card_sdio(host->mmc->card))
-                        datactrl |= MCI_ST_DPSM_SDIOEN;
-
         writel(datactrl, base + MMCIDATACTRL);
         writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
         mmci_set_mask1(host, irqmask);
@@ -786,7 +816,24 @@ static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int rema
                 if (count <= 0)
                         break;
 
-                readsl(base + MMCIFIFO, ptr, count >> 2);
+                /*
+                 * SDIO especially may want to send something that is
+                 * not divisible by 4 (as opposed to card sectors
+                 * etc). Therefore make sure to always read the last bytes
+                 * while only doing full 32-bit reads towards the FIFO.
+                 */
+                if (unlikely(count & 0x3)) {
+                        if (count < 4) {
+                                unsigned char buf[4];
+                                readsl(base + MMCIFIFO, buf, 1);
+                                memcpy(ptr, buf, count);
+                        } else {
+                                readsl(base + MMCIFIFO, ptr, count >> 2);
+                                count &= ~0x3;
+                        }
+                } else {
+                        readsl(base + MMCIFIFO, ptr, count >> 2);
+                }
 
                 ptr += count;
                 remain -= count;
@@ -821,14 +868,13 @@ static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int rem
                  */
                 if (variant->sdio &&
                     mmc_card_sdio(host->mmc->card)) {
+                        u32 clk;
                         if (count < 8)
-                                writel(readl(host->base + MMCICLOCK) &
-                                        ~variant->clkreg_enable,
-                                        host->base + MMCICLOCK);
+                                clk = host->clk_reg & ~variant->clkreg_enable;
                         else
-                                writel(readl(host->base + MMCICLOCK) |
-                                        variant->clkreg_enable,
-                                        host->base + MMCICLOCK);
+                                clk = host->clk_reg | variant->clkreg_enable;
+
+                        mmci_write_clkreg(host, clk);
                 }
 
                 /*
@@ -1015,10 +1061,17 @@ static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct mmci_host *host = mmc_priv(mmc);
+        struct variant_data *variant = host->variant;
         u32 pwr = 0;
         unsigned long flags;
         int ret;
 
+        pm_runtime_get_sync(mmc_dev(mmc));
+
+        if (host->plat->ios_handler &&
+                host->plat->ios_handler(mmc_dev(mmc), ios))
+                        dev_err(mmc_dev(mmc), "platform ios_handler failed\n");
+
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
                 if (host->vcc)
@@ -1035,22 +1088,38 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                                  * power should be rare so we print an error
                                  * and return here.
                                  */
-                                return;
+                                goto out;
                         }
                 }
-                if (host->plat->vdd_handler)
-                        pwr |= host->plat->vdd_handler(mmc_dev(mmc), ios->vdd,
-                                                       ios->power_mode);
-                /* The ST version does not have this, fall through to POWER_ON */
-                if (host->hw_designer != AMBA_VENDOR_ST) {
-                        pwr |= MCI_PWR_UP;
-                        break;
-                }
+                /*
+                 * The ST Micro variant doesn't have the PL180s MCI_PWR_UP
+                 * and instead uses MCI_PWR_ON so apply whatever value is
+                 * configured in the variant data.
+                 */
+                pwr |= variant->pwrreg_powerup;
+
+                break;
         case MMC_POWER_ON:
                 pwr |= MCI_PWR_ON;
                 break;
         }
 
+        if (variant->signal_direction && ios->power_mode != MMC_POWER_OFF) {
+                /*
+                 * The ST Micro variant has some additional bits
+                 * indicating signal direction for the signals in
+                 * the SD/MMC bus and feedback-clock usage.
+                 */
+                pwr |= host->plat->sigdir;
+
+                if (ios->bus_width == MMC_BUS_WIDTH_4)
+                        pwr &= ~MCI_ST_DATA74DIREN;
+                else if (ios->bus_width == MMC_BUS_WIDTH_1)
+                        pwr &= (~MCI_ST_DATA74DIREN &
+                                ~MCI_ST_DATA31DIREN &
+                                ~MCI_ST_DATA2DIREN);
+        }
+
         if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) {
                 if (host->hw_designer != AMBA_VENDOR_ST)
                         pwr |= MCI_ROD;
@@ -1066,13 +1135,13 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_lock_irqsave(&host->lock, flags);
 
         mmci_set_clkreg(host, ios->clock);
-
-        if (host->pwr != pwr) {
-                host->pwr = pwr;
-                writel(pwr, host->base + MMCIPOWER);
-        }
+        mmci_write_pwrreg(host, pwr);
 
         spin_unlock_irqrestore(&host->lock, flags);
+
+ out:
+        pm_runtime_mark_last_busy(mmc_dev(mmc));
+        pm_runtime_put_autosuspend(mmc_dev(mmc));
 }
 
 static int mmci_get_ro(struct mmc_host *mmc)
@@ -1346,6 +1415,8 @@ static int __devinit mmci_probe(struct amba_device *dev,
 
         mmci_dma_setup(host);
 
+        pm_runtime_set_autosuspend_delay(&dev->dev, 50);
+        pm_runtime_use_autosuspend(&dev->dev);
         pm_runtime_put(&dev->dev);
 
         mmc_add_host(mmc);
@@ -1430,43 +1501,49 @@ static int __devexit mmci_remove(struct amba_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int mmci_suspend(struct amba_device *dev, pm_message_t state)
+#ifdef CONFIG_SUSPEND
+static int mmci_suspend(struct device *dev)
 {
-        struct mmc_host *mmc = amba_get_drvdata(dev);
+        struct amba_device *adev = to_amba_device(dev);
+        struct mmc_host *mmc = amba_get_drvdata(adev);
         int ret = 0;
 
         if (mmc) {
                 struct mmci_host *host = mmc_priv(mmc);
 
                 ret = mmc_suspend_host(mmc);
-                if (ret == 0)
+                if (ret == 0) {
+                        pm_runtime_get_sync(dev);
                         writel(0, host->base + MMCIMASK0);
+                }
         }
 
         return ret;
 }
 
-static int mmci_resume(struct amba_device *dev)
+static int mmci_resume(struct device *dev)
 {
-        struct mmc_host *mmc = amba_get_drvdata(dev);
+        struct amba_device *adev = to_amba_device(dev);
+        struct mmc_host *mmc = amba_get_drvdata(adev);
         int ret = 0;
 
         if (mmc) {
                 struct mmci_host *host = mmc_priv(mmc);
 
                 writel(MCI_IRQENABLE, host->base + MMCIMASK0);
+                pm_runtime_put(dev);
 
                 ret = mmc_resume_host(mmc);
         }
 
         return ret;
 }
-#else
-#define mmci_suspend    NULL
-#define mmci_resume     NULL
 #endif
 
+static const struct dev_pm_ops mmci_dev_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(mmci_suspend, mmci_resume)
+};
+
 static struct amba_id mmci_ids[] = {
         {
                 .id     = 0x00041180,
@@ -1512,26 +1589,15 @@ MODULE_DEVICE_TABLE(amba, mmci_ids);
 static struct amba_driver mmci_driver = {
         .drv            = {
                 .name   = DRIVER_NAME,
+                .pm     = &mmci_dev_pm_ops,
         },
         .probe          = mmci_probe,
         .remove         = __devexit_p(mmci_remove),
-        .suspend        = mmci_suspend,
-        .resume         = mmci_resume,
         .id_table       = mmci_ids,
 };
 
-static int __init mmci_init(void)
-{
-        return amba_driver_register(&mmci_driver);
-}
-
-static void __exit mmci_exit(void)
-{
-        amba_driver_unregister(&mmci_driver);
-}
+module_amba_driver(mmci_driver);
 
-module_init(mmci_init);
-module_exit(mmci_exit);
 module_param(fmax, uint, 0444);
 
 MODULE_DESCRIPTION("ARM PrimeCell PL180/181 Multimedia Card Interface driver");
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 79e4143ab9df..d437ccf62d6b 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -13,16 +13,6 @@
 #define MCI_PWR_ON              0x03
 #define MCI_OD                  (1 << 6)
 #define MCI_ROD                 (1 << 7)
-/*
- * The ST Micro version does not have ROD and reuse the voltage registers
- * for direction settings
- */
-#define MCI_ST_DATA2DIREN       (1 << 2)
-#define MCI_ST_CMDDIREN         (1 << 3)
-#define MCI_ST_DATA0DIREN       (1 << 4)
-#define MCI_ST_DATA31DIREN      (1 << 5)
-#define MCI_ST_FBCLKEN          (1 << 7)
-#define MCI_ST_DATA74DIREN      (1 << 8)
 
 #define MMCICLOCK               0x004
 #define MCI_CLK_ENABLE          (1 << 8)
@@ -160,7 +150,7 @@
         (MCI_RXFIFOHALFFULLMASK | MCI_RXDATAAVLBLMASK | \
          MCI_TXFIFOHALFEMPTYMASK)
 
-#define NR_SG           16
+#define NR_SG           128
 
 struct clk;
 struct variant_data;
@@ -189,7 +179,8 @@ struct mmci_host {
 
         unsigned int            mclk;
         unsigned int            cclk;
-        u32                     pwr;
+        u32                     pwr_reg;
+        u32                     clk_reg;
         struct mmci_platform_data *plat;
         struct variant_data     *variant;
 
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 1bcfd6dbb5cc..c3622a69f432 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1606,7 +1606,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
         host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!host->mem) {
                 dev_err(&pdev->dev,
-                        "failed to get io memory region resouce.\n");
+                        "failed to get io memory region resource.\n");
 
                 ret = -ENOENT;
                 goto probe_free_gpio;
@@ -1630,7 +1630,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
 
         host->irq = platform_get_irq(pdev, 0);
         if (host->irq == 0) {
-                dev_err(&pdev->dev, "failed to get interrupt resouce.\n");
+                dev_err(&pdev->dev, "failed to get interrupt resource.\n");
                 ret = -EINVAL;
                 goto probe_iounmap;
         }
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index 78a36eba4df0..cb348569454b 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -23,7 +23,6 @@
 #include <linux/gpio.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
-#include <linux/module.h>
 
 #include <asm/gpio.h>
 
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 352d4797865b..75a485448796 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -56,6 +56,7 @@
 #include <linux/mmc/sh_mmcif.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
+#include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
 #include <linux/spinlock.h>
 #include <linux/module.h>
@@ -1346,6 +1347,8 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto clean_up5;
 
+        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
+
         dev_info(&pdev->dev, "driver version %s\n", DRIVER_VERSION);
         dev_dbg(&pdev->dev, "chip ver H'%04x\n",
                 sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
@@ -1376,6 +1379,8 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
         host->dying = true;
         pm_runtime_get_sync(&pdev->dev);
 
+        dev_pm_qos_hide_latency_limit(&pdev->dev);
+
         mmc_remove_host(host->mmc);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 5f9ad74fbf80..e21988901c36 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -39,6 +39,7 @@
 #include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
+#include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
 #include <linux/scatterlist.h>
 #include <linux/spinlock.h>
@@ -955,6 +956,8 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         mmc_add_host(mmc);
 
+        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
+
         /* Unmask the IRQs we want to know about */
         if (!_host->chan_rx)
                 irq_mask |= TMIO_MASK_READOP;
@@ -993,6 +996,8 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
                 || host->mmc->caps & MMC_CAP_NONREMOVABLE)
                 pm_runtime_get_sync(&pdev->dev);
 
+        dev_pm_qos_hide_latency_limit(&pdev->dev);
+
         mmc_remove_host(host->mmc);
         cancel_work_sync(&host->done);
         cancel_delayed_work_sync(&host->delayed_reset_work);