Merge tag 'mmc-updates-for-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc

Pull MMC update from Chris Ball:
 "MMC highlights for 3.9:

  Core:
   - Support for packed commands in eMMC 4.5.  (This requires a host
     capability to be turned on.  It increases write throughput by 20%+,
     but may also increase average write latency; more testing needed.)
   - Add DT bindings for capability flags.
   - Add mmc_of_parse() for shared DT parsing between drivers.

  Drivers:
   - android-goldfish: New MMC driver for the Android Goldfish emulator.
   - mvsdio: Add DT bindings, pinctrl, use slot-gpio for card detection.
   - omap_hsmmc: Fix boot hangs with RPMB partitions.
   - sdhci-bcm2835: New driver for controller used by Raspberry Pi.
   - sdhci-esdhc-imx: Add 8-bit data, auto CMD23 support, use slot-gpio.
   - sh_mmcif: Add support for eMMC DDR, bundled MMCIF IRQs.
   - tmio_mmc: Add DT bindings, support for vccq regulator"

* tag 'mmc-updates-for-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc: (92 commits)
  mmc: tegra: assume CONFIG_OF, remove platform data
  mmc: add DT bindings for more MMC capability flags
  mmc: tmio: add support for the VccQ regulator
  mmc: tmio: remove unused and deprecated symbols
  mmc: sh_mobile_sdhi: use managed resource allocations
  mmc: sh_mobile_sdhi: remove unused .pdata field
  mmc: tmio-mmc: parse device-tree bindings
  mmc: tmio-mmc: define device-tree bindings
  mmc: sh_mmcif: use mmc_of_parse() to parse standard MMC DT bindings
  mmc: (cosmetic) remove "extern" from function declarations
  mmc: provide a standard MMC device-tree binding parser centrally
  mmc: detailed definition of CD and WP MMC line polarities in DT
  mmc: sdhi, tmio: only check flags in tmio-mmc driver proper
  mmc: sdhci: Fix parameter of sdhci_do_start_signal_voltage_switch()
  mmc: sdhci: check voltage range only on regulators aware of voltage value
  mmc: bcm2835: set SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK
  mmc: support packed write command for eMMC4.5 devices
  mmc: add packed command feature of eMMC4.5
  mmc: rtsx: remove driving adjustment
  mmc: use regulator_can_change_voltage() instead of regulator_count_voltages
  ...

24 files changed, 1759 insertions, 692 deletions

diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 3be8b94d7914..d88219e1d86e 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -238,6 +238,17 @@ config MMC_SDHCI_S3C_DMA
 
           YMMV.
 
+config MMC_SDHCI_BCM2835
+        tristate "SDHCI platform support for the BCM2835 SD/MMC Controller"
+        depends on ARCH_BCM2835
+        depends on MMC_SDHCI_PLTFM
+        select MMC_SDHCI_IO_ACCESSORS
+        help
+          This selects the BCM2835 SD/MMC controller. If you have a BCM2835
+          platform with SD or MMC devices, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_OMAP
         tristate "TI OMAP Multimedia Card Interface support"
         depends on ARCH_OMAP
@@ -361,6 +372,13 @@ config MMC_DAVINCI
           If you have an DAVINCI board with a Multimedia Card slot,
           say Y or M here.  If unsure, say N.
 
+config MMC_GOLDFISH
+        tristate "goldfish qemu Multimedia Card Interface support"
+        depends on GOLDFISH
+        help
+          This selects the Goldfish Multimedia card Interface emulation
+          found on the Goldfish Android virtual device emulation.
+
 config MMC_SPI
         tristate "MMC/SD/SDIO over SPI"
         depends on SPI_MASTER && !HIGHMEM && HAS_DMA
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index e4e218c930bd..c380e3cf0a3b 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_MMC_TIFM_SD)	+= tifm_sd.o
 obj-$(CONFIG_MMC_MSM)           += msm_sdcc.o
 obj-$(CONFIG_MMC_MVSDIO)        += mvsdio.o
 obj-$(CONFIG_MMC_DAVINCI)       += davinci_mmc.o
+obj-$(CONFIG_MMC_GOLDFISH)      += android-goldfish.o
 obj-$(CONFIG_MMC_SPI)           += mmc_spi.o
 ifeq ($(CONFIG_OF),y)
 obj-$(CONFIG_MMC_SPI)           += of_mmc_spi.o
@@ -58,6 +59,7 @@ obj-$(CONFIG_MMC_SDHCI_DOVE)		+= sdhci-dove.o
 obj-$(CONFIG_MMC_SDHCI_TEGRA)           += sdhci-tegra.o
 obj-$(CONFIG_MMC_SDHCI_OF_ESDHC)        += sdhci-of-esdhc.o
 obj-$(CONFIG_MMC_SDHCI_OF_HLWD)         += sdhci-of-hlwd.o
+obj-$(CONFIG_MMC_SDHCI_BCM2835)         += sdhci-bcm2835.o
 
 ifeq ($(CONFIG_CB710_DEBUG),y)
         CFLAGS-cb710-mmc        += -DDEBUG
diff --git a/drivers/mmc/host/android-goldfish.c b/drivers/mmc/host/android-goldfish.c
new file mode 100644
index 000000000000..ef3aef0f376d
--- /dev/null
+++ b/drivers/mmc/host/android-goldfish.c
@@ -0,0 +1,570 @@
+/*
+ *  Copyright 2007, Google Inc.
+ *  Copyright 2012, Intel Inc.
+ *
+ *  based on omap.c driver, which was
+ *  Copyright (C) 2004 Nokia Corporation
+ *  Written by Tuukka Tikkanen and Juha Yrjölä <juha.yrjola@nokia.com>
+ *  Misc hacks here and there by Tony Lindgren <tony@atomide.com>
+ *  Other hacks (DMA, SD, etc) by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/major.h>
+
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/errno.h>
+#include <linux/hdreg.h>
+#include <linux/kdev_t.h>
+#include <linux/blkdev.h>
+#include <linux/mutex.h>
+#include <linux/scatterlist.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/clk.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/scatterlist.h>
+
+#include <asm/types.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#define DRIVER_NAME "goldfish_mmc"
+
+#define BUFFER_SIZE   16384
+
+#define GOLDFISH_MMC_READ(host, addr)   (readl(host->reg_base + addr))
+#define GOLDFISH_MMC_WRITE(host, addr, x)   (writel(x, host->reg_base + addr))
+
+enum {
+        /* status register */
+        MMC_INT_STATUS          = 0x00,
+        /* set this to enable IRQ */
+        MMC_INT_ENABLE          = 0x04,
+        /* set this to specify buffer address */
+        MMC_SET_BUFFER          = 0x08,
+
+        /* MMC command number */
+        MMC_CMD                 = 0x0C,
+
+        /* MMC argument */
+        MMC_ARG                 = 0x10,
+
+        /* MMC response (or R2 bits 0 - 31) */
+        MMC_RESP_0                      = 0x14,
+
+        /* MMC R2 response bits 32 - 63 */
+        MMC_RESP_1                      = 0x18,
+
+        /* MMC R2 response bits 64 - 95 */
+        MMC_RESP_2                      = 0x1C,
+
+        /* MMC R2 response bits 96 - 127 */
+        MMC_RESP_3                      = 0x20,
+
+        MMC_BLOCK_LENGTH        = 0x24,
+        MMC_BLOCK_COUNT         = 0x28,
+
+        /* MMC state flags */
+        MMC_STATE               = 0x2C,
+
+        /* MMC_INT_STATUS bits */
+
+        MMC_STAT_END_OF_CMD     = 1U << 0,
+        MMC_STAT_END_OF_DATA    = 1U << 1,
+        MMC_STAT_STATE_CHANGE   = 1U << 2,
+        MMC_STAT_CMD_TIMEOUT    = 1U << 3,
+
+        /* MMC_STATE bits */
+        MMC_STATE_INSERTED     = 1U << 0,
+        MMC_STATE_READ_ONLY    = 1U << 1,
+};
+
+/*
+ * Command types
+ */
+#define OMAP_MMC_CMDTYPE_BC     0
+#define OMAP_MMC_CMDTYPE_BCR    1
+#define OMAP_MMC_CMDTYPE_AC     2
+#define OMAP_MMC_CMDTYPE_ADTC   3
+
+
+struct goldfish_mmc_host {
+        struct mmc_request      *mrq;
+        struct mmc_command      *cmd;
+        struct mmc_data         *data;
+        struct mmc_host         *mmc;
+        struct device           *dev;
+        unsigned char           id; /* 16xx chips have 2 MMC blocks */
+        void __iomem            *virt_base;
+        unsigned int            phys_base;
+        int                     irq;
+        unsigned char           bus_mode;
+        unsigned char           hw_bus_mode;
+
+        unsigned int            sg_len;
+        unsigned                dma_done:1;
+        unsigned                dma_in_use:1;
+
+        void __iomem            *reg_base;
+};
+
+static inline int
+goldfish_mmc_cover_is_open(struct goldfish_mmc_host *host)
+{
+        return 0;
+}
+
+static ssize_t
+goldfish_mmc_show_cover_switch(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        struct goldfish_mmc_host *host = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%s\n", goldfish_mmc_cover_is_open(host) ? "open" :
+                       "closed");
+}
+
+static DEVICE_ATTR(cover_switch, S_IRUGO, goldfish_mmc_show_cover_switch, NULL);
+
+static void
+goldfish_mmc_start_command(struct goldfish_mmc_host *host, struct mmc_command *cmd)
+{
+        u32 cmdreg;
+        u32 resptype;
+        u32 cmdtype;
+
+        host->cmd = cmd;
+
+        resptype = 0;
+        cmdtype = 0;
+
+        /* Our hardware needs to know exact type */
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE:
+                break;
+        case MMC_RSP_R1:
+        case MMC_RSP_R1B:
+                /* resp 1, 1b, 6, 7 */
+                resptype = 1;
+                break;
+        case MMC_RSP_R2:
+                resptype = 2;
+                break;
+        case MMC_RSP_R3:
+                resptype = 3;
+                break;
+        default:
+                dev_err(mmc_dev(host->mmc),
+                        "Invalid response type: %04x\n", mmc_resp_type(cmd));
+                break;
+        }
+
+        if (mmc_cmd_type(cmd) == MMC_CMD_ADTC)
+                cmdtype = OMAP_MMC_CMDTYPE_ADTC;
+        else if (mmc_cmd_type(cmd) == MMC_CMD_BC)
+                cmdtype = OMAP_MMC_CMDTYPE_BC;
+        else if (mmc_cmd_type(cmd) == MMC_CMD_BCR)
+                cmdtype = OMAP_MMC_CMDTYPE_BCR;
+        else
+                cmdtype = OMAP_MMC_CMDTYPE_AC;
+
+        cmdreg = cmd->opcode | (resptype << 8) | (cmdtype << 12);
+
+        if (host->bus_mode == MMC_BUSMODE_OPENDRAIN)
+                cmdreg |= 1 << 6;
+
+        if (cmd->flags & MMC_RSP_BUSY)
+                cmdreg |= 1 << 11;
+
+        if (host->data && !(host->data->flags & MMC_DATA_WRITE))
+                cmdreg |= 1 << 15;
+
+        GOLDFISH_MMC_WRITE(host, MMC_ARG, cmd->arg);
+        GOLDFISH_MMC_WRITE(host, MMC_CMD, cmdreg);
+}
+
+static void goldfish_mmc_xfer_done(struct goldfish_mmc_host *host,
+                                   struct mmc_data *data)
+{
+        if (host->dma_in_use) {
+                enum dma_data_direction dma_data_dir;
+
+                if (data->flags & MMC_DATA_WRITE)
+                        dma_data_dir = DMA_TO_DEVICE;
+                else
+                        dma_data_dir = DMA_FROM_DEVICE;
+
+                if (dma_data_dir == DMA_FROM_DEVICE) {
+                        /*
+                         * We don't really have DMA, so we need
+                         * to copy from our platform driver buffer
+                         */
+                        uint8_t *dest = (uint8_t *)sg_virt(data->sg);
+                        memcpy(dest, host->virt_base, data->sg->length);
+                }
+                host->data->bytes_xfered += data->sg->length;
+                dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->sg_len,
+                             dma_data_dir);
+        }
+
+        host->data = NULL;
+        host->sg_len = 0;
+
+        /*
+         * NOTE:  MMC layer will sometimes poll-wait CMD13 next, issuing
+         * dozens of requests until the card finishes writing data.
+         * It'd be cheaper to just wait till an EOFB interrupt arrives...
+         */
+
+        if (!data->stop) {
+                host->mrq = NULL;
+                mmc_request_done(host->mmc, data->mrq);
+                return;
+        }
+
+        goldfish_mmc_start_command(host, data->stop);
+}
+
+static void goldfish_mmc_end_of_data(struct goldfish_mmc_host *host,
+                                     struct mmc_data *data)
+{
+        if (!host->dma_in_use) {
+                goldfish_mmc_xfer_done(host, data);
+                return;
+        }
+        if (host->dma_done)
+                goldfish_mmc_xfer_done(host, data);
+}
+
+static void goldfish_mmc_cmd_done(struct goldfish_mmc_host *host,
+                                  struct mmc_command *cmd)
+{
+        host->cmd = NULL;
+        if (cmd->flags & MMC_RSP_PRESENT) {
+                if (cmd->flags & MMC_RSP_136) {
+                        /* response type 2 */
+                        cmd->resp[3] =
+                                GOLDFISH_MMC_READ(host, MMC_RESP_0);
+                        cmd->resp[2] =
+                                GOLDFISH_MMC_READ(host, MMC_RESP_1);
+                        cmd->resp[1] =
+                                GOLDFISH_MMC_READ(host, MMC_RESP_2);
+                        cmd->resp[0] =
+                                GOLDFISH_MMC_READ(host, MMC_RESP_3);
+                } else {
+                        /* response types 1, 1b, 3, 4, 5, 6 */
+                        cmd->resp[0] =
+                                GOLDFISH_MMC_READ(host, MMC_RESP_0);
+                }
+        }
+
+        if (host->data == NULL || cmd->error) {
+                host->mrq = NULL;
+                mmc_request_done(host->mmc, cmd->mrq);
+        }
+}
+
+static irqreturn_t goldfish_mmc_irq(int irq, void *dev_id)
+{
+        struct goldfish_mmc_host *host = (struct goldfish_mmc_host *)dev_id;
+        u16 status;
+        int end_command = 0;
+        int end_transfer = 0;
+        int transfer_error = 0;
+        int state_changed = 0;
+        int cmd_timeout = 0;
+
+        while ((status = GOLDFISH_MMC_READ(host, MMC_INT_STATUS)) != 0) {
+                GOLDFISH_MMC_WRITE(host, MMC_INT_STATUS, status);
+
+                if (status & MMC_STAT_END_OF_CMD)
+                        end_command = 1;
+
+                if (status & MMC_STAT_END_OF_DATA)
+                        end_transfer = 1;
+
+                if (status & MMC_STAT_STATE_CHANGE)
+                        state_changed = 1;
+
+                if (status & MMC_STAT_CMD_TIMEOUT) {
+                        end_command = 0;
+                        cmd_timeout = 1;
+                }
+        }
+
+        if (cmd_timeout) {
+                struct mmc_request *mrq = host->mrq;
+                mrq->cmd->error = -ETIMEDOUT;
+                host->mrq = NULL;
+                mmc_request_done(host->mmc, mrq);
+        }
+
+        if (end_command)
+                goldfish_mmc_cmd_done(host, host->cmd);
+
+        if (transfer_error)
+                goldfish_mmc_xfer_done(host, host->data);
+        else if (end_transfer) {
+                host->dma_done = 1;
+                goldfish_mmc_end_of_data(host, host->data);
+        } else if (host->data != NULL) {
+                /*
+                 * WORKAROUND -- after porting this driver from 2.6 to 3.4,
+                 * during device initialization, cases where host->data is
+                 * non-null but end_transfer is false would occur. Doing
+                 * nothing in such cases results in no further interrupts,
+                 * and initialization failure.
+                 * TODO -- find the real cause.
+                 */
+                host->dma_done = 1;
+                goldfish_mmc_end_of_data(host, host->data);
+        }
+
+        if (state_changed) {
+                u32 state = GOLDFISH_MMC_READ(host, MMC_STATE);
+                pr_info("%s: Card detect now %d\n", __func__,
+                        (state & MMC_STATE_INSERTED));
+                mmc_detect_change(host->mmc, 0);
+        }
+
+        if (!end_command && !end_transfer &&
+            !transfer_error && !state_changed && !cmd_timeout) {
+                status = GOLDFISH_MMC_READ(host, MMC_INT_STATUS);
+                dev_info(mmc_dev(host->mmc),"spurious irq 0x%04x\n", status);
+                if (status != 0) {
+                        GOLDFISH_MMC_WRITE(host, MMC_INT_STATUS, status);
+                        GOLDFISH_MMC_WRITE(host, MMC_INT_ENABLE, 0);
+                }
+        }
+
+        return IRQ_HANDLED;
+}
+
+static void goldfish_mmc_prepare_data(struct goldfish_mmc_host *host,
+                                      struct mmc_request *req)
+{
+        struct mmc_data *data = req->data;
+        int block_size;
+        unsigned sg_len;
+        enum dma_data_direction dma_data_dir;
+
+        host->data = data;
+        if (data == NULL) {
+                GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, 0);
+                GOLDFISH_MMC_WRITE(host, MMC_BLOCK_COUNT, 0);
+                host->dma_in_use = 0;
+                return;
+        }
+
+        block_size = data->blksz;
+
+        GOLDFISH_MMC_WRITE(host, MMC_BLOCK_COUNT, data->blocks - 1);
+        GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, block_size - 1);
+
+        /*
+         * Cope with calling layer confusion; it issues "single
+         * block" writes using multi-block scatterlists.
+         */
+        sg_len = (data->blocks == 1) ? 1 : data->sg_len;
+
+        if (data->flags & MMC_DATA_WRITE)
+                dma_data_dir = DMA_TO_DEVICE;
+        else
+                dma_data_dir = DMA_FROM_DEVICE;
+
+        host->sg_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
+                                  sg_len, dma_data_dir);
+        host->dma_done = 0;
+        host->dma_in_use = 1;
+
+        if (dma_data_dir == DMA_TO_DEVICE) {
+                /*
+                 * We don't really have DMA, so we need to copy to our
+                 * platform driver buffer
+                 */
+                const uint8_t *src = (uint8_t *)sg_virt(data->sg);
+                memcpy(host->virt_base, src, data->sg->length);
+        }
+}
+
+static void goldfish_mmc_request(struct mmc_host *mmc, struct mmc_request *req)
+{
+        struct goldfish_mmc_host *host = mmc_priv(mmc);
+
+        WARN_ON(host->mrq != NULL);
+
+        host->mrq = req;
+        goldfish_mmc_prepare_data(host, req);
+        goldfish_mmc_start_command(host, req->cmd);
+
+        /*
+         * This is to avoid accidentally being detected as an SDIO card
+         * in mmc_attach_sdio().
+         */
+        if (req->cmd->opcode == SD_IO_SEND_OP_COND &&
+            req->cmd->flags == (MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR))
+                req->cmd->error = -EINVAL;
+}
+
+static void goldfish_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct goldfish_mmc_host *host = mmc_priv(mmc);
+
+        host->bus_mode = ios->bus_mode;
+        host->hw_bus_mode = host->bus_mode;
+}
+
+static int goldfish_mmc_get_ro(struct mmc_host *mmc)
+{
+        uint32_t state;
+        struct goldfish_mmc_host *host = mmc_priv(mmc);
+
+        state = GOLDFISH_MMC_READ(host, MMC_STATE);
+        return ((state & MMC_STATE_READ_ONLY) != 0);
+}
+
+static const struct mmc_host_ops goldfish_mmc_ops = {
+        .request        = goldfish_mmc_request,
+        .set_ios        = goldfish_mmc_set_ios,
+        .get_ro         = goldfish_mmc_get_ro,
+};
+
+static int goldfish_mmc_probe(struct platform_device *pdev)
+{
+        struct mmc_host *mmc;
+        struct goldfish_mmc_host *host = NULL;
+        struct resource *res;
+        int ret = 0;
+        int irq;
+        dma_addr_t buf_addr;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (res == NULL || irq < 0)
+                return -ENXIO;
+
+        mmc = mmc_alloc_host(sizeof(struct goldfish_mmc_host), &pdev->dev);
+        if (mmc == NULL) {
+                ret = -ENOMEM;
+                goto err_alloc_host_failed;
+        }
+
+        host = mmc_priv(mmc);
+        host->mmc = mmc;
+
+        pr_err("mmc: Mapping %lX to %lX\n", (long)res->start, (long)res->end);
+        host->reg_base = ioremap(res->start, res->end - res->start + 1);
+        if (host->reg_base == NULL) {
+                ret = -ENOMEM;
+                goto ioremap_failed;
+        }
+        host->virt_base = dma_alloc_coherent(&pdev->dev, BUFFER_SIZE,
+                                             &buf_addr, GFP_KERNEL);
+
+        if (host->virt_base == 0) {
+                ret = -ENOMEM;
+                goto dma_alloc_failed;
+        }
+        host->phys_base = buf_addr;
+
+        host->id = pdev->id;
+        host->irq = irq;
+
+        mmc->ops = &goldfish_mmc_ops;
+        mmc->f_min = 400000;
+        mmc->f_max = 24000000;
+        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
+
+        /* Use scatterlist DMA to reduce per-transfer costs.
+         * NOTE max_seg_size assumption that small blocks aren't
+         * normally used (except e.g. for reading SD registers).
+         */
+        mmc->max_segs = 32;
+        mmc->max_blk_size = 2048;       /* MMC_BLOCK_LENGTH is 11 bits (+1) */
+        mmc->max_blk_count = 2048;      /* MMC_BLOCK_COUNT is 11 bits (+1) */
+        mmc->max_req_size = BUFFER_SIZE;
+        mmc->max_seg_size = mmc->max_req_size;
+
+        ret = request_irq(host->irq, goldfish_mmc_irq, 0, DRIVER_NAME, host);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed IRQ Adding goldfish MMC\n");
+                goto err_request_irq_failed;
+        }
+
+        host->dev = &pdev->dev;
+        platform_set_drvdata(pdev, host);
+
+        ret = device_create_file(&pdev->dev, &dev_attr_cover_switch);
+        if (ret)
+                dev_warn(mmc_dev(host->mmc),
+                         "Unable to create sysfs attributes\n");
+
+        GOLDFISH_MMC_WRITE(host, MMC_SET_BUFFER, host->phys_base);
+        GOLDFISH_MMC_WRITE(host, MMC_INT_ENABLE,
+                           MMC_STAT_END_OF_CMD | MMC_STAT_END_OF_DATA |
+                           MMC_STAT_STATE_CHANGE | MMC_STAT_CMD_TIMEOUT);
+
+        mmc_add_host(mmc);
+        return 0;
+
+err_request_irq_failed:
+        dma_free_coherent(&pdev->dev, BUFFER_SIZE, host->virt_base,
+                          host->phys_base);
+dma_alloc_failed:
+        iounmap(host->reg_base);
+ioremap_failed:
+        mmc_free_host(host->mmc);
+err_alloc_host_failed:
+        return ret;
+}
+
+static int goldfish_mmc_remove(struct platform_device *pdev)
+{
+        struct goldfish_mmc_host *host = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+
+        BUG_ON(host == NULL);
+
+        mmc_remove_host(host->mmc);
+        free_irq(host->irq, host);
+        dma_free_coherent(&pdev->dev, BUFFER_SIZE, host->virt_base, host->phys_base);
+        iounmap(host->reg_base);
+        mmc_free_host(host->mmc);
+        return 0;
+}
+
+static struct platform_driver goldfish_mmc_driver = {
+        .probe          = goldfish_mmc_probe,
+        .remove         = goldfish_mmc_remove,
+        .driver         = {
+                .name   = DRIVER_NAME,
+        },
+};
+
+module_platform_driver(goldfish_mmc_driver);
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/dw_mmc-exynos.c b/drivers/mmc/host/dw_mmc-exynos.c
index 4d50da618166..72fd0f2c9013 100644
--- a/drivers/mmc/host/dw_mmc-exynos.c
+++ b/drivers/mmc/host/dw_mmc-exynos.c
@@ -175,16 +175,6 @@ static int dw_mci_exynos_setup_bus(struct dw_mci *host,
                 }
         }
 
-        gpio = of_get_named_gpio(slot_np, "wp-gpios", 0);
-        if (gpio_is_valid(gpio)) {
-                if (devm_gpio_request(host->dev, gpio, "dw-mci-wp"))
-                        dev_info(host->dev, "gpio [%d] request failed\n",
-                                                gpio);
-        } else {
-                dev_info(host->dev, "wp gpio not available");
-                host->pdata->quirks |= DW_MCI_QUIRK_NO_WRITE_PROTECT;
-        }
-
         if (host->pdata->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION)
                 return 0;
 
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 323c5022c2ca..60063ccb4c4b 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -34,6 +34,7 @@
 #include <linux/regulator/consumer.h>
 #include <linux/workqueue.h>
 #include <linux/of.h>
+#include <linux/of_gpio.h>
 
 #include "dw_mmc.h"
 
@@ -74,6 +75,8 @@ struct idmac_desc {
  * struct dw_mci_slot - MMC slot state
  * @mmc: The mmc_host representing this slot.
  * @host: The MMC controller this slot is using.
+ * @quirks: Slot-level quirks (DW_MCI_SLOT_QUIRK_XXX)
+ * @wp_gpio: If gpio_is_valid() we'll use this to read write protect.
  * @ctype: Card type for this slot.
  * @mrq: mmc_request currently being processed or waiting to be
  *      processed, or NULL when the slot is idle.
@@ -88,6 +91,9 @@ struct dw_mci_slot {
         struct mmc_host         *mmc;
         struct dw_mci           *host;
 
+        int                     quirks;
+        int                     wp_gpio;
+
         u32                     ctype;
 
         struct mmc_request      *mrq;
@@ -825,10 +831,12 @@ static int dw_mci_get_ro(struct mmc_host *mmc)
         struct dw_mci_board *brd = slot->host->pdata;
 
         /* Use platform get_ro function, else try on board write protect */
-        if (brd->quirks & DW_MCI_QUIRK_NO_WRITE_PROTECT)
+        if (slot->quirks & DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT)
                 read_only = 0;
         else if (brd->get_ro)
                 read_only = brd->get_ro(slot->id);
+        else if (gpio_is_valid(slot->wp_gpio))
+                read_only = gpio_get_value(slot->wp_gpio);
         else
                 read_only =
                         mci_readl(slot->host, WRTPRT) & (1 << slot->id) ? 1 : 0;
@@ -1785,6 +1793,30 @@ static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
         return NULL;
 }
 
+static struct dw_mci_of_slot_quirks {
+        char *quirk;
+        int id;
+} of_slot_quirks[] = {
+        {
+                .quirk  = "disable-wp",
+                .id     = DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT,
+        },
+};
+
+static int dw_mci_of_get_slot_quirks(struct device *dev, u8 slot)
+{
+        struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
+        int quirks = 0;
+        int idx;
+
+        /* get quirks */
+        for (idx = 0; idx < ARRAY_SIZE(of_slot_quirks); idx++)
+                if (of_get_property(np, of_slot_quirks[idx].quirk, NULL))
+                        quirks |= of_slot_quirks[idx].id;
+
+        return quirks;
+}
+
 /* find out bus-width for a given slot */
 static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
 {
@@ -1799,7 +1831,34 @@ static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
                                " as 1\n");
         return bus_wd;
 }
+
+/* find the write protect gpio for a given slot; or -1 if none specified */
+static int dw_mci_of_get_wp_gpio(struct device *dev, u8 slot)
+{
+        struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
+        int gpio;
+
+        if (!np)
+                return -EINVAL;
+
+        gpio = of_get_named_gpio(np, "wp-gpios", 0);
+
+        /* Having a missing entry is valid; return silently */
+        if (!gpio_is_valid(gpio))
+                return -EINVAL;
+
+        if (devm_gpio_request(dev, gpio, "dw-mci-wp")) {
+                dev_warn(dev, "gpio [%d] request failed\n", gpio);
+                return -EINVAL;
+        }
+
+        return gpio;
+}
 #else /* CONFIG_OF */
+static int dw_mci_of_get_slot_quirks(struct device *dev, u8 slot)
+{
+        return 0;
+}
 static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
 {
         return 1;
@@ -1808,6 +1867,10 @@ static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
 {
         return NULL;
 }
+static int dw_mci_of_get_wp_gpio(struct device *dev, u8 slot)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_OF */
 
 static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
@@ -1828,6 +1891,8 @@ static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         slot->host = host;
         host->slot[id] = slot;
 
+        slot->quirks = dw_mci_of_get_slot_quirks(host->dev, slot->id);
+
         mmc->ops = &dw_mci_ops;
         mmc->f_min = DIV_ROUND_UP(host->bus_hz, 510);
         mmc->f_max = host->bus_hz;
@@ -1923,6 +1988,8 @@ static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         else
                 clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
 
+        slot->wp_gpio = dw_mci_of_get_wp_gpio(host->dev, slot->id);
+
         mmc_add_host(mmc);
 
 #if defined(CONFIG_DEBUG_FS)
diff --git a/drivers/mmc/host/mvsdio.c b/drivers/mmc/host/mvsdio.c
index f8dd36102949..145cdaf000d1 100644
--- a/drivers/mmc/host/mvsdio.c
+++ b/drivers/mmc/host/mvsdio.c
@@ -21,7 +21,11 @@
 #include <linux/irq.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/slot-gpio.h>
+#include <linux/pinctrl/consumer.h>
 
 #include <asm/sizes.h>
 #include <asm/unaligned.h>
@@ -51,8 +55,6 @@ struct mvsd_host {
         struct mmc_host *mmc;
         struct device *dev;
         struct clk *clk;
-        int gpio_card_detect;
-        int gpio_write_protect;
 };
 
 #define mvsd_write(offs, val)   writel(val, iobase + (offs))
@@ -538,13 +540,6 @@ static void mvsd_timeout_timer(unsigned long data)
                 mmc_request_done(host->mmc, mrq);
 }
 
-static irqreturn_t mvsd_card_detect_irq(int irq, void *dev)
-{
-        struct mvsd_host *host = dev;
-        mmc_detect_change(host->mmc, msecs_to_jiffies(100));
-        return IRQ_HANDLED;
-}
-
 static void mvsd_enable_sdio_irq(struct mmc_host *mmc, int enable)
 {
         struct mvsd_host *host = mmc_priv(mmc);
@@ -564,20 +559,6 @@ static void mvsd_enable_sdio_irq(struct mmc_host *mmc, int enable)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int mvsd_get_ro(struct mmc_host *mmc)
-{
-        struct mvsd_host *host = mmc_priv(mmc);
-
-        if (host->gpio_write_protect)
-                return gpio_get_value(host->gpio_write_protect);
-
-        /*
-         * Board doesn't support read only detection; let the mmc core
-         * decide what to do.
-         */
-        return -ENOSYS;
-}
-
 static void mvsd_power_up(struct mvsd_host *host)
 {
         void __iomem *iobase = host->base;
@@ -674,7 +655,7 @@ static void mvsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
 static const struct mmc_host_ops mvsd_ops = {
         .request                = mvsd_request,
-        .get_ro                 = mvsd_get_ro,
+        .get_ro                 = mmc_gpio_get_ro,
         .set_ios                = mvsd_set_ios,
         .enable_sdio_irq        = mvsd_enable_sdio_irq,
 };
@@ -703,17 +684,18 @@ mv_conf_mbus_windows(struct mvsd_host *host,
 
 static int __init mvsd_probe(struct platform_device *pdev)
 {
+        struct device_node *np = pdev->dev.of_node;
         struct mmc_host *mmc = NULL;
         struct mvsd_host *host = NULL;
-        const struct mvsdio_platform_data *mvsd_data;
         const struct mbus_dram_target_info *dram;
         struct resource *r;
         int ret, irq;
+        int gpio_card_detect, gpio_write_protect;
+        struct pinctrl *pinctrl;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        mvsd_data = pdev->dev.platform_data;
-        if (!r || irq < 0 || !mvsd_data)
+        if (!r || irq < 0)
                 return -ENXIO;
 
         mmc = mmc_alloc_host(sizeof(struct mvsd_host), &pdev->dev);
@@ -725,8 +707,43 @@ static int __init mvsd_probe(struct platform_device *pdev)
         host = mmc_priv(mmc);
         host->mmc = mmc;
         host->dev = &pdev->dev;
-        host->base_clock = mvsd_data->clock / 2;
-        host->clk = ERR_PTR(-EINVAL);
+
+        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(pinctrl))
+                dev_warn(&pdev->dev, "no pins associated\n");
+
+        /*
+         * Some non-DT platforms do not pass a clock, and the clock
+         * frequency is passed through platform_data. On DT platforms,
+         * a clock must always be passed, even if there is no gatable
+         * clock associated to the SDIO interface (it can simply be a
+         * fixed rate clock).
+         */
+        host->clk = devm_clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(host->clk))
+                clk_prepare_enable(host->clk);
+
+        if (np) {
+                if (IS_ERR(host->clk)) {
+                        dev_err(&pdev->dev, "DT platforms must have a clock associated\n");
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                host->base_clock = clk_get_rate(host->clk) / 2;
+                gpio_card_detect = of_get_named_gpio(np, "cd-gpios", 0);
+                gpio_write_protect = of_get_named_gpio(np, "wp-gpios", 0);
+        } else {
+                const struct mvsdio_platform_data *mvsd_data;
+                mvsd_data = pdev->dev.platform_data;
+                if (!mvsd_data) {
+                        ret = -ENXIO;
+                        goto out;
+                }
+                host->base_clock = mvsd_data->clock / 2;
+                gpio_card_detect = mvsd_data->gpio_card_detect;
+                gpio_write_protect = mvsd_data->gpio_write_protect;
+        }
 
         mmc->ops = &mvsd_ops;
 
@@ -765,43 +782,14 @@ static int __init mvsd_probe(struct platform_device *pdev)
                 goto out;
         }
 
-        /* Not all platforms can gate the clock, so it is not
-           an error if the clock does not exists. */
-        host->clk = devm_clk_get(&pdev->dev, NULL);
-        if (!IS_ERR(host->clk))
-                clk_prepare_enable(host->clk);
-
-        if (mvsd_data->gpio_card_detect) {
-                ret = devm_gpio_request_one(&pdev->dev,
-                                            mvsd_data->gpio_card_detect,
-                                            GPIOF_IN, DRIVER_NAME " cd");
-                if (ret == 0) {
-                        irq = gpio_to_irq(mvsd_data->gpio_card_detect);
-                        ret = devm_request_irq(&pdev->dev, irq,
-                                               mvsd_card_detect_irq,
-                                               IRQ_TYPE_EDGE_RISING |
-                                               IRQ_TYPE_EDGE_FALLING,
-                                               DRIVER_NAME " cd", host);
-                        if (ret == 0)
-                                host->gpio_card_detect =
-                                        mvsd_data->gpio_card_detect;
-                        else
-                                devm_gpio_free(&pdev->dev,
-                                               mvsd_data->gpio_card_detect);
-                }
-        }
-        if (!host->gpio_card_detect)
+        if (gpio_is_valid(gpio_card_detect)) {
+                ret = mmc_gpio_request_cd(mmc, gpio_card_detect);
+                if (ret)
+                        goto out;
+        } else
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
-        if (mvsd_data->gpio_write_protect) {
-                ret = devm_gpio_request_one(&pdev->dev,
-                                            mvsd_data->gpio_write_protect,
-                                            GPIOF_IN, DRIVER_NAME " wp");
-                if (ret == 0) {
-                        host->gpio_write_protect =
-                                mvsd_data->gpio_write_protect;
-                }
-        }
+        mmc_gpio_request_ro(mmc, gpio_write_protect);
 
         setup_timer(&host->timer, mvsd_timeout_timer, (unsigned long)host);
         platform_set_drvdata(pdev, mmc);
@@ -811,15 +799,17 @@ static int __init mvsd_probe(struct platform_device *pdev)
 
         pr_notice("%s: %s driver initialized, ",
                            mmc_hostname(mmc), DRIVER_NAME);
-        if (host->gpio_card_detect)
+        if (!(mmc->caps & MMC_CAP_NEEDS_POLL))
                 printk("using GPIO %d for card detection\n",
-                       host->gpio_card_detect);
+                       gpio_card_detect);
         else
                 printk("lacking card detect (fall back to polling)\n");
         return 0;
 
 out:
         if (mmc) {
+                mmc_gpio_free_cd(mmc);
+                mmc_gpio_free_ro(mmc);
                 if (!IS_ERR(host->clk))
                         clk_disable_unprepare(host->clk);
                 mmc_free_host(mmc);
@@ -834,6 +824,8 @@ static int __exit mvsd_remove(struct platform_device *pdev)
 
         struct mvsd_host *host = mmc_priv(mmc);
 
+        mmc_gpio_free_cd(mmc);
+        mmc_gpio_free_ro(mmc);
         mmc_remove_host(mmc);
         del_timer_sync(&host->timer);
         mvsd_power_down(host);
@@ -873,12 +865,19 @@ static int mvsd_resume(struct platform_device *dev)
 #define mvsd_resume     NULL
 #endif
 
+static const struct of_device_id mvsdio_dt_ids[] = {
+        { .compatible = "marvell,orion-sdio" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mvsdio_dt_ids);
+
 static struct platform_driver mvsd_driver = {
         .remove         = __exit_p(mvsd_remove),
         .suspend        = mvsd_suspend,
         .resume         = mvsd_resume,
         .driver         = {
                 .name   = DRIVER_NAME,
+                .of_match_table = mvsdio_dt_ids,
         },
 };
 
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 5b665551a6f3..4efe3021b217 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -354,7 +354,7 @@ static void mxs_mmc_adtc(struct mxs_mmc_host *host)
         struct dma_async_tx_descriptor *desc;
         struct scatterlist *sgl = data->sg, *sg;
         unsigned int sg_len = data->sg_len;
-        int i;
+        unsigned int i;
 
         unsigned short dma_data_dir, timeout;
         enum dma_transfer_direction slave_dirn;
@@ -804,3 +804,4 @@ module_platform_driver(mxs_mmc_driver);
 MODULE_DESCRIPTION("FREESCALE MXS MMC peripheral");
 MODULE_AUTHOR("Freescale Semiconductor");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index 1534b582c419..d720b5e05b9c 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -146,7 +146,7 @@ struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
                 oms->pdata.get_ro = of_mmc_spi_get_ro;
 
         oms->detect_irq = irq_of_parse_and_map(np, 0);
-        if (oms->detect_irq != NO_IRQ) {
+        if (oms->detect_irq != 0) {
                 oms->pdata.init = of_mmc_spi_init;
                 oms->pdata.exit = of_mmc_spi_exit;
         } else {
diff --git a/drivers/mmc/host/rtsx_pci_sdmmc.c b/drivers/mmc/host/rtsx_pci_sdmmc.c
index 468c92303167..f981f7d1f6e3 100644
--- a/drivers/mmc/host/rtsx_pci_sdmmc.c
+++ b/drivers/mmc/host/rtsx_pci_sdmmc.c
@@ -1097,11 +1097,6 @@ static int sdmmc_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
                 voltage = OUTPUT_1V8;
 
         if (voltage == OUTPUT_1V8) {
-                err = rtsx_pci_write_register(pcr,
-                                SD30_DRIVE_SEL, 0x07, DRIVER_TYPE_B);
-                if (err < 0)
-                        goto out;
-
                 err = sd_wait_voltage_stable_1(host);
                 if (err < 0)
                         goto out;
diff --git a/drivers/mmc/host/sdhci-bcm2835.c b/drivers/mmc/host/sdhci-bcm2835.c
new file mode 100644
index 000000000000..8ffea05152c6
--- /dev/null
+++ b/drivers/mmc/host/sdhci-bcm2835.c
@@ -0,0 +1,210 @@
+/*
+ * BCM2835 SDHCI
+ * Copyright (C) 2012 Stephen Warren
+ * Based on U-Boot's MMC driver for the BCM2835 by Oleksandr Tymoshenko & me
+ * Portions of the code there were obviously based on the Linux kernel at:
+ * git://github.com/raspberrypi/linux.git rpi-3.6.y
+ * commit f5b930b "Main bcm2708 linux port" signed-off-by Dom Cobley.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/mmc/host.h>
+#include "sdhci-pltfm.h"
+
+/*
+ * 400KHz is max freq for card ID etc. Use that as min card clock. We need to
+ * know the min to enable static calculation of max BCM2835_SDHCI_WRITE_DELAY.
+ */
+#define MIN_FREQ 400000
+
+/*
+ * The Arasan has a bugette whereby it may lose the content of successive
+ * writes to registers that are within two SD-card clock cycles of each other
+ * (a clock domain crossing problem). It seems, however, that the data
+ * register does not have this problem, which is just as well - otherwise we'd
+ * have to nobble the DMA engine too.
+ *
+ * This should probably be dynamically calculated based on the actual card
+ * frequency. However, this is the longest we'll have to wait, and doesn't
+ * seem to slow access down too much, so the added complexity doesn't seem
+ * worth it for now.
+ *
+ * 1/MIN_FREQ is (max) time per tick of eMMC clock.
+ * 2/MIN_FREQ is time for two ticks.
+ * Multiply by 1000000 to get uS per two ticks.
+ * *1000000 for uSecs.
+ * +1 for hack rounding.
+ */
+#define BCM2835_SDHCI_WRITE_DELAY       (((2 * 1000000) / MIN_FREQ) + 1)
+
+struct bcm2835_sdhci {
+        u32 shadow;
+};
+
+static void bcm2835_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
+{
+        writel(val, host->ioaddr + reg);
+
+        udelay(BCM2835_SDHCI_WRITE_DELAY);
+}
+
+static inline u32 bcm2835_sdhci_readl(struct sdhci_host *host, int reg)
+{
+        u32 val = readl(host->ioaddr + reg);
+
+        if (reg == SDHCI_CAPABILITIES)
+                val |= SDHCI_CAN_VDD_330;
+
+        return val;
+}
+
+static void bcm2835_sdhci_writew(struct sdhci_host *host, u16 val, int reg)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct bcm2835_sdhci *bcm2835_host = pltfm_host->priv;
+        u32 oldval = (reg == SDHCI_COMMAND) ? bcm2835_host->shadow :
+                bcm2835_sdhci_readl(host, reg & ~3);
+        u32 word_num = (reg >> 1) & 1;
+        u32 word_shift = word_num * 16;
+        u32 mask = 0xffff << word_shift;
+        u32 newval = (oldval & ~mask) | (val << word_shift);
+
+        if (reg == SDHCI_TRANSFER_MODE)
+                bcm2835_host->shadow = newval;
+        else
+                bcm2835_sdhci_writel(host, newval, reg & ~3);
+}
+
+static u16 bcm2835_sdhci_readw(struct sdhci_host *host, int reg)
+{
+        u32 val = bcm2835_sdhci_readl(host, (reg & ~3));
+        u32 word_num = (reg >> 1) & 1;
+        u32 word_shift = word_num * 16;
+        u32 word = (val >> word_shift) & 0xffff;
+
+        return word;
+}
+
+static void bcm2835_sdhci_writeb(struct sdhci_host *host, u8 val, int reg)
+{
+        u32 oldval = bcm2835_sdhci_readl(host, reg & ~3);
+        u32 byte_num = reg & 3;
+        u32 byte_shift = byte_num * 8;
+        u32 mask = 0xff << byte_shift;
+        u32 newval = (oldval & ~mask) | (val << byte_shift);
+
+        bcm2835_sdhci_writel(host, newval, reg & ~3);
+}
+
+static u8 bcm2835_sdhci_readb(struct sdhci_host *host, int reg)
+{
+        u32 val = bcm2835_sdhci_readl(host, (reg & ~3));
+        u32 byte_num = reg & 3;
+        u32 byte_shift = byte_num * 8;
+        u32 byte = (val >> byte_shift) & 0xff;
+
+        return byte;
+}
+
+unsigned int bcm2835_sdhci_get_min_clock(struct sdhci_host *host)
+{
+        return MIN_FREQ;
+}
+
+static struct sdhci_ops bcm2835_sdhci_ops = {
+        .write_l = bcm2835_sdhci_writel,
+        .write_w = bcm2835_sdhci_writew,
+        .write_b = bcm2835_sdhci_writeb,
+        .read_l = bcm2835_sdhci_readl,
+        .read_w = bcm2835_sdhci_readw,
+        .read_b = bcm2835_sdhci_readb,
+        .get_max_clock = sdhci_pltfm_clk_get_max_clock,
+        .get_min_clock = bcm2835_sdhci_get_min_clock,
+};
+
+static struct sdhci_pltfm_data bcm2835_sdhci_pdata = {
+        .quirks = SDHCI_QUIRK_BROKEN_CARD_DETECTION |
+                  SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK,
+        .ops = &bcm2835_sdhci_ops,
+};
+
+static int bcm2835_sdhci_probe(struct platform_device *pdev)
+{
+        struct sdhci_host *host;
+        struct bcm2835_sdhci *bcm2835_host;
+        struct sdhci_pltfm_host *pltfm_host;
+        int ret;
+
+        host = sdhci_pltfm_init(pdev, &bcm2835_sdhci_pdata);
+        if (IS_ERR(host))
+                return PTR_ERR(host);
+
+        bcm2835_host = devm_kzalloc(&pdev->dev, sizeof(*bcm2835_host),
+                                        GFP_KERNEL);
+        if (!bcm2835_host) {
+                dev_err(mmc_dev(host->mmc),
+                        "failed to allocate bcm2835_sdhci\n");
+                return -ENOMEM;
+        }
+
+        pltfm_host = sdhci_priv(host);
+        pltfm_host->priv = bcm2835_host;
+
+        pltfm_host->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(pltfm_host->clk)) {
+                ret = PTR_ERR(pltfm_host->clk);
+                goto err;
+        }
+
+        return sdhci_add_host(host);
+
+err:
+        sdhci_pltfm_free(pdev);
+        return ret;
+}
+
+static int bcm2835_sdhci_remove(struct platform_device *pdev)
+{
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+        sdhci_remove_host(host, dead);
+        sdhci_pltfm_free(pdev);
+
+        return 0;
+}
+
+static const struct of_device_id bcm2835_sdhci_of_match[] = {
+        { .compatible = "brcm,bcm2835-sdhci" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, bcm2835_sdhci_of_match);
+
+static struct platform_driver bcm2835_sdhci_driver = {
+        .driver = {
+                .name = "sdhci-bcm2835",
+                .owner = THIS_MODULE,
+                .of_match_table = bcm2835_sdhci_of_match,
+                .pm = SDHCI_PLTFM_PMOPS,
+        },
+        .probe = bcm2835_sdhci_probe,
+        .remove = bcm2835_sdhci_remove,
+};
+module_platform_driver(bcm2835_sdhci_driver);
+
+MODULE_DESCRIPTION("BCM2835 SDHCI driver");
+MODULE_AUTHOR("Stephen Warren");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index e07df812ff1e..78ac00227c1a 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -21,6 +21,7 @@
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
+#include <linux/mmc/slot-gpio.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
@@ -29,12 +30,22 @@
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
-#define SDHCI_CTRL_D3CD                 0x08
+#define ESDHC_CTRL_D3CD                 0x08
 /* VENDOR SPEC register */
-#define SDHCI_VENDOR_SPEC               0xC0
-#define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
-#define SDHCI_WTMK_LVL                  0x44
-#define SDHCI_MIX_CTRL                  0x48
+#define ESDHC_VENDOR_SPEC               0xc0
+#define  ESDHC_VENDOR_SPEC_SDIO_QUIRK   (1 << 1)
+#define ESDHC_WTMK_LVL                  0x44
+#define ESDHC_MIX_CTRL                  0x48
+#define  ESDHC_MIX_CTRL_AC23EN          (1 << 7)
+/* Bits 3 and 6 are not SDHCI standard definitions */
+#define  ESDHC_MIX_CTRL_SDHCI_MASK      0xb7
+
+/*
+ * Our interpretation of the SDHCI_HOST_CONTROL register
+ */
+#define ESDHC_CTRL_4BITBUS              (0x1 << 1)
+#define ESDHC_CTRL_8BITBUS              (0x2 << 1)
+#define ESDHC_CTRL_BUSWIDTH_MASK        (0x3 << 1)
 
 /*
  * There is an INT DMA ERR mis-match between eSDHC and STD SDHC SPEC:
@@ -42,7 +53,7 @@
  * but bit28 is used as the INT DMA ERR in fsl eSDHC design.
  * Define this macro DMA error INT for fsl eSDHC
  */
-#define SDHCI_INT_VENDOR_SPEC_DMA_ERR   0x10000000
+#define ESDHC_INT_VENDOR_SPEC_DMA_ERR   (1 << 28)
 
 /*
  * The CMDTYPE of the CMD register (offset 0xE) should be set to
@@ -143,23 +154,8 @@ static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, i
 
 static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
 {
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct pltfm_imx_data *imx_data = pltfm_host->priv;
-        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
-
-        /* fake CARD_PRESENT flag */
         u32 val = readl(host->ioaddr + reg);
 
-        if (unlikely((reg == SDHCI_PRESENT_STATE)
-                        && gpio_is_valid(boarddata->cd_gpio))) {
-                if (gpio_get_value(boarddata->cd_gpio))
-                        /* no card, if a valid gpio says so... */
-                        val &= ~SDHCI_CARD_PRESENT;
-                else
-                        /* ... in all other cases assume card is present */
-                        val |= SDHCI_CARD_PRESENT;
-        }
-
         if (unlikely(reg == SDHCI_CAPABILITIES)) {
                 /* In FSL esdhc IC module, only bit20 is used to indicate the
                  * ADMA2 capability of esdhc, but this bit is messed up on
@@ -175,8 +171,8 @@ static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
         }
 
         if (unlikely(reg == SDHCI_INT_STATUS)) {
-                if (val & SDHCI_INT_VENDOR_SPEC_DMA_ERR) {
-                        val &= ~SDHCI_INT_VENDOR_SPEC_DMA_ERR;
+                if (val & ESDHC_INT_VENDOR_SPEC_DMA_ERR) {
+                        val &= ~ESDHC_INT_VENDOR_SPEC_DMA_ERR;
                         val |= SDHCI_INT_ADMA_ERROR;
                 }
         }
@@ -188,17 +184,9 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
-        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
         u32 data;
 
         if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
-                if (boarddata->cd_type == ESDHC_CD_GPIO)
-                        /*
-                         * These interrupts won't work with a custom
-                         * card_detect gpio (only applied to mx25/35)
-                         */
-                        val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
-
                 if (val & SDHCI_INT_CARD_INT) {
                         /*
                          * Clear and then set D3CD bit to avoid missing the
@@ -209,9 +197,9 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
                          * re-sample it by the following steps.
                          */
                         data = readl(host->ioaddr + SDHCI_HOST_CONTROL);
-                        data &= ~SDHCI_CTRL_D3CD;
+                        data &= ~ESDHC_CTRL_D3CD;
                         writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
-                        data |= SDHCI_CTRL_D3CD;
+                        data |= ESDHC_CTRL_D3CD;
                         writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
                 }
         }
@@ -220,15 +208,15 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
                                 && (reg == SDHCI_INT_STATUS)
                                 && (val & SDHCI_INT_DATA_END))) {
                         u32 v;
-                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
-                        v &= ~SDHCI_VENDOR_SPEC_SDIO_QUIRK;
-                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v = readl(host->ioaddr + ESDHC_VENDOR_SPEC);
+                        v &= ~ESDHC_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + ESDHC_VENDOR_SPEC);
         }
 
         if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
                 if (val & SDHCI_INT_ADMA_ERROR) {
                         val &= ~SDHCI_INT_ADMA_ERROR;
-                        val |= SDHCI_INT_VENDOR_SPEC_DMA_ERR;
+                        val |= ESDHC_INT_VENDOR_SPEC_DMA_ERR;
                 }
         }
 
@@ -237,15 +225,18 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
 
 static u16 esdhc_readw_le(struct sdhci_host *host, int reg)
 {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+
         if (unlikely(reg == SDHCI_HOST_VERSION)) {
-                u16 val = readw(host->ioaddr + (reg ^ 2));
-                /*
-                 * uSDHC supports SDHCI v3.0, but it's encoded as value
-                 * 0x3 in host controller version register, which violates
-                 * SDHCI_SPEC_300 definition.  Work it around here.
-                 */
-                if ((val & SDHCI_SPEC_VER_MASK) == 3)
-                        return --val;
+                reg ^= 2;
+                if (is_imx6q_usdhc(imx_data)) {
+                        /*
+                         * The usdhc register returns a wrong host version.
+                         * Correct it here.
+                         */
+                        return SDHCI_SPEC_300;
+                }
         }
 
         return readw(host->ioaddr + reg);
@@ -258,20 +249,32 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
 
         switch (reg) {
         case SDHCI_TRANSFER_MODE:
-                /*
-                 * Postpone this write, we must do it together with a
-                 * command write that is down below.
-                 */
                 if ((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
                                 && (host->cmd->opcode == SD_IO_RW_EXTENDED)
                                 && (host->cmd->data->blocks > 1)
                                 && (host->cmd->data->flags & MMC_DATA_READ)) {
                         u32 v;
-                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
-                        v |= SDHCI_VENDOR_SPEC_SDIO_QUIRK;
-                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v = readl(host->ioaddr + ESDHC_VENDOR_SPEC);
+                        v |= ESDHC_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + ESDHC_VENDOR_SPEC);
+                }
+
+                if (is_imx6q_usdhc(imx_data)) {
+                        u32 m = readl(host->ioaddr + ESDHC_MIX_CTRL);
+                        /* Swap AC23 bit */
+                        if (val & SDHCI_TRNS_AUTO_CMD23) {
+                                val &= ~SDHCI_TRNS_AUTO_CMD23;
+                                val |= ESDHC_MIX_CTRL_AC23EN;
+                        }
+                        m = val | (m & ~ESDHC_MIX_CTRL_SDHCI_MASK);
+                        writel(m, host->ioaddr + ESDHC_MIX_CTRL);
+                } else {
+                        /*
+                         * Postpone this write, we must do it together with a
+                         * command write that is down below.
+                         */
+                        imx_data->scratchpad = val;
                 }
-                imx_data->scratchpad = val;
                 return;
         case SDHCI_COMMAND:
                 if ((host->cmd->opcode == MMC_STOP_TRANSMISSION ||
@@ -279,16 +282,12 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
                     (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
                         val |= SDHCI_CMD_ABORTCMD;
 
-                if (is_imx6q_usdhc(imx_data)) {
-                        u32 m = readl(host->ioaddr + SDHCI_MIX_CTRL);
-                        m = imx_data->scratchpad | (m & 0xffff0000);
-                        writel(m, host->ioaddr + SDHCI_MIX_CTRL);
+                if (is_imx6q_usdhc(imx_data))
                         writel(val << 16,
                                host->ioaddr + SDHCI_TRANSFER_MODE);
-                } else {
+                else
                         writel(val << 16 | imx_data->scratchpad,
                                host->ioaddr + SDHCI_TRANSFER_MODE);
-                }
                 return;
         case SDHCI_BLOCK_SIZE:
                 val &= ~SDHCI_MAKE_BLKSZ(0x7, 0);
@@ -302,6 +301,7 @@ 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;
+        u32 mask;
 
         switch (reg) {
         case SDHCI_POWER_CONTROL:
@@ -311,10 +311,8 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                  */
                 return;
         case SDHCI_HOST_CONTROL:
-                /* FSL messed up here, so we can just keep those three */
-                new_val = val & (SDHCI_CTRL_LED | \
-                                SDHCI_CTRL_4BITBUS | \
-                                SDHCI_CTRL_D3CD);
+                /* FSL messed up here, so we need to manually compose it. */
+                new_val = val & SDHCI_CTRL_LED;
                 /* ensure the endianness */
                 new_val |= ESDHC_HOST_CONTROL_LE;
                 /* bits 8&9 are reserved on mx25 */
@@ -323,7 +321,13 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                         new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
                 }
 
-                esdhc_clrset_le(host, 0xffff, new_val, reg);
+                /*
+                 * Do not touch buswidth bits here. This is done in
+                 * esdhc_pltfm_bus_width.
+                 */
+                mask = 0xffff & ~ESDHC_CTRL_BUSWIDTH_MASK;
+
+                esdhc_clrset_le(host, mask, new_val, reg);
                 return;
         }
         esdhc_clrset_le(host, 0xff, val, reg);
@@ -336,15 +340,15 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
          * circuit relies on.  To work around it, we turn the clocks on back
          * to keep card detection circuit functional.
          */
-        if ((reg == SDHCI_SOFTWARE_RESET) && (val & 1))
+        if ((reg == SDHCI_SOFTWARE_RESET) && (val & 1)) {
                 esdhc_clrset_le(host, 0x7, 0x7, ESDHC_SYSTEM_CONTROL);
-}
-
-static unsigned int esdhc_pltfm_get_max_clock(struct sdhci_host *host)
-{
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-
-        return clk_get_rate(pltfm_host->clk);
+                /*
+                 * The reset on usdhc fails to clear MIX_CTRL register.
+                 * Do it manually here.
+                 */
+                if (is_imx6q_usdhc(imx_data))
+                        writel(0, host->ioaddr + ESDHC_MIX_CTRL);
+        }
 }
 
 static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
@@ -362,8 +366,7 @@ static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
 
         switch (boarddata->wp_type) {
         case ESDHC_WP_GPIO:
-                if (gpio_is_valid(boarddata->wp_gpio))
-                        return gpio_get_value(boarddata->wp_gpio);
+                return mmc_gpio_get_ro(host->mmc);
         case ESDHC_WP_CONTROLLER:
                 return !(readl(host->ioaddr + SDHCI_PRESENT_STATE) &
                                SDHCI_WRITE_PROTECT);
@@ -374,6 +377,28 @@ static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
         return -ENOSYS;
 }
 
+static int esdhc_pltfm_bus_width(struct sdhci_host *host, int width)
+{
+        u32 ctrl;
+
+        switch (width) {
+        case MMC_BUS_WIDTH_8:
+                ctrl = ESDHC_CTRL_8BITBUS;
+                break;
+        case MMC_BUS_WIDTH_4:
+                ctrl = ESDHC_CTRL_4BITBUS;
+                break;
+        default:
+                ctrl = 0;
+                break;
+        }
+
+        esdhc_clrset_le(host, ESDHC_CTRL_BUSWIDTH_MASK, ctrl,
+                        SDHCI_HOST_CONTROL);
+
+        return 0;
+}
+
 static struct sdhci_ops sdhci_esdhc_ops = {
         .read_l = esdhc_readl_le,
         .read_w = esdhc_readw_le,
@@ -381,9 +406,10 @@ static struct sdhci_ops sdhci_esdhc_ops = {
         .write_w = esdhc_writew_le,
         .write_b = esdhc_writeb_le,
         .set_clock = esdhc_set_clock,
-        .get_max_clock = esdhc_pltfm_get_max_clock,
+        .get_max_clock = sdhci_pltfm_clk_get_max_clock,
         .get_min_clock = esdhc_pltfm_get_min_clock,
         .get_ro = esdhc_pltfm_get_ro,
+        .platform_bus_width = esdhc_pltfm_bus_width,
 };
 
 static struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
@@ -394,14 +420,6 @@ static struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
         .ops = &sdhci_esdhc_ops,
 };
 
-static irqreturn_t cd_irq(int irq, void *data)
-{
-        struct sdhci_host *sdhost = (struct sdhci_host *)data;
-
-        tasklet_schedule(&sdhost->card_tasklet);
-        return IRQ_HANDLED;
-};
-
 #ifdef CONFIG_OF
 static int
 sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
@@ -429,6 +447,8 @@ sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
         if (gpio_is_valid(boarddata->wp_gpio))
                 boarddata->wp_type = ESDHC_WP_GPIO;
 
+        of_property_read_u32(np, "bus-width", &boarddata->max_bus_width);
+
         return 0;
 }
 #else
@@ -512,7 +532,7 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
          * to something insane.  Change it back here.
          */
         if (is_imx6q_usdhc(imx_data))
-                writel(0x08100810, host->ioaddr + SDHCI_WTMK_LVL);
+                writel(0x08100810, host->ioaddr + ESDHC_WTMK_LVL);
 
         boarddata = &imx_data->boarddata;
         if (sdhci_esdhc_imx_probe_dt(pdev, boarddata) < 0) {
@@ -527,37 +547,22 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         /* write_protect */
         if (boarddata->wp_type == ESDHC_WP_GPIO) {
-                err = devm_gpio_request_one(&pdev->dev, boarddata->wp_gpio,
-                                            GPIOF_IN, "ESDHC_WP");
+                err = mmc_gpio_request_ro(host->mmc, boarddata->wp_gpio);
                 if (err) {
-                        dev_warn(mmc_dev(host->mmc),
-                                 "no write-protect pin available!\n");
-                        boarddata->wp_gpio = -EINVAL;
+                        dev_err(mmc_dev(host->mmc),
+                                "failed to request write-protect gpio!\n");
+                        goto disable_clk;
                 }
-        } else {
-                boarddata->wp_gpio = -EINVAL;
+                host->mmc->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
         }
 
         /* card_detect */
-        if (boarddata->cd_type != ESDHC_CD_GPIO)
-                boarddata->cd_gpio = -EINVAL;
-
         switch (boarddata->cd_type) {
         case ESDHC_CD_GPIO:
-                err = devm_gpio_request_one(&pdev->dev, boarddata->cd_gpio,
-                                            GPIOF_IN, "ESDHC_CD");
+                err = mmc_gpio_request_cd(host->mmc, boarddata->cd_gpio);
                 if (err) {
                         dev_err(mmc_dev(host->mmc),
-                                "no card-detect pin available!\n");
-                        goto disable_clk;
-                }
-
-                err = devm_request_irq(&pdev->dev,
-                                 gpio_to_irq(boarddata->cd_gpio), cd_irq,
-                                 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
-                                 mmc_hostname(host->mmc), host);
-                if (err) {
-                        dev_err(mmc_dev(host->mmc), "request irq error\n");
+                                "failed to request card-detect gpio!\n");
                         goto disable_clk;
                 }
                 /* fall through */
@@ -575,6 +580,19 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
                 break;
         }
 
+        switch (boarddata->max_bus_width) {
+        case 8:
+                host->mmc->caps |= MMC_CAP_8_BIT_DATA | MMC_CAP_4_BIT_DATA;
+                break;
+        case 4:
+                host->mmc->caps |= MMC_CAP_4_BIT_DATA;
+                break;
+        case 1:
+        default:
+                host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA;
+                break;
+        }
+
         err = sdhci_add_host(host);
         if (err)
                 goto disable_clk;
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index c7dd0cbc99de..c7ccf3034dad 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -935,7 +935,7 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
         return 0;
 }
 
-static int sdhci_pci_8bit_width(struct sdhci_host *host, int width)
+static int sdhci_pci_bus_width(struct sdhci_host *host, int width)
 {
         u8 ctrl;
 
@@ -977,7 +977,7 @@ static void sdhci_pci_hw_reset(struct sdhci_host *host)
 
 static struct sdhci_ops sdhci_pci_ops = {
         .enable_dma     = sdhci_pci_enable_dma,
-        .platform_8bit_width    = sdhci_pci_8bit_width,
+        .platform_bus_width     = sdhci_pci_bus_width,
         .hw_reset               = sdhci_pci_hw_reset,
 };
 
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index d4283ef5917a..3145a780b035 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -36,6 +36,14 @@
 #endif
 #include "sdhci-pltfm.h"
 
+unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *host)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+
+        return clk_get_rate(pltfm_host->clk);
+}
+EXPORT_SYMBOL_GPL(sdhci_pltfm_clk_get_max_clock);
+
 static struct sdhci_ops sdhci_pltfm_ops = {
 };
 
diff --git a/drivers/mmc/host/sdhci-pltfm.h b/drivers/mmc/host/sdhci-pltfm.h
index 37e0e184a0bb..153b6c509ebe 100644
--- a/drivers/mmc/host/sdhci-pltfm.h
+++ b/drivers/mmc/host/sdhci-pltfm.h
@@ -98,6 +98,8 @@ extern int sdhci_pltfm_register(struct platform_device *pdev,
                                 struct sdhci_pltfm_data *pdata);
 extern int sdhci_pltfm_unregister(struct platform_device *pdev);
 
+extern unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *host);
+
 #ifdef CONFIG_PM
 extern const struct dev_pm_ops sdhci_pltfm_pmops;
 #define SDHCI_PLTFM_PMOPS (&sdhci_pltfm_pmops)
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index ac854aa192a8..eeb7d439db1d 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -111,17 +111,10 @@ static int pxav2_mmc_set_width(struct sdhci_host *host, int width)
         return 0;
 }
 
-static u32 pxav2_get_max_clock(struct sdhci_host *host)
-{
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-
-        return clk_get_rate(pltfm_host->clk);
-}
-
 static struct sdhci_ops pxav2_sdhci_ops = {
-        .get_max_clock = pxav2_get_max_clock,
+        .get_max_clock = sdhci_pltfm_clk_get_max_clock,
         .platform_reset_exit = pxav2_set_private_registers,
-        .platform_8bit_width = pxav2_mmc_set_width,
+        .platform_bus_width = pxav2_mmc_set_width,
 };
 
 #ifdef CONFIG_OF
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index fad0966427fd..a0cdbc570a83 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -32,10 +32,14 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
 
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 
+#define PXAV3_RPM_DELAY_MS     50
+
 #define SD_CLOCK_BURST_SIZE_SETUP               0x10A
 #define SDCLK_SEL       0x100
 #define SDCLK_DELAY_SHIFT       9
@@ -163,18 +167,11 @@ static int pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
         return 0;
 }
 
-static u32 pxav3_get_max_clock(struct sdhci_host *host)
-{
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-
-        return clk_get_rate(pltfm_host->clk);
-}
-
 static struct sdhci_ops pxav3_sdhci_ops = {
         .platform_reset_exit = pxav3_set_private_registers,
         .set_uhs_signaling = pxav3_set_uhs_signaling,
         .platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
-        .get_max_clock = pxav3_get_max_clock,
+        .get_max_clock = sdhci_pltfm_clk_get_max_clock,
 };
 
 #ifdef CONFIG_OF
@@ -303,20 +300,37 @@ static int sdhci_pxav3_probe(struct platform_device *pdev)
 
         sdhci_get_of_property(pdev);
 
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_set_autosuspend_delay(&pdev->dev, PXAV3_RPM_DELAY_MS);
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_suspend_ignore_children(&pdev->dev, 1);
+        pm_runtime_get_noresume(&pdev->dev);
+
         ret = sdhci_add_host(host);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add host\n");
+                pm_runtime_forbid(&pdev->dev);
+                pm_runtime_disable(&pdev->dev);
                 goto err_add_host;
         }
 
         platform_set_drvdata(pdev, host);
 
+        if (pdata->pm_caps & MMC_PM_KEEP_POWER) {
+                device_init_wakeup(&pdev->dev, 1);
+                host->mmc->pm_flags |= MMC_PM_WAKE_SDIO_IRQ;
+        } else {
+                device_init_wakeup(&pdev->dev, 0);
+        }
+
+        pm_runtime_put_autosuspend(&pdev->dev);
+
         return 0;
 
 err_add_host:
         clk_disable_unprepare(clk);
         clk_put(clk);
-        mmc_gpio_free_cd(host->mmc);
 err_cd_req:
 err_clk_get:
         sdhci_pltfm_free(pdev);
@@ -329,16 +343,14 @@ static int sdhci_pxav3_remove(struct platform_device *pdev)
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_pxa *pxa = pltfm_host->priv;
-        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
 
+        pm_runtime_get_sync(&pdev->dev);
         sdhci_remove_host(host, 1);
+        pm_runtime_disable(&pdev->dev);
 
         clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
 
-        if (gpio_is_valid(pdata->ext_cd_gpio))
-                mmc_gpio_free_cd(host->mmc);
-
         sdhci_pltfm_free(pdev);
         kfree(pxa);
 
@@ -347,6 +359,83 @@ static int sdhci_pxav3_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int sdhci_pxav3_suspend(struct device *dev)
+{
+        int ret;
+        struct sdhci_host *host = dev_get_drvdata(dev);
+
+        pm_runtime_get_sync(dev);
+        ret = sdhci_suspend_host(host);
+        pm_runtime_mark_last_busy(dev);
+        pm_runtime_put_autosuspend(dev);
+
+        return ret;
+}
+
+static int sdhci_pxav3_resume(struct device *dev)
+{
+        int ret;
+        struct sdhci_host *host = dev_get_drvdata(dev);
+
+        pm_runtime_get_sync(dev);
+        ret = sdhci_resume_host(host);
+        pm_runtime_mark_last_busy(dev);
+        pm_runtime_put_autosuspend(dev);
+
+        return ret;
+}
+#endif
+
+#ifdef CONFIG_PM_RUNTIME
+static int sdhci_pxav3_runtime_suspend(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        unsigned long flags;
+
+        if (pltfm_host->clk) {
+                spin_lock_irqsave(&host->lock, flags);
+                host->runtime_suspended = true;
+                spin_unlock_irqrestore(&host->lock, flags);
+
+                clk_disable_unprepare(pltfm_host->clk);
+        }
+
+        return 0;
+}
+
+static int sdhci_pxav3_runtime_resume(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        unsigned long flags;
+
+        if (pltfm_host->clk) {
+                clk_prepare_enable(pltfm_host->clk);
+
+                spin_lock_irqsave(&host->lock, flags);
+                host->runtime_suspended = false;
+                spin_unlock_irqrestore(&host->lock, flags);
+        }
+
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_PM
+static const struct dev_pm_ops sdhci_pxav3_pmops = {
+        SET_SYSTEM_SLEEP_PM_OPS(sdhci_pxav3_suspend, sdhci_pxav3_resume)
+        SET_RUNTIME_PM_OPS(sdhci_pxav3_runtime_suspend,
+                sdhci_pxav3_runtime_resume, NULL)
+};
+
+#define SDHCI_PXAV3_PMOPS (&sdhci_pxav3_pmops)
+
+#else
+#define SDHCI_PXAV3_PMOPS NULL
+#endif
+
 static struct platform_driver sdhci_pxav3_driver = {
         .driver         = {
                 .name   = "sdhci-pxav3",
@@ -354,7 +443,7 @@ static struct platform_driver sdhci_pxav3_driver = {
                 .of_match_table = sdhci_pxav3_of_match,
 #endif
                 .owner  = THIS_MODULE,
-                .pm     = SDHCI_PLTFM_PMOPS,
+                .pm     = SDHCI_PXAV3_PMOPS,
         },
         .probe          = sdhci_pxav3_probe,
         .remove         = sdhci_pxav3_remove,
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index a0c621421ee8..7363efe72287 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -332,14 +332,14 @@ static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
 }
 
 /**
- * sdhci_s3c_platform_8bit_width - support 8bit buswidth
+ * sdhci_s3c_platform_bus_width - support 8bit buswidth
  * @host: The SDHCI host being queried
  * @width: MMC_BUS_WIDTH_ macro for the bus width being requested
  *
  * We have 8-bit width support but is not a v3 controller.
- * So we add platform_8bit_width() and support 8bit width.
+ * So we add platform_bus_width() and support 8bit width.
  */
-static int sdhci_s3c_platform_8bit_width(struct sdhci_host *host, int width)
+static int sdhci_s3c_platform_bus_width(struct sdhci_host *host, int width)
 {
         u8 ctrl;
 
@@ -369,7 +369,7 @@ static struct sdhci_ops sdhci_s3c_ops = {
         .get_max_clock          = sdhci_s3c_get_max_clk,
         .set_clock              = sdhci_s3c_set_clock,
         .get_min_clock          = sdhci_s3c_get_min_clock,
-        .platform_8bit_width    = sdhci_s3c_platform_8bit_width,
+        .platform_bus_width     = sdhci_s3c_platform_bus_width,
 };
 
 static void sdhci_s3c_notify_change(struct platform_device *dev, int state)
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index 3695b2e0cbd2..08b06e9a3a21 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -27,8 +27,6 @@
 
 #include <asm/gpio.h>
 
-#include <linux/platform_data/mmc-sdhci-tegra.h>
-
 #include "sdhci-pltfm.h"
 
 /* Tegra SDHOST controller vendor register definitions */
@@ -45,8 +43,11 @@ struct sdhci_tegra_soc_data {
 };
 
 struct sdhci_tegra {
-        const struct tegra_sdhci_platform_data *plat;
         const struct sdhci_tegra_soc_data *soc_data;
+        int cd_gpio;
+        int wp_gpio;
+        int power_gpio;
+        int is_8bit;
 };
 
 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
@@ -108,12 +109,11 @@ static unsigned int tegra_sdhci_get_ro(struct sdhci_host *host)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_tegra *tegra_host = pltfm_host->priv;
-        const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
 
-        if (!gpio_is_valid(plat->wp_gpio))
+        if (!gpio_is_valid(tegra_host->wp_gpio))
                 return -1;
 
-        return gpio_get_value(plat->wp_gpio);
+        return gpio_get_value(tegra_host->wp_gpio);
 }
 
 static irqreturn_t carddetect_irq(int irq, void *data)
@@ -143,15 +143,14 @@ static void tegra_sdhci_reset_exit(struct sdhci_host *host, u8 mask)
         }
 }
 
-static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
+static int tegra_sdhci_buswidth(struct sdhci_host *host, int bus_width)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_tegra *tegra_host = pltfm_host->priv;
-        const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
         u32 ctrl;
 
         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
-        if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
+        if (tegra_host->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
                 ctrl &= ~SDHCI_CTRL_4BITBUS;
                 ctrl |= SDHCI_CTRL_8BITBUS;
         } else {
@@ -170,7 +169,7 @@ static struct sdhci_ops tegra_sdhci_ops = {
         .read_l     = tegra_sdhci_readl,
         .read_w     = tegra_sdhci_readw,
         .write_l    = tegra_sdhci_writel,
-        .platform_8bit_width = tegra_sdhci_8bit,
+        .platform_bus_width = tegra_sdhci_buswidth,
         .platform_reset_exit = tegra_sdhci_reset_exit,
 };
 
@@ -217,31 +216,19 @@ static const struct of_device_id sdhci_tegra_dt_match[] = {
 };
 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
 
-static struct tegra_sdhci_platform_data *sdhci_tegra_dt_parse_pdata(
-                                                struct platform_device *pdev)
+static void sdhci_tegra_parse_dt(struct device *dev,
+                                        struct sdhci_tegra *tegra_host)
 {
-        struct tegra_sdhci_platform_data *plat;
-        struct device_node *np = pdev->dev.of_node;
+        struct device_node *np = dev->of_node;
         u32 bus_width;
 
-        if (!np)
-                return NULL;
-
-        plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
-        if (!plat) {
-                dev_err(&pdev->dev, "Can't allocate platform data\n");
-                return NULL;
-        }
-
-        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);
+        tegra_host->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
+        tegra_host->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+        tegra_host->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
 
         if (of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
             bus_width == 8)
-                plat->is_8bit = 1;
-
-        return plat;
+                tegra_host->is_8bit = 1;
 }
 
 static int sdhci_tegra_probe(struct platform_device *pdev)
@@ -250,7 +237,6 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
         const struct sdhci_tegra_soc_data *soc_data;
         struct sdhci_host *host;
         struct sdhci_pltfm_host *pltfm_host;
-        struct tegra_sdhci_platform_data *plat;
         struct sdhci_tegra *tegra_host;
         struct clk *clk;
         int rc;
@@ -263,52 +249,40 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
         host = sdhci_pltfm_init(pdev, soc_data->pdata);
         if (IS_ERR(host))
                 return PTR_ERR(host);
-
         pltfm_host = sdhci_priv(host);
 
-        plat = pdev->dev.platform_data;
-
-        if (plat == NULL)
-                plat = sdhci_tegra_dt_parse_pdata(pdev);
-
-        if (plat == NULL) {
-                dev_err(mmc_dev(host->mmc), "missing platform data\n");
-                rc = -ENXIO;
-                goto err_no_plat;
-        }
-
         tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
         if (!tegra_host) {
                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
                 rc = -ENOMEM;
-                goto err_no_plat;
+                goto err_alloc_tegra_host;
         }
-
-        tegra_host->plat = plat;
         tegra_host->soc_data = soc_data;
-
         pltfm_host->priv = tegra_host;
 
-        if (gpio_is_valid(plat->power_gpio)) {
-                rc = gpio_request(plat->power_gpio, "sdhci_power");
+        sdhci_tegra_parse_dt(&pdev->dev, tegra_host);
+
+        if (gpio_is_valid(tegra_host->power_gpio)) {
+                rc = gpio_request(tegra_host->power_gpio, "sdhci_power");
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate power gpio\n");
                         goto err_power_req;
                 }
-                gpio_direction_output(plat->power_gpio, 1);
+                gpio_direction_output(tegra_host->power_gpio, 1);
         }
 
-        if (gpio_is_valid(plat->cd_gpio)) {
-                rc = gpio_request(plat->cd_gpio, "sdhci_cd");
+        if (gpio_is_valid(tegra_host->cd_gpio)) {
+                rc = gpio_request(tegra_host->cd_gpio, "sdhci_cd");
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate cd gpio\n");
                         goto err_cd_req;
                 }
-                gpio_direction_input(plat->cd_gpio);
+                gpio_direction_input(tegra_host->cd_gpio);
 
-                rc = request_irq(gpio_to_irq(plat->cd_gpio), carddetect_irq,
+                rc = request_irq(gpio_to_irq(tegra_host->cd_gpio),
+                                 carddetect_irq,
                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                                  mmc_hostname(host->mmc), host);
 
@@ -319,14 +293,14 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
 
         }
 
-        if (gpio_is_valid(plat->wp_gpio)) {
-                rc = gpio_request(plat->wp_gpio, "sdhci_wp");
+        if (gpio_is_valid(tegra_host->wp_gpio)) {
+                rc = gpio_request(tegra_host->wp_gpio, "sdhci_wp");
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate wp gpio\n");
                         goto err_wp_req;
                 }
-                gpio_direction_input(plat->wp_gpio);
+                gpio_direction_input(tegra_host->wp_gpio);
         }
 
         clk = clk_get(mmc_dev(host->mmc), NULL);
@@ -338,9 +312,7 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
         clk_prepare_enable(clk);
         pltfm_host->clk = clk;
 
-        host->mmc->pm_caps = plat->pm_flags;
-
-        if (plat->is_8bit)
+        if (tegra_host->is_8bit)
                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
 
         rc = sdhci_add_host(host);
@@ -353,19 +325,19 @@ err_add_host:
         clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
 err_clk_get:
-        if (gpio_is_valid(plat->wp_gpio))
-                gpio_free(plat->wp_gpio);
+        if (gpio_is_valid(tegra_host->wp_gpio))
+                gpio_free(tegra_host->wp_gpio);
 err_wp_req:
-        if (gpio_is_valid(plat->cd_gpio))
-                free_irq(gpio_to_irq(plat->cd_gpio), host);
+        if (gpio_is_valid(tegra_host->cd_gpio))
+                free_irq(gpio_to_irq(tegra_host->cd_gpio), host);
 err_cd_irq_req:
-        if (gpio_is_valid(plat->cd_gpio))
-                gpio_free(plat->cd_gpio);
+        if (gpio_is_valid(tegra_host->cd_gpio))
+                gpio_free(tegra_host->cd_gpio);
 err_cd_req:
-        if (gpio_is_valid(plat->power_gpio))
-                gpio_free(plat->power_gpio);
+        if (gpio_is_valid(tegra_host->power_gpio))
+                gpio_free(tegra_host->power_gpio);
 err_power_req:
-err_no_plat:
+err_alloc_tegra_host:
         sdhci_pltfm_free(pdev);
         return rc;
 }
@@ -375,21 +347,20 @@ static int sdhci_tegra_remove(struct platform_device *pdev)
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_tegra *tegra_host = pltfm_host->priv;
-        const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
 
         sdhci_remove_host(host, dead);
 
-        if (gpio_is_valid(plat->wp_gpio))
-                gpio_free(plat->wp_gpio);
+        if (gpio_is_valid(tegra_host->wp_gpio))
+                gpio_free(tegra_host->wp_gpio);
 
-        if (gpio_is_valid(plat->cd_gpio)) {
-                free_irq(gpio_to_irq(plat->cd_gpio), host);
-                gpio_free(plat->cd_gpio);
+        if (gpio_is_valid(tegra_host->cd_gpio)) {
+                free_irq(gpio_to_irq(tegra_host->cd_gpio), host);
+                gpio_free(tegra_host->cd_gpio);
         }
 
-        if (gpio_is_valid(plat->power_gpio))
-                gpio_free(plat->power_gpio);
+        if (gpio_is_valid(tegra_host->power_gpio))
+                gpio_free(tegra_host->power_gpio);
 
         clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 6f0bfc0c8c9c..51bbba486f38 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -53,6 +53,7 @@ static void sdhci_send_command(struct sdhci_host *, struct mmc_command *);
 static void sdhci_finish_command(struct sdhci_host *);
 static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode);
 static void sdhci_tuning_timer(unsigned long data);
+static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
 
 #ifdef CONFIG_PM_RUNTIME
 static int sdhci_runtime_pm_get(struct sdhci_host *host);
@@ -1082,6 +1083,37 @@ static void sdhci_finish_command(struct sdhci_host *host)
         }
 }
 
+static u16 sdhci_get_preset_value(struct sdhci_host *host)
+{
+        u16 ctrl, preset = 0;
+
+        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+        switch (ctrl & SDHCI_CTRL_UHS_MASK) {
+        case SDHCI_CTRL_UHS_SDR12:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
+                break;
+        case SDHCI_CTRL_UHS_SDR25:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR25);
+                break;
+        case SDHCI_CTRL_UHS_SDR50:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR50);
+                break;
+        case SDHCI_CTRL_UHS_SDR104:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR104);
+                break;
+        case SDHCI_CTRL_UHS_DDR50:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50);
+                break;
+        default:
+                pr_warn("%s: Invalid UHS-I mode selected\n",
+                        mmc_hostname(host->mmc));
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
+                break;
+        }
+        return preset;
+}
+
 static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
 {
         int div = 0; /* Initialized for compiler warning */
@@ -1106,35 +1138,43 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
                 goto out;
 
         if (host->version >= SDHCI_SPEC_300) {
+                if (sdhci_readw(host, SDHCI_HOST_CONTROL2) &
+                        SDHCI_CTRL_PRESET_VAL_ENABLE) {
+                        u16 pre_val;
+
+                        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                        pre_val = sdhci_get_preset_value(host);
+                        div = (pre_val & SDHCI_PRESET_SDCLK_FREQ_MASK)
+                                >> SDHCI_PRESET_SDCLK_FREQ_SHIFT;
+                        if (host->clk_mul &&
+                                (pre_val & SDHCI_PRESET_CLKGEN_SEL_MASK)) {
+                                clk = SDHCI_PROG_CLOCK_MODE;
+                                real_div = div + 1;
+                                clk_mul = host->clk_mul;
+                        } else {
+                                real_div = max_t(int, 1, div << 1);
+                        }
+                        goto clock_set;
+                }
+
                 /*
                  * Check if the Host Controller supports Programmable Clock
                  * Mode.
                  */
                 if (host->clk_mul) {
-                        u16 ctrl;
-
+                        for (div = 1; div <= 1024; div++) {
+                                if ((host->max_clk * host->clk_mul / div)
+                                        <= clock)
+                                        break;
+                        }
                         /*
-                         * We need to figure out whether the Host Driver needs
-                         * to select Programmable Clock Mode, or the value can
-                         * be set automatically by the Host Controller based on
-                         * the Preset Value registers.
+                         * Set Programmable Clock Mode in the Clock
+                         * Control register.
                          */
-                        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-                        if (!(ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
-                                for (div = 1; div <= 1024; div++) {
-                                        if (((host->max_clk * host->clk_mul) /
-                                              div) <= clock)
-                                                break;
-                                }
-                                /*
-                                 * Set Programmable Clock Mode in the Clock
-                                 * Control register.
-                                 */
-                                clk = SDHCI_PROG_CLOCK_MODE;
-                                real_div = div;
-                                clk_mul = host->clk_mul;
-                                div--;
-                        }
+                        clk = SDHCI_PROG_CLOCK_MODE;
+                        real_div = div;
+                        clk_mul = host->clk_mul;
+                        div--;
                 } else {
                         /* Version 3.00 divisors must be a multiple of 2. */
                         if (host->max_clk <= clock)
@@ -1159,6 +1199,7 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
                 div >>= 1;
         }
 
+clock_set:
         if (real_div)
                 host->mmc->actual_clock = (host->max_clk * clk_mul) / real_div;
 
@@ -1189,6 +1230,15 @@ out:
         host->clock = clock;
 }
 
+static inline void sdhci_update_clock(struct sdhci_host *host)
+{
+        unsigned int clock;
+
+        clock = host->clock;
+        host->clock = 0;
+        sdhci_set_clock(host, clock);
+}
+
 static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
 {
         u8 pwr = 0;
@@ -1258,7 +1308,7 @@ static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
 static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
         struct sdhci_host *host;
-        bool present;
+        int present;
         unsigned long flags;
         u32 tuning_opcode;
 
@@ -1287,18 +1337,21 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         host->mrq = mrq;
 
-        /* If polling, assume that the card is always present. */
-        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
-                present = true;
-        else
-                present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
-                                SDHCI_CARD_PRESENT;
-
-        /* If we're using a cd-gpio, testing the presence bit might fail. */
-        if (!present) {
-                int ret = mmc_gpio_get_cd(host->mmc);
-                if (ret > 0)
-                        present = true;
+        /*
+         * Firstly check card presence from cd-gpio.  The return could
+         * be one of the following possibilities:
+         *     negative: cd-gpio is not available
+         *     zero: cd-gpio is used, and card is removed
+         *     one: cd-gpio is used, and card is present
+         */
+        present = mmc_gpio_get_cd(host->mmc);
+        if (present < 0) {
+                /* If polling, assume that the card is always present. */
+                if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+                        present = 1;
+                else
+                        present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
+                                        SDHCI_CARD_PRESENT;
         }
 
         if (!present || host->flags & SDHCI_DEVICE_DEAD) {
@@ -1364,6 +1417,10 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                 sdhci_reinit(host);
         }
 
+        if (host->version >= SDHCI_SPEC_300 &&
+                (ios->power_mode == MMC_POWER_UP))
+                sdhci_enable_preset_value(host, false);
+
         sdhci_set_clock(host, ios->clock);
 
         if (ios->power_mode == MMC_POWER_OFF)
@@ -1383,11 +1440,11 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
         /*
          * If your platform has 8-bit width support but is not a v3 controller,
          * or if it requires special setup code, you should implement that in
-         * platform_8bit_width().
+         * platform_bus_width().
          */
-        if (host->ops->platform_8bit_width)
-                host->ops->platform_8bit_width(host, ios->bus_width);
-        else {
+        if (host->ops->platform_bus_width) {
+                host->ops->platform_bus_width(host, ios->bus_width);
+        } else {
                 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
                 if (ios->bus_width == MMC_BUS_WIDTH_8) {
                         ctrl &= ~SDHCI_CTRL_4BITBUS;
@@ -1415,7 +1472,6 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
 
         if (host->version >= SDHCI_SPEC_300) {
                 u16 clk, ctrl_2;
-                unsigned int clock;
 
                 /* In case of UHS-I modes, set High Speed Enable */
                 if ((ios->timing == MMC_TIMING_MMC_HS200) ||
@@ -1455,9 +1511,7 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
                         /* Re-enable SD Clock */
-                        clock = host->clock;
-                        host->clock = 0;
-                        sdhci_set_clock(host, clock);
+                        sdhci_update_clock(host);
                 }
 
 
@@ -1487,10 +1541,22 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
                 }
 
+                if (!(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN) &&
+                                ((ios->timing == MMC_TIMING_UHS_SDR12) ||
+                                 (ios->timing == MMC_TIMING_UHS_SDR25) ||
+                                 (ios->timing == MMC_TIMING_UHS_SDR50) ||
+                                 (ios->timing == MMC_TIMING_UHS_SDR104) ||
+                                 (ios->timing == MMC_TIMING_UHS_DDR50))) {
+                        u16 preset;
+
+                        sdhci_enable_preset_value(host, true);
+                        preset = sdhci_get_preset_value(host);
+                        ios->drv_type = (preset & SDHCI_PRESET_DRV_MASK)
+                                >> SDHCI_PRESET_DRV_SHIFT;
+                }
+
                 /* Re-enable SD Clock */
-                clock = host->clock;
-                host->clock = 0;
-                sdhci_set_clock(host, clock);
+                sdhci_update_clock(host);
         } else
                 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
@@ -1608,141 +1674,91 @@ static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int sdhci_do_3_3v_signal_voltage_switch(struct sdhci_host *host,
-                                                u16 ctrl)
+static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
+                                                struct mmc_ios *ios)
 {
+        u16 ctrl;
         int ret;
 
-        /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
-        ctrl &= ~SDHCI_CTRL_VDD_180;
-        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
-
-        if (host->vqmmc) {
-                ret = regulator_set_voltage(host->vqmmc, 2700000, 3600000);
-                if (ret) {
-                        pr_warning("%s: Switching to 3.3V signalling voltage "
-                                   " failed\n", mmc_hostname(host->mmc));
-                        return -EIO;
-                }
-        }
-        /* Wait for 5ms */
-        usleep_range(5000, 5500);
+        /*
+         * Signal Voltage Switching is only applicable for Host Controllers
+         * v3.00 and above.
+         */
+        if (host->version < SDHCI_SPEC_300)
+                return 0;
 
-        /* 3.3V regulator output should be stable within 5 ms */
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-        if (!(ctrl & SDHCI_CTRL_VDD_180))
-                return 0;
 
-        pr_warning("%s: 3.3V regulator output did not became stable\n",
-                   mmc_hostname(host->mmc));
+        switch (ios->signal_voltage) {
+        case MMC_SIGNAL_VOLTAGE_330:
+                /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+                ctrl &= ~SDHCI_CTRL_VDD_180;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
 
-        return -EIO;
-}
+                if (host->vqmmc) {
+                        ret = regulator_set_voltage(host->vqmmc, 2700000, 3600000);
+                        if (ret) {
+                                pr_warning("%s: Switching to 3.3V signalling voltage "
+                                                " failed\n", mmc_hostname(host->mmc));
+                                return -EIO;
+                        }
+                }
+                /* Wait for 5ms */
+                usleep_range(5000, 5500);
 
-static int sdhci_do_1_8v_signal_voltage_switch(struct sdhci_host *host,
-                                                u16 ctrl)
-{
-        u8 pwr;
-        u16 clk;
-        u32 present_state;
-        int ret;
+                /* 3.3V regulator output should be stable within 5 ms */
+                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                if (!(ctrl & SDHCI_CTRL_VDD_180))
+                        return 0;
 
-        /* Stop SDCLK */
-        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
-        clk &= ~SDHCI_CLOCK_CARD_EN;
-        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+                pr_warning("%s: 3.3V regulator output did not became stable\n",
+                                mmc_hostname(host->mmc));
+
+                return -EAGAIN;
+        case MMC_SIGNAL_VOLTAGE_180:
+                if (host->vqmmc) {
+                        ret = regulator_set_voltage(host->vqmmc,
+                                        1700000, 1950000);
+                        if (ret) {
+                                pr_warning("%s: Switching to 1.8V signalling voltage "
+                                                " failed\n", mmc_hostname(host->mmc));
+                                return -EIO;
+                        }
+                }
 
-        /* Check whether DAT[3:0] is 0000 */
-        present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
-        if (!((present_state & SDHCI_DATA_LVL_MASK) >>
-               SDHCI_DATA_LVL_SHIFT)) {
                 /*
                  * Enable 1.8V Signal Enable in the Host Control2
                  * register
                  */
-                if (host->vqmmc)
-                        ret = regulator_set_voltage(host->vqmmc,
-                                1700000, 1950000);
-                else
-                        ret = 0;
+                ctrl |= SDHCI_CTRL_VDD_180;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
 
-                if (!ret) {
-                        ctrl |= SDHCI_CTRL_VDD_180;
-                        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+                /* Wait for 5ms */
+                usleep_range(5000, 5500);
 
-                        /* Wait for 5ms */
-                        usleep_range(5000, 5500);
+                /* 1.8V regulator output should be stable within 5 ms */
+                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                if (ctrl & SDHCI_CTRL_VDD_180)
+                        return 0;
 
-                        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-                        if (ctrl & SDHCI_CTRL_VDD_180) {
-                                /* Provide SDCLK again and wait for 1ms */
-                                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
-                                clk |= SDHCI_CLOCK_CARD_EN;
-                                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
-                                usleep_range(1000, 1500);
+                pr_warning("%s: 1.8V regulator output did not became stable\n",
+                                mmc_hostname(host->mmc));
 
-                                /*
-                                 * If DAT[3:0] level is 1111b, then the card
-                                 * was successfully switched to 1.8V signaling.
-                                 */
-                                present_state = sdhci_readl(host,
-                                                        SDHCI_PRESENT_STATE);
-                                if ((present_state & SDHCI_DATA_LVL_MASK) ==
-                                     SDHCI_DATA_LVL_MASK)
-                                        return 0;
+                return -EAGAIN;
+        case MMC_SIGNAL_VOLTAGE_120:
+                if (host->vqmmc) {
+                        ret = regulator_set_voltage(host->vqmmc, 1100000, 1300000);
+                        if (ret) {
+                                pr_warning("%s: Switching to 1.2V signalling voltage "
+                                                " failed\n", mmc_hostname(host->mmc));
+                                return -EIO;
                         }
                 }
-        }
-
-        /*
-         * If we are here, that means the switch to 1.8V signaling
-         * failed. We power cycle the card, and retry initialization
-         * sequence by setting S18R to 0.
-         */
-        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_warning("%s: Switching to 1.8V signalling voltage failed, "
-                   "retrying with S18R set to 0\n", mmc_hostname(host->mmc));
-
-        return -EAGAIN;
-}
-
-static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
-                                                struct mmc_ios *ios)
-{
-        u16 ctrl;
-
-        /*
-         * Signal Voltage Switching is only applicable for Host Controllers
-         * v3.00 and above.
-         */
-        if (host->version < SDHCI_SPEC_300)
                 return 0;
-
-        /*
-         * We first check whether the request is to set signalling voltage
-         * to 3.3V. If so, we change the voltage to 3.3V and return quickly.
-         */
-        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-        if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330)
-                return sdhci_do_3_3v_signal_voltage_switch(host, ctrl);
-        else if (!(ctrl & SDHCI_CTRL_VDD_180) &&
-                        (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180))
-                return sdhci_do_1_8v_signal_voltage_switch(host, ctrl);
-        else
+        default:
                 /* No signal voltage switch required */
                 return 0;
+        }
 }
 
 static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
@@ -1759,6 +1775,19 @@ static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
         return err;
 }
 
+static int sdhci_card_busy(struct mmc_host *mmc)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+        u32 present_state;
+
+        sdhci_runtime_pm_get(host);
+        /* Check whether DAT[3:0] is 0000 */
+        present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
+        sdhci_runtime_pm_put(host);
+
+        return !(present_state & SDHCI_DATA_LVL_MASK);
+}
+
 static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
 {
         struct sdhci_host *host;
@@ -1955,17 +1984,15 @@ out:
         return err;
 }
 
-static void sdhci_do_enable_preset_value(struct sdhci_host *host, bool enable)
+
+static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
 {
         u16 ctrl;
-        unsigned long flags;
 
         /* Host Controller v3.00 defines preset value registers */
         if (host->version < SDHCI_SPEC_300)
                 return;
 
-        spin_lock_irqsave(&host->lock, flags);
-
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 
         /*
@@ -1981,17 +2008,6 @@ static void sdhci_do_enable_preset_value(struct sdhci_host *host, bool enable)
                 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
                 host->flags &= ~SDHCI_PV_ENABLED;
         }
-
-        spin_unlock_irqrestore(&host->lock, flags);
-}
-
-static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
-{
-        struct sdhci_host *host = mmc_priv(mmc);
-
-        sdhci_runtime_pm_get(host);
-        sdhci_do_enable_preset_value(host, enable);
-        sdhci_runtime_pm_put(host);
 }
 
 static void sdhci_card_event(struct mmc_host *mmc)
@@ -2027,8 +2043,8 @@ static const struct mmc_host_ops sdhci_ops = {
         .enable_sdio_irq = sdhci_enable_sdio_irq,
         .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,
         .execute_tuning                 = sdhci_execute_tuning,
-        .enable_preset_value            = sdhci_enable_preset_value,
         .card_event                     = sdhci_card_event,
+        .card_busy      = sdhci_card_busy,
 };
 
 /*****************************************************************************\
@@ -2080,14 +2096,9 @@ static void sdhci_tasklet_finish(unsigned long param)
                    (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
 
                 /* Some controllers need this kick or reset won't work here */
-                if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) {
-                        unsigned int clock;
-
+                if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
                         /* This is to force an update */
-                        clock = host->clock;
-                        host->clock = 0;
-                        sdhci_set_clock(host, clock);
-                }
+                        sdhci_update_clock(host);
 
                 /* Spec says we should do both at the same time, but Ricoh
                    controllers do not like that. */
@@ -2455,6 +2466,32 @@ out:
 \*****************************************************************************/
 
 #ifdef CONFIG_PM
+void sdhci_enable_irq_wakeups(struct sdhci_host *host)
+{
+        u8 val;
+        u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE
+                        | SDHCI_WAKE_ON_INT;
+
+        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
+        val |= mask ;
+        /* Avoid fake wake up */
+        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+                val &= ~(SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE);
+        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
+}
+EXPORT_SYMBOL_GPL(sdhci_enable_irq_wakeups);
+
+void sdhci_disable_irq_wakeups(struct sdhci_host *host)
+{
+        u8 val;
+        u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE
+                        | SDHCI_WAKE_ON_INT;
+
+        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
+        val &= ~mask;
+        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
+}
+EXPORT_SYMBOL_GPL(sdhci_disable_irq_wakeups);
 
 int sdhci_suspend_host(struct sdhci_host *host)
 {
@@ -2484,8 +2521,13 @@ int sdhci_suspend_host(struct sdhci_host *host)
                 return ret;
         }
 
-        free_irq(host->irq, host);
-
+        if (!device_may_wakeup(mmc_dev(host->mmc))) {
+                sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
+                free_irq(host->irq, host);
+        } else {
+                sdhci_enable_irq_wakeups(host);
+                enable_irq_wake(host->irq);
+        }
         return ret;
 }
 
@@ -2500,10 +2542,15 @@ int sdhci_resume_host(struct sdhci_host *host)
                         host->ops->enable_dma(host);
         }
 
-        ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
-                          mmc_hostname(host->mmc), host);
-        if (ret)
-                return ret;
+        if (!device_may_wakeup(mmc_dev(host->mmc))) {
+                ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
+                                  mmc_hostname(host->mmc), host);
+                if (ret)
+                        return ret;
+        } else {
+                sdhci_disable_irq_wakeups(host);
+                disable_irq_wake(host->irq);
+        }
 
         if ((host->mmc->pm_flags & MMC_PM_KEEP_POWER) &&
             (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) {
@@ -2531,17 +2578,6 @@ int sdhci_resume_host(struct sdhci_host *host)
 }
 
 EXPORT_SYMBOL_GPL(sdhci_resume_host);
-
-void sdhci_enable_irq_wakeups(struct sdhci_host *host)
-{
-        u8 val;
-        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
-        val |= SDHCI_WAKE_ON_INT;
-        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
-}
-
-EXPORT_SYMBOL_GPL(sdhci_enable_irq_wakeups);
-
 #endif /* CONFIG_PM */
 
 #ifdef CONFIG_PM_RUNTIME
@@ -2600,8 +2636,12 @@ int sdhci_runtime_resume_host(struct sdhci_host *host)
         sdhci_do_set_ios(host, &host->mmc->ios);
 
         sdhci_do_start_signal_voltage_switch(host, &host->mmc->ios);
-        if (host_flags & SDHCI_PV_ENABLED)
-                sdhci_do_enable_preset_value(host, true);
+        if ((host_flags & SDHCI_PV_ENABLED) &&
+                !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) {
+                spin_lock_irqsave(&host->lock, flags);
+                sdhci_enable_preset_value(host, true);
+                spin_unlock_irqrestore(&host->lock, flags);
+        }
 
         /* Set the re-tuning expiration flag */
         if (host->flags & SDHCI_USING_RETUNING_TIMER)
@@ -2936,7 +2976,11 @@ int sdhci_add_host(struct sdhci_host *host)
         }
 
 #ifdef CONFIG_REGULATOR
-        if (host->vmmc) {
+        /*
+         * Voltage range check makes sense only if regulator reports
+         * any voltage value.
+         */
+        if (host->vmmc && regulator_get_voltage(host->vmmc) > 0) {
                 ret = regulator_is_supported_voltage(host->vmmc, 2700000,
                         3600000);
                 if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_330)))
@@ -3139,6 +3183,7 @@ int sdhci_add_host(struct sdhci_host *host)
 #ifdef SDHCI_USE_LEDS_CLASS
 reset:
         sdhci_reset(host, SDHCI_RESET_ALL);
+        sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
         free_irq(host->irq, host);
 #endif
 untasklet:
@@ -3181,6 +3226,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
         if (!dead)
                 sdhci_reset(host, SDHCI_RESET_ALL);
 
+        sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
         free_irq(host->irq, host);
 
         del_timer_sync(&host->timer);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index a6d69b7bdea2..379e09d9f3c1 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -229,6 +229,18 @@
 
 /* 60-FB reserved */
 
+#define SDHCI_PRESET_FOR_SDR12 0x66
+#define SDHCI_PRESET_FOR_SDR25 0x68
+#define SDHCI_PRESET_FOR_SDR50 0x6A
+#define SDHCI_PRESET_FOR_SDR104        0x6C
+#define SDHCI_PRESET_FOR_DDR50 0x6E
+#define SDHCI_PRESET_DRV_MASK  0xC000
+#define SDHCI_PRESET_DRV_SHIFT  14
+#define SDHCI_PRESET_CLKGEN_SEL_MASK   0x400
+#define SDHCI_PRESET_CLKGEN_SEL_SHIFT   10
+#define SDHCI_PRESET_SDCLK_FREQ_MASK   0x3FF
+#define SDHCI_PRESET_SDCLK_FREQ_SHIFT   0
+
 #define SDHCI_SLOT_INT_STATUS   0xFC
 
 #define SDHCI_HOST_VERSION      0xFE
@@ -269,7 +281,7 @@ struct sdhci_ops {
         unsigned int    (*get_max_clock)(struct sdhci_host *host);
         unsigned int    (*get_min_clock)(struct sdhci_host *host);
         unsigned int    (*get_timeout_clock)(struct sdhci_host *host);
-        int             (*platform_8bit_width)(struct sdhci_host *host,
+        int             (*platform_bus_width)(struct sdhci_host *host,
                                                int width);
         void (*platform_send_init_74_clocks)(struct sdhci_host *host,
                                              u8 power_mode);
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 9a4c151067dd..ba76a532ae30 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/mmc/slot-gpio.h>
 #include <linux/mod_devicetable.h>
+#include <linux/mutex.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
 #include <linux/pm_qos.h>
@@ -88,6 +89,7 @@
 #define CMD_SET_TBIT            (1 << 7) /* 1: tran mission bit "Low" */
 #define CMD_SET_OPDM            (1 << 6) /* 1: open/drain */
 #define CMD_SET_CCSH            (1 << 5)
+#define CMD_SET_DARS            (1 << 2) /* Dual Data Rate */
 #define CMD_SET_DATW_1          ((0 << 1) | (0 << 0)) /* 1bit */
 #define CMD_SET_DATW_4          ((0 << 1) | (1 << 0)) /* 4bit */
 #define CMD_SET_DATW_8          ((1 << 1) | (0 << 0)) /* 8bit */
@@ -127,6 +129,10 @@
                                  INT_CCSTO | INT_CRCSTO | INT_WDATTO |    \
                                  INT_RDATTO | INT_RBSYTO | INT_RSPTO)
 
+#define INT_ALL                 (INT_RBSYE | INT_CRSPE | INT_BUFREN |    \
+                                 INT_BUFWEN | INT_CMD12DRE | INT_BUFRE | \
+                                 INT_DTRANE | INT_CMD12RBE | INT_CMD12CRE)
+
 /* CE_INT_MASK */
 #define MASK_ALL                0x00000000
 #define MASK_MCCSDE             (1 << 29)
@@ -158,6 +164,11 @@
                                  MASK_MCCSTO | MASK_MCRCSTO | MASK_MWDATTO | \
                                  MASK_MRDATTO | MASK_MRBSYTO | MASK_MRSPTO)
 
+#define MASK_CLEAN              (INT_ERR_STS | MASK_MRBSYE | MASK_MCRSPE |      \
+                                 MASK_MBUFREN | MASK_MBUFWEN |                  \
+                                 MASK_MCMD12DRE | MASK_MBUFRE | MASK_MDTRANE |  \
+                                 MASK_MCMD12RBE | MASK_MCMD12CRE)
+
 /* CE_HOST_STS1 */
 #define STS1_CMDSEQ             (1 << 31)
 
@@ -195,6 +206,7 @@ enum mmcif_state {
         STATE_IDLE,
         STATE_REQUEST,
         STATE_IOS,
+        STATE_TIMEOUT,
 };
 
 enum mmcif_wait_for {
@@ -216,6 +228,7 @@ struct sh_mmcif_host {
         struct clk *hclk;
         unsigned int clk;
         int bus_width;
+        unsigned char timing;
         bool sd_error;
         bool dying;
         long timeout;
@@ -230,6 +243,7 @@ struct sh_mmcif_host {
         int sg_blkidx;
         bool power;
         bool card_present;
+        struct mutex thread_lock;
 
         /* DMA support */
         struct dma_chan         *chan_rx;
@@ -253,23 +267,14 @@ static inline void sh_mmcif_bitclr(struct sh_mmcif_host *host,
 static void mmcif_dma_complete(void *arg)
 {
         struct sh_mmcif_host *host = arg;
-        struct mmc_data *data = host->mrq->data;
+        struct mmc_request *mrq = host->mrq;
 
         dev_dbg(&host->pd->dev, "Command completed\n");
 
-        if (WARN(!data, "%s: NULL data in DMA completion!\n",
+        if (WARN(!mrq || !mrq->data, "%s: NULL data in DMA completion!\n",
                  dev_name(&host->pd->dev)))
                 return;
 
-        if (data->flags & MMC_DATA_READ)
-                dma_unmap_sg(host->chan_rx->device->dev,
-                             data->sg, data->sg_len,
-                             DMA_FROM_DEVICE);
-        else
-                dma_unmap_sg(host->chan_tx->device->dev,
-                             data->sg, data->sg_len,
-                             DMA_TO_DEVICE);
-
         complete(&host->dma_complete);
 }
 
@@ -423,8 +428,6 @@ static void sh_mmcif_request_dma(struct sh_mmcif_host *host,
         if (ret < 0)
                 goto ecfgrx;
 
-        init_completion(&host->dma_complete);
-
         return;
 
 ecfgrx:
@@ -520,13 +523,16 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
         }
 
         if (state2 & STS2_CRC_ERR) {
-                dev_dbg(&host->pd->dev, ": CRC error\n");
+                dev_err(&host->pd->dev, " CRC error: state %u, wait %u\n",
+                        host->state, host->wait_for);
                 ret = -EIO;
         } else if (state2 & STS2_TIMEOUT_ERR) {
-                dev_dbg(&host->pd->dev, ": Timeout\n");
+                dev_err(&host->pd->dev, " Timeout: state %u, wait %u\n",
+                        host->state, host->wait_for);
                 ret = -ETIMEDOUT;
         } else {
-                dev_dbg(&host->pd->dev, ": End/Index error\n");
+                dev_dbg(&host->pd->dev, " End/Index error: state %u, wait %u\n",
+                        host->state, host->wait_for);
                 ret = -EIO;
         }
         return ret;
@@ -549,10 +555,7 @@ static bool sh_mmcif_next_block(struct sh_mmcif_host *host, u32 *p)
                 host->pio_ptr = p;
         }
 
-        if (host->sg_idx == data->sg_len)
-                return false;
-
-        return true;
+        return host->sg_idx != data->sg_len;
 }
 
 static void sh_mmcif_single_read(struct sh_mmcif_host *host,
@@ -562,7 +565,6 @@ static void sh_mmcif_single_read(struct sh_mmcif_host *host,
                            BLOCK_SIZE_MASK) + 3;
 
         host->wait_for = MMCIF_WAIT_FOR_READ;
-        schedule_delayed_work(&host->timeout_work, host->timeout);
 
         /* buf read enable */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
@@ -576,6 +578,7 @@ static bool sh_mmcif_read_block(struct sh_mmcif_host *host)
 
         if (host->sd_error) {
                 data->error = sh_mmcif_error_manage(host);
+                dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, data->error);
                 return false;
         }
 
@@ -604,7 +607,7 @@ static void sh_mmcif_multi_read(struct sh_mmcif_host *host,
         host->sg_idx = 0;
         host->sg_blkidx = 0;
         host->pio_ptr = sg_virt(data->sg);
-        schedule_delayed_work(&host->timeout_work, host->timeout);
+
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
 }
 
@@ -616,6 +619,7 @@ static bool sh_mmcif_mread_block(struct sh_mmcif_host *host)
 
         if (host->sd_error) {
                 data->error = sh_mmcif_error_manage(host);
+                dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, data->error);
                 return false;
         }
 
@@ -627,7 +631,6 @@ static bool sh_mmcif_mread_block(struct sh_mmcif_host *host)
         if (!sh_mmcif_next_block(host, p))
                 return false;
 
-        schedule_delayed_work(&host->timeout_work, host->timeout);
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
 
         return true;
@@ -640,7 +643,6 @@ static void sh_mmcif_single_write(struct sh_mmcif_host *host,
                            BLOCK_SIZE_MASK) + 3;
 
         host->wait_for = MMCIF_WAIT_FOR_WRITE;
-        schedule_delayed_work(&host->timeout_work, host->timeout);
 
         /* buf write enable */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
@@ -654,6 +656,7 @@ static bool sh_mmcif_write_block(struct sh_mmcif_host *host)
 
         if (host->sd_error) {
                 data->error = sh_mmcif_error_manage(host);
+                dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, data->error);
                 return false;
         }
 
@@ -682,7 +685,7 @@ static void sh_mmcif_multi_write(struct sh_mmcif_host *host,
         host->sg_idx = 0;
         host->sg_blkidx = 0;
         host->pio_ptr = sg_virt(data->sg);
-        schedule_delayed_work(&host->timeout_work, host->timeout);
+
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
 }
 
@@ -694,6 +697,7 @@ static bool sh_mmcif_mwrite_block(struct sh_mmcif_host *host)
 
         if (host->sd_error) {
                 data->error = sh_mmcif_error_manage(host);
+                dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, data->error);
                 return false;
         }
 
@@ -705,7 +709,6 @@ static bool sh_mmcif_mwrite_block(struct sh_mmcif_host *host)
         if (!sh_mmcif_next_block(host, p))
                 return false;
 
-        schedule_delayed_work(&host->timeout_work, host->timeout);
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
 
         return true;
@@ -756,6 +759,7 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
         }
         switch (opc) {
         /* RBSY */
+        case MMC_SLEEP_AWAKE:
         case MMC_SWITCH:
         case MMC_STOP_TRANSMISSION:
         case MMC_SET_WRITE_PROT:
@@ -781,6 +785,17 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
                         dev_err(&host->pd->dev, "Unsupported bus width.\n");
                         break;
                 }
+                switch (host->timing) {
+                case MMC_TIMING_UHS_DDR50:
+                        /*
+                         * MMC core will only set this timing, if the host
+                         * advertises the MMC_CAP_UHS_DDR50 capability. MMCIF
+                         * implementations with this capability, e.g. sh73a0,
+                         * will have to set it in their platform data.
+                         */
+                        tmp |= CMD_SET_DARS;
+                        break;
+                }
         }
         /* DWEN */
         if (opc == MMC_WRITE_BLOCK || opc == MMC_WRITE_MULTIPLE_BLOCK)
@@ -824,7 +839,7 @@ static int sh_mmcif_data_trans(struct sh_mmcif_host *host,
                 sh_mmcif_single_read(host, mrq);
                 return 0;
         default:
-                dev_err(&host->pd->dev, "UNSUPPORTED CMD = d'%08d\n", opc);
+                dev_err(&host->pd->dev, "Unsupported CMD%d\n", opc);
                 return -EINVAL;
         }
 }
@@ -838,6 +853,7 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
 
         switch (opc) {
         /* response busy check */
+        case MMC_SLEEP_AWAKE:
         case MMC_SWITCH:
         case MMC_STOP_TRANSMISSION:
         case MMC_SET_WRITE_PROT:
@@ -885,7 +901,6 @@ static void sh_mmcif_stop_cmd(struct sh_mmcif_host *host,
         }
 
         host->wait_for = MMCIF_WAIT_FOR_STOP;
-        schedule_delayed_work(&host->timeout_work, host->timeout);
 }
 
 static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
@@ -895,6 +910,7 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         spin_lock_irqsave(&host->lock, flags);
         if (host->state != STATE_IDLE) {
+                dev_dbg(&host->pd->dev, "%s() rejected, state %u\n", __func__, host->state);
                 spin_unlock_irqrestore(&host->lock, flags);
                 mrq->cmd->error = -EAGAIN;
                 mmc_request_done(mmc, mrq);
@@ -911,6 +927,7 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 if ((mrq->cmd->flags & MMC_CMD_MASK) != MMC_CMD_BCR)
                         break;
         case MMC_APP_CMD:
+        case SD_IO_RW_DIRECT:
                 host->state = STATE_IDLE;
                 mrq->cmd->error = -ETIMEDOUT;
                 mmc_request_done(mmc, mrq);
@@ -957,6 +974,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         spin_lock_irqsave(&host->lock, flags);
         if (host->state != STATE_IDLE) {
+                dev_dbg(&host->pd->dev, "%s() rejected, state %u\n", __func__, host->state);
                 spin_unlock_irqrestore(&host->lock, flags);
                 return;
         }
@@ -981,7 +999,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         }
                 }
                 if (host->power) {
-                        pm_runtime_put(&host->pd->dev);
+                        pm_runtime_put_sync(&host->pd->dev);
                         clk_disable(host->hclk);
                         host->power = false;
                         if (ios->power_mode == MMC_POWER_OFF)
@@ -1001,6 +1019,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 sh_mmcif_clock_control(host, ios->clock);
         }
 
+        host->timing = ios->timing;
         host->bus_width = ios->bus_width;
         host->state = STATE_IDLE;
 }
@@ -1038,14 +1057,14 @@ static bool sh_mmcif_end_cmd(struct sh_mmcif_host *host)
                 case MMC_SELECT_CARD:
                 case MMC_APP_CMD:
                         cmd->error = -ETIMEDOUT;
-                        host->sd_error = false;
                         break;
                 default:
                         cmd->error = sh_mmcif_error_manage(host);
-                        dev_dbg(&host->pd->dev, "Cmd(d'%d) error %d\n",
-                                cmd->opcode, cmd->error);
                         break;
                 }
+                dev_dbg(&host->pd->dev, "CMD%d error %d\n",
+                        cmd->opcode, cmd->error);
+                host->sd_error = false;
                 return false;
         }
         if (!(cmd->flags & MMC_RSP_PRESENT)) {
@@ -1058,6 +1077,12 @@ static bool sh_mmcif_end_cmd(struct sh_mmcif_host *host)
         if (!data)
                 return false;
 
+        /*
+         * Completion can be signalled from DMA callback and error, so, have to
+         * reset here, before setting .dma_active
+         */
+        init_completion(&host->dma_complete);
+
         if (data->flags & MMC_DATA_READ) {
                 if (host->chan_rx)
                         sh_mmcif_start_dma_rx(host);
@@ -1068,34 +1093,47 @@ static bool sh_mmcif_end_cmd(struct sh_mmcif_host *host)
 
         if (!host->dma_active) {
                 data->error = sh_mmcif_data_trans(host, host->mrq, cmd->opcode);
-                if (!data->error)
-                        return true;
-                return false;
+                return !data->error;
         }
 
         /* Running in the IRQ thread, can sleep */
         time = wait_for_completion_interruptible_timeout(&host->dma_complete,
                                                          host->timeout);
+
+        if (data->flags & MMC_DATA_READ)
+                dma_unmap_sg(host->chan_rx->device->dev,
+                             data->sg, data->sg_len,
+                             DMA_FROM_DEVICE);
+        else
+                dma_unmap_sg(host->chan_tx->device->dev,
+                             data->sg, data->sg_len,
+                             DMA_TO_DEVICE);
+
         if (host->sd_error) {
                 dev_err(host->mmc->parent,
                         "Error IRQ while waiting for DMA completion!\n");
                 /* Woken up by an error IRQ: abort DMA */
-                if (data->flags & MMC_DATA_READ)
-                        dmaengine_terminate_all(host->chan_rx);
-                else
-                        dmaengine_terminate_all(host->chan_tx);
                 data->error = sh_mmcif_error_manage(host);
         } else if (!time) {
+                dev_err(host->mmc->parent, "DMA timeout!\n");
                 data->error = -ETIMEDOUT;
         } else if (time < 0) {
+                dev_err(host->mmc->parent,
+                        "wait_for_completion_...() error %ld!\n", time);
                 data->error = time;
         }
         sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC,
                         BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
         host->dma_active = false;
 
-        if (data->error)
+        if (data->error) {
                 data->bytes_xfered = 0;
+                /* Abort DMA */
+                if (data->flags & MMC_DATA_READ)
+                        dmaengine_terminate_all(host->chan_rx);
+                else
+                        dmaengine_terminate_all(host->chan_tx);
+        }
 
         return false;
 }
@@ -1103,10 +1141,21 @@ static bool sh_mmcif_end_cmd(struct sh_mmcif_host *host)
 static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
 {
         struct sh_mmcif_host *host = dev_id;
-        struct mmc_request *mrq = host->mrq;
+        struct mmc_request *mrq;
+        bool wait = false;
 
         cancel_delayed_work_sync(&host->timeout_work);
 
+        mutex_lock(&host->thread_lock);
+
+        mrq = host->mrq;
+        if (!mrq) {
+                dev_dbg(&host->pd->dev, "IRQ thread state %u, wait %u: NULL mrq!\n",
+                        host->state, host->wait_for);
+                mutex_unlock(&host->thread_lock);
+                return IRQ_HANDLED;
+        }
+
         /*
          * All handlers return true, if processing continues, and false, if the
          * request has to be completed - successfully or not
@@ -1114,35 +1163,32 @@ static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
         switch (host->wait_for) {
         case MMCIF_WAIT_FOR_REQUEST:
                 /* We're too late, the timeout has already kicked in */
+                mutex_unlock(&host->thread_lock);
                 return IRQ_HANDLED;
         case MMCIF_WAIT_FOR_CMD:
-                if (sh_mmcif_end_cmd(host))
-                        /* Wait for data */
-                        return IRQ_HANDLED;
+                /* Wait for data? */
+                wait = sh_mmcif_end_cmd(host);
                 break;
         case MMCIF_WAIT_FOR_MREAD:
-                if (sh_mmcif_mread_block(host))
-                        /* Wait for more data */
-                        return IRQ_HANDLED;
+                /* Wait for more data? */
+                wait = sh_mmcif_mread_block(host);
                 break;
         case MMCIF_WAIT_FOR_READ:
-                if (sh_mmcif_read_block(host))
-                        /* Wait for data end */
-                        return IRQ_HANDLED;
+                /* Wait for data end? */
+                wait = sh_mmcif_read_block(host);
                 break;
         case MMCIF_WAIT_FOR_MWRITE:
-                if (sh_mmcif_mwrite_block(host))
-                        /* Wait data to write */
-                        return IRQ_HANDLED;
+                /* Wait data to write? */
+                wait = sh_mmcif_mwrite_block(host);
                 break;
         case MMCIF_WAIT_FOR_WRITE:
-                if (sh_mmcif_write_block(host))
-                        /* Wait for data end */
-                        return IRQ_HANDLED;
+                /* Wait for data end? */
+                wait = sh_mmcif_write_block(host);
                 break;
         case MMCIF_WAIT_FOR_STOP:
                 if (host->sd_error) {
                         mrq->stop->error = sh_mmcif_error_manage(host);
+                        dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, mrq->stop->error);
                         break;
                 }
                 sh_mmcif_get_cmd12response(host, mrq->stop);
@@ -1150,13 +1196,22 @@ static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
                 break;
         case MMCIF_WAIT_FOR_READ_END:
         case MMCIF_WAIT_FOR_WRITE_END:
-                if (host->sd_error)
+                if (host->sd_error) {
                         mrq->data->error = sh_mmcif_error_manage(host);
+                        dev_dbg(&host->pd->dev, "%s(): %d\n", __func__, mrq->data->error);
+                }
                 break;
         default:
                 BUG();
         }
 
+        if (wait) {
+                schedule_delayed_work(&host->timeout_work, host->timeout);
+                /* Wait for more data */
+                mutex_unlock(&host->thread_lock);
+                return IRQ_HANDLED;
+        }
+
         if (host->wait_for != MMCIF_WAIT_FOR_STOP) {
                 struct mmc_data *data = mrq->data;
                 if (!mrq->cmd->error && data && !data->error)
@@ -1165,8 +1220,11 @@ static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
 
                 if (mrq->stop && !mrq->cmd->error && (!data || !data->error)) {
                         sh_mmcif_stop_cmd(host, mrq);
-                        if (!mrq->stop->error)
+                        if (!mrq->stop->error) {
+                                schedule_delayed_work(&host->timeout_work, host->timeout);
+                                mutex_unlock(&host->thread_lock);
                                 return IRQ_HANDLED;
+                        }
                 }
         }
 
@@ -1175,6 +1233,8 @@ static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
         host->mrq = NULL;
         mmc_request_done(host->mmc, mrq);
 
+        mutex_unlock(&host->thread_lock);
+
         return IRQ_HANDLED;
 }
 
@@ -1182,56 +1242,22 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
 {
         struct sh_mmcif_host *host = dev_id;
         u32 state;
-        int err = 0;
 
         state = sh_mmcif_readl(host->addr, MMCIF_CE_INT);
+        sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
+        sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state & MASK_CLEAN);
 
-        if (state & INT_ERR_STS) {
-                /* error interrupts - process first */
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
-                err = 1;
-        } else if (state & INT_RBSYE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT,
-                                ~(INT_RBSYE | INT_CRSPE));
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MRBSYE);
-        } else if (state & INT_CRSPE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_CRSPE);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCRSPE);
-        } else if (state & INT_BUFREN) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_BUFREN);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
-        } else if (state & INT_BUFWEN) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_BUFWEN);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
-        } else if (state & INT_CMD12DRE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT,
-                        ~(INT_CMD12DRE | INT_CMD12RBE |
-                          INT_CMD12CRE | INT_BUFRE));
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCMD12DRE);
-        } else if (state & INT_BUFRE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_BUFRE);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
-        } else if (state & INT_DTRANE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT,
-                        ~(INT_CMD12DRE | INT_CMD12RBE |
-                          INT_CMD12CRE | INT_DTRANE));
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
-        } else if (state & INT_CMD12RBE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT,
-                                ~(INT_CMD12RBE | INT_CMD12CRE));
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
-        } else {
-                dev_dbg(&host->pd->dev, "Unsupported interrupt: 0x%x\n", state);
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
-                err = 1;
-        }
-        if (err) {
+        if (state & ~MASK_CLEAN)
+                dev_dbg(&host->pd->dev, "IRQ state = 0x%08x incompletely cleared\n",
+                        state);
+
+        if (state & INT_ERR_STS || state & ~INT_ALL) {
                 host->sd_error = true;
-                dev_dbg(&host->pd->dev, "int err state = %08x\n", state);
+                dev_dbg(&host->pd->dev, "int err state = 0x%08x\n", state);
         }
         if (state & ~(INT_CMD12RBE | INT_CMD12CRE)) {
+                if (!host->mrq)
+                        dev_dbg(&host->pd->dev, "NULL IRQ state = 0x%08x\n", state);
                 if (!host->dma_active)
                         return IRQ_WAKE_THREAD;
                 else if (host->sd_error)
@@ -1248,11 +1274,24 @@ static void mmcif_timeout_work(struct work_struct *work)
         struct delayed_work *d = container_of(work, struct delayed_work, work);
         struct sh_mmcif_host *host = container_of(d, struct sh_mmcif_host, timeout_work);
         struct mmc_request *mrq = host->mrq;
+        unsigned long flags;
 
         if (host->dying)
                 /* Don't run after mmc_remove_host() */
                 return;
 
+        dev_err(&host->pd->dev, "Timeout waiting for %u on CMD%u\n",
+                host->wait_for, mrq->cmd->opcode);
+
+        spin_lock_irqsave(&host->lock, flags);
+        if (host->state == STATE_IDLE) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                return;
+        }
+
+        host->state = STATE_TIMEOUT;
+        spin_unlock_irqrestore(&host->lock, flags);
+
         /*
          * Handle races with cancel_delayed_work(), unless
          * cancel_delayed_work_sync() is used
@@ -1306,10 +1345,11 @@ static int sh_mmcif_probe(struct platform_device *pdev)
         struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
         struct resource *res;
         void __iomem *reg;
+        const char *name;
 
         irq[0] = platform_get_irq(pdev, 0);
         irq[1] = platform_get_irq(pdev, 1);
-        if (irq[0] < 0 || irq[1] < 0) {
+        if (irq[0] < 0) {
                 dev_err(&pdev->dev, "Get irq error\n");
                 return -ENXIO;
         }
@@ -1329,10 +1369,11 @@ static int sh_mmcif_probe(struct platform_device *pdev)
                 ret = -ENOMEM;
                 goto ealloch;
         }
+        mmc_of_parse(mmc);
         host            = mmc_priv(mmc);
         host->mmc       = mmc;
         host->addr      = reg;
-        host->timeout   = 1000;
+        host->timeout   = msecs_to_jiffies(1000);
 
         host->pd = pdev;
 
@@ -1341,7 +1382,7 @@ static int sh_mmcif_probe(struct platform_device *pdev)
         mmc->ops = &sh_mmcif_ops;
         sh_mmcif_init_ocr(host);
 
-        mmc->caps = MMC_CAP_MMC_HIGHSPEED;
+        mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_WAIT_WHILE_BUSY;
         if (pd && pd->caps)
                 mmc->caps |= pd->caps;
         mmc->max_segs = 32;
@@ -1374,15 +1415,19 @@ static int sh_mmcif_probe(struct platform_device *pdev)
         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);
+        name = irq[1] < 0 ? dev_name(&pdev->dev) : "sh_mmc:error";
+        ret = request_threaded_irq(irq[0], sh_mmcif_intr, sh_mmcif_irqt, 0, name, host);
         if (ret) {
-                dev_err(&pdev->dev, "request_irq error (sh_mmc:error)\n");
+                dev_err(&pdev->dev, "request_irq error (%s)\n", name);
                 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 ereqirq1;
+        if (irq[1] >= 0) {
+                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 ereqirq1;
+                }
         }
 
         if (pd && pd->use_cd_gpio) {
@@ -1391,6 +1436,8 @@ static int sh_mmcif_probe(struct platform_device *pdev)
                         goto erqcd;
         }
 
+        mutex_init(&host->thread_lock);
+
         clk_disable(host->hclk);
         ret = mmc_add_host(mmc);
         if (ret < 0)
@@ -1404,10 +1451,9 @@ static int sh_mmcif_probe(struct platform_device *pdev)
         return ret;
 
 emmcaddh:
-        if (pd && pd->use_cd_gpio)
-                mmc_gpio_free_cd(mmc);
 erqcd:
-        free_irq(irq[1], host);
+        if (irq[1] >= 0)
+                free_irq(irq[1], host);
 ereqirq1:
         free_irq(irq[0], host);
 ereqirq0:
@@ -1427,7 +1473,6 @@ ealloch:
 static int 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;
@@ -1436,9 +1481,6 @@ static int sh_mmcif_remove(struct platform_device *pdev)
 
         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);
 
@@ -1456,7 +1498,8 @@ static int sh_mmcif_remove(struct platform_device *pdev)
         irq[1] = platform_get_irq(pdev, 1);
 
         free_irq(irq[0], host);
-        free_irq(irq[1], host);
+        if (irq[1] >= 0)
+                free_irq(irq[1], host);
 
         platform_set_drvdata(pdev, NULL);
 
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 524a7f773820..fe90853900b4 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include <linux/mod_devicetable.h>
 #include <linux/module.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/sh_mobile_sdhi.h>
@@ -32,6 +33,16 @@
 
 #include "tmio_mmc.h"
 
+struct sh_mobile_sdhi_of_data {
+        unsigned long tmio_flags;
+};
+
+static const struct sh_mobile_sdhi_of_data sh_mobile_sdhi_of_cfg[] = {
+        {
+                .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT,
+        },
+};
+
 struct sh_mobile_sdhi {
         struct clk *clk;
         struct tmio_mmc_data mmc_data;
@@ -117,8 +128,18 @@ static const struct sh_mobile_sdhi_ops sdhi_ops = {
         .cd_wakeup = sh_mobile_sdhi_cd_wakeup,
 };
 
+static const struct of_device_id sh_mobile_sdhi_of_match[] = {
+        { .compatible = "renesas,shmobile-sdhi" },
+        { .compatible = "renesas,sh7372-sdhi" },
+        { .compatible = "renesas,r8a7740-sdhi", .data = &sh_mobile_sdhi_of_cfg[0], },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sh_mobile_sdhi_of_match);
+
 static int sh_mobile_sdhi_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                of_match_device(sh_mobile_sdhi_of_match, &pdev->dev);
         struct sh_mobile_sdhi *priv;
         struct tmio_mmc_data *mmc_data;
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
@@ -126,7 +147,7 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
         int irq, ret, i = 0;
         bool multiplexed_isr = true;
 
-        priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
         if (priv == NULL) {
                 dev_err(&pdev->dev, "kzalloc failed\n");
                 return -ENOMEM;
@@ -135,15 +156,14 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data = &priv->mmc_data;
 
         if (p) {
-                p->pdata = mmc_data;
                 if (p->init) {
                         ret = p->init(pdev, &sdhi_ops);
                         if (ret)
-                                goto einit;
+                                return ret;
                 }
         }
 
-        priv->clk = clk_get(&pdev->dev, NULL);
+        priv->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(priv->clk)) {
                 ret = PTR_ERR(priv->clk);
                 dev_err(&pdev->dev, "cannot get clock: %d\n", ret);
@@ -153,10 +173,9 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data->clk_enable = sh_mobile_sdhi_clk_enable;
         mmc_data->clk_disable = sh_mobile_sdhi_clk_disable;
         mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
+        mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
         if (p) {
                 mmc_data->flags = p->tmio_flags;
-                if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
-                        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;
@@ -187,6 +206,11 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
          */
         mmc_data->flags |= TMIO_MMC_SDIO_IRQ;
 
+        if (of_id && of_id->data) {
+                const struct sh_mobile_sdhi_of_data *of_data = of_id->data;
+                mmc_data->flags |= of_data->tmio_flags;
+        }
+
         ret = tmio_mmc_host_probe(&host, pdev, mmc_data);
         if (ret < 0)
                 goto eprobe;
@@ -199,33 +223,33 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
         irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
         if (irq >= 0) {
                 multiplexed_isr = false;
-                ret = request_irq(irq, tmio_mmc_card_detect_irq, 0,
+                ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_card_detect_irq, 0,
                                   dev_name(&pdev->dev), host);
                 if (ret)
-                        goto eirq_card_detect;
+                        goto eirq;
         }
 
         irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
         if (irq >= 0) {
                 multiplexed_isr = false;
-                ret = request_irq(irq, tmio_mmc_sdio_irq, 0,
+                ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_sdio_irq, 0,
                                   dev_name(&pdev->dev), host);
                 if (ret)
-                        goto eirq_sdio;
+                        goto eirq;
         }
 
         irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDCARD);
         if (irq >= 0) {
                 multiplexed_isr = false;
-                ret = request_irq(irq, tmio_mmc_sdcard_irq, 0,
+                ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_sdcard_irq, 0,
                                   dev_name(&pdev->dev), host);
                 if (ret)
-                        goto eirq_sdcard;
+                        goto eirq;
         } else if (!multiplexed_isr) {
                 dev_err(&pdev->dev,
                         "Principal SD-card IRQ is missing among named interrupts\n");
                 ret = irq;
-                goto eirq_sdcard;
+                goto eirq;
         }
 
         if (multiplexed_isr) {
@@ -234,15 +258,15 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
                         if (irq < 0)
                                 break;
                         i++;
-                        ret = request_irq(irq, tmio_mmc_irq, 0,
+                        ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_irq, 0,
                                           dev_name(&pdev->dev), host);
                         if (ret)
-                                goto eirq_multiplexed;
+                                goto eirq;
                 }
 
                 /* There must be at least one IRQ source */
                 if (!i)
-                        goto eirq_multiplexed;
+                        goto eirq;
         }
 
         dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n",
@@ -252,28 +276,12 @@ static int sh_mobile_sdhi_probe(struct platform_device *pdev)
 
         return ret;
 
-eirq_multiplexed:
-        while (i--) {
-                irq = platform_get_irq(pdev, i);
-                free_irq(irq, host);
-        }
-eirq_sdcard:
-        irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
-        if (irq >= 0)
-                free_irq(irq, host);
-eirq_sdio:
-        irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
-        if (irq >= 0)
-                free_irq(irq, host);
-eirq_card_detect:
+eirq:
         tmio_mmc_host_remove(host);
 eprobe:
-        clk_put(priv->clk);
 eclkget:
         if (p && p->cleanup)
                 p->cleanup(pdev);
-einit:
-        kfree(priv);
         return ret;
 }
 
@@ -281,29 +289,13 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
 {
         struct mmc_host *mmc = platform_get_drvdata(pdev);
         struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
-        int i = 0, irq;
-
-        if (p)
-                p->pdata = NULL;
 
         tmio_mmc_host_remove(host);
 
-        while (1) {
-                irq = platform_get_irq(pdev, i++);
-                if (irq < 0)
-                        break;
-                free_irq(irq, host);
-        }
-
-        clk_put(priv->clk);
-
         if (p && p->cleanup)
                 p->cleanup(pdev);
 
-        kfree(priv);
-
         return 0;
 }
 
@@ -314,12 +306,6 @@ 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",
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 50bf495a988b..f508ecb5b8a7 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -43,6 +43,7 @@
 #include <linux/platform_device.h>
 #include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
+#include <linux/regulator/consumer.h>
 #include <linux/scatterlist.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
@@ -155,6 +156,7 @@ static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
                 host->set_clk_div(host->pdev, (clk>>22) & 1);
 
         sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & 0x1ff);
+        msleep(10);
 }
 
 static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
@@ -768,16 +770,48 @@ static int tmio_mmc_clk_update(struct mmc_host *mmc)
         return ret;
 }
 
-static void tmio_mmc_set_power(struct tmio_mmc_host *host, struct mmc_ios *ios)
+static void tmio_mmc_power_on(struct tmio_mmc_host *host, unsigned short vdd)
 {
         struct mmc_host *mmc = host->mmc;
+        int ret = 0;
+
+        /* .set_ios() is returning void, so, no chance to report an error */
 
         if (host->set_pwr)
-                host->set_pwr(host->pdev, ios->power_mode != MMC_POWER_OFF);
+                host->set_pwr(host->pdev, 1);
+
+        if (!IS_ERR(mmc->supply.vmmc)) {
+                ret = mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
+                /*
+                 * Attention: empiric value. With a b43 WiFi SDIO card this
+                 * delay proved necessary for reliable card-insertion probing.
+                 * 100us were not enough. Is this the same 140us delay, as in
+                 * tmio_mmc_set_ios()?
+                 */
+                udelay(200);
+        }
+        /*
+         * It seems, VccQ should be switched on after Vcc, this is also what the
+         * omap_hsmmc.c driver does.
+         */
+        if (!IS_ERR(mmc->supply.vqmmc) && !ret) {
+                regulator_enable(mmc->supply.vqmmc);
+                udelay(200);
+        }
+}
+
+static void tmio_mmc_power_off(struct tmio_mmc_host *host)
+{
+        struct mmc_host *mmc = host->mmc;
+
+        if (!IS_ERR(mmc->supply.vqmmc))
+                regulator_disable(mmc->supply.vqmmc);
+
         if (!IS_ERR(mmc->supply.vmmc))
-                /* Errors ignored... */
-                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
-                                      ios->power_mode ? ios->vdd : 0);
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, 0);
+
+        if (host->set_pwr)
+                host->set_pwr(host->pdev, 0);
 }
 
 /* Set MMC clock / power.
@@ -828,18 +862,20 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 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 */
-                tmio_mmc_set_power(host, ios);
+                if (!host->power) {
+                        /* power up SD card and the bus */
+                        tmio_mmc_power_on(host, ios->vdd);
+                        host->power = true;
+                }
                 /* start bus clock */
                 tmio_mmc_clk_start(host);
         } else if (ios->power_mode != MMC_POWER_UP) {
-                if (ios->power_mode == MMC_POWER_OFF)
-                        tmio_mmc_set_power(host, ios);
                 if (host->power) {
                         struct tmio_mmc_data *pdata = host->pdata;
+                        if (ios->power_mode == MMC_POWER_OFF)
+                                tmio_mmc_power_off(host);
                         tmio_mmc_clk_stop(host);
                         host->power = false;
                         pm_runtime_put(dev);
@@ -918,6 +954,17 @@ static void tmio_mmc_init_ocr(struct tmio_mmc_host *host)
                 dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
 }
 
+static void tmio_mmc_of_parse(struct platform_device *pdev,
+                              struct tmio_mmc_data *pdata)
+{
+        const struct device_node *np = pdev->dev.of_node;
+        if (!np)
+                return;
+
+        if (of_get_property(np, "toshiba,mmc-wrprotect-disable", NULL))
+                pdata->flags |= TMIO_MMC_WRPROTECT_DISABLE;
+}
+
 int tmio_mmc_host_probe(struct tmio_mmc_host **host,
                                   struct platform_device *pdev,
                                   struct tmio_mmc_data *pdata)
@@ -928,6 +975,11 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
         int ret;
         u32 irq_mask = TMIO_MASK_CMD;
 
+        tmio_mmc_of_parse(pdev, pdata);
+
+        if (!(pdata->flags & TMIO_MMC_HAS_IDLE_WAIT))
+                pdata->write16_hook = NULL;
+
         res_ctl = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res_ctl)
                 return -EINVAL;
@@ -936,6 +988,8 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
         if (!mmc)
                 return -ENOMEM;
 
+        mmc_of_parse(mmc);
+
         pdata->dev = &pdev->dev;
         _host = mmc_priv(mmc);
         _host->pdata = pdata;
@@ -956,7 +1010,7 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
         }
 
         mmc->ops = &tmio_mmc_ops;
-        mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
+        mmc->caps |= MMC_CAP_4_BIT_DATA | pdata->capabilities;
         mmc->caps2 = pdata->capabilities2;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
@@ -968,7 +1022,8 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         _host->native_hotplug = !(pdata->flags & TMIO_MMC_USE_GPIO_CD ||
                                   mmc->caps & MMC_CAP_NEEDS_POLL ||
-                                  mmc->caps & MMC_CAP_NONREMOVABLE);
+                                  mmc->caps & MMC_CAP_NONREMOVABLE ||
+                                  mmc->slot.cd_irq >= 0);
 
         _host->power = false;
         pm_runtime_enable(&pdev->dev);
@@ -1060,16 +1115,8 @@ EXPORT_SYMBOL(tmio_mmc_host_probe);
 void tmio_mmc_host_remove(struct tmio_mmc_host *host)
 {
         struct platform_device *pdev = host->pdev;
-        struct tmio_mmc_data *pdata = host->pdata;
         struct mmc_host *mmc = host->mmc;
 
-        if (pdata->flags & TMIO_MMC_USE_GPIO_CD)
-                /*
-                 * This means we can miss a card-eject, but this is anyway
-                 * possible, because of delayed processing of hotplug events.
-                 */
-                mmc_gpio_free_cd(mmc);
-
         if (!host->native_hotplug)
                 pm_runtime_get_sync(&pdev->dev);
 
diff --git a/drivers/mmc/host/wmt-sdmmc.c b/drivers/mmc/host/wmt-sdmmc.c
index 154f0e8e931c..c6d001509e5a 100644
--- a/drivers/mmc/host/wmt-sdmmc.c
+++ b/drivers/mmc/host/wmt-sdmmc.c
@@ -1012,7 +1012,7 @@ static const struct dev_pm_ops wmt_mci_pm = {
 
 static struct platform_driver wmt_mci_driver = {
         .probe = wmt_mci_probe,
-        .remove = __exit_p(wmt_mci_remove),
+        .remove = wmt_mci_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,