43 files changed, 1647 insertions, 1063 deletions

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index c6a383d0244d..dabec556ebb8 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -41,7 +41,6 @@
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sd.h>
 
-#include <asm/system.h>
 #include <asm/uaccess.h>
 
 #include "queue.h"
@@ -874,7 +873,7 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
 {
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
-        unsigned int from, nr, arg;
+        unsigned int from, nr, arg, trim_arg, erase_arg;
         int err = 0, type = MMC_BLK_SECDISCARD;
 
         if (!(mmc_can_secure_erase_trim(card) || mmc_can_sanitize(card))) {
@@ -882,20 +881,26 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
                 goto out;
         }
 
+        from = blk_rq_pos(req);
+        nr = blk_rq_sectors(req);
+
         /* The sanitize operation is supported at v4.5 only */
         if (mmc_can_sanitize(card)) {
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                EXT_CSD_SANITIZE_START, 1, 0);
-                goto out;
+                erase_arg = MMC_ERASE_ARG;
+                trim_arg = MMC_TRIM_ARG;
+        } else {
+                erase_arg = MMC_SECURE_ERASE_ARG;
+                trim_arg = MMC_SECURE_TRIM1_ARG;
         }
 
-        from = blk_rq_pos(req);
-        nr = blk_rq_sectors(req);
-
-        if (mmc_can_trim(card) && !mmc_erase_group_aligned(card, from, nr))
-                arg = MMC_SECURE_TRIM1_ARG;
-        else
-                arg = MMC_SECURE_ERASE_ARG;
+        if (mmc_erase_group_aligned(card, from, nr))
+                arg = erase_arg;
+        else if (mmc_can_trim(card))
+                arg = trim_arg;
+        else {
+                err = -EINVAL;
+                goto out;
+        }
 retry:
         if (card->quirks & MMC_QUIRK_INAND_CMD38) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
@@ -905,25 +910,41 @@ retry:
                                  INAND_CMD38_ARG_SECERASE,
                                  0);
                 if (err)
-                        goto out;
+                        goto out_retry;
         }
+
         err = mmc_erase(card, from, nr, arg);
-        if (!err && arg == MMC_SECURE_TRIM1_ARG) {
+        if (err == -EIO)
+                goto out_retry;
+        if (err)
+                goto out;
+
+        if (arg == MMC_SECURE_TRIM1_ARG) {
                 if (card->quirks & MMC_QUIRK_INAND_CMD38) {
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          INAND_CMD38_ARG_EXT_CSD,
                                          INAND_CMD38_ARG_SECTRIM2,
                                          0);
                         if (err)
-                                goto out;
+                                goto out_retry;
                 }
+
                 err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
+                if (err == -EIO)
+                        goto out_retry;
+                if (err)
+                        goto out;
         }
-out:
-        if (err == -EIO && !mmc_blk_reset(md, card->host, type))
+
+        if (mmc_can_sanitize(card))
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_SANITIZE_START, 1, 0);
+out_retry:
+        if (err && !mmc_blk_reset(md, card->host, type))
                 goto retry;
         if (!err)
                 mmc_blk_reset_success(md, type);
+out:
         spin_lock_irq(&md->lock);
         __blk_end_request(req, err, blk_rq_bytes(req));
         spin_unlock_irq(&md->lock);
@@ -1080,6 +1101,7 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         struct mmc_blk_request *brq = &mqrq->brq;
         struct request *req = mqrq->req;
         struct mmc_blk_data *md = mq->data;
+        bool do_data_tag;
 
         /*
          * Reliable writes are used to implement Forced Unit Access and
@@ -1156,6 +1178,16 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
                 mmc_apply_rel_rw(brq, card, req);
 
         /*
+         * Data tag is used only during writing meta data to speed
+         * up write and any subsequent read of this meta data
+         */
+        do_data_tag = (card->ext_csd.data_tag_unit_size) &&
+                (req->cmd_flags & REQ_META) &&
+                (rq_data_dir(req) == WRITE) &&
+                ((brq->data.blocks * brq->data.blksz) >=
+                 card->ext_csd.data_tag_unit_size);
+
+        /*
          * Pre-defined multi-block transfers are preferable to
          * open ended-ones (and necessary for reliable writes).
          * However, it is not sufficient to just send CMD23,
@@ -1173,13 +1205,13 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
          * We'll avoid using CMD23-bounded multiblock writes for
          * these, while retaining features like reliable writes.
          */
-
-        if ((md->flags & MMC_BLK_CMD23) &&
-            mmc_op_multi(brq->cmd.opcode) &&
-            (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23))) {
+        if ((md->flags & MMC_BLK_CMD23) && mmc_op_multi(brq->cmd.opcode) &&
+            (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23) ||
+             do_data_tag)) {
                 brq->sbc.opcode = MMC_SET_BLOCK_COUNT;
                 brq->sbc.arg = brq->data.blocks |
-                        (do_rel_wr ? (1 << 31) : 0);
+                        (do_rel_wr ? (1 << 31) : 0) |
+                        (do_data_tag ? (1 << 29) : 0);
                 brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
                 brq->mrq.sbc = &brq->sbc;
         }
@@ -1613,24 +1645,6 @@ static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
         return ret;
 }
 
-static int
-mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
-{
-        int err;
-
-        mmc_claim_host(card->host);
-        err = mmc_set_blocklen(card, 512);
-        mmc_release_host(card->host);
-
-        if (err) {
-                pr_err("%s: unable to set block size to 512: %d\n",
-                        md->disk->disk_name, err);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
 static void mmc_blk_remove_req(struct mmc_blk_data *md)
 {
         struct mmc_card *card;
@@ -1685,7 +1699,7 @@ static int mmc_add_disk(struct mmc_blk_data *md)
 
         if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
              card->ext_csd.boot_ro_lockable) {
-                mode_t mode;
+                umode_t mode;
 
                 if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
                         mode = S_IRUGO;
@@ -1758,7 +1772,6 @@ static const struct mmc_fixup blk_fixups[] =
 static int mmc_blk_probe(struct mmc_card *card)
 {
         struct mmc_blk_data *md, *part_md;
-        int err;
         char cap_str[10];
 
         /*
@@ -1771,10 +1784,6 @@ static int mmc_blk_probe(struct mmc_card *card)
         if (IS_ERR(md))
                 return PTR_ERR(md);
 
-        err = mmc_blk_set_blksize(md, card);
-        if (err)
-                goto out;
-
         string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
                         cap_str, sizeof(cap_str));
         pr_info("%s: %s %s %s %s\n",
@@ -1799,7 +1808,7 @@ static int mmc_blk_probe(struct mmc_card *card)
  out:
         mmc_blk_remove_parts(card, md);
         mmc_blk_remove_req(md);
-        return err;
+        return 0;
 }
 
 static void mmc_blk_remove(struct mmc_card *card)
@@ -1815,7 +1824,7 @@ static void mmc_blk_remove(struct mmc_card *card)
 }
 
 #ifdef CONFIG_PM
-static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
+static int mmc_blk_suspend(struct mmc_card *card)
 {
         struct mmc_blk_data *part_md;
         struct mmc_blk_data *md = mmc_get_drvdata(card);
@@ -1835,8 +1844,6 @@ static int mmc_blk_resume(struct mmc_card *card)
         struct mmc_blk_data *md = mmc_get_drvdata(card);
 
         if (md) {
-                mmc_blk_set_blksize(md, card);
-
                 /*
                  * Resume involves the card going into idle state,
                  * so current partition is always the main one.
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 2517547b4366..996f8e36e23d 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -139,7 +139,7 @@ static void mmc_queue_setup_discard(struct request_queue *q,
 
         queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
         q->limits.max_discard_sectors = max_discard;
-        if (card->erased_byte == 0)
+        if (card->erased_byte == 0 && !mmc_can_discard(card))
                 q->limits.discard_zeroes_data = 1;
         q->limits.discard_granularity = card->pref_erase << 9;
         /* granularity must not be greater than max. discard */
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index 2c151e18c9e8..5a2cbfac66d2 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -750,15 +750,12 @@ static int sdio_uart_install(struct tty_driver *driver, struct tty_struct *tty)
 {
         int idx = tty->index;
         struct sdio_uart_port *port = sdio_uart_port_get(idx);
-        int ret = tty_init_termios(tty);
+        int ret = tty_standard_install(driver, tty);
 
-        if (ret == 0) {
-                tty_driver_kref_get(driver);
-                tty->count++;
+        if (ret == 0)
                 /* This is the ref sdio_uart_port get provided */
                 tty->driver_data = port;
-                driver->ttys[idx] = tty;
-        } else
+        else
                 sdio_uart_port_put(port);
         return ret;
 }
@@ -1178,7 +1175,6 @@ static int __init sdio_uart_init(void)
         if (!tty_drv)
                 return -ENOMEM;
 
-        tty_drv->owner = THIS_MODULE;
         tty_drv->driver_name = "sdio_uart";
         tty_drv->name =   "ttySDIO";
         tty_drv->major = 0;  /* dynamically allocated */
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 5d011a39dfff..c60cee92a2b2 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -122,14 +122,14 @@ static int mmc_bus_remove(struct device *dev)
         return 0;
 }
 
-static int mmc_bus_suspend(struct device *dev, pm_message_t state)
+static int mmc_bus_suspend(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
         int ret = 0;
 
         if (dev->driver && drv->suspend)
-                ret = drv->suspend(card, state);
+                ret = drv->suspend(card);
         return ret;
 }
 
@@ -165,20 +165,14 @@ static int mmc_runtime_idle(struct device *dev)
         return pm_runtime_suspend(dev);
 }
 
+#endif /* !CONFIG_PM_RUNTIME */
+
 static const struct dev_pm_ops mmc_bus_pm_ops = {
-        .runtime_suspend        = mmc_runtime_suspend,
-        .runtime_resume         = mmc_runtime_resume,
-        .runtime_idle           = mmc_runtime_idle,
+        SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume,
+                        mmc_runtime_idle)
+        SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
 };
 
-#define MMC_PM_OPS_PTR  (&mmc_bus_pm_ops)
-
-#else /* !CONFIG_PM_RUNTIME */
-
-#define MMC_PM_OPS_PTR  NULL
-
-#endif /* !CONFIG_PM_RUNTIME */
-
 static struct bus_type mmc_bus_type = {
         .name           = "mmc",
         .dev_attrs      = mmc_dev_attrs,
@@ -186,9 +180,7 @@ static struct bus_type mmc_bus_type = {
         .uevent         = mmc_bus_uevent,
         .probe          = mmc_bus_probe,
         .remove         = mmc_bus_remove,
-        .suspend        = mmc_bus_suspend,
-        .resume         = mmc_bus_resume,
-        .pm             = MMC_PM_OPS_PTR,
+        .pm             = &mmc_bus_pm_ops,
 };
 
 int mmc_register_bus(void)
@@ -267,6 +259,15 @@ int mmc_add_card(struct mmc_card *card)
 {
         int ret;
         const char *type;
+        const char *uhs_bus_speed_mode = "";
+        static const char *const uhs_speeds[] = {
+                [UHS_SDR12_BUS_SPEED] = "SDR12 ",
+                [UHS_SDR25_BUS_SPEED] = "SDR25 ",
+                [UHS_SDR50_BUS_SPEED] = "SDR50 ",
+                [UHS_SDR104_BUS_SPEED] = "SDR104 ",
+                [UHS_DDR50_BUS_SPEED] = "DDR50 ",
+        };
+
 
         dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
 
@@ -296,6 +297,10 @@ int mmc_add_card(struct mmc_card *card)
                 break;
         }
 
+        if (mmc_sd_card_uhs(card) &&
+                (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
+                uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
+
         if (mmc_host_is_spi(card->host)) {
                 pr_info("%s: new %s%s%s card on SPI\n",
                         mmc_hostname(card->host),
@@ -303,13 +308,13 @@ int mmc_add_card(struct mmc_card *card)
                         mmc_card_ddr_mode(card) ? "DDR " : "",
                         type);
         } else {
-                pr_info("%s: new %s%s%s%s card at address %04x\n",
+                pr_info("%s: new %s%s%s%s%s card at address %04x\n",
                         mmc_hostname(card->host),
                         mmc_card_uhs(card) ? "ultra high speed " :
                         (mmc_card_highspeed(card) ? "high speed " : ""),
                         (mmc_card_hs200(card) ? "HS200 " : ""),
                         mmc_card_ddr_mode(card) ? "DDR " : "",
-                        type, card->rca);
+                        uhs_bus_speed_mode, type, card->rca);
         }
 
 #ifdef CONFIG_DEBUG_FS
diff --git a/drivers/mmc/core/cd-gpio.c b/drivers/mmc/core/cd-gpio.c
index 082202ae4a03..2c14be73254c 100644
--- a/drivers/mmc/core/cd-gpio.c
+++ b/drivers/mmc/core/cd-gpio.c
@@ -12,6 +12,7 @@
 #include <linux/gpio.h>
 #include <linux/interrupt.h>
 #include <linux/jiffies.h>
+#include <linux/mmc/cd-gpio.h>
 #include <linux/mmc/host.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -28,13 +29,17 @@ static irqreturn_t mmc_cd_gpio_irqt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-int mmc_cd_gpio_request(struct mmc_host *host, unsigned int gpio,
-                        unsigned int irq, unsigned long flags)
+int mmc_cd_gpio_request(struct mmc_host *host, unsigned int gpio)
 {
         size_t len = strlen(dev_name(host->parent)) + 4;
-        struct mmc_cd_gpio *cd = kmalloc(sizeof(*cd) + len, GFP_KERNEL);
+        struct mmc_cd_gpio *cd;
+        int irq = gpio_to_irq(gpio);
         int ret;
 
+        if (irq < 0)
+                return irq;
+
+        cd = kmalloc(sizeof(*cd) + len, GFP_KERNEL);
         if (!cd)
                 return -ENOMEM;
 
@@ -45,7 +50,8 @@ int mmc_cd_gpio_request(struct mmc_host *host, unsigned int gpio,
                 goto egpioreq;
 
         ret = request_threaded_irq(irq, NULL, mmc_cd_gpio_irqt,
-                                   flags, cd->label, host);
+                                   IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                   cd->label, host);
         if (ret < 0)
                 goto eirqreq;
 
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 690255c7d4dc..ba821fe70bca 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -188,6 +188,12 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         struct scatterlist *sg;
 #endif
 
+        if (mrq->sbc) {
+                pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
+                         mmc_hostname(host), mrq->sbc->opcode,
+                         mrq->sbc->arg, mrq->sbc->flags);
+        }
+
         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
                  mmc_hostname(host), mrq->cmd->opcode,
                  mrq->cmd->arg, mrq->cmd->flags);
@@ -243,16 +249,17 @@ static void mmc_wait_done(struct mmc_request *mrq)
         complete(&mrq->completion);
 }
 
-static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
+static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
 {
         init_completion(&mrq->completion);
         mrq->done = mmc_wait_done;
         if (mmc_card_removed(host->card)) {
                 mrq->cmd->error = -ENOMEDIUM;
                 complete(&mrq->completion);
-                return;
+                return -ENOMEDIUM;
         }
         mmc_start_request(host, mrq);
+        return 0;
 }
 
 static void mmc_wait_for_req_done(struct mmc_host *host,
@@ -336,6 +343,7 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
                                     struct mmc_async_req *areq, int *error)
 {
         int err = 0;
+        int start_err = 0;
         struct mmc_async_req *data = host->areq;
 
         /* Prepare a new request */
@@ -345,30 +353,23 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
         if (host->areq) {
                 mmc_wait_for_req_done(host, host->areq->mrq);
                 err = host->areq->err_check(host->card, host->areq);
-                if (err) {
-                        /* post process the completed failed request */
-                        mmc_post_req(host, host->areq->mrq, 0);
-                        if (areq)
-                                /*
-                                 * Cancel the new prepared request, because
-                                 * it can't run until the failed
-                                 * request has been properly handled.
-                                 */
-                                mmc_post_req(host, areq->mrq, -EINVAL);
-
-                        host->areq = NULL;
-                        goto out;
-                }
         }
 
-        if (areq)
-                __mmc_start_req(host, areq->mrq);
+        if (!err && areq)
+                start_err = __mmc_start_req(host, areq->mrq);
 
         if (host->areq)
                 mmc_post_req(host, host->areq->mrq, 0);
 
-        host->areq = areq;
- out:
+         /* Cancel a prepared request if it was not started. */
+        if ((err || start_err) && areq)
+                        mmc_post_req(host, areq->mrq, -EINVAL);
+
+        if (err)
+                host->areq = NULL;
+        else
+                host->areq = areq;
+
         if (error)
                 *error = err;
         return data;
@@ -526,10 +527,14 @@ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
 
                 if (data->flags & MMC_DATA_WRITE)
                         /*
-                         * The limit is really 250 ms, but that is
-                         * insufficient for some crappy cards.
+                         * The MMC spec "It is strongly recommended
+                         * for hosts to implement more than 500ms
+                         * timeout value even if the card indicates
+                         * the 250ms maximum busy length."  Even the
+                         * previous value of 300ms is known to be
+                         * insufficient for some cards.
                          */
-                        limit_us = 300000;
+                        limit_us = 3000000;
                 else
                         limit_us = 100000;
 
@@ -599,105 +604,6 @@ unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
 EXPORT_SYMBOL(mmc_align_data_size);
 
 /**
- *      mmc_host_enable - enable a host.
- *      @host: mmc host to enable
- *
- *      Hosts that support power saving can use the 'enable' and 'disable'
- *      methods to exit and enter power saving states. For more information
- *      see comments for struct mmc_host_ops.
- */
-int mmc_host_enable(struct mmc_host *host)
-{
-        if (!(host->caps & MMC_CAP_DISABLE))
-                return 0;
-
-        if (host->en_dis_recurs)
-                return 0;
-
-        if (host->nesting_cnt++)
-                return 0;
-
-        cancel_delayed_work_sync(&host->disable);
-
-        if (host->enabled)
-                return 0;
-
-        if (host->ops->enable) {
-                int err;
-
-                host->en_dis_recurs = 1;
-                mmc_host_clk_hold(host);
-                err = host->ops->enable(host);
-                mmc_host_clk_release(host);
-                host->en_dis_recurs = 0;
-
-                if (err) {
-                        pr_debug("%s: enable error %d\n",
-                                 mmc_hostname(host), err);
-                        return err;
-                }
-        }
-        host->enabled = 1;
-        return 0;
-}
-EXPORT_SYMBOL(mmc_host_enable);
-
-static int mmc_host_do_disable(struct mmc_host *host, int lazy)
-{
-        if (host->ops->disable) {
-                int err;
-
-                host->en_dis_recurs = 1;
-                mmc_host_clk_hold(host);
-                err = host->ops->disable(host, lazy);
-                mmc_host_clk_release(host);
-                host->en_dis_recurs = 0;
-
-                if (err < 0) {
-                        pr_debug("%s: disable error %d\n",
-                                 mmc_hostname(host), err);
-                        return err;
-                }
-                if (err > 0) {
-                        unsigned long delay = msecs_to_jiffies(err);
-
-                        mmc_schedule_delayed_work(&host->disable, delay);
-                }
-        }
-        host->enabled = 0;
-        return 0;
-}
-
-/**
- *      mmc_host_disable - disable a host.
- *      @host: mmc host to disable
- *
- *      Hosts that support power saving can use the 'enable' and 'disable'
- *      methods to exit and enter power saving states. For more information
- *      see comments for struct mmc_host_ops.
- */
-int mmc_host_disable(struct mmc_host *host)
-{
-        int err;
-
-        if (!(host->caps & MMC_CAP_DISABLE))
-                return 0;
-
-        if (host->en_dis_recurs)
-                return 0;
-
-        if (--host->nesting_cnt)
-                return 0;
-
-        if (!host->enabled)
-                return 0;
-
-        err = mmc_host_do_disable(host, 0);
-        return err;
-}
-EXPORT_SYMBOL(mmc_host_disable);
-
-/**
  *      __mmc_claim_host - exclusively claim a host
  *      @host: mmc host to claim
  *      @abort: whether or not the operation should be aborted
@@ -735,8 +641,8 @@ int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
                 wake_up(&host->wq);
         spin_unlock_irqrestore(&host->lock, flags);
         remove_wait_queue(&host->wq, &wait);
-        if (!stop)
-                mmc_host_enable(host);
+        if (host->ops->enable && !stop && host->claim_cnt == 1)
+                host->ops->enable(host);
         return stop;
 }
 
@@ -761,21 +667,28 @@ int mmc_try_claim_host(struct mmc_host *host)
                 claimed_host = 1;
         }
         spin_unlock_irqrestore(&host->lock, flags);
+        if (host->ops->enable && claimed_host && host->claim_cnt == 1)
+                host->ops->enable(host);
         return claimed_host;
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 
 /**
- *      mmc_do_release_host - release a claimed host
+ *      mmc_release_host - release a host
  *      @host: mmc host to release
  *
- *      If you successfully claimed a host, this function will
- *      release it again.
+ *      Release a MMC host, allowing others to claim the host
+ *      for their operations.
  */
-void mmc_do_release_host(struct mmc_host *host)
+void mmc_release_host(struct mmc_host *host)
 {
         unsigned long flags;
 
+        WARN_ON(!host->claimed);
+
+        if (host->ops->disable && host->claim_cnt == 1)
+                host->ops->disable(host);
+
         spin_lock_irqsave(&host->lock, flags);
         if (--host->claim_cnt) {
                 /* Release for nested claim */
@@ -787,67 +700,6 @@ void mmc_do_release_host(struct mmc_host *host)
                 wake_up(&host->wq);
         }
 }
-EXPORT_SYMBOL(mmc_do_release_host);
-
-void mmc_host_deeper_disable(struct work_struct *work)
-{
-        struct mmc_host *host =
-                container_of(work, struct mmc_host, disable.work);
-
-        /* If the host is claimed then we do not want to disable it anymore */
-        if (!mmc_try_claim_host(host))
-                return;
-        mmc_host_do_disable(host, 1);
-        mmc_do_release_host(host);
-}
-
-/**
- *      mmc_host_lazy_disable - lazily disable a host.
- *      @host: mmc host to disable
- *
- *      Hosts that support power saving can use the 'enable' and 'disable'
- *      methods to exit and enter power saving states. For more information
- *      see comments for struct mmc_host_ops.
- */
-int mmc_host_lazy_disable(struct mmc_host *host)
-{
-        if (!(host->caps & MMC_CAP_DISABLE))
-                return 0;
-
-        if (host->en_dis_recurs)
-                return 0;
-
-        if (--host->nesting_cnt)
-                return 0;
-
-        if (!host->enabled)
-                return 0;
-
-        if (host->disable_delay) {
-                mmc_schedule_delayed_work(&host->disable,
-                                msecs_to_jiffies(host->disable_delay));
-                return 0;
-        } else
-                return mmc_host_do_disable(host, 1);
-}
-EXPORT_SYMBOL(mmc_host_lazy_disable);
-
-/**
- *      mmc_release_host - release a host
- *      @host: mmc host to release
- *
- *      Release a MMC host, allowing others to claim the host
- *      for their operations.
- */
-void mmc_release_host(struct mmc_host *host)
-{
-        WARN_ON(!host->claimed);
-
-        mmc_host_lazy_disable(host);
-
-        mmc_do_release_host(host);
-}
-
 EXPORT_SYMBOL(mmc_release_host);
 
 /*
@@ -1557,7 +1409,10 @@ static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
 {
         unsigned int erase_timeout;
 
-        if (card->ext_csd.erase_group_def & 1) {
+        if (arg == MMC_DISCARD_ARG ||
+            (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {
+                erase_timeout = card->ext_csd.trim_timeout;
+        } else if (card->ext_csd.erase_group_def & 1) {
                 /* High Capacity Erase Group Size uses HC timeouts */
                 if (arg == MMC_TRIM_ARG)
                         erase_timeout = card->ext_csd.trim_timeout;
@@ -1829,8 +1684,6 @@ int mmc_can_trim(struct mmc_card *card)
 {
         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
                 return 1;
-        if (mmc_can_discard(card))
-                return 1;
         return 0;
 }
 EXPORT_SYMBOL(mmc_can_trim);
@@ -1849,6 +1702,8 @@ EXPORT_SYMBOL(mmc_can_discard);
 
 int mmc_can_sanitize(struct mmc_card *card)
 {
+        if (!mmc_can_trim(card) && !mmc_can_erase(card))
+                return 0;
         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
                 return 1;
         return 0;
@@ -2068,6 +1923,9 @@ static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
          */
         mmc_hw_reset_for_init(host);
 
+        /* Initialization should be done at 3.3 V I/O voltage. */
+        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
+
         /*
          * sdio_reset sends CMD52 to reset card.  Since we do not know
          * if the card is being re-initialized, just send it.  CMD52
@@ -2112,18 +1970,36 @@ int _mmc_detect_card_removed(struct mmc_host *host)
 int mmc_detect_card_removed(struct mmc_host *host)
 {
         struct mmc_card *card = host->card;
+        int ret;
 
         WARN_ON(!host->claimed);
+
+        if (!card)
+                return 1;
+
+        ret = mmc_card_removed(card);
         /*
          * The card will be considered unchanged unless we have been asked to
          * detect a change or host requires polling to provide card detection.
          */
-        if (card && !host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
-                return mmc_card_removed(card);
+        if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL) &&
+            !(host->caps2 & MMC_CAP2_DETECT_ON_ERR))
+                return ret;
 
         host->detect_change = 0;
+        if (!ret) {
+                ret = _mmc_detect_card_removed(host);
+                if (ret && (host->caps2 & MMC_CAP2_DETECT_ON_ERR)) {
+                        /*
+                         * Schedule a detect work as soon as possible to let a
+                         * rescan handle the card removal.
+                         */
+                        cancel_delayed_work(&host->detect);
+                        mmc_detect_change(host, 0);
+                }
+        }
 
-        return _mmc_detect_card_removed(host);
+        return ret;
 }
 EXPORT_SYMBOL(mmc_detect_card_removed);
 
@@ -2200,8 +2076,6 @@ void mmc_stop_host(struct mmc_host *host)
         spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
-        if (host->caps & MMC_CAP_DISABLE)
-                cancel_delayed_work(&host->disable);
         cancel_delayed_work_sync(&host->detect);
         mmc_flush_scheduled_work();
 
@@ -2364,6 +2238,7 @@ int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
                         mmc_card_is_removable(host))
                 return err;
 
+        mmc_claim_host(host);
         if (card && mmc_card_mmc(card) &&
                         (card->ext_csd.cache_size > 0)) {
                 enable = !!enable;
@@ -2381,6 +2256,7 @@ int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
                                 card->ext_csd.cache_ctrl = enable;
                 }
         }
+        mmc_release_host(host);
 
         return err;
 }
@@ -2396,53 +2272,34 @@ int mmc_suspend_host(struct mmc_host *host)
 {
         int err = 0;
 
-        if (host->caps & MMC_CAP_DISABLE)
-                cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
-        if (mmc_try_claim_host(host)) {
-                err = mmc_cache_ctrl(host, 0);
-                mmc_do_release_host(host);
-        } else {
-                err = -EBUSY;
-        }
 
+        err = mmc_cache_ctrl(host, 0);
         if (err)
                 goto out;
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
 
-                /*
-                 * A long response time is not acceptable for device drivers
-                 * when doing suspend. Prevent mmc_claim_host in the suspend
-                 * sequence, to potentially wait "forever" by trying to
-                 * pre-claim the host.
-                 */
-                if (mmc_try_claim_host(host)) {
-                        if (host->bus_ops->suspend) {
-                                err = host->bus_ops->suspend(host);
-                        }
-                        mmc_do_release_host(host);
-
-                        if (err == -ENOSYS || !host->bus_ops->resume) {
-                                /*
-                                 * We simply "remove" the card in this case.
-                                 * It will be redetected on resume.  (Calling
-                                 * bus_ops->remove() with a claimed host can
-                                 * deadlock.)
-                                 */
-                                if (host->bus_ops->remove)
-                                        host->bus_ops->remove(host);
-                                mmc_claim_host(host);
-                                mmc_detach_bus(host);
-                                mmc_power_off(host);
-                                mmc_release_host(host);
-                                host->pm_flags = 0;
-                                err = 0;
-                        }
-                } else {
-                        err = -EBUSY;
+                if (host->bus_ops->suspend)
+                        err = host->bus_ops->suspend(host);
+
+                if (err == -ENOSYS || !host->bus_ops->resume) {
+                        /*
+                         * We simply "remove" the card in this case.
+                         * It will be redetected on resume.  (Calling
+                         * bus_ops->remove() with a claimed host can
+                         * deadlock.)
+                         */
+                        if (host->bus_ops->remove)
+                                host->bus_ops->remove(host);
+                        mmc_claim_host(host);
+                        mmc_detach_bus(host);
+                        mmc_power_off(host);
+                        mmc_release_host(host);
+                        host->pm_flags = 0;
+                        err = 0;
                 }
         }
         mmc_bus_put(host);
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 30055f2b0d44..91c84c7a1829 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -238,10 +238,10 @@ static inline void mmc_host_clk_init(struct mmc_host *host)
         /* Hold MCI clock for 8 cycles by default */
         host->clk_delay = 8;
         /*
-         * Default clock gating delay is 200ms.
+         * Default clock gating delay is 0ms to avoid wasting power.
          * This value can be tuned by writing into sysfs entry.
          */
-        host->clkgate_delay = 200;
+        host->clkgate_delay = 0;
         host->clk_gated = false;
         INIT_DELAYED_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
         spin_lock_init(&host->clk_lock);
@@ -330,7 +330,6 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
-        INIT_DELAYED_WORK_DEFERRABLE(&host->disable, mmc_host_deeper_disable);
 #ifdef CONFIG_PM
         host->pm_notify.notifier_call = mmc_pm_notify;
 #endif
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index 08a7852ade44..f2ab9e578126 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -14,7 +14,6 @@
 
 int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
-void mmc_host_deeper_disable(struct work_struct *work);
 
 #endif
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index a48066344fa8..54df5adc0413 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -519,6 +519,20 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                         ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
                         ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
                         ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
+
+                if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
+                        card->ext_csd.data_sector_size = 4096;
+                else
+                        card->ext_csd.data_sector_size = 512;
+
+                if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
+                    (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
+                        card->ext_csd.data_tag_unit_size =
+                        ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
+                        (card->ext_csd.data_sector_size);
+                } else {
+                        card->ext_csd.data_tag_unit_size = 0;
+                }
         }
 
 out:
@@ -681,6 +695,11 @@ static int mmc_select_powerclass(struct mmc_card *card,
                 else if (host->ios.clock <= 200000000)
                         index = EXT_CSD_PWR_CL_200_195;
                 break;
+        case MMC_VDD_27_28:
+        case MMC_VDD_28_29:
+        case MMC_VDD_29_30:
+        case MMC_VDD_30_31:
+        case MMC_VDD_31_32:
         case MMC_VDD_32_33:
         case MMC_VDD_33_34:
         case MMC_VDD_34_35:
@@ -816,6 +835,9 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (!mmc_host_is_spi(host))
                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
 
+        /* Initialization should be done at 3.3 V I/O voltage. */
+        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
+
         /*
          * Since we're changing the OCR value, we seem to
          * need to tell some cards to go back to the idle
@@ -935,7 +957,8 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
          * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
          * bit.  This bit will be lost every time after a reset or power off.
          */
-        if (card->ext_csd.enhanced_area_en) {
+        if (card->ext_csd.enhanced_area_en ||
+            (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                  EXT_CSD_ERASE_GROUP_DEF, 1,
                                  card->ext_csd.generic_cmd6_time);
@@ -1030,22 +1053,6 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         }
 
         /*
-         * Enable HPI feature (if supported)
-         */
-        if (card->ext_csd.hpi) {
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_HPI_MGMT, 1, 0);
-                if (err && err != -EBADMSG)
-                        goto free_card;
-                if (err) {
-                        pr_warning("%s: Enabling HPI failed\n",
-                                   mmc_hostname(card->host));
-                        err = 0;
-                } else
-                        card->ext_csd.hpi_en = 1;
-        }
-
-        /*
          * Compute bus speed.
          */
         max_dtr = (unsigned int)-1;
@@ -1094,9 +1101,12 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                  * 4. execute tuning for HS200
                  */
                 if ((host->caps2 & MMC_CAP2_HS200) &&
-                    card->host->ops->execute_tuning)
+                    card->host->ops->execute_tuning) {
+                        mmc_host_clk_hold(card->host);
                         err = card->host->ops->execute_tuning(card->host,
                                 MMC_SEND_TUNING_BLOCK_HS200);
+                        mmc_host_clk_release(card->host);
+                }
                 if (err) {
                         pr_warning("%s: tuning execution failed\n",
                                    mmc_hostname(card->host));
@@ -1106,11 +1116,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
                                 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
                 err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
-                if (err) {
-                        pr_err("%s: power class selection to bus width %d failed\n",
-                                mmc_hostname(card->host), 1 << bus_width);
-                        goto err;
-                }
+                if (err)
+                        pr_warning("%s: power class selection to bus width %d"
+                                   " failed\n", mmc_hostname(card->host),
+                                   1 << bus_width);
         }
 
         /*
@@ -1142,10 +1151,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][0],
                                                     ext_csd);
                         if (err)
-                                pr_err("%s: power class selection to "
-                                       "bus width %d failed\n",
-                                       mmc_hostname(card->host),
-                                       1 << bus_width);
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
@@ -1173,10 +1182,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][1],
                                                     ext_csd);
                         if (err)
-                                pr_err("%s: power class selection to "
-                                       "bus width %d ddr %d failed\n",
-                                       mmc_hostname(card->host),
-                                       1 << bus_width, ddr);
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d ddr %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width, ddr);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
@@ -1216,6 +1225,23 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         }
 
         /*
+         * Enable HPI feature (if supported)
+         */
+        if (card->ext_csd.hpi) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                EXT_CSD_HPI_MGMT, 1,
+                                card->ext_csd.generic_cmd6_time);
+                if (err && err != -EBADMSG)
+                        goto free_card;
+                if (err) {
+                        pr_warning("%s: Enabling HPI failed\n",
+                                   mmc_hostname(card->host));
+                        err = 0;
+                } else
+                        card->ext_csd.hpi_en = 1;
+        }
+
+        /*
          * If cache size is higher than 0, this indicates
          * the existence of cache and it can be turned on.
          */
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 4d41fa984c93..69370f494e05 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -553,18 +553,22 @@ int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
 {
         struct mmc_command cmd = {0};
         unsigned int opcode;
-        unsigned int flags;
         int err;
 
+        if (!card->ext_csd.hpi) {
+                pr_warning("%s: Card didn't support HPI command\n",
+                           mmc_hostname(card->host));
+                return -EINVAL;
+        }
+
         opcode = card->ext_csd.hpi_cmd;
         if (opcode == MMC_STOP_TRANSMISSION)
-                flags = MMC_RSP_R1 | MMC_CMD_AC;
+                cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
         else if (opcode == MMC_SEND_STATUS)
-                flags = MMC_RSP_R1 | MMC_CMD_AC;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
         cmd.opcode = opcode;
         cmd.arg = card->rca << 16 | 1;
-        cmd.flags = flags;
         cmd.cmd_timeout_ms = card->ext_csd.out_of_int_time;
 
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 5017f9354ce2..c272c6868ecf 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -911,6 +911,9 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        /* The initialization should be done at 3.3 V I/O voltage. */
+        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
+
         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
         if (err)
                 return err;
@@ -1156,11 +1159,6 @@ int mmc_attach_sd(struct mmc_host *host)
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
-        /* Make sure we are at 3.3V signalling voltage */
-        err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
-        if (err)
-                return err;
-
         /* Disable preset value enable if already set since last time */
         if (host->ops->enable_preset_value) {
                 mmc_host_clk_hold(host);
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 12cde6ee17f5..2c7c83f832d2 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -585,6 +585,9 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
          * Inform the card of the voltage
          */
         if (!powered_resume) {
+                /* The initialization should be done at 3.3 V I/O voltage. */
+                mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
+
                 err = mmc_send_io_op_cond(host, host->ocr, &ocr);
                 if (err)
                         goto err;
@@ -996,6 +999,11 @@ static int mmc_sdio_power_restore(struct mmc_host *host)
          * With these steps taken, mmc_select_voltage() is also required to
          * restore the correct voltage setting of the card.
          */
+
+        /* The initialization should be done at 3.3 V I/O voltage. */
+        if (!mmc_card_keep_power(host))
+                mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
+
         sdio_reset(host);
         mmc_go_idle(host);
         mmc_send_if_cond(host, host->ocr_avail);
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 40989e6bb53a..236842ec955a 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -192,9 +192,15 @@ static int sdio_bus_remove(struct device *dev)
         return ret;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
+
+static int pm_no_operation(struct device *dev)
+{
+        return 0;
+}
 
 static const struct dev_pm_ops sdio_bus_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(pm_no_operation, pm_no_operation)
         SET_RUNTIME_PM_OPS(
                 pm_generic_runtime_suspend,
                 pm_generic_runtime_resume,
@@ -204,11 +210,11 @@ static const struct dev_pm_ops sdio_bus_pm_ops = {
 
 #define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
 
-#else /* !CONFIG_PM_RUNTIME */
+#else /* !CONFIG_PM */
 
 #define SDIO_PM_OPS_PTR NULL
 
-#endif /* !CONFIG_PM_RUNTIME */
+#endif /* !CONFIG_PM */
 
 static struct bus_type sdio_bus_type = {
         .name           = "sdio",
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 00fcbed1afd2..2bc06e7344db 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -395,7 +395,7 @@ config MMC_SPI
 
 config MMC_S3C
         tristate "Samsung S3C SD/MMC Card Interface support"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C24XX
         help
           This selects a driver for the MCI interface found in
           Samsung's S3C2410, S3C2412, S3C2440, S3C2442 CPUs.
@@ -533,6 +533,31 @@ config MMC_DW_IDMAC
           Designware Mobile Storage IP block. This disables the external DMA
           interface.
 
+config MMC_DW_PLTFM
+        tristate "Synopsys Designware MCI Support as platform device"
+        depends on MMC_DW
+        default y
+        help
+          This selects the common helper functions support for Host Controller
+          Interface based platform driver. Please select this option if the IP
+          is present as a platform device. This is the common interface for the
+          Synopsys Designware IP.
+
+          If you have a controller with this interface, say Y or M here.
+
+          If unsure, say Y.
+
+config MMC_DW_PCI
+        tristate "Synopsys Designware MCI support on PCI bus"
+        depends on MMC_DW && PCI
+        help
+          This selects the PCI bus for the Synopsys Designware Mobile Storage IP.
+          Select this option if the IP is present on PCI platform.
+
+          If you have a controller with this interface, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_SH_MMCIF
         tristate "SuperH Internal MMCIF support"
         depends on MMC_BLOCK && (SUPERH || ARCH_SHMOBILE)
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 745f8fce2519..3e7e26d08073 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -39,6 +39,8 @@ obj-$(CONFIG_MMC_CB710)		+= cb710-mmc.o
 obj-$(CONFIG_MMC_VIA_SDMMC)     += via-sdmmc.o
 obj-$(CONFIG_SDH_BFIN)          += bfin_sdh.o
 obj-$(CONFIG_MMC_DW)            += dw_mmc.o
+obj-$(CONFIG_MMC_DW_PLTFM)      += dw_mmc-pltfm.o
+obj-$(CONFIG_MMC_DW_PCI)        += dw_mmc-pci.o
 obj-$(CONFIG_MMC_SH_MMCIF)      += sh_mmcif.o
 obj-$(CONFIG_MMC_JZ4740)        += jz4740_mmc.o
 obj-$(CONFIG_MMC_VUB300)        += vub300.o
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 947faa5d2ce4..efdb81d21c44 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -86,7 +86,6 @@ static inline int at91mci_is_mci1rev2xx(void)
 {
         return (   cpu_is_at91sam9260()
                 || cpu_is_at91sam9263()
-                || cpu_is_at91cap9()
                 || cpu_is_at91sam9rl()
                 || cpu_is_at91sam9g10()
                 || cpu_is_at91sam9g20()
diff --git a/drivers/mmc/host/atmel-mci-regs.h b/drivers/mmc/host/atmel-mci-regs.h
index 000b3ad0f5ca..787aba1682bb 100644
--- a/drivers/mmc/host/atmel-mci-regs.h
+++ b/drivers/mmc/host/atmel-mci-regs.h
@@ -31,6 +31,7 @@
 # define ATMCI_MR_PDCFBYTE              (  1 << 13)     /* Force Byte Transfer */
 # define ATMCI_MR_PDCPADV               (  1 << 14)     /* Padding Value */
 # define ATMCI_MR_PDCMODE               (  1 << 15)     /* PDC-oriented Mode */
+# define ATMCI_MR_CLKODD(x)             ((x) << 16)     /* LSB of Clock Divider */
 #define ATMCI_DTOR                      0x0008  /* Data Timeout */
 # define ATMCI_DTOCYC(x)                ((x) <<  0)     /* Data Timeout Cycles */
 # define ATMCI_DTOMUL(x)                ((x) <<  4)     /* Data Timeout Multiplier */
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 6985cdb0bb26..e94476beca18 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -24,6 +24,7 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
+#include <linux/types.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/sdio.h>
@@ -76,6 +77,7 @@ struct atmel_mci_caps {
         bool    has_cstor_reg;
         bool    has_highspeed;
         bool    has_rwproof;
+        bool    has_odd_clk_div;
 };
 
 struct atmel_mci_dma {
@@ -173,6 +175,7 @@ struct atmel_mci {
 
         struct atmel_mci_dma    dma;
         struct dma_chan         *data_chan;
+        struct dma_slave_config dma_conf;
 
         u32                     cmd_status;
         u32                     data_status;
@@ -480,7 +483,14 @@ err:
 static inline unsigned int atmci_ns_to_clocks(struct atmel_mci *host,
                                         unsigned int ns)
 {
-        return (ns * (host->bus_hz / 1000000) + 999) / 1000;
+        /*
+         * It is easier here to use us instead of ns for the timeout,
+         * it prevents from overflows during calculation.
+         */
+        unsigned int us = DIV_ROUND_UP(ns, 1000);
+
+        /* Maximum clock frequency is host->bus_hz/2 */
+        return us * (DIV_ROUND_UP(host->bus_hz, 2000000));
 }
 
 static void atmci_set_timeout(struct atmel_mci *host,
@@ -863,16 +873,17 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
 
         if (data->flags & MMC_DATA_READ) {
                 direction = DMA_FROM_DEVICE;
-                slave_dirn = DMA_DEV_TO_MEM;
+                host->dma_conf.direction = slave_dirn = DMA_DEV_TO_MEM;
         } else {
                 direction = DMA_TO_DEVICE;
-                slave_dirn = DMA_MEM_TO_DEV;
+                host->dma_conf.direction = slave_dirn = DMA_MEM_TO_DEV;
         }
 
         sglen = dma_map_sg(chan->device->dev, data->sg,
                         data->sg_len, direction);
 
-        desc = chan->device->device_prep_slave_sg(chan,
+        dmaengine_slave_config(chan, &host->dma_conf);
+        desc = dmaengine_prep_slave_sg(chan,
                         data->sg, sglen, slave_dirn,
                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc)
@@ -1124,16 +1135,27 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 }
 
                 /* Calculate clock divider */
-                clkdiv = DIV_ROUND_UP(host->bus_hz, 2 * clock_min) - 1;
-                if (clkdiv > 255) {
-                        dev_warn(&mmc->class_dev,
-                                "clock %u too slow; using %lu\n",
-                                clock_min, host->bus_hz / (2 * 256));
-                        clkdiv = 255;
+                if (host->caps.has_odd_clk_div) {
+                        clkdiv = DIV_ROUND_UP(host->bus_hz, clock_min) - 2;
+                        if (clkdiv > 511) {
+                                dev_warn(&mmc->class_dev,
+                                         "clock %u too slow; using %lu\n",
+                                         clock_min, host->bus_hz / (511 + 2));
+                                clkdiv = 511;
+                        }
+                        host->mode_reg = ATMCI_MR_CLKDIV(clkdiv >> 1)
+                                         | ATMCI_MR_CLKODD(clkdiv & 1);
+                } else {
+                        clkdiv = DIV_ROUND_UP(host->bus_hz, 2 * clock_min) - 1;
+                        if (clkdiv > 255) {
+                                dev_warn(&mmc->class_dev,
+                                         "clock %u too slow; using %lu\n",
+                                         clock_min, host->bus_hz / (2 * 256));
+                                clkdiv = 255;
+                        }
+                        host->mode_reg = ATMCI_MR_CLKDIV(clkdiv);
                 }
 
-                host->mode_reg = ATMCI_MR_CLKDIV(clkdiv);
-
                 /*
                  * WRPROOF and RDPROOF prevent overruns/underruns by
                  * stopping the clock when the FIFO is full/empty.
@@ -1948,34 +1970,41 @@ static bool atmci_filter(struct dma_chan *chan, void *slave)
         }
 }
 
-static void atmci_configure_dma(struct atmel_mci *host)
+static bool atmci_configure_dma(struct atmel_mci *host)
 {
         struct mci_platform_data        *pdata;
 
         if (host == NULL)
-                return;
+                return false;
 
         pdata = host->pdev->dev.platform_data;
 
         if (pdata && find_slave_dev(pdata->dma_slave)) {
                 dma_cap_mask_t mask;
 
-                setup_dma_addr(pdata->dma_slave,
-                               host->mapbase + ATMCI_TDR,
-                               host->mapbase + ATMCI_RDR);
-
                 /* Try to grab a DMA channel */
                 dma_cap_zero(mask);
                 dma_cap_set(DMA_SLAVE, mask);
                 host->dma.chan =
                         dma_request_channel(mask, atmci_filter, pdata->dma_slave);
         }
-        if (!host->dma.chan)
-                dev_notice(&host->pdev->dev, "DMA not available, using PIO\n");
-        else
+        if (!host->dma.chan) {
+                dev_warn(&host->pdev->dev, "no DMA channel available\n");
+                return false;
+        } else {
                 dev_info(&host->pdev->dev,
-                                        "Using %s for DMA transfers\n",
+                                        "using %s for DMA transfers\n",
                                         dma_chan_name(host->dma.chan));
+
+                host->dma_conf.src_addr = host->mapbase + ATMCI_RDR;
+                host->dma_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+                host->dma_conf.src_maxburst = 1;
+                host->dma_conf.dst_addr = host->mapbase + ATMCI_TDR;
+                host->dma_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+                host->dma_conf.dst_maxburst = 1;
+                host->dma_conf.device_fc = false;
+                return true;
+        }
 }
 
 static inline unsigned int atmci_get_version(struct atmel_mci *host)
@@ -1997,35 +2026,35 @@ static void __init atmci_get_cap(struct atmel_mci *host)
                         "version: 0x%x\n", version);
 
         host->caps.has_dma = 0;
-        host->caps.has_pdc = 0;
+        host->caps.has_pdc = 1;
         host->caps.has_cfg_reg = 0;
         host->caps.has_cstor_reg = 0;
         host->caps.has_highspeed = 0;
         host->caps.has_rwproof = 0;
+        host->caps.has_odd_clk_div = 0;
 
         /* keep only major version number */
         switch (version & 0xf00) {
-        case 0x100:
-        case 0x200:
-                host->caps.has_pdc = 1;
-                host->caps.has_rwproof = 1;
-                break;
-        case 0x300:
-        case 0x400:
         case 0x500:
+                host->caps.has_odd_clk_div = 1;
+        case 0x400:
+        case 0x300:
 #ifdef CONFIG_AT_HDMAC
                 host->caps.has_dma = 1;
 #else
-                host->caps.has_dma = 0;
                 dev_info(&host->pdev->dev,
                         "has dma capability but dma engine is not selected, then use pio\n");
 #endif
+                host->caps.has_pdc = 0;
                 host->caps.has_cfg_reg = 1;
                 host->caps.has_cstor_reg = 1;
                 host->caps.has_highspeed = 1;
+        case 0x200:
                 host->caps.has_rwproof = 1;
+        case 0x100:
                 break;
         default:
+                host->caps.has_pdc = 0;
                 dev_warn(&host->pdev->dev,
                                 "Unmanaged mci version, set minimum capabilities\n");
                 break;
@@ -2085,8 +2114,7 @@ static int __init atmci_probe(struct platform_device *pdev)
 
         /* Get MCI capabilities and set operations according to it */
         atmci_get_cap(host);
-        if (host->caps.has_dma) {
-                dev_info(&pdev->dev, "using DMA\n");
+        if (host->caps.has_dma && atmci_configure_dma(host)) {
                 host->prepare_data = &atmci_prepare_data_dma;
                 host->submit_data = &atmci_submit_data_dma;
                 host->stop_transfer = &atmci_stop_transfer_dma;
@@ -2096,15 +2124,12 @@ static int __init atmci_probe(struct platform_device *pdev)
                 host->submit_data = &atmci_submit_data_pdc;
                 host->stop_transfer = &atmci_stop_transfer_pdc;
         } else {
-                dev_info(&pdev->dev, "no DMA, no PDC\n");
+                dev_info(&pdev->dev, "using PIO\n");
                 host->prepare_data = &atmci_prepare_data;
                 host->submit_data = &atmci_submit_data;
                 host->stop_transfer = &atmci_stop_transfer;
         }
 
-        if (host->caps.has_dma)
-                atmci_configure_dma(host);
-
         platform_set_drvdata(pdev, host);
 
         /* We need at least one slot to succeed */
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index 64a8325a4a8a..c1f3673ae1ef 100644
--- a/drivers/mmc/host/davinci_mmc.c
+++ b/drivers/mmc/host/davinci_mmc.c
@@ -160,6 +160,16 @@ module_param(rw_threshold, uint, S_IRUGO);
 MODULE_PARM_DESC(rw_threshold,
                 "Read/Write threshold. Default = 32");
 
+static unsigned poll_threshold = 128;
+module_param(poll_threshold, uint, S_IRUGO);
+MODULE_PARM_DESC(poll_threshold,
+                 "Polling transaction size threshold. Default = 128");
+
+static unsigned poll_loopcount = 32;
+module_param(poll_loopcount, uint, S_IRUGO);
+MODULE_PARM_DESC(poll_loopcount,
+                 "Maximum polling loop count. Default = 32");
+
 static unsigned __initdata use_dma = 1;
 module_param(use_dma, uint, 0);
 MODULE_PARM_DESC(use_dma, "Whether to use DMA or not. Default = 1");
@@ -193,6 +203,7 @@ struct mmc_davinci_host {
         bool use_dma;
         bool do_dma;
         bool sdio_int;
+        bool active_request;
 
         /* Scatterlist DMA uses one or more parameter RAM entries:
          * the main one (associated with rxdma or txdma) plus zero or
@@ -219,6 +230,7 @@ struct mmc_davinci_host {
 #endif
 };
 
+static irqreturn_t mmc_davinci_irq(int irq, void *dev_id);
 
 /* PIO only */
 static void mmc_davinci_sg_to_buf(struct mmc_davinci_host *host)
@@ -376,7 +388,20 @@ static void mmc_davinci_start_command(struct mmc_davinci_host *host,
 
         writel(cmd->arg, host->base + DAVINCI_MMCARGHL);
         writel(cmd_reg,  host->base + DAVINCI_MMCCMD);
-        writel(im_val, host->base + DAVINCI_MMCIM);
+
+        host->active_request = true;
+
+        if (!host->do_dma && host->bytes_left <= poll_threshold) {
+                u32 count = poll_loopcount;
+
+                while (host->active_request && count--) {
+                        mmc_davinci_irq(0, host);
+                        cpu_relax();
+                }
+        }
+
+        if (host->active_request)
+                writel(im_val, host->base + DAVINCI_MMCIM);
 }
 
 /*----------------------------------------------------------------------*/
@@ -915,6 +940,7 @@ mmc_davinci_xfer_done(struct mmc_davinci_host *host, struct mmc_data *data)
         if (!data->stop || (host->cmd && host->cmd->error)) {
                 mmc_request_done(host->mmc, data->mrq);
                 writel(0, host->base + DAVINCI_MMCIM);
+                host->active_request = false;
         } else
                 mmc_davinci_start_command(host, data->stop);
 }
@@ -942,6 +968,7 @@ static void mmc_davinci_cmd_done(struct mmc_davinci_host *host,
                         cmd->mrq->cmd->retries = 0;
                 mmc_request_done(host->mmc, cmd->mrq);
                 writel(0, host->base + DAVINCI_MMCIM);
+                host->active_request = false;
         }
 }
 
@@ -1009,12 +1036,33 @@ static irqreturn_t mmc_davinci_irq(int irq, void *dev_id)
          * by read. So, it is not unbouned loop even in the case of
          * non-dma.
          */
-        while (host->bytes_left && (status & (MMCST0_DXRDY | MMCST0_DRRDY))) {
-                davinci_fifo_data_trans(host, rw_threshold);
-                status = readl(host->base + DAVINCI_MMCST0);
-                if (!status)
-                        break;
-                qstatus |= status;
+        if (host->bytes_left && (status & (MMCST0_DXRDY | MMCST0_DRRDY))) {
+                unsigned long im_val;
+
+                /*
+                 * If interrupts fire during the following loop, they will be
+                 * handled by the handler, but the PIC will still buffer these.
+                 * As a result, the handler will be called again to serve these
+                 * needlessly. In order to avoid these spurious interrupts,
+                 * keep interrupts masked during the loop.
+                 */
+                im_val = readl(host->base + DAVINCI_MMCIM);
+                writel(0, host->base + DAVINCI_MMCIM);
+
+                do {
+                        davinci_fifo_data_trans(host, rw_threshold);
+                        status = readl(host->base + DAVINCI_MMCST0);
+                        qstatus |= status;
+                } while (host->bytes_left &&
+                         (status & (MMCST0_DXRDY | MMCST0_DRRDY)));
+
+                /*
+                 * If an interrupt is pending, it is assumed it will fire when
+                 * it is unmasked. This assumption is also taken when the MMCIM
+                 * is first set. Otherwise, writing to MMCIM after reading the
+                 * status is race-prone.
+                 */
+                writel(im_val, host->base + DAVINCI_MMCIM);
         }
 
         if (qstatus & MMCST0_DATDNE) {
@@ -1418,17 +1466,14 @@ static int davinci_mmcsd_suspend(struct device *dev)
         struct mmc_davinci_host *host = platform_get_drvdata(pdev);
         int ret;
 
-        mmc_host_enable(host->mmc);
         ret = mmc_suspend_host(host->mmc);
         if (!ret) {
                 writel(0, host->base + DAVINCI_MMCIM);
                 mmc_davinci_reset_ctrl(host, 1);
-                mmc_host_disable(host->mmc);
                 clk_disable(host->clk);
                 host->suspended = 1;
         } else {
                 host->suspended = 0;
-                mmc_host_disable(host->mmc);
         }
 
         return ret;
@@ -1444,7 +1489,6 @@ static int davinci_mmcsd_resume(struct device *dev)
                 return 0;
 
         clk_enable(host->clk);
-        mmc_host_enable(host->mmc);
 
         mmc_davinci_reset_ctrl(host, 0);
         ret = mmc_resume_host(host->mmc);
diff --git a/drivers/mmc/host/dw_mmc-pci.c b/drivers/mmc/host/dw_mmc-pci.c
new file mode 100644
index 000000000000..dc0d25a013e0
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc-pci.c
@@ -0,0 +1,158 @@
+/*
+ * Synopsys DesignWare Multimedia Card PCI Interface driver
+ *
+ * Copyright (C) 2012 Vayavya Labs Pvt. Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/dw_mmc.h>
+#include "dw_mmc.h"
+
+#define PCI_BAR_NO 2
+#define COMPLETE_BAR 0
+#define SYNOPSYS_DW_MCI_VENDOR_ID 0x700
+#define SYNOPSYS_DW_MCI_DEVICE_ID 0x1107
+/* Defining the Capabilities */
+#define DW_MCI_CAPABILITIES (MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED |\
+                                MMC_CAP_SD_HIGHSPEED | MMC_CAP_8_BIT_DATA |\
+                                MMC_CAP_SDIO_IRQ)
+
+static struct dw_mci_board pci_board_data = {
+        .num_slots                      = 1,
+        .caps                           = DW_MCI_CAPABILITIES,
+        .bus_hz                         = 33 * 1000 * 1000,
+        .detect_delay_ms                = 200,
+        .fifo_depth                     = 32,
+};
+
+static int __devinit dw_mci_pci_probe(struct pci_dev *pdev,
+                                  const struct pci_device_id *entries)
+{
+        struct dw_mci *host;
+        int ret;
+
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
+        if (pci_request_regions(pdev, "dw_mmc_pci")) {
+                ret = -ENODEV;
+                goto err_disable_dev;
+        }
+
+        host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
+        if (!host) {
+                ret = -ENOMEM;
+                goto err_release;
+        }
+
+        host->irq = pdev->irq;
+        host->irq_flags = IRQF_SHARED;
+        host->dev = pdev->dev;
+        host->pdata = &pci_board_data;
+
+        host->regs = pci_iomap(pdev, PCI_BAR_NO, COMPLETE_BAR);
+        if (!host->regs) {
+                ret = -EIO;
+                goto err_unmap;
+        }
+
+        pci_set_drvdata(pdev, host);
+        ret = dw_mci_probe(host);
+        if (ret)
+                goto err_probe_failed;
+        return ret;
+
+err_probe_failed:
+        pci_iounmap(pdev, host->regs);
+err_unmap:
+        kfree(host);
+err_release:
+        pci_release_regions(pdev);
+err_disable_dev:
+        pci_disable_device(pdev);
+        return ret;
+}
+
+static void __devexit dw_mci_pci_remove(struct pci_dev *pdev)
+{
+        struct dw_mci *host = pci_get_drvdata(pdev);
+
+        dw_mci_remove(host);
+        pci_set_drvdata(pdev, NULL);
+        pci_release_regions(pdev);
+        pci_iounmap(pdev, host->regs);
+        kfree(host);
+        pci_disable_device(pdev);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int dw_mci_pci_suspend(struct device *dev)
+{
+        int ret;
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct dw_mci *host = pci_get_drvdata(pdev);
+
+        ret = dw_mci_suspend(host);
+        return ret;
+}
+
+static int dw_mci_pci_resume(struct device *dev)
+{
+        int ret;
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct dw_mci *host = pci_get_drvdata(pdev);
+
+        ret = dw_mci_resume(host);
+        return ret;
+}
+#else
+#define dw_mci_pci_suspend      NULL
+#define dw_mci_pci_resume       NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(dw_mci_pci_pmops, dw_mci_pci_suspend, dw_mci_pci_resume);
+
+static DEFINE_PCI_DEVICE_TABLE(dw_mci_pci_id) = {
+        { PCI_DEVICE(SYNOPSYS_DW_MCI_VENDOR_ID, SYNOPSYS_DW_MCI_DEVICE_ID) },
+        {}
+};
+MODULE_DEVICE_TABLE(pci, dw_mci_pci_id);
+
+static struct pci_driver dw_mci_pci_driver = {
+        .name           = "dw_mmc_pci",
+        .id_table       = dw_mci_pci_id,
+        .probe          = dw_mci_pci_probe,
+        .remove         = dw_mci_pci_remove,
+        .driver         =       {
+                .pm =   &dw_mci_pci_pmops
+        },
+};
+
+static int __init dw_mci_init(void)
+{
+        return pci_register_driver(&dw_mci_pci_driver);
+}
+
+static void __exit dw_mci_exit(void)
+{
+        pci_unregister_driver(&dw_mci_pci_driver);
+}
+
+module_init(dw_mci_init);
+module_exit(dw_mci_exit);
+
+MODULE_DESCRIPTION("DW Multimedia Card PCI Interface driver");
+MODULE_AUTHOR("Shashidhar Hiremath <shashidharh@vayavyalabs.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/dw_mmc-pltfm.c b/drivers/mmc/host/dw_mmc-pltfm.c
new file mode 100644
index 000000000000..92ec3eb3aae7
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc-pltfm.c
@@ -0,0 +1,134 @@
+/*
+ * Synopsys DesignWare Multimedia Card Interface driver
+ *
+ * Copyright (C) 2009 NXP Semiconductors
+ * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/dw_mmc.h>
+#include "dw_mmc.h"
+
+static int dw_mci_pltfm_probe(struct platform_device *pdev)
+{
+        struct dw_mci *host;
+        struct resource *regs;
+        int ret;
+
+        host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
+        if (!host)
+                return -ENOMEM;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs) {
+                ret = -ENXIO;
+                goto err_free;
+        }
+
+        host->irq = platform_get_irq(pdev, 0);
+        if (host->irq < 0) {
+                ret = host->irq;
+                goto err_free;
+        }
+
+        host->dev = pdev->dev;
+        host->irq_flags = 0;
+        host->pdata = pdev->dev.platform_data;
+        ret = -ENOMEM;
+        host->regs = ioremap(regs->start, resource_size(regs));
+        if (!host->regs)
+                goto err_free;
+        platform_set_drvdata(pdev, host);
+        ret = dw_mci_probe(host);
+        if (ret)
+                goto err_out;
+        return ret;
+err_out:
+        iounmap(host->regs);
+err_free:
+        kfree(host);
+        return ret;
+}
+
+static int __exit dw_mci_pltfm_remove(struct platform_device *pdev)
+{
+        struct dw_mci *host = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        dw_mci_remove(host);
+        iounmap(host->regs);
+        kfree(host);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+/*
+ * TODO: we should probably disable the clock to the card in the suspend path.
+ */
+static int dw_mci_pltfm_suspend(struct device *dev)
+{
+        int ret;
+        struct dw_mci *host = dev_get_drvdata(dev);
+
+        ret = dw_mci_suspend(host);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int dw_mci_pltfm_resume(struct device *dev)
+{
+        int ret;
+        struct dw_mci *host = dev_get_drvdata(dev);
+
+        ret = dw_mci_resume(host);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+#else
+#define dw_mci_pltfm_suspend    NULL
+#define dw_mci_pltfm_resume     NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(dw_mci_pltfm_pmops, dw_mci_pltfm_suspend, dw_mci_pltfm_resume);
+
+static struct platform_driver dw_mci_pltfm_driver = {
+        .remove         = __exit_p(dw_mci_pltfm_remove),
+        .driver         = {
+                .name           = "dw_mmc",
+                .pm             = &dw_mci_pltfm_pmops,
+        },
+};
+
+static int __init dw_mci_init(void)
+{
+        return platform_driver_probe(&dw_mci_pltfm_driver, dw_mci_pltfm_probe);
+}
+
+static void __exit dw_mci_exit(void)
+{
+        platform_driver_unregister(&dw_mci_pltfm_driver);
+}
+
+module_init(dw_mci_init);
+module_exit(dw_mci_exit);
+
+MODULE_DESCRIPTION("DW Multimedia Card Interface driver");
+MODULE_AUTHOR("NXP Semiconductor VietNam");
+MODULE_AUTHOR("Imagination Technologies Ltd");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 8bec1c36b159..ab3fc4617107 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -268,7 +268,7 @@ static void dw_mci_start_command(struct dw_mci *host,
                                  struct mmc_command *cmd, u32 cmd_flags)
 {
         host->cmd = cmd;
-        dev_vdbg(&host->pdev->dev,
+        dev_vdbg(&host->dev,
                  "start command: ARGR=0x%08x CMDR=0x%08x\n",
                  cmd->arg, cmd_flags);
 
@@ -295,15 +295,25 @@ static void dw_mci_stop_dma(struct dw_mci *host)
         }
 }
 
+static int dw_mci_get_dma_dir(struct mmc_data *data)
+{
+        if (data->flags & MMC_DATA_WRITE)
+                return DMA_TO_DEVICE;
+        else
+                return DMA_FROM_DEVICE;
+}
+
 #ifdef CONFIG_MMC_DW_IDMAC
 static void dw_mci_dma_cleanup(struct dw_mci *host)
 {
         struct mmc_data *data = host->data;
 
         if (data)
-                dma_unmap_sg(&host->pdev->dev, data->sg, data->sg_len,
-                             ((data->flags & MMC_DATA_WRITE)
-                              ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
+                if (!data->host_cookie)
+                        dma_unmap_sg(&host->dev,
+                                     data->sg,
+                                     data->sg_len,
+                                     dw_mci_get_dma_dir(data));
 }
 
 static void dw_mci_idmac_stop_dma(struct dw_mci *host)
@@ -326,7 +336,7 @@ static void dw_mci_idmac_complete_dma(struct dw_mci *host)
 {
         struct mmc_data *data = host->data;
 
-        dev_vdbg(&host->pdev->dev, "DMA complete\n");
+        dev_vdbg(&host->dev, "DMA complete\n");
 
         host->dma_ops->cleanup(host);
 
@@ -428,17 +438,15 @@ static struct dw_mci_dma_ops dw_mci_idmac_ops = {
 };
 #endif /* CONFIG_MMC_DW_IDMAC */
 
-static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
+static int dw_mci_pre_dma_transfer(struct dw_mci *host,
+                                   struct mmc_data *data,
+                                   bool next)
 {
         struct scatterlist *sg;
-        unsigned int i, direction, sg_len;
-        u32 temp;
+        unsigned int i, sg_len;
 
-        host->using_dma = 0;
-
-        /* If we don't have a channel, we can't do DMA */
-        if (!host->use_dma)
-                return -ENODEV;
+        if (!next && data->host_cookie)
+                return data->host_cookie;
 
         /*
          * We don't do DMA on "complex" transfers, i.e. with
@@ -447,6 +455,7 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
          */
         if (data->blocks * data->blksz < DW_MCI_DMA_THRESHOLD)
                 return -EINVAL;
+
         if (data->blksz & 3)
                 return -EINVAL;
 
@@ -455,17 +464,76 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
                         return -EINVAL;
         }
 
-        host->using_dma = 1;
+        sg_len = dma_map_sg(&host->dev,
+                            data->sg,
+                            data->sg_len,
+                            dw_mci_get_dma_dir(data));
+        if (sg_len == 0)
+                return -EINVAL;
 
-        if (data->flags & MMC_DATA_READ)
-                direction = DMA_FROM_DEVICE;
-        else
-                direction = DMA_TO_DEVICE;
+        if (next)
+                data->host_cookie = sg_len;
+
+        return sg_len;
+}
+
+static void dw_mci_pre_req(struct mmc_host *mmc,
+                           struct mmc_request *mrq,
+                           bool is_first_req)
+{
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        struct mmc_data *data = mrq->data;
 
-        sg_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len,
-                            direction);
+        if (!slot->host->use_dma || !data)
+                return;
+
+        if (data->host_cookie) {
+                data->host_cookie = 0;
+                return;
+        }
+
+        if (dw_mci_pre_dma_transfer(slot->host, mrq->data, 1) < 0)
+                data->host_cookie = 0;
+}
+
+static void dw_mci_post_req(struct mmc_host *mmc,
+                            struct mmc_request *mrq,
+                            int err)
+{
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        struct mmc_data *data = mrq->data;
+
+        if (!slot->host->use_dma || !data)
+                return;
 
-        dev_vdbg(&host->pdev->dev,
+        if (data->host_cookie)
+                dma_unmap_sg(&slot->host->dev,
+                             data->sg,
+                             data->sg_len,
+                             dw_mci_get_dma_dir(data));
+        data->host_cookie = 0;
+}
+
+static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
+{
+        int sg_len;
+        u32 temp;
+
+        host->using_dma = 0;
+
+        /* If we don't have a channel, we can't do DMA */
+        if (!host->use_dma)
+                return -ENODEV;
+
+        sg_len = dw_mci_pre_dma_transfer(host, data, 0);
+        if (sg_len < 0) {
+                host->dma_ops->stop(host);
+                return sg_len;
+        }
+
+        host->using_dma = 1;
+
+        dev_vdbg(&host->dev,
                  "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
                  (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
                  sg_len);
@@ -579,8 +647,8 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
                              SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
 
                 /* enable clock */
-                mci_writel(host, CLKENA, SDMMC_CLKEN_ENABLE |
-                           SDMMC_CLKEN_LOW_PWR);
+                mci_writel(host, CLKENA, ((SDMMC_CLKEN_ENABLE |
+                           SDMMC_CLKEN_LOW_PWR) << slot->id));
 
                 /* inform CIU */
                 mci_send_cmd(slot,
@@ -800,6 +868,8 @@ static void dw_mci_enable_sdio_irq(struct mmc_host *mmc, int enb)
 
 static const struct mmc_host_ops dw_mci_ops = {
         .request                = dw_mci_request,
+        .pre_req                = dw_mci_pre_req,
+        .post_req               = dw_mci_post_req,
         .set_ios                = dw_mci_set_ios,
         .get_ro                 = dw_mci_get_ro,
         .get_cd                 = dw_mci_get_cd,
@@ -821,12 +891,12 @@ static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
                 slot = list_entry(host->queue.next,
                                   struct dw_mci_slot, queue_node);
                 list_del(&slot->queue_node);
-                dev_vdbg(&host->pdev->dev, "list not empty: %s is next\n",
+                dev_vdbg(&host->dev, "list not empty: %s is next\n",
                          mmc_hostname(slot->mmc));
                 host->state = STATE_SENDING_CMD;
                 dw_mci_start_request(host, slot);
         } else {
-                dev_vdbg(&host->pdev->dev, "list empty\n");
+                dev_vdbg(&host->dev, "list empty\n");
                 host->state = STATE_IDLE;
         }
 
@@ -965,7 +1035,7 @@ static void dw_mci_tasklet_func(unsigned long priv)
                                         data->bytes_xfered = 0;
                                         data->error = -ETIMEDOUT;
                                 } else {
-                                        dev_err(&host->pdev->dev,
+                                        dev_err(&host->dev,
                                                 "data FIFO error "
                                                 "(status=%08x)\n",
                                                 status);
@@ -1682,7 +1752,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         struct mmc_host *mmc;
         struct dw_mci_slot *slot;
 
-        mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->pdev->dev);
+        mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->dev);
         if (!mmc)
                 return -ENOMEM;
 
@@ -1720,13 +1790,11 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
-#ifdef CONFIG_MMC_DW_IDMAC
-        mmc->max_segs = host->ring_size;
-        mmc->max_blk_size = 65536;
-        mmc->max_blk_count = host->ring_size;
-        mmc->max_seg_size = 0x1000;
-        mmc->max_req_size = mmc->max_seg_size * mmc->max_blk_count;
-#else
+        if (mmc->caps2 & MMC_CAP2_POWEROFF_NOTIFY)
+                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
+        else
+                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_NONE;
+
         if (host->pdata->blk_settings) {
                 mmc->max_segs = host->pdata->blk_settings->max_segs;
                 mmc->max_blk_size = host->pdata->blk_settings->max_blk_size;
@@ -1735,13 +1803,20 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
                 mmc->max_seg_size = host->pdata->blk_settings->max_seg_size;
         } else {
                 /* Useful defaults if platform data is unset. */
+#ifdef CONFIG_MMC_DW_IDMAC
+                mmc->max_segs = host->ring_size;
+                mmc->max_blk_size = 65536;
+                mmc->max_blk_count = host->ring_size;
+                mmc->max_seg_size = 0x1000;
+                mmc->max_req_size = mmc->max_seg_size * mmc->max_blk_count;
+#else
                 mmc->max_segs = 64;
                 mmc->max_blk_size = 65536; /* BLKSIZ is 16 bits */
                 mmc->max_blk_count = 512;
                 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
                 mmc->max_seg_size = mmc->max_req_size;
-        }
 #endif /* CONFIG_MMC_DW_IDMAC */
+        }
 
         host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
         if (IS_ERR(host->vmmc)) {
@@ -1789,10 +1864,10 @@ static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
 static void dw_mci_init_dma(struct dw_mci *host)
 {
         /* Alloc memory for sg translation */
-        host->sg_cpu = dma_alloc_coherent(&host->pdev->dev, PAGE_SIZE,
+        host->sg_cpu = dma_alloc_coherent(&host->dev, PAGE_SIZE,
                                           &host->sg_dma, GFP_KERNEL);
         if (!host->sg_cpu) {
-                dev_err(&host->pdev->dev, "%s: could not alloc DMA memory\n",
+                dev_err(&host->dev, "%s: could not alloc DMA memory\n",
                         __func__);
                 goto no_dma;
         }
@@ -1800,20 +1875,21 @@ static void dw_mci_init_dma(struct dw_mci *host)
         /* Determine which DMA interface to use */
 #ifdef CONFIG_MMC_DW_IDMAC
         host->dma_ops = &dw_mci_idmac_ops;
-        dev_info(&host->pdev->dev, "Using internal DMA controller.\n");
+        dev_info(&host->dev, "Using internal DMA controller.\n");
 #endif
 
         if (!host->dma_ops)
                 goto no_dma;
 
-        if (host->dma_ops->init) {
+        if (host->dma_ops->init && host->dma_ops->start &&
+            host->dma_ops->stop && host->dma_ops->cleanup) {
                 if (host->dma_ops->init(host)) {
-                        dev_err(&host->pdev->dev, "%s: Unable to initialize "
+                        dev_err(&host->dev, "%s: Unable to initialize "
                                 "DMA Controller.\n", __func__);
                         goto no_dma;
                 }
         } else {
-                dev_err(&host->pdev->dev, "DMA initialization not found.\n");
+                dev_err(&host->dev, "DMA initialization not found.\n");
                 goto no_dma;
         }
 
@@ -1821,7 +1897,7 @@ static void dw_mci_init_dma(struct dw_mci *host)
         return;
 
 no_dma:
-        dev_info(&host->pdev->dev, "Using PIO mode.\n");
+        dev_info(&host->dev, "Using PIO mode.\n");
         host->use_dma = 0;
         return;
 }
@@ -1847,61 +1923,37 @@ static bool mci_wait_reset(struct device *dev, struct dw_mci *host)
         return false;
 }
 
-static int dw_mci_probe(struct platform_device *pdev)
+int dw_mci_probe(struct dw_mci *host)
 {
-        struct dw_mci *host;
-        struct resource *regs;
-        struct dw_mci_board *pdata;
-        int irq, ret, i, width;
+        int width, i, ret = 0;
         u32 fifo_size;
 
-        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!regs)
-                return -ENXIO;
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0)
-                return irq;
-
-        host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
-        if (!host)
-                return -ENOMEM;
-
-        host->pdev = pdev;
-        host->pdata = pdata = pdev->dev.platform_data;
-        if (!pdata || !pdata->init) {
-                dev_err(&pdev->dev,
+        if (!host->pdata || !host->pdata->init) {
+                dev_err(&host->dev,
                         "Platform data must supply init function\n");
-                ret = -ENODEV;
-                goto err_freehost;
+                return -ENODEV;
         }
 
-        if (!pdata->select_slot && pdata->num_slots > 1) {
-                dev_err(&pdev->dev,
+        if (!host->pdata->select_slot && host->pdata->num_slots > 1) {
+                dev_err(&host->dev,
                         "Platform data must supply select_slot function\n");
-                ret = -ENODEV;
-                goto err_freehost;
+                return -ENODEV;
         }
 
-        if (!pdata->bus_hz) {
-                dev_err(&pdev->dev,
+        if (!host->pdata->bus_hz) {
+                dev_err(&host->dev,
                         "Platform data must supply bus speed\n");
-                ret = -ENODEV;
-                goto err_freehost;
+                return -ENODEV;
         }
 
-        host->bus_hz = pdata->bus_hz;
-        host->quirks = pdata->quirks;
+        host->bus_hz = host->pdata->bus_hz;
+        host->quirks = host->pdata->quirks;
 
         spin_lock_init(&host->lock);
         INIT_LIST_HEAD(&host->queue);
 
-        ret = -ENOMEM;
-        host->regs = ioremap(regs->start, resource_size(regs));
-        if (!host->regs)
-                goto err_freehost;
 
-        host->dma_ops = pdata->dma_ops;
+        host->dma_ops = host->pdata->dma_ops;
         dw_mci_init_dma(host);
 
         /*
@@ -1931,7 +1983,7 @@ static int dw_mci_probe(struct platform_device *pdev)
         }
 
         /* Reset all blocks */
-        if (!mci_wait_reset(&pdev->dev, host)) {
+        if (!mci_wait_reset(&host->dev, host)) {
                 ret = -ENODEV;
                 goto err_dmaunmap;
         }
@@ -1974,13 +2026,10 @@ static int dw_mci_probe(struct platform_device *pdev)
         if (!dw_mci_card_workqueue)
                 goto err_dmaunmap;
         INIT_WORK(&host->card_work, dw_mci_work_routine_card);
-
-        ret = request_irq(irq, dw_mci_interrupt, 0, "dw-mci", host);
+        ret = request_irq(host->irq, dw_mci_interrupt, host->irq_flags, "dw-mci", host);
         if (ret)
                 goto err_workqueue;
 
-        platform_set_drvdata(pdev, host);
-
         if (host->pdata->num_slots)
                 host->num_slots = host->pdata->num_slots;
         else
@@ -2000,7 +2049,7 @@ static int dw_mci_probe(struct platform_device *pdev)
          * Need to check the version-id and set data-offset for DATA register.
          */
         host->verid = SDMMC_GET_VERID(mci_readl(host, VERID));
-        dev_info(&pdev->dev, "Version ID is %04x\n", host->verid);
+        dev_info(&host->dev, "Version ID is %04x\n", host->verid);
 
         if (host->verid < DW_MMC_240A)
                 host->data_offset = DATA_OFFSET;
@@ -2017,12 +2066,12 @@ static int dw_mci_probe(struct platform_device *pdev)
                    DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
         mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
 
-        dev_info(&pdev->dev, "DW MMC controller at irq %d, "
+        dev_info(&host->dev, "DW MMC controller at irq %d, "
                  "%d bit host data width, "
                  "%u deep fifo\n",
-                 irq, width, fifo_size);
+                 host->irq, width, fifo_size);
         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
-                dev_info(&pdev->dev, "Internal DMAC interrupt fix enabled.\n");
+                dev_info(&host->dev, "Internal DMAC interrupt fix enabled.\n");
 
         return 0;
 
@@ -2033,7 +2082,7 @@ err_init_slot:
                         dw_mci_cleanup_slot(host->slot[i], i);
                 i--;
         }
-        free_irq(irq, host);
+        free_irq(host->irq, host);
 
 err_workqueue:
         destroy_workqueue(dw_mci_card_workqueue);
@@ -2041,33 +2090,26 @@ err_workqueue:
 err_dmaunmap:
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
-        dma_free_coherent(&host->pdev->dev, PAGE_SIZE,
+        dma_free_coherent(&host->dev, PAGE_SIZE,
                           host->sg_cpu, host->sg_dma);
-        iounmap(host->regs);
 
         if (host->vmmc) {
                 regulator_disable(host->vmmc);
                 regulator_put(host->vmmc);
         }
-
-
-err_freehost:
-        kfree(host);
         return ret;
 }
+EXPORT_SYMBOL(dw_mci_probe);
 
-static int __exit dw_mci_remove(struct platform_device *pdev)
+void dw_mci_remove(struct dw_mci *host)
 {
-        struct dw_mci *host = platform_get_drvdata(pdev);
         int i;
 
         mci_writel(host, RINTSTS, 0xFFFFFFFF);
         mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
 
-        platform_set_drvdata(pdev, NULL);
-
         for (i = 0; i < host->num_slots; i++) {
-                dev_dbg(&pdev->dev, "remove slot %d\n", i);
+                dev_dbg(&host->dev, "remove slot %d\n", i);
                 if (host->slot[i])
                         dw_mci_cleanup_slot(host->slot[i], i);
         }
@@ -2076,9 +2118,9 @@ static int __exit dw_mci_remove(struct platform_device *pdev)
         mci_writel(host, CLKENA, 0);
         mci_writel(host, CLKSRC, 0);
 
-        free_irq(platform_get_irq(pdev, 0), host);
+        free_irq(host->irq, host);
         destroy_workqueue(dw_mci_card_workqueue);
-        dma_free_coherent(&pdev->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
+        dma_free_coherent(&host->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
 
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
@@ -2088,20 +2130,18 @@ static int __exit dw_mci_remove(struct platform_device *pdev)
                 regulator_put(host->vmmc);
         }
 
-        iounmap(host->regs);
-
-        kfree(host);
-        return 0;
 }
+EXPORT_SYMBOL(dw_mci_remove);
+
+
 
 #ifdef CONFIG_PM_SLEEP
 /*
  * TODO: we should probably disable the clock to the card in the suspend path.
  */
-static int dw_mci_suspend(struct device *dev)
+int dw_mci_suspend(struct dw_mci *host)
 {
-        int i, ret;
-        struct dw_mci *host = dev_get_drvdata(dev);
+        int i, ret = 0;
 
         for (i = 0; i < host->num_slots; i++) {
                 struct dw_mci_slot *slot = host->slot[i];
@@ -2123,11 +2163,11 @@ static int dw_mci_suspend(struct device *dev)
 
         return 0;
 }
+EXPORT_SYMBOL(dw_mci_suspend);
 
-static int dw_mci_resume(struct device *dev)
+int dw_mci_resume(struct dw_mci *host)
 {
         int i, ret;
-        struct dw_mci *host = dev_get_drvdata(dev);
 
         if (host->vmmc)
                 regulator_enable(host->vmmc);
@@ -2135,7 +2175,7 @@ static int dw_mci_resume(struct device *dev)
         if (host->dma_ops->init)
                 host->dma_ops->init(host);
 
-        if (!mci_wait_reset(dev, host)) {
+        if (!mci_wait_reset(&host->dev, host)) {
                 ret = -ENODEV;
                 return ret;
         }
@@ -2157,32 +2197,19 @@ static int dw_mci_resume(struct device *dev)
                 if (ret < 0)
                         return ret;
         }
-
         return 0;
 }
-#else
-#define dw_mci_suspend  NULL
-#define dw_mci_resume   NULL
+EXPORT_SYMBOL(dw_mci_resume);
 #endif /* CONFIG_PM_SLEEP */
 
-static SIMPLE_DEV_PM_OPS(dw_mci_pmops, dw_mci_suspend, dw_mci_resume);
-
-static struct platform_driver dw_mci_driver = {
-        .remove         = __exit_p(dw_mci_remove),
-        .driver         = {
-                .name           = "dw_mmc",
-                .pm             = &dw_mci_pmops,
-        },
-};
-
 static int __init dw_mci_init(void)
 {
-        return platform_driver_probe(&dw_mci_driver, dw_mci_probe);
+        printk(KERN_INFO "Synopsys Designware Multimedia Card Interface Driver");
+        return 0;
 }
 
 static void __exit dw_mci_exit(void)
 {
-        platform_driver_unregister(&dw_mci_driver);
 }
 
 module_init(dw_mci_init);
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
index df392a1143f2..15c27e17c23f 100644
--- a/drivers/mmc/host/dw_mmc.h
+++ b/drivers/mmc/host/dw_mmc.h
@@ -175,4 +175,11 @@
         (*(volatile u64 __force *)((dev)->regs + SDMMC_##reg) = (value))
 #endif
 
+extern int dw_mci_probe(struct dw_mci *host);
+extern void dw_mci_remove(struct dw_mci *host);
+#ifdef CONFIG_PM
+extern int dw_mci_suspend(struct dw_mci *host);
+extern int dw_mci_resume(struct dw_mci *host);
+#endif
+
 #endif /* _DW_MMC_H_ */
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 0d955ffaf44e..032b84791a16 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -30,6 +30,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/amba/mmci.h>
 #include <linux/pm_runtime.h>
+#include <linux/types.h>
 
 #include <asm/div64.h>
 #include <asm/io.h>
@@ -53,6 +54,8 @@ static unsigned int fmax = 515633;
  * @sdio: variant supports SDIO
  * @st_clkdiv: true if using a ST-specific clock divider algorithm
  * @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
+ * @pwrreg_powerup: power up value for MMCIPOWER register
+ * @signal_direction: input/out direction of bus signals can be indicated
  */
 struct variant_data {
         unsigned int            clkreg;
@@ -63,18 +66,22 @@ struct variant_data {
         bool                    sdio;
         bool                    st_clkdiv;
         bool                    blksz_datactrl16;
+        u32                     pwrreg_powerup;
+        bool                    signal_direction;
 };
 
 static struct variant_data variant_arm = {
         .fifosize               = 16 * 4,
         .fifohalfsize           = 8 * 4,
         .datalength_bits        = 16,
+        .pwrreg_powerup         = MCI_PWR_UP,
 };
 
 static struct variant_data variant_arm_extended_fifo = {
         .fifosize               = 128 * 4,
         .fifohalfsize           = 64 * 4,
         .datalength_bits        = 16,
+        .pwrreg_powerup         = MCI_PWR_UP,
 };
 
 static struct variant_data variant_u300 = {
@@ -83,6 +90,8 @@ static struct variant_data variant_u300 = {
         .clkreg_enable          = MCI_ST_U300_HWFCEN,
         .datalength_bits        = 16,
         .sdio                   = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 static struct variant_data variant_ux500 = {
@@ -93,6 +102,8 @@ static struct variant_data variant_ux500 = {
         .datalength_bits        = 24,
         .sdio                   = true,
         .st_clkdiv              = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 static struct variant_data variant_ux500v2 = {
@@ -104,11 +115,35 @@ static struct variant_data variant_ux500v2 = {
         .sdio                   = true,
         .st_clkdiv              = true,
         .blksz_datactrl16       = true,
+        .pwrreg_powerup         = MCI_PWR_ON,
+        .signal_direction       = true,
 };
 
 /*
  * This must be called with host->lock held
  */
+static void mmci_write_clkreg(struct mmci_host *host, u32 clk)
+{
+        if (host->clk_reg != clk) {
+                host->clk_reg = clk;
+                writel(clk, host->base + MMCICLOCK);
+        }
+}
+
+/*
+ * This must be called with host->lock held
+ */
+static void mmci_write_pwrreg(struct mmci_host *host, u32 pwr)
+{
+        if (host->pwr_reg != pwr) {
+                host->pwr_reg = pwr;
+                writel(pwr, host->base + MMCIPOWER);
+        }
+}
+
+/*
+ * This must be called with host->lock held
+ */
 static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
 {
         struct variant_data *variant = host->variant;
@@ -153,7 +188,7 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
         if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
                 clk |= MCI_ST_8BIT_BUS;
 
-        writel(clk, host->base + MMCICLOCK);
+        mmci_write_clkreg(host, clk);
 }
 
 static void
@@ -166,14 +201,10 @@ mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
         host->mrq = NULL;
         host->cmd = NULL;
 
-        /*
-         * Need to drop the host lock here; mmc_request_done may call
-         * back into the driver...
-         */
-        spin_unlock(&host->lock);
-        pm_runtime_put(mmc_dev(host->mmc));
         mmc_request_done(host->mmc, mrq);
-        spin_lock(&host->lock);
+
+        pm_runtime_mark_last_busy(mmc_dev(host->mmc));
+        pm_runtime_put_autosuspend(mmc_dev(host->mmc));
 }
 
 static void mmci_set_mask1(struct mmci_host *host, unsigned int mask)
@@ -370,6 +401,7 @@ static int mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data,
                 .dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
                 .src_maxburst = variant->fifohalfsize >> 2, /* # of words */
                 .dst_maxburst = variant->fifohalfsize >> 2, /* # of words */
+                .device_fc = false,
         };
         struct dma_chan *chan;
         struct dma_device *device;
@@ -411,7 +443,7 @@ static int mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data,
                 return -EINVAL;
 
         dmaengine_slave_config(chan, &conf);
-        desc = device->device_prep_slave_sg(chan, data->sg, nr_sg,
+        desc = dmaengine_prep_slave_sg(chan, data->sg, nr_sg,
                                             conf.direction, DMA_CTRL_ACK);
         if (!desc)
                 goto unmap_exit;
@@ -607,6 +639,11 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         if (data->flags & MMC_DATA_READ)
                 datactrl |= MCI_DPSM_DIRECTION;
 
+        /* The ST Micro variants has a special bit to enable SDIO */
+        if (variant->sdio && host->mmc->card)
+                if (mmc_card_sdio(host->mmc->card))
+                        datactrl |= MCI_ST_DPSM_SDIOEN;
+
         /*
          * Attempt to use DMA operation mode, if this
          * should fail, fall back to PIO mode
@@ -635,11 +672,6 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                 irqmask = MCI_TXFIFOHALFEMPTYMASK;
         }
 
-        /* The ST Micro variants has a special bit to enable SDIO */
-        if (variant->sdio && host->mmc->card)
-                if (mmc_card_sdio(host->mmc->card))
-                        datactrl |= MCI_ST_DPSM_SDIOEN;
-
         writel(datactrl, base + MMCIDATACTRL);
         writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
         mmci_set_mask1(host, irqmask);
@@ -786,7 +818,24 @@ static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int rema
                 if (count <= 0)
                         break;
 
-                readsl(base + MMCIFIFO, ptr, count >> 2);
+                /*
+                 * SDIO especially may want to send something that is
+                 * not divisible by 4 (as opposed to card sectors
+                 * etc). Therefore make sure to always read the last bytes
+                 * while only doing full 32-bit reads towards the FIFO.
+                 */
+                if (unlikely(count & 0x3)) {
+                        if (count < 4) {
+                                unsigned char buf[4];
+                                readsl(base + MMCIFIFO, buf, 1);
+                                memcpy(ptr, buf, count);
+                        } else {
+                                readsl(base + MMCIFIFO, ptr, count >> 2);
+                                count &= ~0x3;
+                        }
+                } else {
+                        readsl(base + MMCIFIFO, ptr, count >> 2);
+                }
 
                 ptr += count;
                 remain -= count;
@@ -821,14 +870,13 @@ static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int rem
                  */
                 if (variant->sdio &&
                     mmc_card_sdio(host->mmc->card)) {
+                        u32 clk;
                         if (count < 8)
-                                writel(readl(host->base + MMCICLOCK) &
-                                        ~variant->clkreg_enable,
-                                        host->base + MMCICLOCK);
+                                clk = host->clk_reg & ~variant->clkreg_enable;
                         else
-                                writel(readl(host->base + MMCICLOCK) |
-                                        variant->clkreg_enable,
-                                        host->base + MMCICLOCK);
+                                clk = host->clk_reg | variant->clkreg_enable;
+
+                        mmci_write_clkreg(host, clk);
                 }
 
                 /*
@@ -1015,10 +1063,17 @@ static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct mmci_host *host = mmc_priv(mmc);
+        struct variant_data *variant = host->variant;
         u32 pwr = 0;
         unsigned long flags;
         int ret;
 
+        pm_runtime_get_sync(mmc_dev(mmc));
+
+        if (host->plat->ios_handler &&
+                host->plat->ios_handler(mmc_dev(mmc), ios))
+                        dev_err(mmc_dev(mmc), "platform ios_handler failed\n");
+
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
                 if (host->vcc)
@@ -1035,22 +1090,38 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                                  * power should be rare so we print an error
                                  * and return here.
                                  */
-                                return;
+                                goto out;
                         }
                 }
-                if (host->plat->vdd_handler)
-                        pwr |= host->plat->vdd_handler(mmc_dev(mmc), ios->vdd,
-                                                       ios->power_mode);
-                /* The ST version does not have this, fall through to POWER_ON */
-                if (host->hw_designer != AMBA_VENDOR_ST) {
-                        pwr |= MCI_PWR_UP;
-                        break;
-                }
+                /*
+                 * The ST Micro variant doesn't have the PL180s MCI_PWR_UP
+                 * and instead uses MCI_PWR_ON so apply whatever value is
+                 * configured in the variant data.
+                 */
+                pwr |= variant->pwrreg_powerup;
+
+                break;
         case MMC_POWER_ON:
                 pwr |= MCI_PWR_ON;
                 break;
         }
 
+        if (variant->signal_direction && ios->power_mode != MMC_POWER_OFF) {
+                /*
+                 * The ST Micro variant has some additional bits
+                 * indicating signal direction for the signals in
+                 * the SD/MMC bus and feedback-clock usage.
+                 */
+                pwr |= host->plat->sigdir;
+
+                if (ios->bus_width == MMC_BUS_WIDTH_4)
+                        pwr &= ~MCI_ST_DATA74DIREN;
+                else if (ios->bus_width == MMC_BUS_WIDTH_1)
+                        pwr &= (~MCI_ST_DATA74DIREN &
+                                ~MCI_ST_DATA31DIREN &
+                                ~MCI_ST_DATA2DIREN);
+        }
+
         if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) {
                 if (host->hw_designer != AMBA_VENDOR_ST)
                         pwr |= MCI_ROD;
@@ -1066,13 +1137,13 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_lock_irqsave(&host->lock, flags);
 
         mmci_set_clkreg(host, ios->clock);
-
-        if (host->pwr != pwr) {
-                host->pwr = pwr;
-                writel(pwr, host->base + MMCIPOWER);
-        }
+        mmci_write_pwrreg(host, pwr);
 
         spin_unlock_irqrestore(&host->lock, flags);
+
+ out:
+        pm_runtime_mark_last_busy(mmc_dev(mmc));
+        pm_runtime_put_autosuspend(mmc_dev(mmc));
 }
 
 static int mmci_get_ro(struct mmc_host *mmc)
@@ -1271,12 +1342,13 @@ static int __devinit mmci_probe(struct amba_device *dev,
         /*
          * Block size can be up to 2048 bytes, but must be a power of two.
          */
-        mmc->max_blk_size = 2048;
+        mmc->max_blk_size = 1 << 11;
 
         /*
-         * No limit on the number of blocks transferred.
+         * Limit the number of blocks transferred so that we don't overflow
+         * the maximum request size.
          */
-        mmc->max_blk_count = mmc->max_req_size;
+        mmc->max_blk_count = mmc->max_req_size >> 11;
 
         spin_lock_init(&host->lock);
 
@@ -1325,7 +1397,7 @@ static int __devinit mmci_probe(struct amba_device *dev,
         if (ret)
                 goto unmap;
 
-        if (dev->irq[1] == NO_IRQ)
+        if (dev->irq[1] == NO_IRQ || !dev->irq[1])
                 host->singleirq = true;
         else {
                 ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED,
@@ -1345,6 +1417,8 @@ static int __devinit mmci_probe(struct amba_device *dev,
 
         mmci_dma_setup(host);
 
+        pm_runtime_set_autosuspend_delay(&dev->dev, 50);
+        pm_runtime_use_autosuspend(&dev->dev);
         pm_runtime_put(&dev->dev);
 
         mmc_add_host(mmc);
@@ -1429,43 +1503,49 @@ static int __devexit mmci_remove(struct amba_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int mmci_suspend(struct amba_device *dev, pm_message_t state)
+#ifdef CONFIG_SUSPEND
+static int mmci_suspend(struct device *dev)
 {
-        struct mmc_host *mmc = amba_get_drvdata(dev);
+        struct amba_device *adev = to_amba_device(dev);
+        struct mmc_host *mmc = amba_get_drvdata(adev);
         int ret = 0;
 
         if (mmc) {
                 struct mmci_host *host = mmc_priv(mmc);
 
                 ret = mmc_suspend_host(mmc);
-                if (ret == 0)
+                if (ret == 0) {
+                        pm_runtime_get_sync(dev);
                         writel(0, host->base + MMCIMASK0);
+                }
         }
 
         return ret;
 }
 
-static int mmci_resume(struct amba_device *dev)
+static int mmci_resume(struct device *dev)
 {
-        struct mmc_host *mmc = amba_get_drvdata(dev);
+        struct amba_device *adev = to_amba_device(dev);
+        struct mmc_host *mmc = amba_get_drvdata(adev);
         int ret = 0;
 
         if (mmc) {
                 struct mmci_host *host = mmc_priv(mmc);
 
                 writel(MCI_IRQENABLE, host->base + MMCIMASK0);
+                pm_runtime_put(dev);
 
                 ret = mmc_resume_host(mmc);
         }
 
         return ret;
 }
-#else
-#define mmci_suspend    NULL
-#define mmci_resume     NULL
 #endif
 
+static const struct dev_pm_ops mmci_dev_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(mmci_suspend, mmci_resume)
+};
+
 static struct amba_id mmci_ids[] = {
         {
                 .id     = 0x00041180,
@@ -1511,26 +1591,15 @@ MODULE_DEVICE_TABLE(amba, mmci_ids);
 static struct amba_driver mmci_driver = {
         .drv            = {
                 .name   = DRIVER_NAME,
+                .pm     = &mmci_dev_pm_ops,
         },
         .probe          = mmci_probe,
         .remove         = __devexit_p(mmci_remove),
-        .suspend        = mmci_suspend,
-        .resume         = mmci_resume,
         .id_table       = mmci_ids,
 };
 
-static int __init mmci_init(void)
-{
-        return amba_driver_register(&mmci_driver);
-}
-
-static void __exit mmci_exit(void)
-{
-        amba_driver_unregister(&mmci_driver);
-}
+module_amba_driver(mmci_driver);
 
-module_init(mmci_init);
-module_exit(mmci_exit);
 module_param(fmax, uint, 0444);
 
 MODULE_DESCRIPTION("ARM PrimeCell PL180/181 Multimedia Card Interface driver");
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 79e4143ab9df..d437ccf62d6b 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -13,16 +13,6 @@
 #define MCI_PWR_ON              0x03
 #define MCI_OD                  (1 << 6)
 #define MCI_ROD                 (1 << 7)
-/*
- * The ST Micro version does not have ROD and reuse the voltage registers
- * for direction settings
- */
-#define MCI_ST_DATA2DIREN       (1 << 2)
-#define MCI_ST_CMDDIREN         (1 << 3)
-#define MCI_ST_DATA0DIREN       (1 << 4)
-#define MCI_ST_DATA31DIREN      (1 << 5)
-#define MCI_ST_FBCLKEN          (1 << 7)
-#define MCI_ST_DATA74DIREN      (1 << 8)
 
 #define MMCICLOCK               0x004
 #define MCI_CLK_ENABLE          (1 << 8)
@@ -160,7 +150,7 @@
         (MCI_RXFIFOHALFFULLMASK | MCI_RXDATAAVLBLMASK | \
          MCI_TXFIFOHALFEMPTYMASK)
 
-#define NR_SG           16
+#define NR_SG           128
 
 struct clk;
 struct variant_data;
@@ -189,7 +179,8 @@ struct mmci_host {
 
         unsigned int            mclk;
         unsigned int            cclk;
-        u32                     pwr;
+        u32                     pwr_reg;
+        u32                     clk_reg;
         struct mmci_platform_data *plat;
         struct variant_data     *variant;
 
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 4184b7946bbf..b2058b432320 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -33,6 +33,7 @@
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/dmaengine.h>
+#include <linux/types.h>
 
 #include <asm/dma.h>
 #include <asm/irq.h>
@@ -254,7 +255,7 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
         if (nents != data->sg_len)
                 return -EINVAL;
 
-        host->desc = host->dma->device->device_prep_slave_sg(host->dma,
+        host->desc = dmaengine_prep_slave_sg(host->dma,
                 data->sg, data->sg_len, slave_dirn,
                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 
@@ -267,6 +268,7 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
         wmb();
 
         dmaengine_submit(host->desc);
+        dma_async_issue_pending(host->dma);
 
         return 0;
 }
@@ -710,6 +712,7 @@ static int mxcmci_setup_dma(struct mmc_host *mmc)
         config->src_addr_width = 4;
         config->dst_maxburst = host->burstlen;
         config->src_maxburst = host->burstlen;
+        config->device_fc = false;
 
         return dmaengine_slave_config(host->dma, config);
 }
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 382c835d217c..b0f2ef988188 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -38,10 +38,10 @@
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/module.h>
+#include <linux/fsl/mxs-dma.h>
 
 #include <mach/mxs.h>
 #include <mach/common.h>
-#include <mach/dma.h>
 #include <mach/mmc.h>
 
 #define DRIVER_NAME     "mxs-mmc"
@@ -305,7 +305,7 @@ static irqreturn_t mxs_mmc_irq_handler(int irq, void *dev_id)
 }
 
 static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
-        struct mxs_mmc_host *host, unsigned int append)
+        struct mxs_mmc_host *host, unsigned long flags)
 {
         struct dma_async_tx_descriptor *desc;
         struct mmc_data *data = host->data;
@@ -324,8 +324,8 @@ static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
                 sg_len = SSP_PIO_NUM;
         }
 
-        desc = host->dmach->device->device_prep_slave_sg(host->dmach,
-                                sgl, sg_len, host->slave_dirn, append);
+        desc = dmaengine_prep_slave_sg(host->dmach,
+                                sgl, sg_len, host->slave_dirn, flags);
         if (desc) {
                 desc->callback = mxs_mmc_dma_irq_callback;
                 desc->callback_param = host;
@@ -358,7 +358,7 @@ static void mxs_mmc_bc(struct mxs_mmc_host *host)
         host->ssp_pio_words[2] = cmd1;
         host->dma_dir = DMA_NONE;
         host->slave_dirn = DMA_TRANS_NONE;
-        desc = mxs_mmc_prep_dma(host, 0);
+        desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK);
         if (!desc)
                 goto out;
 
@@ -398,7 +398,7 @@ static void mxs_mmc_ac(struct mxs_mmc_host *host)
         host->ssp_pio_words[2] = cmd1;
         host->dma_dir = DMA_NONE;
         host->slave_dirn = DMA_TRANS_NONE;
-        desc = mxs_mmc_prep_dma(host, 0);
+        desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK);
         if (!desc)
                 goto out;
 
@@ -526,7 +526,7 @@ static void mxs_mmc_adtc(struct mxs_mmc_host *host)
         host->data = data;
         host->dma_dir = dma_data_dir;
         host->slave_dirn = slave_dirn;
-        desc = mxs_mmc_prep_dma(host, 1);
+        desc = mxs_mmc_prep_dma(host, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc)
                 goto out;
 
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index fd0c661bbad3..56d4499d4388 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -26,6 +26,9 @@
 #include <linux/platform_device.h>
 #include <linux/timer.h>
 #include <linux/clk.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_device.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/core.h>
 #include <linux/mmc/mmc.h>
@@ -106,17 +109,6 @@
 #define SOFTRESET               (1 << 1)
 #define RESETDONE               (1 << 0)
 
-/*
- * FIXME: Most likely all the data using these _DEVID defines should come
- * from the platform_data, or implemented in controller and slot specific
- * functions.
- */
-#define OMAP_MMC1_DEVID         0
-#define OMAP_MMC2_DEVID         1
-#define OMAP_MMC3_DEVID         2
-#define OMAP_MMC4_DEVID         3
-#define OMAP_MMC5_DEVID         4
-
 #define MMC_AUTOSUSPEND_DELAY   100
 #define MMC_TIMEOUT_MS          20
 #define OMAP_MMC_MIN_CLOCK      400000
@@ -164,7 +156,6 @@ struct omap_hsmmc_host {
         void    __iomem         *base;
         resource_size_t         mapbase;
         spinlock_t              irq_lock; /* Prevent races with irq handler */
-        unsigned int            id;
         unsigned int            dma_len;
         unsigned int            dma_sg_idx;
         unsigned char           bus_mode;
@@ -179,7 +170,6 @@ struct omap_hsmmc_host {
         int                     got_dbclk;
         int                     response_busy;
         int                     context_loss;
-        int                     dpm_state;
         int                     vdd;
         int                     protect_card;
         int                     reqs_blocked;
@@ -241,28 +231,7 @@ static int omap_hsmmc_resume_cdirq(struct device *dev, int slot)
 
 #ifdef CONFIG_REGULATOR
 
-static int omap_hsmmc_1_set_power(struct device *dev, int slot, int power_on,
-                                  int vdd)
-{
-        struct omap_hsmmc_host *host =
-                platform_get_drvdata(to_platform_device(dev));
-        int ret;
-
-        if (mmc_slot(host).before_set_reg)
-                mmc_slot(host).before_set_reg(dev, slot, power_on, vdd);
-
-        if (power_on)
-                ret = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
-        else
-                ret = mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
-
-        if (mmc_slot(host).after_set_reg)
-                mmc_slot(host).after_set_reg(dev, slot, power_on, vdd);
-
-        return ret;
-}
-
-static int omap_hsmmc_235_set_power(struct device *dev, int slot, int power_on,
+static int omap_hsmmc_set_power(struct device *dev, int slot, int power_on,
                                    int vdd)
 {
         struct omap_hsmmc_host *host =
@@ -275,6 +244,13 @@ static int omap_hsmmc_235_set_power(struct device *dev, int slot, int power_on,
          */
         if (!host->vcc)
                 return 0;
+        /*
+         * With DT, never turn OFF the regulator. This is because
+         * the pbias cell programming support is still missing when
+         * booting with Device tree
+         */
+        if (dev->of_node && !vdd)
+                return 0;
 
         if (mmc_slot(host).before_set_reg)
                 mmc_slot(host).before_set_reg(dev, slot, power_on, vdd);
@@ -318,106 +294,16 @@ static int omap_hsmmc_235_set_power(struct device *dev, int slot, int power_on,
         return ret;
 }
 
-static int omap_hsmmc_4_set_power(struct device *dev, int slot, int power_on,
-                                        int vdd)
-{
-        return 0;
-}
-
-static int omap_hsmmc_1_set_sleep(struct device *dev, int slot, int sleep,
-                                  int vdd, int cardsleep)
-{
-        struct omap_hsmmc_host *host =
-                platform_get_drvdata(to_platform_device(dev));
-        int mode = sleep ? REGULATOR_MODE_STANDBY : REGULATOR_MODE_NORMAL;
-
-        return regulator_set_mode(host->vcc, mode);
-}
-
-static int omap_hsmmc_235_set_sleep(struct device *dev, int slot, int sleep,
-                                   int vdd, int cardsleep)
-{
-        struct omap_hsmmc_host *host =
-                platform_get_drvdata(to_platform_device(dev));
-        int err, mode;
-
-        /*
-         * If we don't see a Vcc regulator, assume it's a fixed
-         * voltage always-on regulator.
-         */
-        if (!host->vcc)
-                return 0;
-
-        mode = sleep ? REGULATOR_MODE_STANDBY : REGULATOR_MODE_NORMAL;
-
-        if (!host->vcc_aux)
-                return regulator_set_mode(host->vcc, mode);
-
-        if (cardsleep) {
-                /* VCC can be turned off if card is asleep */
-                if (sleep)
-                        err = mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
-                else
-                        err = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
-        } else
-                err = regulator_set_mode(host->vcc, mode);
-        if (err)
-                return err;
-
-        if (!mmc_slot(host).vcc_aux_disable_is_sleep)
-                return regulator_set_mode(host->vcc_aux, mode);
-
-        if (sleep)
-                return regulator_disable(host->vcc_aux);
-        else
-                return regulator_enable(host->vcc_aux);
-}
-
-static int omap_hsmmc_4_set_sleep(struct device *dev, int slot, int sleep,
-                                        int vdd, int cardsleep)
-{
-        return 0;
-}
-
 static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
 {
         struct regulator *reg;
-        int ret = 0;
         int ocr_value = 0;
 
-        switch (host->id) {
-        case OMAP_MMC1_DEVID:
-                /* On-chip level shifting via PBIAS0/PBIAS1 */
-                mmc_slot(host).set_power = omap_hsmmc_1_set_power;
-                mmc_slot(host).set_sleep = omap_hsmmc_1_set_sleep;
-                break;
-        case OMAP_MMC2_DEVID:
-        case OMAP_MMC3_DEVID:
-        case OMAP_MMC5_DEVID:
-                /* Off-chip level shifting, or none */
-                mmc_slot(host).set_power = omap_hsmmc_235_set_power;
-                mmc_slot(host).set_sleep = omap_hsmmc_235_set_sleep;
-                break;
-        case OMAP_MMC4_DEVID:
-                mmc_slot(host).set_power = omap_hsmmc_4_set_power;
-                mmc_slot(host).set_sleep = omap_hsmmc_4_set_sleep;
-        default:
-                pr_err("MMC%d configuration not supported!\n", host->id);
-                return -EINVAL;
-        }
+        mmc_slot(host).set_power = omap_hsmmc_set_power;
 
         reg = regulator_get(host->dev, "vmmc");
         if (IS_ERR(reg)) {
                 dev_dbg(host->dev, "vmmc regulator missing\n");
-                /*
-                * HACK: until fixed.c regulator is usable,
-                * we don't require a main regulator
-                * for MMC2 or MMC3
-                */
-                if (host->id == OMAP_MMC1_DEVID) {
-                        ret = PTR_ERR(reg);
-                        goto err;
-                }
         } else {
                 host->vcc = reg;
                 ocr_value = mmc_regulator_get_ocrmask(reg);
@@ -425,8 +311,8 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
                         mmc_slot(host).ocr_mask = ocr_value;
                 } else {
                         if (!(mmc_slot(host).ocr_mask & ocr_value)) {
-                                pr_err("MMC%d ocrmask %x is not supported\n",
-                                        host->id, mmc_slot(host).ocr_mask);
+                                dev_err(host->dev, "ocrmask %x is not supported\n",
+                                        mmc_slot(host).ocr_mask);
                                 mmc_slot(host).ocr_mask = 0;
                                 return -EINVAL;
                         }
@@ -459,11 +345,6 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
         }
 
         return 0;
-
-err:
-        mmc_slot(host).set_power = NULL;
-        mmc_slot(host).set_sleep = NULL;
-        return ret;
 }
 
 static void omap_hsmmc_reg_put(struct omap_hsmmc_host *host)
@@ -471,7 +352,6 @@ static void omap_hsmmc_reg_put(struct omap_hsmmc_host *host)
         regulator_put(host->vcc);
         regulator_put(host->vcc_aux);
         mmc_slot(host).set_power = NULL;
-        mmc_slot(host).set_sleep = NULL;
 }
 
 static inline int omap_hsmmc_have_reg(void)
@@ -710,7 +590,7 @@ static int omap_hsmmc_context_restore(struct omap_hsmmc_host *host)
         OMAP_HSMMC_WRITE(host->base, SYSCONFIG,
                         OMAP_HSMMC_READ(host->base, SYSCONFIG) | AUTOIDLE);
 
-        if (host->id == OMAP_MMC1_DEVID) {
+        if (host->pdata->controller_flags & OMAP_HSMMC_SUPPORTS_DUAL_VOLT) {
                 if (host->power_mode != MMC_POWER_OFF &&
                     (1 << ios->vdd) <= MMC_VDD_23_24)
                         hctl = SDVS18;
@@ -1261,14 +1141,14 @@ static void omap_hsmmc_protect_card(struct omap_hsmmc_host *host)
         host->reqs_blocked = 0;
         if (mmc_slot(host).get_cover_state(host->dev, host->slot_id)) {
                 if (host->protect_card) {
-                        pr_info("%s: cover is closed, "
+                        dev_info(host->dev, "%s: cover is closed, "
                                          "card is now accessible\n",
                                          mmc_hostname(host->mmc));
                         host->protect_card = 0;
                 }
         } else {
                 if (!host->protect_card) {
-                        pr_info("%s: cover is open, "
+                        dev_info(host->dev, "%s: cover is open, "
                                          "card is now inaccessible\n",
                                          mmc_hostname(host->mmc));
                         host->protect_card = 1;
@@ -1405,7 +1285,7 @@ static int omap_hsmmc_pre_dma_transfer(struct omap_hsmmc_host *host,
 
         if (!next && data->host_cookie &&
             data->host_cookie != host->next_data.cookie) {
-                pr_warning("[%s] invalid cookie: data->host_cookie %d"
+                dev_warn(host->dev, "[%s] invalid cookie: data->host_cookie %d"
                        " host->next_data.cookie %d\n",
                        __func__, data->host_cookie, host->next_data.cookie);
                 data->host_cookie = 0;
@@ -1663,7 +1543,13 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                  * of external transceiver; but they all handle 1.8V.
                  */
                 if ((OMAP_HSMMC_READ(host->base, HCTL) & SDVSDET) &&
-                        (ios->vdd == DUAL_VOLT_OCR_BIT)) {
+                        (ios->vdd == DUAL_VOLT_OCR_BIT) &&
+                        /*
+                         * With pbias cell programming missing, this
+                         * can't be allowed when booting with device
+                         * tree.
+                         */
+                        !host->dev->of_node) {
                                 /*
                                  * The mmc_select_voltage fn of the core does
                                  * not seem to set the power_mode to
@@ -1748,7 +1634,7 @@ static int omap_hsmmc_enable_fclk(struct mmc_host *mmc)
         return 0;
 }
 
-static int omap_hsmmc_disable_fclk(struct mmc_host *mmc, int lazy)
+static int omap_hsmmc_disable_fclk(struct mmc_host *mmc)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
@@ -1782,15 +1668,8 @@ static int omap_hsmmc_regs_show(struct seq_file *s, void *data)
         if (host->pdata->get_context_loss_count)
                 context_loss = host->pdata->get_context_loss_count(host->dev);
 
-        seq_printf(s, "mmc%d:\n"
-                        " enabled:\t%d\n"
-                        " dpm_state:\t%d\n"
-                        " nesting_cnt:\t%d\n"
-                        " ctx_loss:\t%d:%d\n"
-                        "\nregs:\n",
-                        mmc->index, mmc->enabled ? 1 : 0,
-                        host->dpm_state, mmc->nesting_cnt,
-                        host->context_loss, context_loss);
+        seq_printf(s, "mmc%d:\n ctx_loss:\t%d:%d\n\nregs:\n",
+                        mmc->index, host->context_loss, context_loss);
 
         if (host->suspended) {
                 seq_printf(s, "host suspended, can't read registers\n");
@@ -1847,13 +1726,82 @@ static void omap_hsmmc_debugfs(struct mmc_host *mmc)
 
 #endif
 
-static int __init omap_hsmmc_probe(struct platform_device *pdev)
+#ifdef CONFIG_OF
+static u16 omap4_reg_offset = 0x100;
+
+static const struct of_device_id omap_mmc_of_match[] = {
+        {
+                .compatible = "ti,omap2-hsmmc",
+        },
+        {
+                .compatible = "ti,omap3-hsmmc",
+        },
+        {
+                .compatible = "ti,omap4-hsmmc",
+                .data = &omap4_reg_offset,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, omap_mmc_of_match);
+
+static struct omap_mmc_platform_data *of_get_hsmmc_pdata(struct device *dev)
+{
+        struct omap_mmc_platform_data *pdata;
+        struct device_node *np = dev->of_node;
+        u32 bus_width;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL; /* out of memory */
+
+        if (of_find_property(np, "ti,dual-volt", NULL))
+                pdata->controller_flags |= OMAP_HSMMC_SUPPORTS_DUAL_VOLT;
+
+        /* This driver only supports 1 slot */
+        pdata->nr_slots = 1;
+        pdata->slots[0].switch_pin = of_get_named_gpio(np, "cd-gpios", 0);
+        pdata->slots[0].gpio_wp = of_get_named_gpio(np, "wp-gpios", 0);
+
+        if (of_find_property(np, "ti,non-removable", NULL)) {
+                pdata->slots[0].nonremovable = true;
+                pdata->slots[0].no_regulator_off_init = true;
+        }
+        of_property_read_u32(np, "ti,bus-width", &bus_width);
+        if (bus_width == 4)
+                pdata->slots[0].caps |= MMC_CAP_4_BIT_DATA;
+        else if (bus_width == 8)
+                pdata->slots[0].caps |= MMC_CAP_8_BIT_DATA;
+
+        if (of_find_property(np, "ti,needs-special-reset", NULL))
+                pdata->slots[0].features |= HSMMC_HAS_UPDATED_RESET;
+
+        return pdata;
+}
+#else
+static inline struct omap_mmc_platform_data
+                        *of_get_hsmmc_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
+
+static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
 {
         struct omap_mmc_platform_data *pdata = pdev->dev.platform_data;
         struct mmc_host *mmc;
         struct omap_hsmmc_host *host = NULL;
         struct resource *res;
         int ret, irq;
+        const struct of_device_id *match;
+
+        match = of_match_device(of_match_ptr(omap_mmc_of_match), &pdev->dev);
+        if (match) {
+                pdata = of_get_hsmmc_pdata(&pdev->dev);
+                if (match->data) {
+                        u16 *offsetp = match->data;
+                        pdata->reg_offset = *offsetp;
+                }
+        }
 
         if (pdata == NULL) {
                 dev_err(&pdev->dev, "Platform Data is missing\n");
@@ -1870,8 +1818,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         if (res == NULL || irq < 0)
                 return -ENXIO;
 
-        res->start += pdata->reg_offset;
-        res->end += pdata->reg_offset;
         res = request_mem_region(res->start, resource_size(res), pdev->name);
         if (res == NULL)
                 return -EBUSY;
@@ -1894,9 +1840,8 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         host->dev->dma_mask = &pdata->dma_mask;
         host->dma_ch    = -1;
         host->irq       = irq;
-        host->id        = pdev->id;
         host->slot_id   = 0;
-        host->mapbase   = res->start;
+        host->mapbase   = res->start + pdata->reg_offset;
         host->base      = ioremap(host->mapbase, SZ_4K);
         host->power_mode = MMC_POWER_OFF;
         host->next_data.cookie = 1;
@@ -1912,8 +1857,12 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         if (mmc_slot(host).vcc_aux_disable_is_sleep)
                 mmc_slot(host).no_off = 1;
 
-        mmc->f_min      = OMAP_MMC_MIN_CLOCK;
-        mmc->f_max      = OMAP_MMC_MAX_CLOCK;
+        mmc->f_min = OMAP_MMC_MIN_CLOCK;
+
+        if (pdata->max_freq > 0)
+                mmc->f_max = pdata->max_freq;
+        else
+                mmc->f_max = OMAP_MMC_MAX_CLOCK;
 
         spin_lock_init(&host->irq_lock);
 
@@ -1924,9 +1873,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        omap_hsmmc_context_save(host);
-
-        mmc->caps |= MMC_CAP_DISABLE;
         if (host->pdata->controller_flags & OMAP_HSMMC_BROKEN_MULTIBLOCK_READ) {
                 dev_info(&pdev->dev, "multiblock reads disabled due to 35xx erratum 2.1.1.128; MMC read performance may suffer\n");
                 mmc->caps2 |= MMC_CAP2_NO_MULTI_READ;
@@ -1937,6 +1883,8 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         pm_runtime_set_autosuspend_delay(host->dev, MMC_AUTOSUSPEND_DELAY);
         pm_runtime_use_autosuspend(host->dev);
 
+        omap_hsmmc_context_save(host);
+
         if (cpu_is_omap2430()) {
                 host->dbclk = clk_get(&pdev->dev, "mmchsdb_fck");
                 /*
@@ -1977,32 +1925,19 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
 
         omap_hsmmc_conf_bus_power(host);
 
-        /* Select DMA lines */
-        switch (host->id) {
-        case OMAP_MMC1_DEVID:
-                host->dma_line_tx = OMAP24XX_DMA_MMC1_TX;
-                host->dma_line_rx = OMAP24XX_DMA_MMC1_RX;
-                break;
-        case OMAP_MMC2_DEVID:
-                host->dma_line_tx = OMAP24XX_DMA_MMC2_TX;
-                host->dma_line_rx = OMAP24XX_DMA_MMC2_RX;
-                break;
-        case OMAP_MMC3_DEVID:
-                host->dma_line_tx = OMAP34XX_DMA_MMC3_TX;
-                host->dma_line_rx = OMAP34XX_DMA_MMC3_RX;
-                break;
-        case OMAP_MMC4_DEVID:
-                host->dma_line_tx = OMAP44XX_DMA_MMC4_TX;
-                host->dma_line_rx = OMAP44XX_DMA_MMC4_RX;
-                break;
-        case OMAP_MMC5_DEVID:
-                host->dma_line_tx = OMAP44XX_DMA_MMC5_TX;
-                host->dma_line_rx = OMAP44XX_DMA_MMC5_RX;
-                break;
-        default:
-                dev_err(mmc_dev(host->mmc), "Invalid MMC id\n");
+        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx");
+        if (!res) {
+                dev_err(mmc_dev(host->mmc), "cannot get DMA TX channel\n");
                 goto err_irq;
         }
+        host->dma_line_tx = res->start;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx");
+        if (!res) {
+                dev_err(mmc_dev(host->mmc), "cannot get DMA RX channel\n");
+                goto err_irq;
+        }
+        host->dma_line_rx = res->start;
 
         /* Request IRQ for MMC operations */
         ret = request_irq(host->irq, omap_hsmmc_irq, 0,
@@ -2081,8 +2016,8 @@ err_reg:
 err_irq_cd_init:
         free_irq(host->irq, host);
 err_irq:
-        pm_runtime_mark_last_busy(host->dev);
-        pm_runtime_put_autosuspend(host->dev);
+        pm_runtime_put_sync(host->dev);
+        pm_runtime_disable(host->dev);
         clk_put(host->fclk);
         if (host->got_dbclk) {
                 clk_disable(host->dbclk);
@@ -2099,35 +2034,33 @@ err:
         return ret;
 }
 
-static int omap_hsmmc_remove(struct platform_device *pdev)
+static int __devexit omap_hsmmc_remove(struct platform_device *pdev)
 {
         struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
         struct resource *res;
 
-        if (host) {
-                pm_runtime_get_sync(host->dev);
-                mmc_remove_host(host->mmc);
-                if (host->use_reg)
-                        omap_hsmmc_reg_put(host);
-                if (host->pdata->cleanup)
-                        host->pdata->cleanup(&pdev->dev);
-                free_irq(host->irq, host);
-                if (mmc_slot(host).card_detect_irq)
-                        free_irq(mmc_slot(host).card_detect_irq, host);
-
-                pm_runtime_put_sync(host->dev);
-                pm_runtime_disable(host->dev);
-                clk_put(host->fclk);
-                if (host->got_dbclk) {
-                        clk_disable(host->dbclk);
-                        clk_put(host->dbclk);
-                }
+        pm_runtime_get_sync(host->dev);
+        mmc_remove_host(host->mmc);
+        if (host->use_reg)
+                omap_hsmmc_reg_put(host);
+        if (host->pdata->cleanup)
+                host->pdata->cleanup(&pdev->dev);
+        free_irq(host->irq, host);
+        if (mmc_slot(host).card_detect_irq)
+                free_irq(mmc_slot(host).card_detect_irq, host);
 
-                mmc_free_host(host->mmc);
-                iounmap(host->base);
-                omap_hsmmc_gpio_free(pdev->dev.platform_data);
+        pm_runtime_put_sync(host->dev);
+        pm_runtime_disable(host->dev);
+        clk_put(host->fclk);
+        if (host->got_dbclk) {
+                clk_disable(host->dbclk);
+                clk_put(host->dbclk);
         }
 
+        mmc_free_host(host->mmc);
+        iounmap(host->base);
+        omap_hsmmc_gpio_free(pdev->dev.platform_data);
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res)
                 release_mem_region(res->start, resource_size(res));
@@ -2140,49 +2073,45 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
 static int omap_hsmmc_suspend(struct device *dev)
 {
         int ret = 0;
-        struct platform_device *pdev = to_platform_device(dev);
-        struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
+        struct omap_hsmmc_host *host = dev_get_drvdata(dev);
 
-        if (host && host->suspended)
+        if (!host)
                 return 0;
 
-        if (host) {
-                pm_runtime_get_sync(host->dev);
-                host->suspended = 1;
-                if (host->pdata->suspend) {
-                        ret = host->pdata->suspend(&pdev->dev,
-                                                        host->slot_id);
-                        if (ret) {
-                                dev_dbg(mmc_dev(host->mmc),
-                                        "Unable to handle MMC board"
-                                        " level suspend\n");
-                                host->suspended = 0;
-                                return ret;
-                        }
-                }
-                ret = mmc_suspend_host(host->mmc);
+        if (host && host->suspended)
+                return 0;
 
+        pm_runtime_get_sync(host->dev);
+        host->suspended = 1;
+        if (host->pdata->suspend) {
+                ret = host->pdata->suspend(dev, host->slot_id);
                 if (ret) {
+                        dev_dbg(dev, "Unable to handle MMC board"
+                                        " level suspend\n");
                         host->suspended = 0;
-                        if (host->pdata->resume) {
-                                ret = host->pdata->resume(&pdev->dev,
-                                                          host->slot_id);
-                                if (ret)
-                                        dev_dbg(mmc_dev(host->mmc),
-                                                "Unmask interrupt failed\n");
-                        }
-                        goto err;
+                        return ret;
                 }
+        }
+        ret = mmc_suspend_host(host->mmc);
 
-                if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER)) {
-                        omap_hsmmc_disable_irq(host);
-                        OMAP_HSMMC_WRITE(host->base, HCTL,
-                                OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
+        if (ret) {
+                host->suspended = 0;
+                if (host->pdata->resume) {
+                        ret = host->pdata->resume(dev, host->slot_id);
+                        if (ret)
+                                dev_dbg(dev, "Unmask interrupt failed\n");
                 }
-                if (host->got_dbclk)
-                        clk_disable(host->dbclk);
+                goto err;
+        }
 
+        if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER)) {
+                omap_hsmmc_disable_irq(host);
+                OMAP_HSMMC_WRITE(host->base, HCTL,
+                                OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
         }
+
+        if (host->got_dbclk)
+                clk_disable(host->dbclk);
 err:
         pm_runtime_put_sync(host->dev);
         return ret;
@@ -2192,38 +2121,37 @@ err:
 static int omap_hsmmc_resume(struct device *dev)
 {
         int ret = 0;
-        struct platform_device *pdev = to_platform_device(dev);
-        struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
+        struct omap_hsmmc_host *host = dev_get_drvdata(dev);
+
+        if (!host)
+                return 0;
 
         if (host && !host->suspended)
                 return 0;
 
-        if (host) {
-                pm_runtime_get_sync(host->dev);
+        pm_runtime_get_sync(host->dev);
 
-                if (host->got_dbclk)
-                        clk_enable(host->dbclk);
+        if (host->got_dbclk)
+                clk_enable(host->dbclk);
 
-                if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER))
-                        omap_hsmmc_conf_bus_power(host);
+        if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER))
+                omap_hsmmc_conf_bus_power(host);
 
-                if (host->pdata->resume) {
-                        ret = host->pdata->resume(&pdev->dev, host->slot_id);
-                        if (ret)
-                                dev_dbg(mmc_dev(host->mmc),
-                                        "Unmask interrupt failed\n");
-                }
+        if (host->pdata->resume) {
+                ret = host->pdata->resume(dev, host->slot_id);
+                if (ret)
+                        dev_dbg(dev, "Unmask interrupt failed\n");
+        }
 
-                omap_hsmmc_protect_card(host);
+        omap_hsmmc_protect_card(host);
 
-                /* Notify the core to resume the host */
-                ret = mmc_resume_host(host->mmc);
-                if (ret == 0)
-                        host->suspended = 0;
+        /* Notify the core to resume the host */
+        ret = mmc_resume_host(host->mmc);
+        if (ret == 0)
+                host->suspended = 0;
 
-                pm_runtime_mark_last_busy(host->dev);
-                pm_runtime_put_autosuspend(host->dev);
-        }
+        pm_runtime_mark_last_busy(host->dev);
+        pm_runtime_put_autosuspend(host->dev);
 
         return ret;
 
@@ -2240,7 +2168,7 @@ static int omap_hsmmc_runtime_suspend(struct device *dev)
 
         host = platform_get_drvdata(to_platform_device(dev));
         omap_hsmmc_context_save(host);
-        dev_dbg(mmc_dev(host->mmc), "disabled\n");
+        dev_dbg(dev, "disabled\n");
 
         return 0;
 }
@@ -2251,7 +2179,7 @@ static int omap_hsmmc_runtime_resume(struct device *dev)
 
         host = platform_get_drvdata(to_platform_device(dev));
         omap_hsmmc_context_restore(host);
-        dev_dbg(mmc_dev(host->mmc), "enabled\n");
+        dev_dbg(dev, "enabled\n");
 
         return 0;
 }
@@ -2264,29 +2192,17 @@ static struct dev_pm_ops omap_hsmmc_dev_pm_ops = {
 };
 
 static struct platform_driver omap_hsmmc_driver = {
-        .remove         = omap_hsmmc_remove,
+        .probe          = omap_hsmmc_probe,
+        .remove         = __devexit_p(omap_hsmmc_remove),
         .driver         = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
                 .pm = &omap_hsmmc_dev_pm_ops,
+                .of_match_table = of_match_ptr(omap_mmc_of_match),
         },
 };
 
-static int __init omap_hsmmc_init(void)
-{
-        /* Register the MMC driver */
-        return platform_driver_probe(&omap_hsmmc_driver, omap_hsmmc_probe);
-}
-
-static void __exit omap_hsmmc_cleanup(void)
-{
-        /* Unregister MMC driver */
-        platform_driver_unregister(&omap_hsmmc_driver);
-}
-
-module_init(omap_hsmmc_init);
-module_exit(omap_hsmmc_cleanup);
-
+module_platform_driver(omap_hsmmc_driver);
 MODULE_DESCRIPTION("OMAP High Speed Multimedia Card driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 1bcfd6dbb5cc..c3622a69f432 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1606,7 +1606,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
         host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!host->mem) {
                 dev_err(&pdev->dev,
-                        "failed to get io memory region resouce.\n");
+                        "failed to get io memory region resource.\n");
 
                 ret = -ENOENT;
                 goto probe_free_gpio;
@@ -1630,7 +1630,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
 
         host->irq = platform_get_irq(pdev, 0);
         if (host->irq == 0) {
-                dev_err(&pdev->dev, "failed to get interrupt resouce.\n");
+                dev_err(&pdev->dev, "failed to get interrupt resource.\n");
                 ret = -EINVAL;
                 goto probe_iounmap;
         }
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index 46fd1fd1b605..177f697b5835 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/io.h>
+#include <linux/module.h>
 #include <linux/mmc/host.h>
 
 #include "sdhci-pltfm.h"
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index d601e41af282..8abdaf6697a8 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -269,8 +269,9 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
                 imx_data->scratchpad = val;
                 return;
         case SDHCI_COMMAND:
-                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION)
-                        && (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
+                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION ||
+                     host->cmd->opcode == MMC_SET_BLOCK_COUNT) &&
+                    (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
                         val |= SDHCI_CMD_ABORTCMD;
 
                 if (is_imx6q_usdhc(imx_data)) {
@@ -463,11 +464,10 @@ static int __devinit sdhci_esdhc_imx_probe(struct platform_device *pdev)
                 err = PTR_ERR(clk);
                 goto err_clk_get;
         }
-        clk_enable(clk);
+        clk_prepare_enable(clk);
         pltfm_host->clk = clk;
 
-        if (!is_imx25_esdhc(imx_data))
-                host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
+        host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
         if (is_imx25_esdhc(imx_data) || is_imx35_esdhc(imx_data))
                 /* Fix errata ENGcm07207 present on i.MX25 and i.MX35 */
@@ -558,7 +558,7 @@ no_card_detect_irq:
                 gpio_free(boarddata->wp_gpio);
 no_card_detect_pin:
 no_board_data:
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
 err_clk_get:
         kfree(imx_data);
@@ -585,7 +585,7 @@ static int __devexit sdhci_esdhc_imx_remove(struct platform_device *pdev)
                 gpio_free(boarddata->cd_gpio);
         }
 
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
         kfree(imx_data);
 
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index 5d876ff86f37..f8eb1fb0c921 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -1,7 +1,7 @@
 /*
  * Freescale eSDHC controller driver.
  *
- * Copyright (c) 2007, 2010 Freescale Semiconductor, Inc.
+ * Copyright (c) 2007, 2010, 2012 Freescale Semiconductor, Inc.
  * Copyright (c) 2009 MontaVista Software, Inc.
  *
  * Authors: Xiaobo Xie <X.Xie@freescale.com>
@@ -14,6 +14,7 @@
  */
 
 #include <linux/io.h>
+#include <linux/of.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/mmc/host.h>
@@ -114,6 +115,34 @@ static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host)
         return pltfm_host->clock / 256 / 16;
 }
 
+static void esdhc_of_set_clock(struct sdhci_host *host, unsigned int clock)
+{
+        /* Workaround to reduce the clock frequency for p1010 esdhc */
+        if (of_find_compatible_node(NULL, NULL, "fsl,p1010-esdhc")) {
+                if (clock > 20000000)
+                        clock -= 5000000;
+                if (clock > 40000000)
+                        clock -= 5000000;
+        }
+
+        /* Set the clock */
+        esdhc_set_clock(host, clock);
+}
+
+#ifdef CONFIG_PM
+static u32 esdhc_proctl;
+static void esdhc_of_suspend(struct sdhci_host *host)
+{
+        esdhc_proctl = sdhci_be32bs_readl(host, SDHCI_HOST_CONTROL);
+}
+
+static void esdhc_of_resume(struct sdhci_host *host)
+{
+        esdhc_of_enable_dma(host);
+        sdhci_be32bs_writel(host, esdhc_proctl, SDHCI_HOST_CONTROL);
+}
+#endif
+
 static struct sdhci_ops sdhci_esdhc_ops = {
         .read_l = sdhci_be32bs_readl,
         .read_w = esdhc_readw,
@@ -121,10 +150,14 @@ static struct sdhci_ops sdhci_esdhc_ops = {
         .write_l = sdhci_be32bs_writel,
         .write_w = esdhc_writew,
         .write_b = esdhc_writeb,
-        .set_clock = esdhc_set_clock,
+        .set_clock = esdhc_of_set_clock,
         .enable_dma = esdhc_of_enable_dma,
         .get_max_clock = esdhc_of_get_max_clock,
         .get_min_clock = esdhc_of_get_min_clock,
+#ifdef CONFIG_PM
+        .platform_suspend = esdhc_of_suspend,
+        .platform_resume = esdhc_of_resume,
+#endif
 };
 
 static struct sdhci_pltfm_data sdhci_esdhc_pdata = {
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 6ebdc4010e7c..69ef0beae104 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -29,6 +29,12 @@
 #include "sdhci.h"
 
 /*
+ * PCI device IDs
+ */
+#define PCI_DEVICE_ID_INTEL_PCH_SDIO0   0x8809
+#define PCI_DEVICE_ID_INTEL_PCH_SDIO1   0x880a
+
+/*
  * PCI registers
  */
 
@@ -47,6 +53,7 @@ struct sdhci_pci_slot;
 
 struct sdhci_pci_fixes {
         unsigned int            quirks;
+        unsigned int            quirks2;
         bool                    allow_runtime_pm;
 
         int                     (*probe) (struct sdhci_pci_chip *);
@@ -73,6 +80,7 @@ struct sdhci_pci_chip {
         struct pci_dev          *pdev;
 
         unsigned int            quirks;
+        unsigned int            quirks2;
         bool                    allow_runtime_pm;
         const struct sdhci_pci_fixes *fixes;
 
@@ -172,6 +180,12 @@ static int mrst_hc_probe(struct sdhci_pci_chip *chip)
         return 0;
 }
 
+static int pch_hc_probe_slot(struct sdhci_pci_slot *slot)
+{
+        slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+        return 0;
+}
+
 #ifdef CONFIG_PM_RUNTIME
 
 static irqreturn_t sdhci_pci_sd_cd(int irq, void *dev_id)
@@ -244,7 +258,8 @@ static inline void sdhci_pci_remove_own_cd(struct sdhci_pci_slot *slot)
 static int mfd_emmc_probe_slot(struct sdhci_pci_slot *slot)
 {
         slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE;
-        slot->host->mmc->caps2 = MMC_CAP2_BOOTPART_NOACC;
+        slot->host->mmc->caps2 |= MMC_CAP2_BOOTPART_NOACC |
+                                  MMC_CAP2_HC_ERASE_SZ;
         return 0;
 }
 
@@ -271,6 +286,7 @@ static const struct sdhci_pci_fixes sdhci_intel_mfd_sd = {
 
 static const struct sdhci_pci_fixes sdhci_intel_mfd_sdio = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
+        .quirks2        = SDHCI_QUIRK2_HOST_OFF_CARD_ON,
         .allow_runtime_pm = true,
         .probe_slot     = mfd_sdio_probe_slot,
 };
@@ -281,6 +297,11 @@ static const struct sdhci_pci_fixes sdhci_intel_mfd_emmc = {
         .probe_slot     = mfd_emmc_probe_slot,
 };
 
+static const struct sdhci_pci_fixes sdhci_intel_pch_sdio = {
+        .quirks         = SDHCI_QUIRK_BROKEN_ADMA,
+        .probe_slot     = pch_hc_probe_slot,
+};
+
 /* O2Micro extra registers */
 #define O2_SD_LOCK_WP           0xD3
 #define O2_SD_MULTI_VCC3V       0xEE
@@ -817,6 +838,22 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
         },
 
         {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_PCH_SDIO0,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_pch_sdio,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_PCH_SDIO1,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_pch_sdio,
+        },
+
+        {
                 .vendor         = PCI_VENDOR_ID_O2,
                 .device         = PCI_DEVICE_ID_O2_8120,
                 .subvendor      = PCI_ANY_ID,
@@ -1206,6 +1243,7 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
         host->hw_name = "PCI";
         host->ops = &sdhci_pci_ops;
         host->quirks = chip->quirks;
+        host->quirks2 = chip->quirks2;
 
         host->irq = pdev->irq;
 
@@ -1365,6 +1403,7 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
         chip->fixes = (const struct sdhci_pci_fixes *)ent->driver_data;
         if (chip->fixes) {
                 chip->quirks = chip->fixes->quirks;
+                chip->quirks2 = chip->fixes->quirks2;
                 chip->allow_runtime_pm = chip->fixes->allow_runtime_pm;
         }
         chip->num_slots = slots;
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 1af756ee0f9a..55a164fcaa15 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -20,6 +20,10 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 #include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/host.h>
 
@@ -53,6 +57,18 @@ struct sdhci_s3c {
         struct clk              *clk_bus[MAX_BUS_CLK];
 };
 
+/**
+ * struct sdhci_s3c_driver_data - S3C SDHCI platform specific driver data
+ * @sdhci_quirks: sdhci host specific quirks.
+ *
+ * Specifies platform specific configuration of sdhci controller.
+ * Note: A structure for driver specific platform data is used for future
+ * expansion of its usage.
+ */
+struct sdhci_s3c_drv_data {
+        unsigned int    sdhci_quirks;
+};
+
 static inline struct sdhci_s3c *to_s3c(struct sdhci_host *host)
 {
         return sdhci_priv(host);
@@ -132,10 +148,10 @@ static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c *ourhost,
                 return UINT_MAX;
 
         /*
-         * Clock divider's step is different as 1 from that of host controller
-         * when 'clk_type' is S3C_SDHCI_CLK_DIV_EXTERNAL.
+         * If controller uses a non-standard clock division, find the best clock
+         * speed possible with selected clock source and skip the division.
          */
-        if (ourhost->pdata->clk_type) {
+        if (ourhost->host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK) {
                 rate = clk_round_rate(clksrc, wanted);
                 return wanted - rate;
         }
@@ -272,6 +288,8 @@ static unsigned int sdhci_cmu_get_min_clock(struct sdhci_host *host)
 static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
 {
         struct sdhci_s3c *ourhost = to_s3c(host);
+        unsigned long timeout;
+        u16 clk = 0;
 
         /* don't bother if the clock is going off */
         if (clock == 0)
@@ -282,6 +300,25 @@ static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
         clk_set_rate(ourhost->clk_bus[ourhost->cur_clk], clock);
 
         host->clock = clock;
+
+        clk = SDHCI_CLOCK_INT_EN;
+        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+
+        /* Wait max 20 ms */
+        timeout = 20;
+        while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
+                & SDHCI_CLOCK_INT_STABLE)) {
+                if (timeout == 0) {
+                        printk(KERN_ERR "%s: Internal clock never "
+                                "stabilised.\n", mmc_hostname(host->mmc));
+                        return;
+                }
+                timeout--;
+                mdelay(1);
+        }
+
+        clk |= SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
 }
 
 /**
@@ -382,16 +419,24 @@ static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc)
         }
 }
 
+static inline struct sdhci_s3c_drv_data *sdhci_s3c_get_driver_data(
+                        struct platform_device *pdev)
+{
+        return (struct sdhci_s3c_drv_data *)
+                        platform_get_device_id(pdev)->driver_data;
+}
+
 static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 {
-        struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data;
+        struct s3c_sdhci_platdata *pdata;
+        struct sdhci_s3c_drv_data *drv_data;
         struct device *dev = &pdev->dev;
         struct sdhci_host *host;
         struct sdhci_s3c *sc;
         struct resource *res;
         int ret, irq, ptr, clks;
 
-        if (!pdata) {
+        if (!pdev->dev.platform_data) {
                 dev_err(dev, "no device data specified\n");
                 return -ENOENT;
         }
@@ -402,18 +447,20 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
                 return irq;
         }
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(dev, "no memory specified\n");
-                return -ENOENT;
-        }
-
         host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c));
         if (IS_ERR(host)) {
                 dev_err(dev, "sdhci_alloc_host() failed\n");
                 return PTR_ERR(host);
         }
 
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                ret = -ENOMEM;
+                goto err_io_clk;
+        }
+        memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
+
+        drv_data = sdhci_s3c_get_driver_data(pdev);
         sc = sdhci_priv(host);
 
         sc->host = host;
@@ -464,15 +511,8 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
                 goto err_no_busclks;
         }
 
-        sc->ioarea = request_mem_region(res->start, resource_size(res),
-                                        mmc_hostname(host->mmc));
-        if (!sc->ioarea) {
-                dev_err(dev, "failed to reserve register area\n");
-                ret = -ENXIO;
-                goto err_req_regs;
-        }
-
-        host->ioaddr = ioremap_nocache(res->start, resource_size(res));
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        host->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
         if (!host->ioaddr) {
                 dev_err(dev, "failed to map registers\n");
                 ret = -ENXIO;
@@ -491,6 +531,8 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         /* Setup quirks for the controller */
         host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
         host->quirks |= SDHCI_QUIRK_NO_HISPD_BIT;
+        if (drv_data)
+                host->quirks |= drv_data->sdhci_quirks;
 
 #ifndef CONFIG_MMC_SDHCI_S3C_DMA
 
@@ -518,8 +560,13 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->mmc->caps = MMC_CAP_NONREMOVABLE;
 
-        if (pdata->host_caps)
-                host->mmc->caps |= pdata->host_caps;
+        switch (pdata->max_width) {
+        case 8:
+                host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+        case 4:
+                host->mmc->caps |= MMC_CAP_4_BIT_DATA;
+                break;
+        }
 
         if (pdata->pm_caps)
                 host->mmc->pm_caps |= pdata->pm_caps;
@@ -534,7 +581,7 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
          * If controller does not have internal clock divider,
          * we can use overriding functions instead of default.
          */
-        if (pdata->clk_type) {
+        if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK) {
                 sdhci_s3c_ops.set_clock = sdhci_cmu_set_clock;
                 sdhci_s3c_ops.get_min_clock = sdhci_cmu_get_min_clock;
                 sdhci_s3c_ops.get_max_clock = sdhci_cmu_get_max_clock;
@@ -544,10 +591,20 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         if (pdata->host_caps)
                 host->mmc->caps |= pdata->host_caps;
 
+        if (pdata->host_caps2)
+                host->mmc->caps2 |= pdata->host_caps2;
+
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_set_autosuspend_delay(&pdev->dev, 50);
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_suspend_ignore_children(&pdev->dev, 1);
+
         ret = sdhci_add_host(host);
         if (ret) {
                 dev_err(dev, "sdhci_add_host() failed\n");
-                goto err_add_host;
+                pm_runtime_forbid(&pdev->dev);
+                pm_runtime_get_noresume(&pdev->dev);
+                goto err_req_regs;
         }
 
         /* The following two methods of card detection might call
@@ -561,10 +618,6 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
         return 0;
 
- err_add_host:
-        release_resource(sc->ioarea);
-        kfree(sc->ioarea);
-
  err_req_regs:
         for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
                 if (sc->clk_bus[ptr]) {
@@ -601,6 +654,8 @@ static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
 
         sdhci_remove_host(host, 1);
 
+        pm_runtime_disable(&pdev->dev);
+
         for (ptr = 0; ptr < 3; ptr++) {
                 if (sc->clk_bus[ptr]) {
                         clk_disable(sc->clk_bus[ptr]);
@@ -610,18 +665,13 @@ static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
         clk_disable(sc->clk_io);
         clk_put(sc->clk_io);
 
-        iounmap(host->ioaddr);
-        release_resource(sc->ioarea);
-        kfree(sc->ioarea);
-
         sdhci_free_host(host);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
-#ifdef CONFIG_PM
-
+#ifdef CONFIG_PM_SLEEP
 static int sdhci_s3c_suspend(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
@@ -635,10 +685,29 @@ static int sdhci_s3c_resume(struct device *dev)
 
         return sdhci_resume_host(host);
 }
+#endif
+
+#ifdef CONFIG_PM_RUNTIME
+static int sdhci_s3c_runtime_suspend(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+
+        return sdhci_runtime_suspend_host(host);
+}
+
+static int sdhci_s3c_runtime_resume(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+
+        return sdhci_runtime_resume_host(host);
+}
+#endif
 
+#ifdef CONFIG_PM
 static const struct dev_pm_ops sdhci_s3c_pmops = {
-        .suspend        = sdhci_s3c_suspend,
-        .resume         = sdhci_s3c_resume,
+        SET_SYSTEM_SLEEP_PM_OPS(sdhci_s3c_suspend, sdhci_s3c_resume)
+        SET_RUNTIME_PM_OPS(sdhci_s3c_runtime_suspend, sdhci_s3c_runtime_resume,
+                           NULL)
 };
 
 #define SDHCI_S3C_PMOPS (&sdhci_s3c_pmops)
@@ -647,9 +716,31 @@ static const struct dev_pm_ops sdhci_s3c_pmops = {
 #define SDHCI_S3C_PMOPS NULL
 #endif
 
+#if defined(CONFIG_CPU_EXYNOS4210) || defined(CONFIG_SOC_EXYNOS4212)
+static struct sdhci_s3c_drv_data exynos4_sdhci_drv_data = {
+        .sdhci_quirks = SDHCI_QUIRK_NONSTANDARD_CLOCK,
+};
+#define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)&exynos4_sdhci_drv_data)
+#else
+#define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)NULL)
+#endif
+
+static struct platform_device_id sdhci_s3c_driver_ids[] = {
+        {
+                .name           = "s3c-sdhci",
+                .driver_data    = (kernel_ulong_t)NULL,
+        }, {
+                .name           = "exynos4-sdhci",
+                .driver_data    = EXYNOS4_SDHCI_DRV_DATA,
+        },
+        { }
+};
+MODULE_DEVICE_TABLE(platform, sdhci_s3c_driver_ids);
+
 static struct platform_driver sdhci_s3c_driver = {
         .probe          = sdhci_s3c_probe,
         .remove         = __devexit_p(sdhci_s3c_remove),
+        .id_table       = sdhci_s3c_driver_ids,
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = "s3c-sdhci",
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index b7f8b33c5f19..6dfa82e03c7e 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -300,20 +300,15 @@ static int sdhci_resume(struct device *dev)
 
         return sdhci_resume_host(host);
 }
-
-const struct dev_pm_ops sdhci_pm_ops = {
-        .suspend        = sdhci_suspend,
-        .resume         = sdhci_resume,
-};
 #endif
 
+static SIMPLE_DEV_PM_OPS(sdhci_pm_ops, sdhci_suspend, sdhci_resume);
+
 static struct platform_driver sdhci_driver = {
         .driver = {
                 .name   = "sdhci",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
                 .pm     = &sdhci_pm_ops,
-#endif
         },
         .probe          = sdhci_probe,
         .remove         = __devexit_p(sdhci_remove),
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index 78a36eba4df0..53b26502f6e2 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -19,11 +19,11 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/of_gpio.h>
 #include <linux/gpio.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
-#include <linux/module.h>
 
 #include <asm/gpio.h>
 
@@ -32,6 +32,19 @@
 
 #include "sdhci-pltfm.h"
 
+#define NVQUIRK_FORCE_SDHCI_SPEC_200    BIT(0)
+#define NVQUIRK_ENABLE_BLOCK_GAP_DET    BIT(1)
+
+struct sdhci_tegra_soc_data {
+        struct sdhci_pltfm_data *pdata;
+        u32 nvquirks;
+};
+
+struct sdhci_tegra {
+        const struct tegra_sdhci_platform_data *plat;
+        const struct sdhci_tegra_soc_data *soc_data;
+};
+
 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
 {
         u32 val;
@@ -47,7 +60,12 @@ static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
 
 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
 {
-        if (unlikely(reg == SDHCI_HOST_VERSION)) {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_tegra *tegra_host = pltfm_host->priv;
+        const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
+
+        if (unlikely((soc_data->nvquirks & NVQUIRK_FORCE_SDHCI_SPEC_200) &&
+                        (reg == SDHCI_HOST_VERSION))) {
                 /* Erratum: Version register is invalid in HW. */
                 return SDHCI_SPEC_200;
         }
@@ -57,6 +75,10 @@ static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
 
 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
 {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_tegra *tegra_host = pltfm_host->priv;
+        const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
+
         /* Seems like we're getting spurious timeout and crc errors, so
          * disable signalling of them. In case of real errors software
          * timers should take care of eventually detecting them.
@@ -66,7 +88,8 @@ static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
 
         writel(val, host->ioaddr + reg);
 
-        if (unlikely(reg == SDHCI_INT_ENABLE)) {
+        if (unlikely((soc_data->nvquirks & NVQUIRK_ENABLE_BLOCK_GAP_DET) &&
+                        (reg == SDHCI_INT_ENABLE))) {
                 /* Erratum: Must enable block gap interrupt detection */
                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
                 if (val & SDHCI_INT_CARD_INT)
@@ -77,10 +100,11 @@ static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
         }
 }
 
-static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
+static unsigned int tegra_sdhci_get_ro(struct sdhci_host *host)
 {
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
-        struct tegra_sdhci_platform_data *plat = pltfm_host->priv;
+        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))
                 return -1;
@@ -99,7 +123,8 @@ static irqreturn_t carddetect_irq(int irq, void *data)
 static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct tegra_sdhci_platform_data *plat = pltfm_host->priv;
+        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);
@@ -125,7 +150,8 @@ static struct sdhci_ops tegra_sdhci_ops = {
         .platform_8bit_width = tegra_sdhci_8bit,
 };
 
-static struct sdhci_pltfm_data sdhci_tegra_pdata = {
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+static struct sdhci_pltfm_data sdhci_tegra20_pdata = {
         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                   SDHCI_QUIRK_SINGLE_POWER_WRITE |
                   SDHCI_QUIRK_NO_HISPD_BIT |
@@ -133,8 +159,35 @@ static struct sdhci_pltfm_data sdhci_tegra_pdata = {
         .ops  = &tegra_sdhci_ops,
 };
 
+static struct sdhci_tegra_soc_data soc_data_tegra20 = {
+        .pdata = &sdhci_tegra20_pdata,
+        .nvquirks = NVQUIRK_FORCE_SDHCI_SPEC_200 |
+                    NVQUIRK_ENABLE_BLOCK_GAP_DET,
+};
+#endif
+
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+static struct sdhci_pltfm_data sdhci_tegra30_pdata = {
+        .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
+                  SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
+                  SDHCI_QUIRK_SINGLE_POWER_WRITE |
+                  SDHCI_QUIRK_NO_HISPD_BIT |
+                  SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC,
+        .ops  = &tegra_sdhci_ops,
+};
+
+static struct sdhci_tegra_soc_data soc_data_tegra30 = {
+        .pdata = &sdhci_tegra30_pdata,
+};
+#endif
+
 static const struct of_device_id sdhci_tegra_dt_match[] __devinitdata = {
-        { .compatible = "nvidia,tegra20-sdhci", },
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+        { .compatible = "nvidia,tegra30-sdhci", .data = &soc_data_tegra30 },
+#endif
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+        { .compatible = "nvidia,tegra20-sdhci", .data = &soc_data_tegra20 },
+#endif
         {}
 };
 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
@@ -165,13 +218,22 @@ static struct tegra_sdhci_platform_data * __devinit sdhci_tegra_dt_parse_pdata(
 
 static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *match;
+        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_host *host;
+        struct sdhci_tegra *tegra_host;
         struct clk *clk;
         int rc;
 
-        host = sdhci_pltfm_init(pdev, &sdhci_tegra_pdata);
+        match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
+        if (match)
+                soc_data = match->data;
+        else
+                soc_data = &soc_data_tegra20;
+
+        host = sdhci_pltfm_init(pdev, soc_data->pdata);
         if (IS_ERR(host))
                 return PTR_ERR(host);
 
@@ -188,7 +250,17 @@ static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
                 goto err_no_plat;
         }
 
-        pltfm_host->priv = 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;
+        }
+
+        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");
@@ -284,7 +356,8 @@ static int __devexit 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 tegra_sdhci_platform_data *plat = pltfm_host->priv;
+        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);
@@ -327,5 +400,5 @@ static struct platform_driver sdhci_tegra_driver = {
 module_platform_driver(sdhci_tegra_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for Tegra");
-MODULE_AUTHOR(" Google, Inc.");
+MODULE_AUTHOR("Google, Inc.");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 8d66706824a6..ccefdebeff14 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -147,7 +147,7 @@ static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
         u32 present, irqs;
 
         if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
-            !mmc_card_is_removable(host->mmc))
+            (host->mmc->caps & MMC_CAP_NONREMOVABLE))
                 return;
 
         present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
@@ -2267,8 +2267,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
 {
         irqreturn_t result;
         struct sdhci_host *host = dev_id;
-        u32 intmask;
-        int cardint = 0;
+        u32 intmask, unexpected = 0;
+        int cardint = 0, max_loops = 16;
 
         spin_lock(&host->lock);
 
@@ -2286,6 +2286,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
                 goto out;
         }
 
+again:
         DBG("*** %s got interrupt: 0x%08x\n",
                 mmc_hostname(host->mmc), intmask);
 
@@ -2344,19 +2345,23 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
         intmask &= ~SDHCI_INT_CARD_INT;
 
         if (intmask) {
-                pr_err("%s: Unexpected interrupt 0x%08x.\n",
-                        mmc_hostname(host->mmc), intmask);
-                sdhci_dumpregs(host);
-
+                unexpected |= intmask;
                 sdhci_writel(host, intmask, SDHCI_INT_STATUS);
         }
 
         result = IRQ_HANDLED;
 
-        mmiowb();
+        intmask = sdhci_readl(host, SDHCI_INT_STATUS);
+        if (intmask && --max_loops)
+                goto again;
 out:
         spin_unlock(&host->lock);
 
+        if (unexpected) {
+                pr_err("%s: Unexpected interrupt 0x%08x.\n",
+                           mmc_hostname(host->mmc), unexpected);
+                sdhci_dumpregs(host);
+        }
         /*
          * We have to delay this as it calls back into the driver.
          */
@@ -2379,6 +2384,9 @@ int sdhci_suspend_host(struct sdhci_host *host)
         int ret;
         bool has_tuning_timer;
 
+        if (host->ops->platform_suspend)
+                host->ops->platform_suspend(host);
+
         sdhci_disable_card_detection(host);
 
         /* Disable tuning since we are suspending */
@@ -2423,12 +2431,24 @@ int sdhci_resume_host(struct sdhci_host *host)
         if (ret)
                 return ret;
 
-        sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
-        mmiowb();
+        if ((host->mmc->pm_flags & MMC_PM_KEEP_POWER) &&
+            (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) {
+                /* Card keeps power but host controller does not */
+                sdhci_init(host, 0);
+                host->pwr = 0;
+                host->clock = 0;
+                sdhci_do_set_ios(host, &host->mmc->ios);
+        } else {
+                sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
+                mmiowb();
+        }
 
         ret = mmc_resume_host(host->mmc);
         sdhci_enable_card_detection(host);
 
+        if (host->ops->platform_resume)
+                host->ops->platform_resume(host);
+
         /* Set the re-tuning expiration flag */
         if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
             (host->tuning_mode == SDHCI_TUNING_MODE_1))
@@ -2762,8 +2782,9 @@ int sdhci_add_host(struct sdhci_host *host)
             mmc_card_is_removable(mmc))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
-        /* UHS-I mode(s) supported by the host controller. */
-        if (host->version >= SDHCI_SPEC_300)
+        /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
+        if (caps[1] & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
+                       SDHCI_SUPPORT_DDR50))
                 mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;
 
         /* SDR104 supports also implies SDR50 support */
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index ad265b96b75b..f761f23d2a28 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -275,6 +275,8 @@ struct sdhci_ops {
         void    (*platform_reset_exit)(struct sdhci_host *host, u8 mask);
         int     (*set_uhs_signaling)(struct sdhci_host *host, unsigned int uhs);
         void    (*hw_reset)(struct sdhci_host *host);
+        void    (*platform_suspend)(struct sdhci_host *host);
+        void    (*platform_resume)(struct sdhci_host *host);
 };
 
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 352d4797865b..724b35e85a26 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -56,6 +56,7 @@
 #include <linux/mmc/sh_mmcif.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
+#include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
 #include <linux/spinlock.h>
 #include <linux/module.h>
@@ -285,7 +286,7 @@ static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
                          DMA_FROM_DEVICE);
         if (ret > 0) {
                 host->dma_active = true;
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                desc = dmaengine_prep_slave_sg(chan, sg, ret,
                         DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         }
 
@@ -334,7 +335,7 @@ static void sh_mmcif_start_dma_tx(struct sh_mmcif_host *host)
                          DMA_TO_DEVICE);
         if (ret > 0) {
                 host->dma_active = true;
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                desc = dmaengine_prep_slave_sg(chan, sg, ret,
                         DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         }
 
@@ -453,7 +454,8 @@ static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_SUP_PCLK);
         else
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR &
-                                ((fls(host->clk / clk) - 1) << 16));
+                                ((fls(DIV_ROUND_UP(host->clk,
+                                                   clk) - 1) - 1) << 16));
 
         sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
 }
@@ -745,7 +747,6 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
         case MMC_SET_WRITE_PROT:
         case MMC_CLR_WRITE_PROT:
         case MMC_ERASE:
-        case MMC_GEN_CMD:
                 tmp |= CMD_SET_RBSY;
                 break;
         }
@@ -828,7 +829,6 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
         case MMC_SET_WRITE_PROT:
         case MMC_CLR_WRITE_PROT:
         case MMC_ERASE:
-        case MMC_GEN_CMD:
                 mask = MASK_START_CMD | MASK_MRBSYE;
                 break;
         default:
@@ -1298,14 +1298,8 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         spin_lock_init(&host->lock);
 
         mmc->ops = &sh_mmcif_ops;
-        mmc->f_max = host->clk;
-        /* close to 400KHz */
-        if (mmc->f_max < 51200000)
-                mmc->f_min = mmc->f_max / 128;
-        else if (mmc->f_max < 102400000)
-                mmc->f_min = mmc->f_max / 256;
-        else
-                mmc->f_min = mmc->f_max / 512;
+        mmc->f_max = host->clk / 2;
+        mmc->f_min = host->clk / 512;
         if (pd->ocr)
                 mmc->ocr_avail = pd->ocr;
         mmc->caps = MMC_CAP_MMC_HIGHSPEED;
@@ -1346,6 +1340,8 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto clean_up5;
 
+        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
+
         dev_info(&pdev->dev, "driver version %s\n", DRIVER_VERSION);
         dev_dbg(&pdev->dev, "chip ver H'%04x\n",
                 sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
@@ -1376,6 +1372,8 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
         host->dying = true;
         pm_runtime_get_sync(&pdev->dev);
 
+        dev_pm_qos_hide_latency_limit(&pdev->dev);
+
         mmc_remove_host(host->mmc);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 58da3c44acc5..934b68e9efc3 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -90,6 +90,15 @@ static int sh_mobile_sdhi_write16_hook(struct tmio_mmc_host *host, int addr)
         return 0;
 }
 
+static void sh_mobile_sdhi_cd_wakeup(const struct platform_device *pdev)
+{
+        mmc_detect_change(dev_get_drvdata(&pdev->dev), msecs_to_jiffies(100));
+}
+
+static const struct sh_mobile_sdhi_ops sdhi_ops = {
+        .cd_wakeup = sh_mobile_sdhi_cd_wakeup,
+};
+
 static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
 {
         struct sh_mobile_sdhi *priv;
@@ -109,6 +118,12 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data = &priv->mmc_data;
         p->pdata = mmc_data;
 
+        if (p->init) {
+                ret = p->init(pdev, &sdhi_ops);
+                if (ret)
+                        goto einit;
+        }
+
         snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
         priv->clk = clk_get(&pdev->dev, clk_name);
         if (IS_ERR(priv->clk)) {
@@ -117,8 +132,6 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                 goto eclkget;
         }
 
-        clk_enable(priv->clk);
-
         mmc_data->hclk = clk_get_rate(priv->clk);
         mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
         mmc_data->get_cd = sh_mobile_sdhi_get_cd;
@@ -129,6 +142,7 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                         mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
+                mmc_data->cd_gpio = p->cd_gpio;
 
                 if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
                         priv->param_tx.slave_id = p->dma_slave_tx;
@@ -211,7 +225,7 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
 
         dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n",
                  mmc_hostname(host->mmc), (unsigned long)
-                 (platform_get_resource(pdev,IORESOURCE_MEM, 0)->start),
+                 (platform_get_resource(pdev, IORESOURCE_MEM, 0)->start),
                  mmc_data->hclk / 1000000);
 
         return ret;
@@ -232,9 +246,11 @@ eirq_sdio:
 eirq_card_detect:
         tmio_mmc_host_remove(host);
 eprobe:
-        clk_disable(priv->clk);
         clk_put(priv->clk);
 eclkget:
+        if (p->cleanup)
+                p->cleanup(pdev);
+einit:
         kfree(priv);
         return ret;
 }
@@ -258,8 +274,11 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
                 free_irq(irq, host);
         }
 
-        clk_disable(priv->clk);
         clk_put(priv->clk);
+
+        if (p->cleanup)
+                p->cleanup(pdev);
+
         kfree(priv);
 
         return 0;
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index f96c536d130a..d857f5c6e7d9 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -47,16 +47,14 @@ struct tmio_mmc_host {
         struct mmc_request      *mrq;
         struct mmc_data         *data;
         struct mmc_host         *mmc;
-        unsigned int            sdio_irq_enabled;
+
+        /* Controller power state */
+        bool                    power;
 
         /* Callbacks for clock / power control */
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
 
-        int                     pm_error;
-        /* recognise system-wide suspend in runtime PM methods */
-        bool                    pm_global;
-
         /* pio related stuff */
         struct scatterlist      *sg_ptr;
         struct scatterlist      *sg_orig;
@@ -86,6 +84,7 @@ struct tmio_mmc_host {
         spinlock_t              lock;           /* protect host private data */
         unsigned long           last_req_ts;
         struct mutex            ios_lock;       /* protect set_ios() context */
+        bool                    native_hotplug;
 };
 
 int tmio_mmc_host_probe(struct tmio_mmc_host **host,
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
index 8253ec12003e..fff928604859 100644
--- a/drivers/mmc/host/tmio_mmc_dma.c
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -88,7 +88,7 @@ static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
 
         ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
         if (ret > 0)
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                desc = dmaengine_prep_slave_sg(chan, sg, ret,
                         DMA_DEV_TO_MEM, DMA_CTRL_ACK);
 
         if (desc) {
@@ -169,7 +169,7 @@ static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
 
         ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
         if (ret > 0)
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                desc = dmaengine_prep_slave_sg(chan, sg, ret,
                         DMA_MEM_TO_DEV, DMA_CTRL_ACK);
 
         if (desc) {
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 5f9ad74fbf80..9a7996ade58e 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -34,11 +34,13 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/mfd/tmio.h>
+#include <linux/mmc/cd-gpio.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/tmio.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
+#include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
 #include <linux/scatterlist.h>
 #include <linux/spinlock.h>
@@ -126,7 +128,6 @@ static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
         struct tmio_mmc_host *host = mmc_priv(mmc);
 
         if (enable) {
-                host->sdio_irq_enabled = 1;
                 host->sdio_irq_mask = TMIO_SDIO_MASK_ALL &
                                         ~TMIO_SDIO_STAT_IOIRQ;
                 sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
@@ -135,7 +136,6 @@ static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
                 host->sdio_irq_mask = TMIO_SDIO_MASK_ALL;
                 sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
                 sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0000);
-                host->sdio_irq_enabled = 0;
         }
 }
 
@@ -303,6 +303,7 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
 {
         struct mmc_data *data = host->data;
         int c = cmd->opcode;
+        u32 irq_mask = TMIO_MASK_CMD;
 
         /* Command 12 is handled by hardware */
         if (cmd->opcode == 12 && !cmd->arg) {
@@ -338,7 +339,9 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
                         c |= TRANSFER_READ;
         }
 
-        tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_CMD);
+        if (!host->native_hotplug)
+                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
+        tmio_mmc_enable_mmc_irqs(host, irq_mask);
 
         /* Fire off the command */
         sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
@@ -757,7 +760,7 @@ fail:
 static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct tmio_mmc_data *pdata = host->pdata;
+        struct device *dev = &host->pdev->dev;
         unsigned long flags;
 
         mutex_lock(&host->ios_lock);
@@ -765,13 +768,13 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_lock_irqsave(&host->lock, flags);
         if (host->mrq) {
                 if (IS_ERR(host->mrq)) {
-                        dev_dbg(&host->pdev->dev,
+                        dev_dbg(dev,
                                 "%s.%d: concurrent .set_ios(), clk %u, mode %u\n",
                                 current->comm, task_pid_nr(current),
                                 ios->clock, ios->power_mode);
                         host->mrq = ERR_PTR(-EINTR);
                 } else {
-                        dev_dbg(&host->pdev->dev,
+                        dev_dbg(dev,
                                 "%s.%d: CMD%u active since %lu, now %lu!\n",
                                 current->comm, task_pid_nr(current),
                                 host->mrq->cmd->opcode, host->last_req_ts, jiffies);
@@ -787,13 +790,15 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_unlock_irqrestore(&host->lock, flags);
 
         /*
-         * pdata->power == false only if COLD_CD is available, otherwise only
-         * in short time intervals during probing or resuming
+         * host->power toggles between false and true in both cases - either
+         * or not the controller can be runtime-suspended during inactivity.
+         * But if the controller has to be kept on, the runtime-pm usage_count
+         * is kept positive, so no suspending actually takes place.
          */
         if (ios->power_mode == MMC_POWER_ON && ios->clock) {
-                if (!pdata->power) {
-                        pm_runtime_get_sync(&host->pdev->dev);
-                        pdata->power = true;
+                if (!host->power) {
+                        pm_runtime_get_sync(dev);
+                        host->power = true;
                 }
                 tmio_mmc_set_clock(host, ios->clock);
                 /* power up SD bus */
@@ -804,9 +809,9 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         } else if (ios->power_mode != MMC_POWER_UP) {
                 if (host->set_pwr && ios->power_mode == MMC_POWER_OFF)
                         host->set_pwr(host->pdev, 0);
-                if (pdata->power) {
-                        pdata->power = false;
-                        pm_runtime_put(&host->pdev->dev);
+                if (host->power) {
+                        host->power = false;
+                        pm_runtime_put(dev);
                 }
                 tmio_mmc_clk_stop(host);
         }
@@ -912,7 +917,11 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         else
                 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 
-        pdata->power = false;
+        _host->native_hotplug = !(pdata->flags & TMIO_MMC_USE_GPIO_CD ||
+                                  mmc->caps & MMC_CAP_NEEDS_POLL ||
+                                  mmc->caps & MMC_CAP_NONREMOVABLE);
+
+        _host->power = false;
         pm_runtime_enable(&pdev->dev);
         ret = pm_runtime_resume(&pdev->dev);
         if (ret < 0)
@@ -925,14 +934,13 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
          *  3) a worker thread polls the sdhi - indicated by MMC_CAP_NEEDS_POLL
          *  4) the medium is non-removable - indicated by MMC_CAP_NONREMOVABLE
          *
-         *  While we increment the rtpm counter for all scenarios when the mmc
-         *  core activates us by calling an appropriate set_ios(), we must
+         *  While we increment the runtime PM counter for all scenarios when
+         *  the mmc core activates us by calling an appropriate set_ios(), we
+         *  must additionally ensure that in case 2) the tmio mmc hardware stays
          *  additionally ensure that in case 2) the tmio mmc hardware stays
          *  powered on during runtime for the card detection to work.
          */
-        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD
-                || mmc->caps & MMC_CAP_NEEDS_POLL
-                || mmc->caps & MMC_CAP_NONREMOVABLE))
+        if (_host->native_hotplug)
                 pm_runtime_get_noresume(&pdev->dev);
 
         tmio_mmc_clk_stop(_host);
@@ -955,14 +963,26 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         mmc_add_host(mmc);
 
+        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
+
         /* Unmask the IRQs we want to know about */
         if (!_host->chan_rx)
                 irq_mask |= TMIO_MASK_READOP;
         if (!_host->chan_tx)
                 irq_mask |= TMIO_MASK_WRITEOP;
+        if (!_host->native_hotplug)
+                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
 
         tmio_mmc_enable_mmc_irqs(_host, irq_mask);
 
+        if (pdata->flags & TMIO_MMC_USE_GPIO_CD) {
+                ret = mmc_cd_gpio_request(mmc, pdata->cd_gpio);
+                if (ret < 0) {
+                        tmio_mmc_host_remove(_host);
+                        return ret;
+                }
+        }
+
         *host = _host;
 
         return 0;
@@ -980,20 +1000,22 @@ 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;
 
-        /*
-         * We don't have to manipulate pdata->power here: if there is a card in
-         * the slot, the runtime PM is active and our .runtime_resume() will not
-         * be run. If there is no card in the slot and the platform can suspend
-         * the controller, the runtime PM is suspended and pdata->power == false,
-         * so, our .runtime_resume() will not try to detect a card in the slot.
-         */
-        if (host->pdata->flags & TMIO_MMC_HAS_COLD_CD
-                || host->mmc->caps & MMC_CAP_NEEDS_POLL
-                || host->mmc->caps & MMC_CAP_NONREMOVABLE)
+        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_cd_gpio_free(mmc);
+
+        if (!host->native_hotplug)
                 pm_runtime_get_sync(&pdev->dev);
 
-        mmc_remove_host(host->mmc);
+        dev_pm_qos_hide_latency_limit(&pdev->dev);
+
+        mmc_remove_host(mmc);
         cancel_work_sync(&host->done);
         cancel_delayed_work_sync(&host->delayed_reset_work);
         tmio_mmc_release_dma(host);
@@ -1002,7 +1024,7 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
         pm_runtime_disable(&pdev->dev);
 
         iounmap(host->ctl);
-        mmc_free_host(host->mmc);
+        mmc_free_host(mmc);
 }
 EXPORT_SYMBOL(tmio_mmc_host_remove);
 
@@ -1016,8 +1038,6 @@ int tmio_mmc_host_suspend(struct device *dev)
         if (!ret)
                 tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_ALL);
 
-        host->pm_error = pm_runtime_put_sync(dev);
-
         return ret;
 }
 EXPORT_SYMBOL(tmio_mmc_host_suspend);
@@ -1027,20 +1047,10 @@ int tmio_mmc_host_resume(struct device *dev)
         struct mmc_host *mmc = dev_get_drvdata(dev);
         struct tmio_mmc_host *host = mmc_priv(mmc);
 
-        /* The MMC core will perform the complete set up */
-        host->pdata->power = false;
-
-        host->pm_global = true;
-        if (!host->pm_error)
-                pm_runtime_get_sync(dev);
-
-        if (host->pm_global) {
-                /* Runtime PM resume callback didn't run */
-                tmio_mmc_reset(host);
-                tmio_mmc_enable_dma(host, true);
-                host->pm_global = false;
-        }
+        tmio_mmc_reset(host);
+        tmio_mmc_enable_dma(host, true);
 
+        /* The MMC core will perform the complete set up */
         return mmc_resume_host(mmc);
 }
 EXPORT_SYMBOL(tmio_mmc_host_resume);
@@ -1057,19 +1067,10 @@ int tmio_mmc_host_runtime_resume(struct device *dev)
 {
         struct mmc_host *mmc = dev_get_drvdata(dev);
         struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct tmio_mmc_data *pdata = host->pdata;
 
         tmio_mmc_reset(host);
         tmio_mmc_enable_dma(host, true);
 
-        if (pdata->power) {
-                /* Only entered after a card-insert interrupt */
-                if (!mmc->card)
-                        tmio_mmc_set_ios(mmc, &mmc->ios);
-                mmc_detect_change(mmc, msecs_to_jiffies(100));
-        }
-        host->pm_global = false;
-
         return 0;
 }
 EXPORT_SYMBOL(tmio_mmc_host_runtime_resume);