21 files changed, 657 insertions, 256 deletions
diff --git a/drivers/mmc/host/atmel-mci-regs.h b/drivers/mmc/host/atmel-mci-regs.h
index 787aba1682bb..ab56f7db5315 100644
--- a/drivers/mmc/host/atmel-mci-regs.h
+++ b/drivers/mmc/host/atmel-mci-regs.h
@@ -140,4 +140,18 @@
 #define atmci_writel(port,reg,value)                    \
        __raw_writel((value), (port)->regs + reg)
+/*
+ * Fix sconfig's burst size according to atmel MCI. We need to convert them as:
+ * 1 -> 0, 4 -> 1, 8 -> 2, 16 -> 3.
+ *
+ * This can be done by finding most significant bit set.
+ */
+static inline unsigned int atmci_convert_chksize(unsigned int maxburst)
+{
+        if (maxburst > 1)
+                return fls(maxburst) - 2;
+        else
+                return 0;
+}
 #endif /* __DRIVERS_MMC_ATMEL_MCI_H__ */
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 420aca642b14..322412cec4ee 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -391,11 +391,17 @@ static int atmci_regs_show(struct seq_file *s, void *v)
        clk_disable(host->mck);
        spin_unlock_bh(&host->lock);
-        seq_printf(s, "MR:\t0x%08x%s%s CLKDIV=%u\n",
+        seq_printf(s, "MR:\t0x%08x%s%s ",
                        buf[ATMCI_MR / 4],
                        buf[ATMCI_MR / 4] & ATMCI_MR_RDPROOF ? " RDPROOF" : "",
-                        buf[ATMCI_MR / 4] & ATMCI_MR_WRPROOF ? " WRPROOF" : "",
+                        buf[ATMCI_MR / 4] & ATMCI_MR_WRPROOF ? " WRPROOF" : "");
-                        buf[ATMCI_MR / 4] & 0xff);
+        if (host->caps.has_odd_clk_div)
+                seq_printf(s, "{CLKDIV,CLKODD}=%u\n",
+                                ((buf[ATMCI_MR / 4] & 0xff) << 1)
+                                | ((buf[ATMCI_MR / 4] >> 16) & 1));
+        else
+                seq_printf(s, "CLKDIV=%u\n",
+                                (buf[ATMCI_MR / 4] & 0xff));
        seq_printf(s, "DTOR:\t0x%08x\n", buf[ATMCI_DTOR / 4]);
        seq_printf(s, "SDCR:\t0x%08x\n", buf[ATMCI_SDCR / 4]);
        seq_printf(s, "ARGR:\t0x%08x\n", buf[ATMCI_ARGR / 4]);
@@ -910,6 +916,7 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
        enum dma_data_direction         direction;
        enum dma_transfer_direction     slave_dirn;
        unsigned int                    sglen;
+        u32                             maxburst;
        u32 iflags;
        data->error = -EINPROGRESS;
@@ -943,17 +950,18 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
        if (!chan)
                return -ENODEV;
-        if (host->caps.has_dma)
-                atmci_writel(host, ATMCI_DMA, ATMCI_DMA_CHKSIZE(3) | ATMCI_DMAEN);
        if (data->flags & MMC_DATA_READ) {
                direction = DMA_FROM_DEVICE;
                host->dma_conf.direction = slave_dirn = DMA_DEV_TO_MEM;
+                maxburst = atmci_convert_chksize(host->dma_conf.src_maxburst);
        } else {
                direction = DMA_TO_DEVICE;
                host->dma_conf.direction = slave_dirn = DMA_MEM_TO_DEV;
+                maxburst = atmci_convert_chksize(host->dma_conf.dst_maxburst);
        }
+        atmci_writel(host, ATMCI_DMA, ATMCI_DMA_CHKSIZE(maxburst) | ATMCI_DMAEN);
        sglen = dma_map_sg(chan->device->dev, data->sg,
                        data->sg_len, direction);
@@ -1683,7 +1691,6 @@ static void atmci_tasklet_func(unsigned long priv)
                        dev_dbg(&host->pdev->dev, "FSM: cmd ready\n");
                        host->cmd = NULL;
-                        host->data = NULL;
                        data->bytes_xfered = data->blocks * data->blksz;
                        data->error = 0;
                        atmci_command_complete(host, mrq->stop);
@@ -1697,6 +1704,7 @@ static void atmci_tasklet_func(unsigned long priv)
                                atmci_writel(host, ATMCI_IER, ATMCI_NOTBUSY);
                                state = STATE_WAITING_NOTBUSY;
                        }
+                        host->data = NULL;
                        break;
                case STATE_END_REQUEST:
@@ -2314,6 +2322,8 @@ static int __init atmci_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, host);
+        setup_timer(&host->timer, atmci_timeout_timer, (unsigned long)host);
        /* We need at least one slot to succeed */
        nr_slots = 0;
        ret = -ENODEV;
@@ -2352,8 +2362,6 @@ static int __init atmci_probe(struct platform_device *pdev)
                }
        }
-        setup_timer(&host->timer, atmci_timeout_timer, (unsigned long)host);
        dev_info(&pdev->dev,
                        "Atmel MCI controller at 0x%08lx irq %d, %u slots\n",
                        host->mapbase, irq, nr_slots);
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 9bbf45f8c538..72dc3cde646d 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -405,11 +405,23 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 static int dw_mci_idmac_init(struct dw_mci *host)
 {
        struct idmac_desc *p;
-        int i;
+        int i, dma_support;
        /* Number of descriptors in the ring buffer */
        host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
+        /* Check if Hardware Configuration Register has support for DMA */
+        dma_support = (mci_readl(host, HCON) >> 16) & 0x3;
+        if (!dma_support || dma_support > 2) {
+                dev_err(&host->dev,
+                        "Host Controller does not support IDMA Tx.\n");
+                host->dma_ops = NULL;
+                return -ENODEV;
+        }
+        dev_info(&host->dev, "Using internal DMA controller.\n");
        /* Forward link the descriptor list */
        for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
                p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
@@ -418,6 +430,8 @@ static int dw_mci_idmac_init(struct dw_mci *host)
        p->des3 = host->sg_dma;
        p->des0 = IDMAC_DES0_ER;
+        mci_writel(host, BMOD, SDMMC_IDMAC_SWRESET);
        /* Mask out interrupts - get Tx & Rx complete only */
        mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
                   SDMMC_IDMAC_INT_TI);
@@ -615,14 +629,15 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
        u32 div;
        if (slot->clock != host->current_speed) {
-                if (host->bus_hz % slot->clock)
+                div = host->bus_hz / slot->clock;
+                if (host->bus_hz % slot->clock && host->bus_hz > slot->clock)
                        /*
                         * move the + 1 after the divide to prevent
                         * over-clocking the card.
                         */
-                        div = ((host->bus_hz / slot->clock) >> 1) + 1;
+                        div += 1;
-                else
-                        div = (host->bus_hz  / slot->clock) >> 1;
+                div = (host->bus_hz != slot->clock) ? DIV_ROUND_UP(div, 2) : 0;
                dev_info(&slot->mmc->class_dev,
                         "Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ"
@@ -939,8 +954,8 @@ static void dw_mci_command_complete(struct dw_mci *host, struct mmc_command *cmd
                        mdelay(20);
                if (cmd->data) {
-                        host->data = NULL;
                        dw_mci_stop_dma(host);
+                        host->data = NULL;
                }
        }
 }
@@ -1623,7 +1638,6 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
        if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI);
                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
-                set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
                host->dma_ops->complete(host);
        }
 #endif
@@ -1725,7 +1739,8 @@ static void dw_mci_work_routine_card(struct work_struct *work)
 #ifdef CONFIG_MMC_DW_IDMAC
                                ctrl = mci_readl(host, BMOD);
-                                ctrl |= 0x01; /* Software reset of DMA */
+                                /* Software reset of DMA */
+                                ctrl |= SDMMC_IDMAC_SWRESET;
                                mci_writel(host, BMOD, ctrl);
 #endif
@@ -1873,7 +1888,6 @@ static void dw_mci_init_dma(struct dw_mci *host)
        /* Determine which DMA interface to use */
 #ifdef CONFIG_MMC_DW_IDMAC
        host->dma_ops = &dw_mci_idmac_ops;
-        dev_info(&host->dev, "Using internal DMA controller.\n");
 #endif
        if (!host->dma_ops)
@@ -1950,10 +1964,6 @@ int dw_mci_probe(struct dw_mci *host)
        spin_lock_init(&host->lock);
        INIT_LIST_HEAD(&host->queue);
-        host->dma_ops = host->pdata->dma_ops;
-        dw_mci_init_dma(host);
        /*
         * Get the host data width - this assumes that HCON has been set with
         * the correct values.
@@ -1981,10 +1991,11 @@ int dw_mci_probe(struct dw_mci *host)
        }
        /* Reset all blocks */
-        if (!mci_wait_reset(&host->dev, host)) {
+        if (!mci_wait_reset(&host->dev, host))
-                ret = -ENODEV;
+                return -ENODEV;
-                goto err_dmaunmap;
-        }
+        host->dma_ops = host->pdata->dma_ops;
+        dw_mci_init_dma(host);
        /* Clear the interrupts for the host controller */
        mci_writel(host, RINTSTS, 0xFFFFFFFF);
@@ -2170,14 +2181,14 @@ int dw_mci_resume(struct dw_mci *host)
        if (host->vmmc)
                regulator_enable(host->vmmc);
-        if (host->dma_ops->init)
-                host->dma_ops->init(host);
        if (!mci_wait_reset(&host->dev, host)) {
                ret = -ENODEV;
                return ret;
        }
+        if (host->use_dma && host->dma_ops->init)
+                host->dma_ops->init(host);
        /* Restore the old value at FIFOTH register */
        mci_writel(host, FIFOTH, host->fifoth_val);
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index f0fcce40cd8d..50ff19a62368 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -1216,12 +1216,7 @@ static void mmci_dt_populate_generic_pdata(struct device_node *np,
        int bus_width = 0;
        pdata->gpio_wp = of_get_named_gpio(np, "wp-gpios", 0);
-        if (!pdata->gpio_wp)
-                pdata->gpio_wp = -1;
        pdata->gpio_cd = of_get_named_gpio(np, "cd-gpios", 0);
-        if (!pdata->gpio_cd)
-                pdata->gpio_cd = -1;
        if (of_get_property(np, "cd-inverted", NULL))
                pdata->cd_invert = true;
@@ -1276,6 +1271,12 @@ static int __devinit mmci_probe(struct amba_device *dev,
                return -EINVAL;
        }
+        if (!plat) {
+                plat = devm_kzalloc(&dev->dev, sizeof(*plat), GFP_KERNEL);
+                if (!plat)
+                        return -ENOMEM;
+        }
        if (np)
                mmci_dt_populate_generic_pdata(np, plat);
@@ -1424,6 +1425,10 @@ static int __devinit mmci_probe(struct amba_device *dev,
        writel(0, host->base + MMCIMASK1);
        writel(0xfff, host->base + MMCICLEAR);
+        if (plat->gpio_cd == -EPROBE_DEFER) {
+                ret = -EPROBE_DEFER;
+                goto err_gpio_cd;
+        }
        if (gpio_is_valid(plat->gpio_cd)) {
                ret = gpio_request(plat->gpio_cd, DRIVER_NAME " (cd)");
                if (ret == 0)
@@ -1447,6 +1452,10 @@ static int __devinit mmci_probe(struct amba_device *dev,
                if (ret >= 0)
                        host->gpio_cd_irq = gpio_to_irq(plat->gpio_cd);
        }
+        if (plat->gpio_wp == -EPROBE_DEFER) {
+                ret = -EPROBE_DEFER;
+                goto err_gpio_wp;
+        }
        if (gpio_is_valid(plat->gpio_wp)) {
                ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
                if (ret == 0)
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 34a90266ab11..a51f9309ffbb 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -164,16 +164,23 @@ struct mxs_mmc_host {
        spinlock_t                      lock;
        int                             sdio_irq_en;
        int                             wp_gpio;
+        bool                            wp_inverted;
 };
 static int mxs_mmc_get_ro(struct mmc_host *mmc)
 {
        struct mxs_mmc_host *host = mmc_priv(mmc);
+        int ret;
        if (!gpio_is_valid(host->wp_gpio))
                return -EINVAL;
-        return gpio_get_value(host->wp_gpio);
+        ret = gpio_get_value(host->wp_gpio);
+        if (host->wp_inverted)
+                ret = !ret;
+        return ret;
 }
 static int mxs_mmc_get_cd(struct mmc_host *mmc)
@@ -707,6 +714,8 @@ static int mxs_mmc_probe(struct platform_device *pdev)
        struct pinctrl *pinctrl;
        int ret = 0, irq_err, irq_dma;
        dma_cap_mask_t mask;
+        struct regulator *reg_vmmc;
+        enum of_gpio_flags flags;
        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
@@ -747,6 +756,16 @@ static int mxs_mmc_probe(struct platform_device *pdev)
        host->mmc = mmc;
        host->sdio_irq_en = 0;
+        reg_vmmc = devm_regulator_get(&pdev->dev, "vmmc");
+        if (!IS_ERR(reg_vmmc)) {
+                ret = regulator_enable(reg_vmmc);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "Failed to enable vmmc regulator: %d\n", ret);
+                        goto out_mmc_free;
+                }
+        }
        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
        if (IS_ERR(pinctrl)) {
                ret = PTR_ERR(pinctrl);
@@ -785,7 +804,10 @@ static int mxs_mmc_probe(struct platform_device *pdev)
                        mmc->caps |= MMC_CAP_4_BIT_DATA;
                else if (bus_width == 8)
                        mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
-                host->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+                host->wp_gpio = of_get_named_gpio_flags(np, "wp-gpios", 0,
+                                                        &flags);
+                if (flags & OF_GPIO_ACTIVE_LOW)
+                        host->wp_inverted = 1;
        } else {
                if (pdata->flags & SLOTF_8_BIT_CAPABLE)
                        mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
@@ -894,8 +916,8 @@ static struct platform_driver mxs_mmc_driver = {
                .owner  = THIS_MODULE,
 #ifdef CONFIG_PM
                .pm     = &mxs_mmc_pm_ops,
-                .of_match_table = mxs_mmc_dt_ids,
 #endif
+                .of_match_table = mxs_mmc_dt_ids,
        },
 };
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 552196c764d4..3e8dcf8d2e05 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -1300,7 +1300,7 @@ static const struct mmc_host_ops mmc_omap_ops = {
        .set_ios        = mmc_omap_set_ios,
 };
-static int __init mmc_omap_new_slot(struct mmc_omap_host *host, int id)
+static int __devinit mmc_omap_new_slot(struct mmc_omap_host *host, int id)
 {
        struct mmc_omap_slot *slot = NULL;
        struct mmc_host *mmc;
@@ -1485,24 +1485,26 @@ static int __devinit mmc_omap_probe(struct platform_device *pdev)
        }
        host->nr_slots = pdata->nr_slots;
+        host->reg_shift = (cpu_is_omap7xx() ? 1 : 2);
+        host->mmc_omap_wq = alloc_workqueue("mmc_omap", 0, 0);
+        if (!host->mmc_omap_wq)
+                goto err_plat_cleanup;
        for (i = 0; i < pdata->nr_slots; i++) {
                ret = mmc_omap_new_slot(host, i);
                if (ret < 0) {
                        while (--i >= 0)
                                mmc_omap_remove_slot(host->slots[i]);
-                        goto err_plat_cleanup;
+                        goto err_destroy_wq;
                }
        }
-        host->reg_shift = (cpu_is_omap7xx() ? 1 : 2);
-        host->mmc_omap_wq = alloc_workqueue("mmc_omap", 0, 0);
-        if (!host->mmc_omap_wq)
-                goto err_plat_cleanup;
        return 0;
+err_destroy_wq:
+        destroy_workqueue(host->mmc_omap_wq);
 err_plat_cleanup:
        if (pdata->cleanup)
                pdata->cleanup(&pdev->dev);
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 9a7a60aeb19e..bc28627af66b 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -85,7 +85,6 @@
 #define BRR_ENABLE              (1 << 5)
 #define DTO_ENABLE              (1 << 20)
 #define INIT_STREAM             (1 << 1)
-#define ACEN_ACMD12             (1 << 2)
 #define DP_SELECT               (1 << 21)
 #define DDIR                    (1 << 4)
 #define DMA_EN                  0x1
@@ -117,7 +116,6 @@
 #define OMAP_MMC_MAX_CLOCK      52000000
 #define DRIVER_NAME             "omap_hsmmc"
-#define AUTO_CMD12              (1 << 0)        /* Auto CMD12 support */
 /*
 * One controller can have multiple slots, like on some omap boards using
 * omap.c controller driver. Luckily this is not currently done on any known
@@ -177,7 +175,6 @@ struct omap_hsmmc_host {
        int                     reqs_blocked;
        int                     use_reg;
        int                     req_in_progress;
-        unsigned int            flags;
        struct omap_hsmmc_next  next_data;
        struct  omap_mmc_platform_data  *pdata;
@@ -773,8 +770,6 @@ omap_hsmmc_start_command(struct omap_hsmmc_host *host, struct mmc_command *cmd,
                cmdtype = 0x3;
        cmdreg = (cmd->opcode << 24) | (resptype << 16) | (cmdtype << 22);
-        if ((host->flags & AUTO_CMD12) && mmc_op_multi(cmd->opcode))
-                cmdreg |= ACEN_ACMD12;
        if (data) {
                cmdreg |= DP_SELECT | MSBS | BCE;
@@ -847,14 +842,11 @@ omap_hsmmc_xfer_done(struct omap_hsmmc_host *host, struct mmc_data *data)
        else
                data->bytes_xfered = 0;
-        if (data->stop && ((!(host->flags & AUTO_CMD12)) || data->error)) {
+        if (!data->stop) {
-                omap_hsmmc_start_command(host, data->stop, NULL);
-        } else {
-                if (data->stop)
-                        data->stop->resp[0] = OMAP_HSMMC_READ(host->base,
-                                                        RSP76);
                omap_hsmmc_request_done(host, data->mrq);
+                return;
        }
+        omap_hsmmc_start_command(host, data->stop, NULL);
 }
 /*
@@ -1097,7 +1089,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
        /* Disable the clocks */
        pm_runtime_put_sync(host->dev);
        if (host->dbclk)
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
        /* Turn the power off */
        ret = mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
@@ -1108,7 +1100,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
                                               vdd);
        pm_runtime_get_sync(host->dev);
        if (host->dbclk)
-                clk_enable(host->dbclk);
+                clk_prepare_enable(host->dbclk);
        if (ret != 0)
                goto err;
@@ -1859,7 +1851,6 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
        host->mapbase   = res->start + pdata->reg_offset;
        host->base      = ioremap(host->mapbase, SZ_4K);
        host->power_mode = MMC_POWER_OFF;
-        host->flags     = AUTO_CMD12;
        host->next_data.cookie = 1;
        platform_set_drvdata(pdev, host);
@@ -1908,7 +1899,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
        if (IS_ERR(host->dbclk)) {
                dev_warn(mmc_dev(host->mmc), "Failed to get debounce clk\n");
                host->dbclk = NULL;
-        } else if (clk_enable(host->dbclk) != 0) {
+        } else if (clk_prepare_enable(host->dbclk) != 0) {
                dev_warn(mmc_dev(host->mmc), "Failed to enable debounce clk\n");
                clk_put(host->dbclk);
                host->dbclk = NULL;
@@ -1940,6 +1931,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx");
        if (!res) {
                dev_err(mmc_dev(host->mmc), "cannot get DMA TX channel\n");
+                ret = -ENXIO;
                goto err_irq;
        }
        host->dma_line_tx = res->start;
@@ -1947,6 +1939,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx");
        if (!res) {
                dev_err(mmc_dev(host->mmc), "cannot get DMA RX channel\n");
+                ret = -ENXIO;
                goto err_irq;
        }
        host->dma_line_rx = res->start;
@@ -2032,7 +2025,7 @@ err_irq:
        pm_runtime_disable(host->dev);
        clk_put(host->fclk);
        if (host->dbclk) {
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
                clk_put(host->dbclk);
        }
 err1:
@@ -2067,7 +2060,7 @@ static int __devexit omap_hsmmc_remove(struct platform_device *pdev)
        pm_runtime_disable(host->dev);
        clk_put(host->fclk);
        if (host->dbclk) {
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
                clk_put(host->dbclk);
        }
@@ -2125,7 +2118,7 @@ static int omap_hsmmc_suspend(struct device *dev)
        }
        if (host->dbclk)
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
 err:
        pm_runtime_put_sync(host->dev);
        return ret;
@@ -2146,7 +2139,7 @@ static int omap_hsmmc_resume(struct device *dev)
        pm_runtime_get_sync(host->dev);
        if (host->dbclk)
-                clk_enable(host->dbclk);
+                clk_prepare_enable(host->dbclk);
        if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER))
                omap_hsmmc_conf_bus_power(host);
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index c3622a69f432..bd5a5cce122c 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -26,7 +26,6 @@
 #include <mach/dma.h>
 #include <mach/regs-sdi.h>
-#include <mach/regs-gpio.h>
 #include <plat/mci.h>
@@ -1237,12 +1236,9 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
        switch (ios->power_mode) {
        case MMC_POWER_ON:
        case MMC_POWER_UP:
-                s3c2410_gpio_cfgpin(S3C2410_GPE(5), S3C2410_GPE5_SDCLK);
+                /* Configure GPE5...GPE10 pins in SD mode */
-                s3c2410_gpio_cfgpin(S3C2410_GPE(6), S3C2410_GPE6_SDCMD);
+                s3c_gpio_cfgall_range(S3C2410_GPE(5), 6, S3C_GPIO_SFN(2),
-                s3c2410_gpio_cfgpin(S3C2410_GPE(7), S3C2410_GPE7_SDDAT0);
+                                      S3C_GPIO_PULL_NONE);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(8), S3C2410_GPE8_SDDAT1);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(9), S3C2410_GPE9_SDDAT2);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(10), S3C2410_GPE10_SDDAT3);
                if (host->pdata->set_power)
                        host->pdata->set_power(ios->power_mode, ios->vdd);
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index 177f697b5835..a6e53a1ebb08 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -20,11 +20,17 @@
 */
 #include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
 #include <linux/module.h>
 #include <linux/mmc/host.h>
 #include "sdhci-pltfm.h"
+struct sdhci_dove_priv {
+        struct clk *clk;
+};
 static u16 sdhci_dove_readw(struct sdhci_host *host, int reg)
 {
        u16 ret;
@@ -66,16 +72,57 @@ static struct sdhci_pltfm_data sdhci_dove_pdata = {
        .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                  SDHCI_QUIRK_NO_BUSY_IRQ |
                  SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
-                  SDHCI_QUIRK_FORCE_DMA,
+                  SDHCI_QUIRK_FORCE_DMA |
+                  SDHCI_QUIRK_NO_HISPD_BIT,
 };
 static int __devinit sdhci_dove_probe(struct platform_device *pdev)
 {
-        return sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+        struct sdhci_host *host;
+        struct sdhci_pltfm_host *pltfm_host;
+        struct sdhci_dove_priv *priv;
+        int ret;
+        ret = sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+        if (ret)
+                goto sdhci_dove_register_fail;
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_dove_priv),
+                            GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "unable to allocate private data");
+                ret = -ENOMEM;
+                goto sdhci_dove_allocate_fail;
+        }
+        host = platform_get_drvdata(pdev);
+        pltfm_host = sdhci_priv(host);
+        pltfm_host->priv = priv;
+        priv->clk = clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(priv->clk))
+                clk_prepare_enable(priv->clk);
+        return 0;
+sdhci_dove_allocate_fail:
+        sdhci_pltfm_unregister(pdev);
+sdhci_dove_register_fail:
+        return ret;
 }
 static int __devexit sdhci_dove_remove(struct platform_device *pdev)
 {
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_dove_priv *priv = pltfm_host->priv;
+        if (priv->clk) {
+                if (!IS_ERR(priv->clk)) {
+                        clk_disable_unprepare(priv->clk);
+                        clk_put(priv->clk);
+                }
+                devm_kfree(&pdev->dev, priv->clk);
+        }
        return sdhci_pltfm_unregister(pdev);
 }
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index ebbe984e5d00..e23f8134591c 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -299,6 +299,8 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
 static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
 {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
        u32 new_val;
        switch (reg) {
@@ -315,8 +317,11 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                                SDHCI_CTRL_D3CD);
                /* ensure the endianess */
                new_val |= ESDHC_HOST_CONTROL_LE;
-                /* DMA mode bits are shifted */
+                /* bits 8&9 are reserved on mx25 */
-                new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
+                if (!is_imx25_esdhc(imx_data)) {
+                        /* DMA mode bits are shifted */
+                        new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
+                }
                esdhc_clrset_le(host, 0xffff, new_val, reg);
                return;
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 69ef0beae104..504da715a41a 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -157,6 +157,7 @@ static const struct sdhci_pci_fixes sdhci_ene_714 = {
 static const struct sdhci_pci_fixes sdhci_cafe = {
        .quirks         = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                          SDHCI_QUIRK_NO_BUSY_IRQ |
+                          SDHCI_QUIRK_BROKEN_CARD_DETECTION |
                          SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
 };
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index dbb75bfbcffb..b6ee8857e226 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -28,6 +28,9 @@
 #include <linux/mmc/host.h>
 #include <linux/platform_data/pxa_sdhci.h>
 #include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
@@ -121,6 +124,48 @@ static struct sdhci_ops pxav2_sdhci_ops = {
        .platform_8bit_width = pxav2_mmc_set_width,
 };
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_pxav2_of_match[] = {
+        {
+                .compatible = "mrvl,pxav2-mmc",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sdhci_pxav2_of_match);
+static struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev)
+{
+        struct sdhci_pxa_platdata *pdata;
+        struct device_node *np = dev->of_node;
+        u32 bus_width;
+        u32 clk_delay_cycles;
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+        if (of_find_property(np, "non-removable", NULL))
+                pdata->flags |= PXA_FLAG_CARD_PERMANENT;
+        of_property_read_u32(np, "bus-width", &bus_width);
+        if (bus_width == 8)
+                pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT;
+        of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles);
+        if (clk_delay_cycles > 0) {
+                pdata->clk_delay_sel = 1;
+                pdata->clk_delay_cycles = clk_delay_cycles;
+        }
+        return pdata;
+}
+#else
+static inline struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
 static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
 {
        struct sdhci_pltfm_host *pltfm_host;
@@ -128,6 +173,8 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
        struct device *dev = &pdev->dev;
        struct sdhci_host *host = NULL;
        struct sdhci_pxa *pxa = NULL;
+        const struct of_device_id *match;
        int ret;
        struct clk *clk;
@@ -156,6 +203,10 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
                | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
                | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;
+        match = of_match_device(of_match_ptr(sdhci_pxav2_of_match), &pdev->dev);
+        if (match) {
+                pdata = pxav2_get_mmc_pdata(dev);
+        }
        if (pdata) {
                if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
                        /* on-chip device */
@@ -218,6 +269,9 @@ static struct platform_driver sdhci_pxav2_driver = {
        .driver         = {
                .name   = "sdhci-pxav2",
                .owner  = THIS_MODULE,
+#ifdef CONFIG_OF
+                .of_match_table = sdhci_pxav2_of_match,
+#endif
                .pm     = SDHCI_PLTFM_PMOPS,
        },
        .probe          = sdhci_pxav2_probe,
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index f29695683556..07fe3834fe0b 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -28,6 +28,9 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
@@ -164,6 +167,46 @@ static struct sdhci_ops pxav3_sdhci_ops = {
        .platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
 };
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_pxav3_of_match[] = {
+        {
+                .compatible = "mrvl,pxav3-mmc",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sdhci_pxav3_of_match);
+static struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
+{
+        struct sdhci_pxa_platdata *pdata;
+        struct device_node *np = dev->of_node;
+        u32 bus_width;
+        u32 clk_delay_cycles;
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+        if (of_find_property(np, "non-removable", NULL))
+                pdata->flags |= PXA_FLAG_CARD_PERMANENT;
+        of_property_read_u32(np, "bus-width", &bus_width);
+        if (bus_width == 8)
+                pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT;
+        of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles);
+        if (clk_delay_cycles > 0)
+                pdata->clk_delay_cycles = clk_delay_cycles;
+        return pdata;
+}
+#else
+static inline struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
 static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
 {
        struct sdhci_pltfm_host *pltfm_host;
@@ -171,6 +214,8 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
        struct device *dev = &pdev->dev;
        struct sdhci_host *host = NULL;
        struct sdhci_pxa *pxa = NULL;
+        const struct of_device_id *match;
        int ret;
        struct clk *clk;
@@ -202,6 +247,10 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
        /* enable 1/8V DDR capable */
        host->mmc->caps |= MMC_CAP_1_8V_DDR;
+        match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
+        if (match)
+                pdata = pxav3_get_mmc_pdata(dev);
        if (pdata) {
                if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
                        /* on-chip device */
@@ -263,6 +312,9 @@ static int __devexit sdhci_pxav3_remove(struct platform_device *pdev)
 static struct platform_driver sdhci_pxav3_driver = {
        .driver         = {
                .name   = "sdhci-pxav3",
+#ifdef CONFIG_OF
+                .of_match_table = sdhci_pxav3_of_match,
+#endif
                .owner  = THIS_MODULE,
                .pm     = SDHCI_PLTFM_PMOPS,
        },
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 55a164fcaa15..a50c205ea208 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -404,7 +404,7 @@ static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc)
                if (sc->ext_cd_irq &&
                    request_threaded_irq(sc->ext_cd_irq, NULL,
                                         sdhci_s3c_gpio_card_detect_thread,
-                                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                         dev_name(dev), sc) == 0) {
                        int status = gpio_get_value(sc->ext_cd_gpio);
                        if (pdata->ext_cd_gpio_invert)
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index 1fe32dfa7cd4..423da8194cd8 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -4,7 +4,7 @@
 * Support of SDHCI platform devices for spear soc family
 *
 * Copyright (C) 2010 ST Microelectronics
- * Viresh Kumar<viresh.kumar@st.com>
+ * Viresh Kumar <viresh.linux@gmail.com>
 *
 * Inspired by sdhci-pltfm.c
 *
@@ -289,5 +289,5 @@ static struct platform_driver sdhci_driver = {
 module_platform_driver(sdhci_driver);
 MODULE_DESCRIPTION("SPEAr Secure Digital Host Controller Interface driver");
-MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
+MODULE_AUTHOR("Viresh Kumar <viresh.linux@gmail.com>");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index b38d8a78f6a0..0810ccc23d7e 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -223,6 +223,7 @@ static struct tegra_sdhci_platform_data * __devinit sdhci_tegra_dt_parse_pdata(
 {
        struct tegra_sdhci_platform_data *plat;
        struct device_node *np = pdev->dev.of_node;
+        u32 bus_width;
        if (!np)
                return NULL;
@@ -236,7 +237,9 @@ static struct tegra_sdhci_platform_data * __devinit sdhci_tegra_dt_parse_pdata(
        plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
        plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
        plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
-        if (of_find_property(np, "support-8bit", NULL))
+        if (of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
+            bus_width == 8)
                plat->is_8bit = 1;
        return plat;
@@ -334,7 +337,7 @@ static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
                rc = PTR_ERR(clk);
                goto err_clk_get;
        }
-        clk_enable(clk);
+        clk_prepare_enable(clk);
        pltfm_host->clk = clk;
        host->mmc->pm_caps = plat->pm_flags;
@@ -349,7 +352,7 @@ static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
        return 0;
 err_add_host:
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
        clk_put(pltfm_host->clk);
 err_clk_get:
        if (gpio_is_valid(plat->wp_gpio))
@@ -390,7 +393,7 @@ static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
        if (gpio_is_valid(plat->power_gpio))
                gpio_free(plat->power_gpio);
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
        clk_put(pltfm_host->clk);
        sdhci_pltfm_free(pdev);
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index e626732aff77..9a11dc39921c 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -27,6 +27,7 @@
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 #include "sdhci.h"
@@ -244,6 +245,19 @@ static void sdhci_init(struct sdhci_host *host, int soft)
 static void sdhci_reinit(struct sdhci_host *host)
 {
        sdhci_init(host, 0);
+        /*
+         * Retuning stuffs are affected by different cards inserted and only
+         * applicable to UHS-I cards. So reset these fields to their initial
+         * value when card is removed.
+         */
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
+                host->flags &= ~SDHCI_USING_RETUNING_TIMER;
+                del_timer_sync(&host->tuning_timer);
+                host->flags &= ~SDHCI_NEEDS_RETUNING;
+                host->mmc->max_blk_count =
+                        (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
+        }
        sdhci_enable_card_detection(host);
 }
@@ -680,8 +694,8 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
        }
        if (count >= 0xF) {
-                pr_warning("%s: Too large timeout 0x%x requested for CMD%d!\n",
+                DBG("%s: Too large timeout 0x%x requested for CMD%d!\n",
-                           mmc_hostname(host->mmc), count, cmd->opcode);
+                    mmc_hostname(host->mmc), count, cmd->opcode);
                count = 0xE;
        }
@@ -1245,6 +1259,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
        struct sdhci_host *host;
        bool present;
        unsigned long flags;
+        u32 tuning_opcode;
        host = mmc_priv(mmc);
@@ -1292,8 +1307,12 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 */
                if ((host->flags & SDHCI_NEEDS_RETUNING) &&
                    !(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ))) {
+                        /* eMMC uses cmd21 while sd and sdio use cmd19 */
+                        tuning_opcode = mmc->card->type == MMC_TYPE_MMC ?
+                                MMC_SEND_TUNING_BLOCK_HS200 :
+                                MMC_SEND_TUNING_BLOCK;
                        spin_unlock_irqrestore(&host->lock, flags);
-                        sdhci_execute_tuning(mmc, mrq->cmd->opcode);
+                        sdhci_execute_tuning(mmc, tuning_opcode);
                        spin_lock_irqsave(&host->lock, flags);
                        /* Restore original mmc_request structure */
@@ -1663,11 +1682,15 @@ static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
                pwr = sdhci_readb(host, SDHCI_POWER_CONTROL);
                pwr &= ~SDHCI_POWER_ON;
                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+                if (host->vmmc)
+                        regulator_disable(host->vmmc);
                /* Wait for 1ms as per the spec */
                usleep_range(1000, 1500);
                pwr |= SDHCI_POWER_ON;
                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+                if (host->vmmc)
+                        regulator_enable(host->vmmc);
                pr_info(DRIVER_NAME ": Switching to 1.8V signalling "
                        "voltage failed, retrying with S18R set to 0\n");
@@ -1855,6 +1878,7 @@ out:
         */
        if (!(host->flags & SDHCI_NEEDS_RETUNING) && host->tuning_count &&
            (host->tuning_mode == SDHCI_TUNING_MODE_1)) {
+                host->flags |= SDHCI_USING_RETUNING_TIMER;
                mod_timer(&host->tuning_timer, jiffies +
                        host->tuning_count * HZ);
                /* Tuning mode 1 limits the maximum data length to 4MB */
@@ -1872,10 +1896,10 @@ out:
         * try tuning again at a later time, when the re-tuning timer expires.
         * So for these controllers, we return 0. Since there might be other
         * controllers who do not have this capability, we return error for
-         * them.
+         * them. SDHCI_USING_RETUNING_TIMER means the host is currently using
+         * a retuning timer to do the retuning for the card.
         */
-        if (err && host->tuning_count &&
+        if (err && (host->flags & SDHCI_USING_RETUNING_TIMER))
-            host->tuning_mode == SDHCI_TUNING_MODE_1)
                err = 0;
        sdhci_clear_set_irqs(host, SDHCI_INT_DATA_AVAIL, ier);
@@ -2382,7 +2406,6 @@ out:
 int sdhci_suspend_host(struct sdhci_host *host)
 {
        int ret;
-        bool has_tuning_timer;
        if (host->ops->platform_suspend)
                host->ops->platform_suspend(host);
@@ -2390,16 +2413,14 @@ int sdhci_suspend_host(struct sdhci_host *host)
        sdhci_disable_card_detection(host);
        /* Disable tuning since we are suspending */
-        has_tuning_timer = host->version >= SDHCI_SPEC_300 &&
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
-                host->tuning_count && host->tuning_mode == SDHCI_TUNING_MODE_1;
-        if (has_tuning_timer) {
                del_timer_sync(&host->tuning_timer);
                host->flags &= ~SDHCI_NEEDS_RETUNING;
        }
        ret = mmc_suspend_host(host->mmc);
        if (ret) {
-                if (has_tuning_timer) {
+                if (host->flags & SDHCI_USING_RETUNING_TIMER) {
                        host->flags |= SDHCI_NEEDS_RETUNING;
                        mod_timer(&host->tuning_timer, jiffies +
                                        host->tuning_count * HZ);
@@ -2450,8 +2471,7 @@ int sdhci_resume_host(struct sdhci_host *host)
                host->ops->platform_resume(host);
        /* Set the re-tuning expiration flag */
-        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
+        if (host->flags & SDHCI_USING_RETUNING_TIMER)
-            (host->tuning_mode == SDHCI_TUNING_MODE_1))
                host->flags |= SDHCI_NEEDS_RETUNING;
        return ret;
@@ -2490,8 +2510,7 @@ int sdhci_runtime_suspend_host(struct sdhci_host *host)
        int ret = 0;
        /* Disable tuning since we are suspending */
-        if (host->version >= SDHCI_SPEC_300 &&
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
-            host->tuning_mode == SDHCI_TUNING_MODE_1) {
                del_timer_sync(&host->tuning_timer);
                host->flags &= ~SDHCI_NEEDS_RETUNING;
        }
@@ -2532,8 +2551,7 @@ int sdhci_runtime_resume_host(struct sdhci_host *host)
                sdhci_do_enable_preset_value(host, true);
        /* Set the re-tuning expiration flag */
-        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
+        if (host->flags & SDHCI_USING_RETUNING_TIMER)
-            (host->tuning_mode == SDHCI_TUNING_MODE_1))
                host->flags |= SDHCI_NEEDS_RETUNING;
        spin_lock_irqsave(&host->lock, flags);
@@ -2584,7 +2602,7 @@ EXPORT_SYMBOL_GPL(sdhci_alloc_host);
 int sdhci_add_host(struct sdhci_host *host)
 {
        struct mmc_host *mmc;
-        u32 caps[2];
+        u32 caps[2] = {0, 0};
        u32 max_current_caps;
        unsigned int ocr_avail;
        int ret;
@@ -2614,8 +2632,10 @@ int sdhci_add_host(struct sdhci_host *host)
        caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
                sdhci_readl(host, SDHCI_CAPABILITIES);
-        caps[1] = (host->version >= SDHCI_SPEC_300) ?
+        if (host->version >= SDHCI_SPEC_300)
-                sdhci_readl(host, SDHCI_CAPABILITIES_1) : 0;
+                caps[1] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ?
+                        host->caps1 :
+                        sdhci_readl(host, SDHCI_CAPABILITIES_1);
        if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
                host->flags |= SDHCI_USE_SDMA;
@@ -2779,7 +2799,7 @@ int sdhci_add_host(struct sdhci_host *host)
                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
-            mmc_card_is_removable(mmc))
+            !(host->mmc->caps & MMC_CAP_NONREMOVABLE))
                mmc->caps |= MMC_CAP_NEEDS_POLL;
        /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
@@ -2837,6 +2857,30 @@ int sdhci_add_host(struct sdhci_host *host)
                             SDHCI_RETUNING_MODE_SHIFT;
        ocr_avail = 0;
+        host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
+        if (IS_ERR(host->vmmc)) {
+                pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
+                host->vmmc = NULL;
+        }
+#ifdef CONFIG_REGULATOR
+        if (host->vmmc) {
+                ret = regulator_is_supported_voltage(host->vmmc, 3300000,
+                        3300000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_330)))
+                        caps[0] &= ~SDHCI_CAN_VDD_330;
+                ret = regulator_is_supported_voltage(host->vmmc, 3000000,
+                        3000000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_300)))
+                        caps[0] &= ~SDHCI_CAN_VDD_300;
+                ret = regulator_is_supported_voltage(host->vmmc, 1800000,
+                        1800000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_180)))
+                        caps[0] &= ~SDHCI_CAN_VDD_180;
+        }
+#endif /* CONFIG_REGULATOR */
        /*
         * According to SD Host Controller spec v3.00, if the Host System
         * can afford more than 150mA, Host Driver should set XPC to 1. Also
@@ -2845,55 +2889,45 @@ int sdhci_add_host(struct sdhci_host *host)
         * value.
         */
        max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
+        if (!max_current_caps && host->vmmc) {
+                u32 curr = regulator_get_current_limit(host->vmmc);
+                if (curr > 0) {
+                        /* convert to SDHCI_MAX_CURRENT format */
+                        curr = curr/1000;  /* convert to mA */
+                        curr = curr/SDHCI_MAX_CURRENT_MULTIPLIER;
+                        curr = min_t(u32, curr, SDHCI_MAX_CURRENT_LIMIT);
+                        max_current_caps =
+                                (curr << SDHCI_MAX_CURRENT_330_SHIFT) |
+                                (curr << SDHCI_MAX_CURRENT_300_SHIFT) |
+                                (curr << SDHCI_MAX_CURRENT_180_SHIFT);
+                }
+        }
        if (caps[0] & SDHCI_CAN_VDD_330) {
-                int max_current_330;
                ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;
-                max_current_330 = ((max_current_caps &
+                mmc->max_current_330 = ((max_current_caps &
                                   SDHCI_MAX_CURRENT_330_MASK) >>
                                   SDHCI_MAX_CURRENT_330_SHIFT) *
                                   SDHCI_MAX_CURRENT_MULTIPLIER;
-                if (max_current_330 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_330;
        }
        if (caps[0] & SDHCI_CAN_VDD_300) {
-                int max_current_300;
                ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
-                max_current_300 = ((max_current_caps &
+                mmc->max_current_300 = ((max_current_caps &
                                   SDHCI_MAX_CURRENT_300_MASK) >>
                                   SDHCI_MAX_CURRENT_300_SHIFT) *
                                   SDHCI_MAX_CURRENT_MULTIPLIER;
-                if (max_current_300 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_300;
        }
        if (caps[0] & SDHCI_CAN_VDD_180) {
-                int max_current_180;
                ocr_avail |= MMC_VDD_165_195;
-                max_current_180 = ((max_current_caps &
+                mmc->max_current_180 = ((max_current_caps &
                                   SDHCI_MAX_CURRENT_180_MASK) >>
                                   SDHCI_MAX_CURRENT_180_SHIFT) *
                                   SDHCI_MAX_CURRENT_MULTIPLIER;
-                if (max_current_180 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_180;
-                /* Maximum current capabilities of the host at 1.8V */
-                if (max_current_180 >= 800)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_800;
-                else if (max_current_180 >= 600)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_600;
-                else if (max_current_180 >= 400)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_400;
-                else
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_200;
        }
        mmc->ocr_avail = ocr_avail;
@@ -2992,13 +3026,10 @@ int sdhci_add_host(struct sdhci_host *host)
        ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
                mmc_hostname(mmc), host);
-        if (ret)
+        if (ret) {
+                pr_err("%s: Failed to request IRQ %d: %d\n",
+                       mmc_hostname(mmc), host->irq, ret);
                goto untasklet;
-        host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
-        if (IS_ERR(host->vmmc)) {
-                pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
-                host->vmmc = NULL;
        }
        sdhci_init(host, 0);
@@ -3016,8 +3047,11 @@ int sdhci_add_host(struct sdhci_host *host)
        host->led.brightness_set = sdhci_led_control;
        ret = led_classdev_register(mmc_dev(mmc), &host->led);
-        if (ret)
+        if (ret) {
+                pr_err("%s: Failed to register LED device: %d\n",
+                       mmc_hostname(mmc), ret);
                goto reset;
+        }
 #endif
        mmiowb();
@@ -3081,8 +3115,6 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
        free_irq(host->irq, host);
        del_timer_sync(&host->timer);
-        if (host->version >= SDHCI_SPEC_300)
-                del_timer_sync(&host->tuning_timer);
        tasklet_kill(&host->card_tasklet);
        tasklet_kill(&host->finish_tasklet);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index f761f23d2a28..97653ea8942b 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -205,6 +205,7 @@
 #define SDHCI_CAPABILITIES_1    0x44
 #define SDHCI_MAX_CURRENT               0x48
+#define  SDHCI_MAX_CURRENT_LIMIT        0xFF
 #define  SDHCI_MAX_CURRENT_330_MASK     0x0000FF
 #define  SDHCI_MAX_CURRENT_330_SHIFT    0
 #define  SDHCI_MAX_CURRENT_300_MASK     0x00FF00
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 0f07d2878c49..5d8142773fac 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -54,6 +54,8 @@
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sh_mmcif.h>
+#include <linux/mmc/slot-gpio.h>
+#include <linux/mod_devicetable.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
 #include <linux/pm_qos.h>
@@ -379,6 +381,9 @@ static void sh_mmcif_request_dma(struct sh_mmcif_host *host,
        host->dma_active = false;
+        if (!pdata)
+                return;
        if (pdata->slave_id_tx <= 0 || pdata->slave_id_rx <= 0)
                return;
@@ -452,13 +457,14 @@ static void sh_mmcif_release_dma(struct sh_mmcif_host *host)
 static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
 {
        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+        bool sup_pclk = p ? p->sup_pclk : false;
        sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
        sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR);
        if (!clk)
                return;
-        if (p->sup_pclk && clk == host->clk)
+        if (sup_pclk && clk == host->clk)
                sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_SUP_PCLK);
        else
                sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR &
@@ -900,21 +906,15 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
        switch (mrq->cmd->opcode) {
        /* MMCIF does not support SD/SDIO command */
-        case SD_IO_SEND_OP_COND:
+        case MMC_SLEEP_AWAKE: /* = SD_IO_SEND_OP_COND (5) */
+        case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
+                if ((mrq->cmd->flags & MMC_CMD_MASK) != MMC_CMD_BCR)
+                        break;
        case MMC_APP_CMD:
                host->state = STATE_IDLE;
                mrq->cmd->error = -ETIMEDOUT;
                mmc_request_done(mmc, mrq);
                return;
-        case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
-                if (!mrq->data) {
-                        /* send_if_cond cmd (not support) */
-                        host->state = STATE_IDLE;
-                        mrq->cmd->error = -ETIMEDOUT;
-                        mmc_request_done(mmc, mrq);
-                        return;
-                }
-                break;
        default:
                break;
        }
@@ -924,10 +924,35 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
        sh_mmcif_start_cmd(host, mrq);
 }
+static int sh_mmcif_clk_update(struct sh_mmcif_host *host)
+{
+        int ret = clk_enable(host->hclk);
+        if (!ret) {
+                host->clk = clk_get_rate(host->hclk);
+                host->mmc->f_max = host->clk / 2;
+                host->mmc->f_min = host->clk / 512;
+        }
+        return ret;
+}
+static void sh_mmcif_set_power(struct sh_mmcif_host *host, struct mmc_ios *ios)
+{
+        struct sh_mmcif_plat_data *pd = host->pd->dev.platform_data;
+        struct mmc_host *mmc = host->mmc;
+        if (pd && pd->set_pwr)
+                pd->set_pwr(host->pd, ios->power_mode != MMC_POWER_OFF);
+        if (!IS_ERR(mmc->supply.vmmc))
+                /* Errors ignored... */
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
+                                      ios->power_mode ? ios->vdd : 0);
+}
 static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
        struct sh_mmcif_host *host = mmc_priv(mmc);
-        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
        unsigned long flags;
        spin_lock_irqsave(&host->lock, flags);
@@ -945,6 +970,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                        sh_mmcif_request_dma(host, host->pd->dev.platform_data);
                        host->card_present = true;
                }
+                sh_mmcif_set_power(host, ios);
        } else if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
                /* clock stop */
                sh_mmcif_clock_control(host, 0);
@@ -956,9 +982,10 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                }
                if (host->power) {
                        pm_runtime_put(&host->pd->dev);
+                        clk_disable(host->hclk);
                        host->power = false;
-                        if (p->down_pwr && ios->power_mode == MMC_POWER_OFF)
+                        if (ios->power_mode == MMC_POWER_OFF)
-                                p->down_pwr(host->pd);
+                                sh_mmcif_set_power(host, ios);
                }
                host->state = STATE_IDLE;
                return;
@@ -966,8 +993,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
        if (ios->clock) {
                if (!host->power) {
-                        if (p->set_pwr)
+                        sh_mmcif_clk_update(host);
-                                p->set_pwr(host->pd, ios->power_mode);
                        pm_runtime_get_sync(&host->pd->dev);
                        host->power = true;
                        sh_mmcif_sync_reset(host);
@@ -983,8 +1009,12 @@ static int sh_mmcif_get_cd(struct mmc_host *mmc)
 {
        struct sh_mmcif_host *host = mmc_priv(mmc);
        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+        int ret = mmc_gpio_get_cd(mmc);
+        if (ret >= 0)
+                return ret;
-        if (!p->get_cd)
+        if (!p || !p->get_cd)
                return -ENOSYS;
        else
                return p->get_cd(host->pd);
@@ -1250,12 +1280,28 @@ static void mmcif_timeout_work(struct work_struct *work)
        mmc_request_done(host->mmc, mrq);
 }
+static void sh_mmcif_init_ocr(struct sh_mmcif_host *host)
+{
+        struct sh_mmcif_plat_data *pd = host->pd->dev.platform_data;
+        struct mmc_host *mmc = host->mmc;
+        mmc_regulator_get_supply(mmc);
+        if (!pd)
+                return;
+        if (!mmc->ocr_avail)
+                mmc->ocr_avail = pd->ocr;
+        else if (pd->ocr)
+                dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
+}
 static int __devinit sh_mmcif_probe(struct platform_device *pdev)
 {
        int ret = 0, irq[2];
        struct mmc_host *mmc;
        struct sh_mmcif_host *host;
-        struct sh_mmcif_plat_data *pd;
+        struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
        struct resource *res;
        void __iomem *reg;
        char clk_name[8];
@@ -1276,42 +1322,26 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
                dev_err(&pdev->dev, "ioremap error.\n");
                return -ENOMEM;
        }
-        pd = pdev->dev.platform_data;
-        if (!pd) {
-                dev_err(&pdev->dev, "sh_mmcif plat data error.\n");
-                ret = -ENXIO;
-                goto clean_up;
-        }
        mmc = mmc_alloc_host(sizeof(struct sh_mmcif_host), &pdev->dev);
        if (!mmc) {
                ret = -ENOMEM;
-                goto clean_up;
+                goto ealloch;
        }
        host            = mmc_priv(mmc);
        host->mmc       = mmc;
        host->addr      = reg;
        host->timeout   = 1000;
-        snprintf(clk_name, sizeof(clk_name), "mmc%d", pdev->id);
-        host->hclk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(host->hclk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                ret = PTR_ERR(host->hclk);
-                goto clean_up1;
-        }
-        clk_enable(host->hclk);
-        host->clk = clk_get_rate(host->hclk);
        host->pd = pdev;
        spin_lock_init(&host->lock);
        mmc->ops = &sh_mmcif_ops;
-        mmc->f_max = host->clk / 2;
+        sh_mmcif_init_ocr(host);
-        mmc->f_min = host->clk / 512;
-        if (pd->ocr)
-                mmc->ocr_avail = pd->ocr;
        mmc->caps = MMC_CAP_MMC_HIGHSPEED;
-        if (pd->caps)
+        if (pd && pd->caps)
                mmc->caps |= pd->caps;
        mmc->max_segs = 32;
        mmc->max_blk_size = 512;
@@ -1319,34 +1349,52 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
        mmc->max_blk_count = mmc->max_req_size / mmc->max_blk_size;
        mmc->max_seg_size = mmc->max_req_size;
-        sh_mmcif_sync_reset(host);
        platform_set_drvdata(pdev, host);
        pm_runtime_enable(&pdev->dev);
        host->power = false;
+        snprintf(clk_name, sizeof(clk_name), "mmc%d", pdev->id);
+        host->hclk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(host->hclk)) {
+                ret = PTR_ERR(host->hclk);
+                dev_err(&pdev->dev, "cannot get clock \"%s\": %d\n", clk_name, ret);
+                goto eclkget;
+        }
+        ret = sh_mmcif_clk_update(host);
+        if (ret < 0)
+                goto eclkupdate;
        ret = pm_runtime_resume(&pdev->dev);
        if (ret < 0)
-                goto clean_up2;
+                goto eresume;
        INIT_DELAYED_WORK(&host->timeout_work, mmcif_timeout_work);
+        sh_mmcif_sync_reset(host);
        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
        ret = request_threaded_irq(irq[0], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:error", host);
        if (ret) {
                dev_err(&pdev->dev, "request_irq error (sh_mmc:error)\n");
-                goto clean_up3;
+                goto ereqirq0;
        }
        ret = request_threaded_irq(irq[1], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:int", host);
        if (ret) {
                dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
-                goto clean_up4;
+                goto ereqirq1;
+        }
+        if (pd && pd->use_cd_gpio) {
+                ret = mmc_gpio_request_cd(mmc, pd->cd_gpio);
+                if (ret < 0)
+                        goto erqcd;
        }
+        clk_disable(host->hclk);
        ret = mmc_add_host(mmc);
        if (ret < 0)
-                goto clean_up5;
+                goto emmcaddh;
        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
@@ -1355,33 +1403,42 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
                sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
        return ret;
-clean_up5:
+emmcaddh:
+        if (pd && pd->use_cd_gpio)
+                mmc_gpio_free_cd(mmc);
+erqcd:
        free_irq(irq[1], host);
-clean_up4:
+ereqirq1:
        free_irq(irq[0], host);
-clean_up3:
+ereqirq0:
        pm_runtime_suspend(&pdev->dev);
-clean_up2:
+eresume:
-        pm_runtime_disable(&pdev->dev);
        clk_disable(host->hclk);
-clean_up1:
+eclkupdate:
+        clk_put(host->hclk);
+eclkget:
+        pm_runtime_disable(&pdev->dev);
        mmc_free_host(mmc);
-clean_up:
+ealloch:
-        if (reg)
+        iounmap(reg);
-                iounmap(reg);
        return ret;
 }
 static int __devexit sh_mmcif_remove(struct platform_device *pdev)
 {
        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+        struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
        int irq[2];
        host->dying = true;
+        clk_enable(host->hclk);
        pm_runtime_get_sync(&pdev->dev);
        dev_pm_qos_hide_latency_limit(&pdev->dev);
+        if (pd && pd->use_cd_gpio)
+                mmc_gpio_free_cd(host->mmc);
        mmc_remove_host(host->mmc);
        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
@@ -1403,9 +1460,9 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
        platform_set_drvdata(pdev, NULL);
-        clk_disable(host->hclk);
        mmc_free_host(host->mmc);
        pm_runtime_put_sync(&pdev->dev);
+        clk_disable(host->hclk);
        pm_runtime_disable(&pdev->dev);
        return 0;
@@ -1414,24 +1471,18 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int sh_mmcif_suspend(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mmcif_host *host = dev_get_drvdata(dev);
-        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
        int ret = mmc_suspend_host(host->mmc);
-        if (!ret) {
+        if (!ret)
                sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
-                clk_disable(host->hclk);
-        }
        return ret;
 }
 static int sh_mmcif_resume(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mmcif_host *host = dev_get_drvdata(dev);
-        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
-        clk_enable(host->hclk);
        return mmc_resume_host(host->mmc);
 }
@@ -1440,6 +1491,12 @@ static int sh_mmcif_resume(struct device *dev)
 #define sh_mmcif_resume         NULL
 #endif  /* CONFIG_PM */
+static const struct of_device_id mmcif_of_match[] = {
+        { .compatible = "renesas,sh-mmcif" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, mmcif_of_match);
 static const struct dev_pm_ops sh_mmcif_dev_pm_ops = {
        .suspend = sh_mmcif_suspend,
        .resume = sh_mmcif_resume,
@@ -1451,6 +1508,8 @@ static struct platform_driver sh_mmcif_driver = {
        .driver         = {
                .name   = DRIVER_NAME,
                .pm     = &sh_mmcif_dev_pm_ops,
+                .owner  = THIS_MODULE,
+                .of_match_table = mmcif_of_match,
        },
 };
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index b8d7004cf04a..0bdc146178db 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -21,6 +21,7 @@
 #include <linux/kernel.h>
 #include <linux/clk.h>
 #include <linux/slab.h>
+#include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/mmc/host.h>
@@ -39,22 +40,39 @@ struct sh_mobile_sdhi {
        struct tmio_mmc_dma dma_priv;
 };
+static int sh_mobile_sdhi_clk_enable(struct platform_device *pdev, unsigned int *f)
+{
+        struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
+        int ret = clk_enable(priv->clk);
+        if (ret < 0)
+                return ret;
+        *f = clk_get_rate(priv->clk);
+        return 0;
+}
+static void sh_mobile_sdhi_clk_disable(struct platform_device *pdev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
+        clk_disable(priv->clk);
+}
 static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
 {
        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
-        if (p && p->set_pwr)
+        p->set_pwr(pdev, state);
-                p->set_pwr(pdev, state);
 }
 static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
 {
        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
-        if (p && p->get_cd)
+        return p->get_cd(pdev);
-                return p->get_cd(pdev);
-        else
-                return -ENOSYS;
 }
 static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host)
@@ -116,12 +134,14 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
        }
        mmc_data = &priv->mmc_data;
-        p->pdata = mmc_data;
-        if (p->init) {
+        if (p) {
-                ret = p->init(pdev, &sdhi_ops);
+                p->pdata = mmc_data;
-                if (ret)
+                if (p->init) {
-                        goto einit;
+                        ret = p->init(pdev, &sdhi_ops);
+                        if (ret)
+                                goto einit;
+                }
        }
        snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
@@ -132,9 +152,8 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                goto eclkget;
        }
-        mmc_data->hclk = clk_get_rate(priv->clk);
+        mmc_data->clk_enable = sh_mobile_sdhi_clk_enable;
-        mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
+        mmc_data->clk_disable = sh_mobile_sdhi_clk_disable;
-        mmc_data->get_cd = sh_mobile_sdhi_get_cd;
        mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
        if (p) {
                mmc_data->flags = p->tmio_flags;
@@ -142,7 +161,12 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                        mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                mmc_data->ocr_mask = p->tmio_ocr_mask;
                mmc_data->capabilities |= p->tmio_caps;
+                mmc_data->capabilities2 |= p->tmio_caps2;
                mmc_data->cd_gpio = p->cd_gpio;
+                if (p->set_pwr)
+                        mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
+                if (p->get_cd)
+                        mmc_data->get_cd = sh_mobile_sdhi_get_cd;
                if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
                        priv->param_tx.shdma_slave.slave_id = p->dma_slave_tx;
@@ -248,7 +272,7 @@ eirq_card_detect:
 eprobe:
        clk_put(priv->clk);
 eclkget:
-        if (p->cleanup)
+        if (p && p->cleanup)
                p->cleanup(pdev);
 einit:
        kfree(priv);
@@ -263,7 +287,8 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
        int i = 0, irq;
-        p->pdata = NULL;
+        if (p)
+                p->pdata = NULL;
        tmio_mmc_host_remove(host);
@@ -276,7 +301,7 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
        clk_put(priv->clk);
-        if (p->cleanup)
+        if (p && p->cleanup)
                p->cleanup(pdev);
        kfree(priv);
@@ -291,11 +316,18 @@ static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
        .runtime_resume = tmio_mmc_host_runtime_resume,
 };
+static const struct of_device_id sh_mobile_sdhi_of_match[] = {
+        { .compatible = "renesas,shmobile-sdhi" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, sh_mobile_sdhi_of_match);
 static struct platform_driver sh_mobile_sdhi_driver = {
        .driver         = {
                .name   = "sh_mobile_sdhi",
                .owner  = THIS_MODULE,
                .pm     = &tmio_mmc_dev_pm_ops,
+                .of_match_table = sh_mobile_sdhi_of_match,
        },
        .probe          = sh_mobile_sdhi_probe,
        .remove         = __devexit_p(sh_mobile_sdhi_remove),
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 9a7996ade58e..0d8a9bbe30be 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -34,8 +34,9 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/mfd/tmio.h>
-#include <linux/mmc/cd-gpio.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/slot-gpio.h>
 #include <linux/mmc/tmio.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
@@ -305,8 +306,8 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
        int c = cmd->opcode;
        u32 irq_mask = TMIO_MASK_CMD;
-        /* Command 12 is handled by hardware */
+        /* CMD12 is handled by hardware */
-        if (cmd->opcode == 12 && !cmd->arg) {
+        if (cmd->opcode == MMC_STOP_TRANSMISSION && !cmd->arg) {
                sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
                return 0;
        }
@@ -449,7 +450,7 @@ void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
        }
        if (stop) {
-                if (stop->opcode == 12 && !stop->arg)
+                if (stop->opcode == MMC_STOP_TRANSMISSION && !stop->arg)
                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
                else
                        BUG();
@@ -751,6 +752,34 @@ fail:
        mmc_request_done(mmc, mrq);
 }
+static int tmio_mmc_clk_update(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+        int ret;
+        if (!pdata->clk_enable)
+                return -ENOTSUPP;
+        ret = pdata->clk_enable(host->pdev, &mmc->f_max);
+        if (!ret)
+                mmc->f_min = mmc->f_max / 512;
+        return ret;
+}
+static void tmio_mmc_set_power(struct tmio_mmc_host *host, struct mmc_ios *ios)
+{
+        struct mmc_host *mmc = host->mmc;
+        if (host->set_pwr)
+                host->set_pwr(host->pdev, ios->power_mode != MMC_POWER_OFF);
+        if (!IS_ERR(mmc->supply.vmmc))
+                /* Errors ignored... */
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
+                                      ios->power_mode ? ios->vdd : 0);
+}
 /* Set MMC clock / power.
 * Note: This controller uses a simple divider scheme therefore it cannot
 * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
@@ -797,32 +826,37 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         */
        if (ios->power_mode == MMC_POWER_ON && ios->clock) {
                if (!host->power) {
+                        tmio_mmc_clk_update(mmc);
                        pm_runtime_get_sync(dev);
                        host->power = true;
                }
                tmio_mmc_set_clock(host, ios->clock);
                /* power up SD bus */
-                if (host->set_pwr)
+                tmio_mmc_set_power(host, ios);
-                        host->set_pwr(host->pdev, 1);
                /* start bus clock */
                tmio_mmc_clk_start(host);
        } else if (ios->power_mode != MMC_POWER_UP) {
-                if (host->set_pwr && ios->power_mode == MMC_POWER_OFF)
+                if (ios->power_mode == MMC_POWER_OFF)
-                        host->set_pwr(host->pdev, 0);
+                        tmio_mmc_set_power(host, ios);
                if (host->power) {
+                        struct tmio_mmc_data *pdata = host->pdata;
+                        tmio_mmc_clk_stop(host);
                        host->power = false;
                        pm_runtime_put(dev);
+                        if (pdata->clk_disable)
+                                pdata->clk_disable(host->pdev);
                }
-                tmio_mmc_clk_stop(host);
        }
-        switch (ios->bus_width) {
+        if (host->power) {
-        case MMC_BUS_WIDTH_1:
+                switch (ios->bus_width) {
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
+                case MMC_BUS_WIDTH_1:
-        break;
+                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
-        case MMC_BUS_WIDTH_4:
+                break;
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+                case MMC_BUS_WIDTH_4:
-        break;
+                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+                break;
+                }
        }
        /* Let things settle. delay taken from winCE driver */
@@ -841,6 +875,9 @@ static int tmio_mmc_get_ro(struct mmc_host *mmc)
 {
        struct tmio_mmc_host *host = mmc_priv(mmc);
        struct tmio_mmc_data *pdata = host->pdata;
+        int ret = mmc_gpio_get_ro(mmc);
+        if (ret >= 0)
+                return ret;
        return !((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
                 (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT));
@@ -850,6 +887,9 @@ static int tmio_mmc_get_cd(struct mmc_host *mmc)
 {
        struct tmio_mmc_host *host = mmc_priv(mmc);
        struct tmio_mmc_data *pdata = host->pdata;
+        int ret = mmc_gpio_get_cd(mmc);
+        if (ret >= 0)
+                return ret;
        if (!pdata->get_cd)
                return -ENOSYS;
@@ -865,6 +905,19 @@ static const struct mmc_host_ops tmio_mmc_ops = {
        .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
 };
+static void tmio_mmc_init_ocr(struct tmio_mmc_host *host)
+{
+        struct tmio_mmc_data *pdata = host->pdata;
+        struct mmc_host *mmc = host->mmc;
+        mmc_regulator_get_supply(mmc);
+        if (!mmc->ocr_avail)
+                mmc->ocr_avail = pdata->ocr_mask ? : MMC_VDD_32_33 | MMC_VDD_33_34;
+        else if (pdata->ocr_mask)
+                dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
+}
 int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
                                  struct platform_device *pdev,
                                  struct tmio_mmc_data *pdata)
@@ -904,18 +957,14 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
        mmc->ops = &tmio_mmc_ops;
        mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
-        mmc->f_max = pdata->hclk;
+        mmc->caps2 = pdata->capabilities2;
-        mmc->f_min = mmc->f_max / 512;
        mmc->max_segs = 32;
        mmc->max_blk_size = 512;
        mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
                mmc->max_segs;
        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
        mmc->max_seg_size = mmc->max_req_size;
-        if (pdata->ocr_mask)
+        tmio_mmc_init_ocr(_host);
-                mmc->ocr_avail = pdata->ocr_mask;
-        else
-                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
        _host->native_hotplug = !(pdata->flags & TMIO_MMC_USE_GPIO_CD ||
                                  mmc->caps & MMC_CAP_NEEDS_POLL ||
@@ -927,6 +976,11 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
        if (ret < 0)
                goto pm_disable;
+        if (tmio_mmc_clk_update(mmc) < 0) {
+                mmc->f_max = pdata->hclk;
+                mmc->f_min = mmc->f_max / 512;
+        }
        /*
         * There are 4 different scenarios for the card detection:
         *  1) an external gpio irq handles the cd (best for power savings)
@@ -937,7 +991,6 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         *  While we increment the runtime PM counter for all scenarios when
         *  the mmc core activates us by calling an appropriate set_ios(), we
         *  must additionally ensure that in case 2) the tmio mmc hardware stays
-         *  additionally ensure that in case 2) the tmio mmc hardware stays
         *  powered on during runtime for the card detection to work.
         */
        if (_host->native_hotplug)
@@ -948,6 +1001,17 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
        _host->sdcard_irq_mask = sd_ctrl_read32(_host, CTL_IRQ_MASK);
        tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
+        /* Unmask the IRQs we want to know about */
+        if (!_host->chan_rx)
+                irq_mask |= TMIO_MASK_READOP;
+        if (!_host->chan_tx)
+                irq_mask |= TMIO_MASK_WRITEOP;
+        if (!_host->native_hotplug)
+                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
+        _host->sdcard_irq_mask &= ~irq_mask;
        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
                tmio_mmc_enable_sdio_irq(mmc, 0);
@@ -961,22 +1025,18 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
        /* See if we also get DMA */
        tmio_mmc_request_dma(_host, pdata);
-        mmc_add_host(mmc);
+        ret = mmc_add_host(mmc);
+        if (pdata->clk_disable)
+                pdata->clk_disable(pdev);
+        if (ret < 0) {
+                tmio_mmc_host_remove(_host);
+                return ret;
+        }
        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;
-        if (!_host->chan_tx)
-                irq_mask |= TMIO_MASK_WRITEOP;
-        if (!_host->native_hotplug)
-                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
-        tmio_mmc_enable_mmc_irqs(_host, irq_mask);
        if (pdata->flags & TMIO_MMC_USE_GPIO_CD) {
-                ret = mmc_cd_gpio_request(mmc, pdata->cd_gpio);
+                ret = mmc_gpio_request_cd(mmc, pdata->cd_gpio);
                if (ret < 0) {
                        tmio_mmc_host_remove(_host);
                        return ret;
@@ -1008,7 +1068,7 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
                 * This means we can miss a card-eject, but this is anyway
                 * possible, because of delayed processing of hotplug events.
                 */
-                mmc_cd_gpio_free(mmc);
+                mmc_gpio_free_cd(mmc);
        if (!host->native_hotplug)
                pm_runtime_get_sync(&pdev->dev);