54 files changed, 6371 insertions, 2199 deletions

diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
index 3b1f783bf92..ebb4afe6c70 100644
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -50,6 +50,15 @@ config MMC_BLOCK_BOUNCE
 
           If unsure, say Y here.
 
+config MMC_BLOCK_DEFERRED_RESUME
+        bool "Deferr MMC layer resume until I/O is requested"
+        depends on MMC_BLOCK
+        default n
+        help
+          Say Y here to enable deferred MMC resume until I/O
+          is requested. This will reduce overall resume latency and
+          save power when theres an SD card inserted but not being used.
+
 config SDIO_UART
         tristate "SDIO UART/GPS class support"
         help
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index f85e4222455..2bd93d7a517 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -59,6 +59,8 @@ MODULE_ALIAS("mmc:block");
 #define INAND_CMD38_ARG_SECTRIM1 0x81
 #define INAND_CMD38_ARG_SECTRIM2 0x88
 
+#define MMC_CMD_RETRIES         10
+
 static DEFINE_MUTEX(block_mutex);
 
 /*
@@ -106,6 +108,16 @@ struct mmc_blk_data {
 
 static DEFINE_MUTEX(open_lock);
 
+enum mmc_blk_status {
+        MMC_BLK_SUCCESS = 0,
+        MMC_BLK_PARTIAL,
+        MMC_BLK_RETRY,
+        MMC_BLK_RETRY_SINGLE,
+        MMC_BLK_DATA_ERR,
+        MMC_BLK_CMD_ERR,
+        MMC_BLK_ABORT,
+};
+
 module_param(perdev_minors, int, 0444);
 MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device");
 
@@ -126,11 +138,7 @@ static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
 
 static inline int mmc_get_devidx(struct gendisk *disk)
 {
-        int devmaj = MAJOR(disk_devt(disk));
-        int devidx = MINOR(disk_devt(disk)) / perdev_minors;
-
-        if (!devmaj)
-                devidx = disk->first_minor / perdev_minors;
+        int devidx = disk->first_minor / perdev_minors;
         return devidx;
 }
 
@@ -427,14 +435,6 @@ static const struct block_device_operations mmc_bdops = {
 #endif
 };
 
-struct mmc_blk_request {
-        struct mmc_request      mrq;
-        struct mmc_command      sbc;
-        struct mmc_command      cmd;
-        struct mmc_command      stop;
-        struct mmc_data         data;
-};
-
 static inline int mmc_blk_part_switch(struct mmc_card *card,
                                       struct mmc_blk_data *md)
 {
@@ -525,7 +525,20 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         return result;
 }
 
-static u32 get_card_status(struct mmc_card *card, struct request *req)
+static int send_stop(struct mmc_card *card, u32 *status)
+{
+        struct mmc_command cmd = {0};
+        int err;
+
+        cmd.opcode = MMC_STOP_TRANSMISSION;
+        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        err = mmc_wait_for_cmd(card->host, &cmd, 5);
+        if (err == 0)
+                *status = cmd.resp[0];
+        return err;
+}
+
+static int get_card_status(struct mmc_card *card, u32 *status, int retries)
 {
         struct mmc_command cmd = {0};
         int err;
@@ -534,11 +547,145 @@ static u32 get_card_status(struct mmc_card *card, struct request *req)
         if (!mmc_host_is_spi(card->host))
                 cmd.arg = card->rca << 16;
         cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
-        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        err = mmc_wait_for_cmd(card->host, &cmd, retries);
+        if (err == 0)
+                *status = cmd.resp[0];
+        return err;
+}
+
+#define ERR_RETRY       2
+#define ERR_ABORT       1
+#define ERR_CONTINUE    0
+
+static int mmc_blk_cmd_error(struct request *req, const char *name, int error,
+        bool status_valid, u32 status)
+{
+        switch (error) {
+        case -EILSEQ:
+                /* response crc error, retry the r/w cmd */
+                pr_err("%s: %s sending %s command, card status %#x\n",
+                        req->rq_disk->disk_name, "response CRC error",
+                        name, status);
+                return ERR_RETRY;
+
+        case -ETIMEDOUT:
+                pr_err("%s: %s sending %s command, card status %#x\n",
+                        req->rq_disk->disk_name, "timed out", name, status);
+
+                /* If the status cmd initially failed, retry the r/w cmd */
+                if (!status_valid) {
+                        pr_err("%s: status not valid, retrying timeout\n", req->rq_disk->disk_name);
+                        return ERR_RETRY;
+                }
+                /*
+                 * If it was a r/w cmd crc error, or illegal command
+                 * (eg, issued in wrong state) then retry - we should
+                 * have corrected the state problem above.
+                 */
+                if (status & (R1_COM_CRC_ERROR | R1_ILLEGAL_COMMAND)) {
+                        pr_err("%s: command error, retrying timeout\n", req->rq_disk->disk_name);
+                        return ERR_RETRY;
+                }
+
+                /* Otherwise abort the command */
+                pr_err("%s: not retrying timeout\n", req->rq_disk->disk_name);
+                return ERR_ABORT;
+
+        default:
+                /* We don't understand the error code the driver gave us */
+                pr_err("%s: unknown error %d sending read/write command, card status %#x\n",
+                       req->rq_disk->disk_name, error, status);
+                return ERR_ABORT;
+        }
+}
+
+/*
+ * Initial r/w and stop cmd error recovery.
+ * We don't know whether the card received the r/w cmd or not, so try to
+ * restore things back to a sane state.  Essentially, we do this as follows:
+ * - Obtain card status.  If the first attempt to obtain card status fails,
+ *   the status word will reflect the failed status cmd, not the failed
+ *   r/w cmd.  If we fail to obtain card status, it suggests we can no
+ *   longer communicate with the card.
+ * - Check the card state.  If the card received the cmd but there was a
+ *   transient problem with the response, it might still be in a data transfer
+ *   mode.  Try to send it a stop command.  If this fails, we can't recover.
+ * - If the r/w cmd failed due to a response CRC error, it was probably
+ *   transient, so retry the cmd.
+ * - If the r/w cmd timed out, but we didn't get the r/w cmd status, retry.
+ * - If the r/w cmd timed out, and the r/w cmd failed due to CRC error or
+ *   illegal cmd, retry.
+ * Otherwise we don't understand what happened, so abort.
+ */
+static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
+        struct mmc_blk_request *brq)
+{
+        bool prev_cmd_status_valid = true;
+        u32 status, stop_status = 0;
+        int err, retry;
+
+        /*
+         * Try to get card status which indicates both the card state
+         * and why there was no response.  If the first attempt fails,
+         * we can't be sure the returned status is for the r/w command.
+         */
+        for (retry = 2; retry >= 0; retry--) {
+                err = get_card_status(card, &status, 0);
+                if (!err)
+                        break;
+
+                prev_cmd_status_valid = false;
+                pr_err("%s: error %d sending status command, %sing\n",
+                       req->rq_disk->disk_name, err, retry ? "retry" : "abort");
+        }
+
+        /* We couldn't get a response from the card.  Give up. */
         if (err)
-                printk(KERN_ERR "%s: error %d sending status command",
-                       req->rq_disk->disk_name, err);
-        return cmd.resp[0];
+                return ERR_ABORT;
+
+        /*
+         * Check the current card state.  If it is in some data transfer
+         * mode, tell it to stop (and hopefully transition back to TRAN.)
+         */
+        if (R1_CURRENT_STATE(status) == R1_STATE_DATA ||
+            R1_CURRENT_STATE(status) == R1_STATE_RCV) {
+                err = send_stop(card, &stop_status);
+                if (err)
+                        pr_err("%s: error %d sending stop command\n",
+                               req->rq_disk->disk_name, err);
+
+                /*
+                 * If the stop cmd also timed out, the card is probably
+                 * not present, so abort.  Other errors are bad news too.
+                 */
+                if (err)
+                        return ERR_ABORT;
+        }
+
+        /* Check for set block count errors */
+        if (brq->sbc.error)
+                return mmc_blk_cmd_error(req, "SET_BLOCK_COUNT", brq->sbc.error,
+                                prev_cmd_status_valid, status);
+
+        /* Check for r/w command errors */
+        if (brq->cmd.error)
+                return mmc_blk_cmd_error(req, "r/w cmd", brq->cmd.error,
+                                prev_cmd_status_valid, status);
+
+        /* Now for stop errors.  These aren't fatal to the transfer. */
+        pr_err("%s: error %d sending stop command, original cmd response %#x, card status %#x\n",
+               req->rq_disk->disk_name, brq->stop.error,
+               brq->cmd.resp[0], status);
+
+        /*
+         * Subsitute in our own stop status as this will give the error
+         * state which happened during the execution of the r/w command.
+         */
+        if (stop_status) {
+                brq->stop.resp[0] = stop_status;
+                brq->stop.error = 0;
+        }
+        return ERR_CONTINUE;
 }
 
 static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
@@ -669,242 +816,333 @@ static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq,
         }
 }
 
-static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
+#define CMD_ERRORS                                                      \
+        (R1_OUT_OF_RANGE |      /* Command argument out of range */     \
+         R1_ADDRESS_ERROR |     /* Misaligned address */                \
+         R1_BLOCK_LEN_ERROR |   /* Transferred block length incorrect */\
+         R1_WP_VIOLATION |      /* Tried to write to protected block */ \
+         R1_CC_ERROR |          /* Card controller error */             \
+         R1_ERROR)              /* General/unknown error */
+
+static int mmc_blk_err_check(struct mmc_card *card,
+                             struct mmc_async_req *areq)
 {
-        struct mmc_blk_data *md = mq->data;
-        struct mmc_card *card = md->queue.card;
-        struct mmc_blk_request brq;
-        int ret = 1, disable_multi = 0;
+        enum mmc_blk_status ret = MMC_BLK_SUCCESS;
+        struct mmc_queue_req *mq_mrq = container_of(areq, struct mmc_queue_req,
+                                                    mmc_active);
+        struct mmc_blk_request *brq = &mq_mrq->brq;
+        struct request *req = mq_mrq->req;
 
         /*
-         * Reliable writes are used to implement Forced Unit Access and
-         * REQ_META accesses, and are supported only on MMCs.
+         * sbc.error indicates a problem with the set block count
+         * command.  No data will have been transferred.
+         *
+         * cmd.error indicates a problem with the r/w command.  No
+         * data will have been transferred.
+         *
+         * stop.error indicates a problem with the stop command.  Data
+         * may have been transferred, or may still be transferring.
          */
-        bool do_rel_wr = ((req->cmd_flags & REQ_FUA) ||
-                          (req->cmd_flags & REQ_META)) &&
-                (rq_data_dir(req) == WRITE) &&
-                (md->flags & MMC_BLK_REL_WR);
+        if (brq->sbc.error || brq->cmd.error || brq->stop.error) {
+                switch (mmc_blk_cmd_recovery(card, req, brq)) {
+                case ERR_RETRY:
+                        return MMC_BLK_RETRY;
+                case ERR_ABORT:
+                        return MMC_BLK_ABORT;
+                case ERR_CONTINUE:
+                        break;
+                }
+        }
 
-        do {
-                struct mmc_command cmd = {0};
-                u32 readcmd, writecmd, status = 0;
-
-                memset(&brq, 0, sizeof(struct mmc_blk_request));
-                brq.mrq.cmd = &brq.cmd;
-                brq.mrq.data = &brq.data;
-
-                brq.cmd.arg = blk_rq_pos(req);
-                if (!mmc_card_blockaddr(card))
-                        brq.cmd.arg <<= 9;
-                brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
-                brq.data.blksz = 512;
-                brq.stop.opcode = MMC_STOP_TRANSMISSION;
-                brq.stop.arg = 0;
-                brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-                brq.data.blocks = blk_rq_sectors(req);
+        /*
+         * Check for errors relating to the execution of the
+         * initial command - such as address errors.  No data
+         * has been transferred.
+         */
+        if (brq->cmd.resp[0] & CMD_ERRORS) {
+                pr_err("%s: r/w command failed, status = %#x\n",
+                       req->rq_disk->disk_name, brq->cmd.resp[0]);
+                return MMC_BLK_ABORT;
+        }
 
-                /*
-                 * The block layer doesn't support all sector count
-                 * restrictions, so we need to be prepared for too big
-                 * requests.
-                 */
-                if (brq.data.blocks > card->host->max_blk_count)
-                        brq.data.blocks = card->host->max_blk_count;
+        /*
+         * Everything else is either success, or a data error of some
+         * kind.  If it was a write, we may have transitioned to
+         * program mode, which we have to wait for it to complete.
+         */
+        if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
+                u32 status;
+                do {
+                        int err = get_card_status(card, &status, 5);
+                        if (err) {
+                                printk(KERN_ERR "%s: error %d requesting status\n",
+                                       req->rq_disk->disk_name, err);
+                                return MMC_BLK_CMD_ERR;
+                        }
+                        /*
+                         * Some cards mishandle the status bits,
+                         * so make sure to check both the busy
+                         * indication and the card state.
+                         */
+                } while (!(status & R1_READY_FOR_DATA) ||
+                         (R1_CURRENT_STATE(status) == R1_STATE_PRG));
+        }
 
-                /*
-                 * After a read error, we redo the request one sector at a time
-                 * in order to accurately determine which sectors can be read
-                 * successfully.
-                 */
-                if (disable_multi && brq.data.blocks > 1)
-                        brq.data.blocks = 1;
+        if (brq->data.error) {
+                pr_err("%s: error %d transferring data, sector %u, nr %u, cmd response %#x, card status %#x\n",
+                       req->rq_disk->disk_name, brq->data.error,
+                       (unsigned)blk_rq_pos(req),
+                       (unsigned)blk_rq_sectors(req),
+                       brq->cmd.resp[0], brq->stop.resp[0]);
 
-                if (brq.data.blocks > 1 || do_rel_wr) {
-                        /* SPI multiblock writes terminate using a special
-                         * token, not a STOP_TRANSMISSION request.
-                         */
-                        if (!mmc_host_is_spi(card->host) ||
-                            rq_data_dir(req) == READ)
-                                brq.mrq.stop = &brq.stop;
-                        readcmd = MMC_READ_MULTIPLE_BLOCK;
-                        writecmd = MMC_WRITE_MULTIPLE_BLOCK;
-                } else {
-                        brq.mrq.stop = NULL;
-                        readcmd = MMC_READ_SINGLE_BLOCK;
-                        writecmd = MMC_WRITE_BLOCK;
-                }
                 if (rq_data_dir(req) == READ) {
-                        brq.cmd.opcode = readcmd;
-                        brq.data.flags |= MMC_DATA_READ;
+                        if (brq->data.blocks > 1) {
+                                /* Redo read one sector at a time */
+                                pr_warning("%s: retrying using single block read\n",
+                                           req->rq_disk->disk_name);
+                                return MMC_BLK_RETRY_SINGLE;
+                        }
+                        return MMC_BLK_DATA_ERR;
                 } else {
-                        brq.cmd.opcode = writecmd;
-                        brq.data.flags |= MMC_DATA_WRITE;
+                        return MMC_BLK_CMD_ERR;
                 }
+        }
 
-                if (do_rel_wr)
-                        mmc_apply_rel_rw(&brq, card, req);
+        if (ret == MMC_BLK_SUCCESS &&
+            blk_rq_bytes(req) != brq->data.bytes_xfered)
+                ret = MMC_BLK_PARTIAL;
 
-                /*
-                 * 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,
-                 * and avoid the final CMD12, as on an error condition
-                 * CMD12 (stop) needs to be sent anyway. This, coupled
-                 * with Auto-CMD23 enhancements provided by some
-                 * hosts, means that the complexity of dealing
-                 * with this is best left to the host. If CMD23 is
-                 * supported by card and host, we'll fill sbc in and let
-                 * the host deal with handling it correctly. This means
-                 * that for hosts that don't expose MMC_CAP_CMD23, no
-                 * change of behavior will be observed.
-                 *
-                 * N.B: Some MMC cards experience perf degradation.
-                 * We'll avoid using CMD23-bounded multiblock writes for
-                 * these, while retaining features like reliable writes.
-                 */
+        return ret;
+}
 
-                if ((md->flags & MMC_BLK_CMD23) &&
-                    mmc_op_multi(brq.cmd.opcode) &&
-                    (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23))) {
-                        brq.sbc.opcode = MMC_SET_BLOCK_COUNT;
-                        brq.sbc.arg = brq.data.blocks |
-                                (do_rel_wr ? (1 << 31) : 0);
-                        brq.sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
-                        brq.mrq.sbc = &brq.sbc;
-                }
+static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
+                               struct mmc_card *card,
+                               int disable_multi,
+                               struct mmc_queue *mq)
+{
+        u32 readcmd, writecmd;
+        struct mmc_blk_request *brq = &mqrq->brq;
+        struct request *req = mqrq->req;
+        struct mmc_blk_data *md = mq->data;
 
-                mmc_set_data_timeout(&brq.data, card);
+        /*
+         * Reliable writes are used to implement Forced Unit Access and
+         * REQ_META accesses, and are supported only on MMCs.
+         *
+         * XXX: this really needs a good explanation of why REQ_META
+         * is treated special.
+         */
+        bool do_rel_wr = ((req->cmd_flags & REQ_FUA) ||
+                          (req->cmd_flags & REQ_META)) &&
+                (rq_data_dir(req) == WRITE) &&
+                (md->flags & MMC_BLK_REL_WR);
 
-                brq.data.sg = mq->sg;
-                brq.data.sg_len = mmc_queue_map_sg(mq);
+        memset(brq, 0, sizeof(struct mmc_blk_request));
+        brq->mrq.cmd = &brq->cmd;
+        brq->mrq.data = &brq->data;
+
+        brq->cmd.arg = blk_rq_pos(req);
+        if (!mmc_card_blockaddr(card))
+                brq->cmd.arg <<= 9;
+        brq->cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+        brq->cmd.retries = MMC_CMD_RETRIES;
+        brq->data.blksz = 512;
+        brq->stop.opcode = MMC_STOP_TRANSMISSION;
+        brq->stop.arg = 0;
+        brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        brq->data.blocks = blk_rq_sectors(req);
 
-                /*
-                 * Adjust the sg list so it is the same size as the
-                 * request.
+        /*
+         * The block layer doesn't support all sector count
+         * restrictions, so we need to be prepared for too big
+         * requests.
+         */
+        if (brq->data.blocks > card->host->max_blk_count)
+                brq->data.blocks = card->host->max_blk_count;
+
+        /*
+         * After a read error, we redo the request one sector at a time
+         * in order to accurately determine which sectors can be read
+         * successfully.
+         */
+        if (disable_multi && brq->data.blocks > 1)
+                brq->data.blocks = 1;
+
+        if (brq->data.blocks > 1 || do_rel_wr) {
+                /* SPI multiblock writes terminate using a special
+                 * token, not a STOP_TRANSMISSION request.
                  */
-                if (brq.data.blocks != blk_rq_sectors(req)) {
-                        int i, data_size = brq.data.blocks << 9;
-                        struct scatterlist *sg;
-
-                        for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) {
-                                data_size -= sg->length;
-                                if (data_size <= 0) {
-                                        sg->length += data_size;
-                                        i++;
-                                        break;
-                                }
-                        }
-                        brq.data.sg_len = i;
-                }
+                if (!mmc_host_is_spi(card->host) ||
+                    rq_data_dir(req) == READ)
+                        brq->mrq.stop = &brq->stop;
+                readcmd = MMC_READ_MULTIPLE_BLOCK;
+                writecmd = MMC_WRITE_MULTIPLE_BLOCK;
+        } else {
+                brq->mrq.stop = NULL;
+                readcmd = MMC_READ_SINGLE_BLOCK;
+                writecmd = MMC_WRITE_BLOCK;
+        }
+        if (rq_data_dir(req) == READ) {
+                brq->cmd.opcode = readcmd;
+                brq->data.flags |= MMC_DATA_READ;
+        } else {
+                brq->cmd.opcode = writecmd;
+                brq->data.flags |= MMC_DATA_WRITE;
+        }
 
-                mmc_queue_bounce_pre(mq);
+        if (do_rel_wr)
+                mmc_apply_rel_rw(brq, card, req);
 
-                mmc_wait_for_req(card->host, &brq.mrq);
+        /*
+         * 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,
+         * and avoid the final CMD12, as on an error condition
+         * CMD12 (stop) needs to be sent anyway. This, coupled
+         * with Auto-CMD23 enhancements provided by some
+         * hosts, means that the complexity of dealing
+         * with this is best left to the host. If CMD23 is
+         * supported by card and host, we'll fill sbc in and let
+         * the host deal with handling it correctly. This means
+         * that for hosts that don't expose MMC_CAP_CMD23, no
+         * change of behavior will be observed.
+         *
+         * N.B: Some MMC cards experience perf degradation.
+         * We'll avoid using CMD23-bounded multiblock writes for
+         * these, while retaining features like reliable writes.
+         */
 
-                mmc_queue_bounce_post(mq);
+        if ((md->flags & MMC_BLK_CMD23) &&
+            mmc_op_multi(brq->cmd.opcode) &&
+            (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23))) {
+                brq->sbc.opcode = MMC_SET_BLOCK_COUNT;
+                brq->sbc.arg = brq->data.blocks |
+                        (do_rel_wr ? (1 << 31) : 0);
+                brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
+                brq->mrq.sbc = &brq->sbc;
+        }
 
-                /*
-                 * Check for errors here, but don't jump to cmd_err
-                 * until later as we need to wait for the card to leave
-                 * programming mode even when things go wrong.
-                 */
-                if (brq.sbc.error || brq.cmd.error ||
-                    brq.data.error || brq.stop.error) {
-                        if (brq.data.blocks > 1 && rq_data_dir(req) == READ) {
-                                /* Redo read one sector at a time */
-                                printk(KERN_WARNING "%s: retrying using single "
-                                       "block read\n", req->rq_disk->disk_name);
-                                disable_multi = 1;
-                                continue;
-                        }
-                        status = get_card_status(card, req);
-                }
+        mmc_set_data_timeout(&brq->data, card);
 
-                if (brq.sbc.error) {
-                        printk(KERN_ERR "%s: error %d sending SET_BLOCK_COUNT "
-                               "command, response %#x, card status %#x\n",
-                               req->rq_disk->disk_name, brq.sbc.error,
-                               brq.sbc.resp[0], status);
-                }
+        brq->data.sg = mqrq->sg;
+        brq->data.sg_len = mmc_queue_map_sg(mq, mqrq);
 
-                if (brq.cmd.error) {
-                        printk(KERN_ERR "%s: error %d sending read/write "
-                               "command, response %#x, card status %#x\n",
-                               req->rq_disk->disk_name, brq.cmd.error,
-                               brq.cmd.resp[0], status);
+        /*
+         * Adjust the sg list so it is the same size as the
+         * request.
+         */
+        if (brq->data.blocks != blk_rq_sectors(req)) {
+                int i, data_size = brq->data.blocks << 9;
+                struct scatterlist *sg;
+
+                for_each_sg(brq->data.sg, sg, brq->data.sg_len, i) {
+                        data_size -= sg->length;
+                        if (data_size <= 0) {
+                                sg->length += data_size;
+                                i++;
+                                break;
+                        }
                 }
+                brq->data.sg_len = i;
+        }
 
-                if (brq.data.error) {
-                        if (brq.data.error == -ETIMEDOUT && brq.mrq.stop)
-                                /* 'Stop' response contains card status */
-                                status = brq.mrq.stop->resp[0];
-                        printk(KERN_ERR "%s: error %d transferring data,"
-                               " sector %u, nr %u, card status %#x\n",
-                               req->rq_disk->disk_name, brq.data.error,
-                               (unsigned)blk_rq_pos(req),
-                               (unsigned)blk_rq_sectors(req), status);
-                }
+        mqrq->mmc_active.mrq = &brq->mrq;
+        mqrq->mmc_active.err_check = mmc_blk_err_check;
 
-                if (brq.stop.error) {
-                        printk(KERN_ERR "%s: error %d sending stop command, "
-                               "response %#x, card status %#x\n",
-                               req->rq_disk->disk_name, brq.stop.error,
-                               brq.stop.resp[0], status);
-                }
+        mmc_queue_bounce_pre(mqrq);
+}
 
-                if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
-                        do {
-                                int err;
-
-                                cmd.opcode = MMC_SEND_STATUS;
-                                cmd.arg = card->rca << 16;
-                                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-                                err = mmc_wait_for_cmd(card->host, &cmd, 5);
-                                if (err) {
-                                        printk(KERN_ERR "%s: error %d requesting status\n",
-                                               req->rq_disk->disk_name, err);
-                                        goto cmd_err;
-                                }
-                                /*
-                                 * Some cards mishandle the status bits,
-                                 * so make sure to check both the busy
-                                 * indication and the card state.
-                                 */
-                        } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
-                                (R1_CURRENT_STATE(cmd.resp[0]) == 7));
-
-#if 0
-                        if (cmd.resp[0] & ~0x00000900)
-                                printk(KERN_ERR "%s: status = %08x\n",
-                                       req->rq_disk->disk_name, cmd.resp[0]);
-                        if (mmc_decode_status(cmd.resp))
-                                goto cmd_err;
-#endif
-                }
+static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
+{
+        struct mmc_blk_data *md = mq->data;
+        struct mmc_card *card = md->queue.card;
+        struct mmc_blk_request *brq = &mq->mqrq_cur->brq;
+        int ret = 1, disable_multi = 0, retry = 0;
+        enum mmc_blk_status status;
+        struct mmc_queue_req *mq_rq;
+        struct request *req;
+        struct mmc_async_req *areq;
+
+        if (!rqc && !mq->mqrq_prev->req)
+                return 0;
 
-                if (brq.cmd.error || brq.stop.error || brq.data.error) {
-                        if (rq_data_dir(req) == READ) {
+        do {
+                if (rqc) {
+                        mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
+                        areq = &mq->mqrq_cur->mmc_active;
+                } else
+                        areq = NULL;
+                areq = mmc_start_req(card->host, areq, (int *) &status);
+                if (!areq)
+                        return 0;
+
+                mq_rq = container_of(areq, struct mmc_queue_req, mmc_active);
+                brq = &mq_rq->brq;
+                req = mq_rq->req;
+                mmc_queue_bounce_post(mq_rq);
+
+                switch (status) {
+                case MMC_BLK_SUCCESS:
+                case MMC_BLK_PARTIAL:
+                        /*
+                         * A block was successfully transferred.
+                         */
+                        spin_lock_irq(&md->lock);
+                        ret = __blk_end_request(req, 0,
+                                                brq->data.bytes_xfered);
+                        spin_unlock_irq(&md->lock);
+                        if (status == MMC_BLK_SUCCESS && ret) {
                                 /*
-                                 * After an error, we redo I/O one sector at a
-                                 * time, so we only reach here after trying to
-                                 * read a single sector.
+                                 * The blk_end_request has returned non zero
+                                 * even though all data is transfered and no
+                                 * erros returned by host.
+                                 * If this happen it's a bug.
                                  */
-                                spin_lock_irq(&md->lock);
-                                ret = __blk_end_request(req, -EIO, brq.data.blksz);
-                                spin_unlock_irq(&md->lock);
-                                continue;
+                                printk(KERN_ERR "%s BUG rq_tot %d d_xfer %d\n",
+                                       __func__, blk_rq_bytes(req),
+                                       brq->data.bytes_xfered);
+                                rqc = NULL;
+                                goto cmd_abort;
                         }
+                        break;
+                case MMC_BLK_CMD_ERR:
                         goto cmd_err;
+                case MMC_BLK_RETRY_SINGLE:
+                        disable_multi = 1;
+                        break;
+                case MMC_BLK_RETRY:
+                        if (retry++ < 5)
+                                break;
+                case MMC_BLK_ABORT:
+                        goto cmd_abort;
+                case MMC_BLK_DATA_ERR:
+                        /*
+                         * After an error, we redo I/O one sector at a
+                         * time, so we only reach here after trying to
+                         * read a single sector.
+                         */
+                        spin_lock_irq(&md->lock);
+                        ret = __blk_end_request(req, -EIO,
+                                                brq->data.blksz);
+                        spin_unlock_irq(&md->lock);
+                        if (!ret)
+                                goto start_new_req;
+                        break;
                 }
 
-                /*
-                 * A block was successfully transferred.
-                 */
-                spin_lock_irq(&md->lock);
-                ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
-                spin_unlock_irq(&md->lock);
+                if (ret) {
+                        /*
+                         * In case of a none complete request
+                         * prepare it again and resend.
+                         */
+                        mmc_blk_rw_rq_prep(mq_rq, card, disable_multi, mq);
+                        mmc_start_req(card->host, &mq_rq->mmc_active, NULL);
+                }
         } while (ret);
 
+        if (brq->cmd.resp[0] & R1_URGENT_BKOPS)
+                mmc_card_set_need_bkops(card);
+
         return 1;
 
  cmd_err:
@@ -927,44 +1165,76 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                 }
         } else {
                 spin_lock_irq(&md->lock);
-                ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
+                ret = __blk_end_request(req, 0, brq->data.bytes_xfered);
                 spin_unlock_irq(&md->lock);
         }
 
+ cmd_abort:
         spin_lock_irq(&md->lock);
         while (ret)
                 ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
         spin_unlock_irq(&md->lock);
 
+ start_new_req:
+        if (rqc) {
+                mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
+                mmc_start_req(card->host, &mq->mqrq_cur->mmc_active, NULL);
+        }
+
         return 0;
 }
 
+static int
+mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card);
+
 static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 {
         int ret;
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
 
-        mmc_claim_host(card->host);
+#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
+        if (mmc_bus_needs_resume(card->host)) {
+                mmc_resume_bus(card->host);
+                mmc_blk_set_blksize(md, card);
+        }
+#endif
+
+        if (req && !mq->mqrq_prev->req)
+                /* claim host only for the first request */
+                mmc_claim_host(card->host);
+
         ret = mmc_blk_part_switch(card, md);
         if (ret) {
                 ret = 0;
                 goto out;
         }
 
-        if (req->cmd_flags & REQ_DISCARD) {
+        if (req && req->cmd_flags & REQ_DISCARD) {
+                /* complete ongoing async transfer before issuing discard */
+                if (card->host->areq)
+                        mmc_blk_issue_rw_rq(mq, NULL);
                 if (req->cmd_flags & REQ_SECURE)
                         ret = mmc_blk_issue_secdiscard_rq(mq, req);
                 else
                         ret = mmc_blk_issue_discard_rq(mq, req);
-        } else if (req->cmd_flags & REQ_FLUSH) {
+        } else if (req && req->cmd_flags & REQ_FLUSH) {
+                /* complete ongoing async transfer before issuing flush */
+                if (card->host->areq)
+                        mmc_blk_issue_rw_rq(mq, NULL);
                 ret = mmc_blk_issue_flush(mq, req);
         } else {
+                /* Abort any current bk ops of eMMC card by issuing HPI */
+                if (mmc_card_mmc(mq->card) && mmc_card_doing_bkops(mq->card))
+                        mmc_interrupt_hpi(mq->card);
+
                 ret = mmc_blk_issue_rw_rq(mq, req);
         }
 
 out:
-        mmc_release_host(card->host);
+        if (!req)
+                /* release host only when there are no more requests */
+                mmc_release_host(card->host);
         return ret;
 }
 
@@ -1038,6 +1308,7 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
         md->disk->queue = md->queue.queue;
         md->disk->driverfs_dev = parent;
         set_disk_ro(md->disk, md->read_only || default_ro);
+        md->disk->flags = GENHD_FL_EXT_DEVT;
 
         /*
          * As discussed on lkml, GENHD_FL_REMOVABLE should:
@@ -1277,6 +1548,9 @@ static int mmc_blk_probe(struct mmc_card *card)
         mmc_set_drvdata(card, md);
         mmc_fixup_device(card, blk_fixups);
 
+#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
+        mmc_set_bus_resume_policy(card->host, 1);
+#endif
         if (mmc_add_disk(md))
                 goto out;
 
@@ -1302,6 +1576,9 @@ static void mmc_blk_remove(struct mmc_card *card)
         mmc_release_host(card->host);
         mmc_blk_remove_req(md);
         mmc_set_drvdata(card, NULL);
+#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
+        mmc_set_bus_resume_policy(card->host, 0);
+#endif
 }
 
 #ifdef CONFIG_PM
@@ -1325,7 +1602,9 @@ static int mmc_blk_resume(struct mmc_card *card)
         struct mmc_blk_data *md = mmc_get_drvdata(card);
 
         if (md) {
+#ifndef CONFIG_MMC_BLOCK_DEFERRED_RESUME
                 mmc_blk_set_blksize(md, card);
+#endif
 
                 /*
                  * Resume involves the card going into idle state,
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 233cdfae92f..440b97d9e44 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -148,6 +148,117 @@ struct mmc_test_card {
         struct mmc_test_general_result  *gr;
 };
 
+enum mmc_test_prep_media {
+        MMC_TEST_PREP_NONE = 0,
+        MMC_TEST_PREP_WRITE_FULL = 1 << 0,
+        MMC_TEST_PREP_ERASE = 1 << 1,
+};
+
+struct mmc_test_multiple_rw {
+        unsigned int *sg_len;
+        unsigned int *bs;
+        unsigned int len;
+        unsigned int size;
+        bool do_write;
+        bool do_nonblock_req;
+        enum mmc_test_prep_media prepare;
+};
+
+struct mmc_test_async_req {
+        struct mmc_async_req areq;
+        struct mmc_test_card *test;
+};
+
+struct mmc_test_parameter {
+        const char *name;
+        long value;
+        long (*exec)(struct mmc_test_card *);
+        const char *input;
+};
+
+static long mmc_test_set_testcase(struct mmc_test_card *test);
+static long mmc_test_set_clock(struct mmc_test_card *test);
+static long mmc_test_set_bus_width(struct mmc_test_card *test);
+static long mmc_test_set_timing(struct mmc_test_card *test);
+
+
+static struct mmc_test_parameter mmc_test_parameter[] = {
+        {
+                .name = "Testcase Number",
+                .value = 1,
+                .exec = mmc_test_set_testcase,
+                .input = "-n",
+        },
+        {
+                .name = "Clock Rate",
+                .value = -1,
+                .exec = mmc_test_set_clock,
+                .input = "-c",
+        },
+        {
+                .name = "Bus Width",
+                .value = -1,
+                .exec = mmc_test_set_bus_width,
+                .input = "-b",
+        },
+        {
+                .name = "Timing",
+                .value = -1,
+                .exec = mmc_test_set_timing,
+                .input = "-t",
+        },
+};
+
+static long mmc_test_set_testcase(struct mmc_test_card *test)
+{
+        return 0;
+}
+
+static long mmc_test_set_clock(struct mmc_test_card *test)
+{
+        long clock = mmc_test_parameter[1].value;
+        if (-1 == clock)
+                return test->card->host->ios.clock;
+        WARN_ON(clock < test->card->host->f_min);
+        if (clock > test->card->host->f_max)
+                clock = test->card->host->f_max;
+
+        test->card->host->ios.clock = clock;
+
+        return test->card->host->ios.clock;
+}
+
+static long mmc_test_set_bus_width(struct mmc_test_card *test)
+{
+        long bus_width = mmc_test_parameter[2].value;
+        if (-1 == bus_width)
+                return test->card->host->ios.bus_width;
+
+        test->card->host->ios.bus_width = bus_width;
+
+        return test->card->host->ios.bus_width = bus_width;
+}
+
+static long mmc_test_set_timing(struct mmc_test_card *test)
+{
+        long timing = mmc_test_parameter[3].value;
+        if (-1 == timing)
+                return test->card->host->ios.timing;
+        test->card->host->ios.timing = timing;
+
+        return test->card->host->ios.timing;
+}
+
+static void mmc_test_set_parameters(struct mmc_test_card *test)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(mmc_test_parameter); i++) {
+                printk(KERN_INFO "Parameter[%s] set to [%ld]\n",
+                        mmc_test_parameter[i].name,
+                        mmc_test_parameter[i].exec(test));
+        }
+}
+
 /*******************************************************************/
 /*  General helper functions                                       */
 /*******************************************************************/
@@ -203,7 +314,7 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
 static int mmc_test_busy(struct mmc_command *cmd)
 {
         return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
-                (R1_CURRENT_STATE(cmd->resp[0]) == 7);
+                (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
 }
 
 /*
@@ -367,21 +478,26 @@ out_free:
  * Map memory into a scatterlist.  Optionally allow the same memory to be
  * mapped more than once.
  */
-static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
+static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long size,
                            struct scatterlist *sglist, int repeat,
                            unsigned int max_segs, unsigned int max_seg_sz,
-                           unsigned int *sg_len)
+                           unsigned int *sg_len, int min_sg_len)
 {
         struct scatterlist *sg = NULL;
         unsigned int i;
+        unsigned long sz = size;
 
         sg_init_table(sglist, max_segs);
+        if (min_sg_len > max_segs)
+                min_sg_len = max_segs;
 
         *sg_len = 0;
         do {
                 for (i = 0; i < mem->cnt; i++) {
                         unsigned long len = PAGE_SIZE << mem->arr[i].order;
 
+                        if (min_sg_len && (size / min_sg_len < len))
+                                len = ALIGN(size / min_sg_len, 512);
                         if (len > sz)
                                 len = sz;
                         if (len > max_seg_sz)
@@ -554,11 +670,12 @@ static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
 
         printk(KERN_INFO "%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
                          "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
-                         "%u.%02u IOPS)\n",
+                         "%u.%02u IOPS, sg_len %d)\n",
                          mmc_hostname(test->card->host), count, sectors, count,
                          sectors >> 1, (sectors & 1 ? ".5" : ""),
                          (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
-                         rate / 1000, rate / 1024, iops / 100, iops % 100);
+                         rate / 1000, rate / 1024, iops / 100, iops % 100,
+                         test->area.sg_len);
 
         mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
 }
@@ -661,7 +778,7 @@ static void mmc_test_prepare_broken_mrq(struct mmc_test_card *test,
  * Checks that a normal transfer didn't have any errors
  */
 static int mmc_test_check_result(struct mmc_test_card *test,
-        struct mmc_request *mrq)
+                                 struct mmc_request *mrq)
 {
         int ret;
 
@@ -685,6 +802,17 @@ static int mmc_test_check_result(struct mmc_test_card *test,
         return ret;
 }
 
+static int mmc_test_check_result_async(struct mmc_card *card,
+                                       struct mmc_async_req *areq)
+{
+        struct mmc_test_async_req *test_async =
+                container_of(areq, struct mmc_test_async_req, areq);
+
+        mmc_test_wait_busy(test_async->test);
+
+        return mmc_test_check_result(test_async->test, areq->mrq);
+}
+
 /*
  * Checks that a "short transfer" behaved as expected
  */
@@ -720,6 +848,85 @@ static int mmc_test_check_broken_result(struct mmc_test_card *test,
 }
 
 /*
+ * Tests nonblock transfer with certain parameters
+ */
+static void mmc_test_nonblock_reset(struct mmc_request *mrq,
+                                    struct mmc_command *cmd,
+                                    struct mmc_command *stop,
+                                    struct mmc_data *data)
+{
+        memset(mrq, 0, sizeof(struct mmc_request));
+        memset(cmd, 0, sizeof(struct mmc_command));
+        memset(data, 0, sizeof(struct mmc_data));
+        memset(stop, 0, sizeof(struct mmc_command));
+
+        mrq->cmd = cmd;
+        mrq->data = data;
+        mrq->stop = stop;
+}
+static int mmc_test_nonblock_transfer(struct mmc_test_card *test,
+                                      struct scatterlist *sg, unsigned sg_len,
+                                      unsigned dev_addr, unsigned blocks,
+                                      unsigned blksz, int write, int count)
+{
+        struct mmc_request mrq1;
+        struct mmc_command cmd1;
+        struct mmc_command stop1;
+        struct mmc_data data1;
+
+        struct mmc_request mrq2;
+        struct mmc_command cmd2;
+        struct mmc_command stop2;
+        struct mmc_data data2;
+
+        struct mmc_test_async_req test_areq[2];
+        struct mmc_async_req *done_areq;
+        struct mmc_async_req *cur_areq = &test_areq[0].areq;
+        struct mmc_async_req *other_areq = &test_areq[1].areq;
+        int i;
+        int ret;
+
+        test_areq[0].test = test;
+        test_areq[1].test = test;
+
+        mmc_test_nonblock_reset(&mrq1, &cmd1, &stop1, &data1);
+        mmc_test_nonblock_reset(&mrq2, &cmd2, &stop2, &data2);
+
+        cur_areq->mrq = &mrq1;
+        cur_areq->err_check = mmc_test_check_result_async;
+        other_areq->mrq = &mrq2;
+        other_areq->err_check = mmc_test_check_result_async;
+
+        for (i = 0; i < count; i++) {
+                mmc_test_prepare_mrq(test, cur_areq->mrq, sg, sg_len, dev_addr,
+                                     blocks, blksz, write);
+                done_areq = mmc_start_req(test->card->host, cur_areq, &ret);
+
+                if (ret || (!done_areq && i > 0))
+                        goto err;
+
+                if (done_areq) {
+                        if (done_areq->mrq == &mrq2)
+                                mmc_test_nonblock_reset(&mrq2, &cmd2,
+                                                        &stop2, &data2);
+                        else
+                                mmc_test_nonblock_reset(&mrq1, &cmd1,
+                                                        &stop1, &data1);
+                }
+                done_areq = cur_areq;
+                cur_areq = other_areq;
+                other_areq = done_areq;
+                dev_addr += blocks;
+        }
+
+        done_areq = mmc_start_req(test->card->host, NULL, &ret);
+
+        return ret;
+err:
+        return ret;
+}
+
+/*
  * Tests a basic transfer with certain parameters
  */
 static int mmc_test_simple_transfer(struct mmc_test_card *test,
@@ -1302,7 +1509,7 @@ static int mmc_test_no_highmem(struct mmc_test_card *test)
  * Map sz bytes so that it can be transferred.
  */
 static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
-                             int max_scatter)
+                             int max_scatter, int min_sg_len)
 {
         struct mmc_test_area *t = &test->area;
         int err;
@@ -1315,7 +1522,7 @@ static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
                                        &t->sg_len);
         } else {
                 err = mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
-                                      t->max_seg_sz, &t->sg_len);
+                                      t->max_seg_sz, &t->sg_len, min_sg_len);
         }
         if (err)
                 printk(KERN_INFO "%s: Failed to map sg list\n",
@@ -1336,14 +1543,17 @@ static int mmc_test_area_transfer(struct mmc_test_card *test,
 }
 
 /*
- * Map and transfer bytes.
+ * Map and transfer bytes for multiple transfers.
  */
-static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
-                            unsigned int dev_addr, int write, int max_scatter,
-                            int timed)
+static int mmc_test_area_io_seq(struct mmc_test_card *test, unsigned long sz,
+                                unsigned int dev_addr, int write,
+                                int max_scatter, int timed, int count,
+                                bool nonblock, int min_sg_len)
 {
         struct timespec ts1, ts2;
-        int ret;
+        int ret = 0;
+        int i;
+        struct mmc_test_area *t = &test->area;
 
         /*
          * In the case of a maximally scattered transfer, the maximum transfer
@@ -1361,14 +1571,21 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
                         sz = max_tfr;
         }
 
-        ret = mmc_test_area_map(test, sz, max_scatter);
+        ret = mmc_test_area_map(test, sz, max_scatter, min_sg_len);
         if (ret)
                 return ret;
 
         if (timed)
                 getnstimeofday(&ts1);
+        if (nonblock)
+                ret = mmc_test_nonblock_transfer(test, t->sg, t->sg_len,
+                                 dev_addr, t->blocks, 512, write, count);
+        else
+                for (i = 0; i < count && ret == 0; i++) {
+                        ret = mmc_test_area_transfer(test, dev_addr, write);
+                        dev_addr += sz >> 9;
+                }
 
-        ret = mmc_test_area_transfer(test, dev_addr, write);
         if (ret)
                 return ret;
 
@@ -1376,11 +1593,19 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
                 getnstimeofday(&ts2);
 
         if (timed)
-                mmc_test_print_rate(test, sz, &ts1, &ts2);
+                mmc_test_print_avg_rate(test, sz, count, &ts1, &ts2);
 
         return 0;
 }
 
+static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
+                            unsigned int dev_addr, int write, int max_scatter,
+                            int timed)
+{
+        return mmc_test_area_io_seq(test, sz, dev_addr, write, max_scatter,
+                                    timed, 1, false, 0);
+}
+
 /*
  * Write the test area entirely.
  */
@@ -1954,6 +2179,245 @@ static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
         return mmc_test_large_seq_perf(test, 1);
 }
 
+static int mmc_test_rw_multiple(struct mmc_test_card *test,
+                                struct mmc_test_multiple_rw *tdata,
+                                unsigned int reqsize, unsigned int size,
+                                int min_sg_len)
+{
+        unsigned int dev_addr;
+        struct mmc_test_area *t = &test->area;
+        int ret = 0;
+
+        /* Set up test area */
+        if (size > mmc_test_capacity(test->card) / 2 * 512)
+                size = mmc_test_capacity(test->card) / 2 * 512;
+        if (reqsize > t->max_tfr)
+                reqsize = t->max_tfr;
+        dev_addr = mmc_test_capacity(test->card) / 4;
+        if ((dev_addr & 0xffff0000))
+                dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
+        else
+                dev_addr &= 0xfffff800; /* Round to 1MiB boundary */
+        if (!dev_addr)
+                goto err;
+
+        if (reqsize > size)
+                return 0;
+
+        /* prepare test area */
+        if (mmc_can_erase(test->card) &&
+            tdata->prepare & MMC_TEST_PREP_ERASE) {
+                ret = mmc_erase(test->card, dev_addr,
+                                size / 512, MMC_SECURE_ERASE_ARG);
+                if (ret)
+                        ret = mmc_erase(test->card, dev_addr,
+                                        size / 512, MMC_ERASE_ARG);
+                if (ret)
+                        goto err;
+        }
+
+        /* Run test */
+        ret = mmc_test_area_io_seq(test, reqsize, dev_addr,
+                                   tdata->do_write, 0, 1, size / reqsize,
+                                   tdata->do_nonblock_req, min_sg_len);
+        if (ret)
+                goto err;
+
+        return ret;
+ err:
+        printk(KERN_INFO "[%s] error\n", __func__);
+        return ret;
+}
+
+static int mmc_test_rw_multiple_size(struct mmc_test_card *test,
+                                     struct mmc_test_multiple_rw *rw)
+{
+        int ret = 0;
+        int i;
+        void *pre_req = test->card->host->ops->pre_req;
+        void *post_req = test->card->host->ops->post_req;
+
+        if (rw->do_nonblock_req &&
+            ((!pre_req && post_req) || (pre_req && !post_req))) {
+                printk(KERN_INFO "error: only one of pre/post is defined\n");
+                return -EINVAL;
+        }
+
+        for (i = 0 ; i < rw->len && ret == 0; i++) {
+                ret = mmc_test_rw_multiple(test, rw, rw->bs[i], rw->size, 0);
+                if (ret)
+                        break;
+        }
+        return ret;
+}
+
+static int mmc_test_rw_multiple_sg_len(struct mmc_test_card *test,
+                                       struct mmc_test_multiple_rw *rw)
+{
+        int ret = 0;
+        int i;
+
+        for (i = 0 ; i < rw->len && ret == 0; i++) {
+                ret = mmc_test_rw_multiple(test, rw, 512*1024, rw->size,
+                                           rw->sg_len[i]);
+                if (ret)
+                        break;
+        }
+        return ret;
+}
+
+/*
+ * Multiple blocking write 4k to 4 MB chunks
+ */
+static int mmc_test_profile_mult_write_blocking_perf(struct mmc_test_card *test)
+{
+        unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
+                             1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
+        struct mmc_test_multiple_rw test_data = {
+                .bs = bs,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(bs),
+                .do_write = true,
+                .do_nonblock_req = false,
+                .prepare = MMC_TEST_PREP_ERASE,
+        };
+
+        return mmc_test_rw_multiple_size(test, &test_data);
+};
+
+/*
+ * Multiple non-blocking write 4k to 4 MB chunks
+ */
+static int mmc_test_profile_mult_write_nonblock_perf(struct mmc_test_card *test)
+{
+        unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
+                             1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
+        struct mmc_test_multiple_rw test_data = {
+                .bs = bs,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(bs),
+                .do_write = true,
+                .do_nonblock_req = true,
+                .prepare = MMC_TEST_PREP_ERASE,
+        };
+
+        return mmc_test_rw_multiple_size(test, &test_data);
+}
+
+/*
+ * Multiple blocking read 4k to 4 MB chunks
+ */
+static int mmc_test_profile_mult_read_blocking_perf(struct mmc_test_card *test)
+{
+        unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
+                             1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
+        struct mmc_test_multiple_rw test_data = {
+                .bs = bs,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(bs),
+                .do_write = false,
+                .do_nonblock_req = false,
+                .prepare = MMC_TEST_PREP_NONE,
+        };
+
+        return mmc_test_rw_multiple_size(test, &test_data);
+}
+
+/*
+ * Multiple non-blocking read 4k to 4 MB chunks
+ */
+static int mmc_test_profile_mult_read_nonblock_perf(struct mmc_test_card *test)
+{
+        unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
+                             1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
+        struct mmc_test_multiple_rw test_data = {
+                .bs = bs,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(bs),
+                .do_write = false,
+                .do_nonblock_req = true,
+                .prepare = MMC_TEST_PREP_NONE,
+        };
+
+        return mmc_test_rw_multiple_size(test, &test_data);
+}
+
+/*
+ * Multiple blocking write 1 to 512 sg elements
+ */
+static int mmc_test_profile_sglen_wr_blocking_perf(struct mmc_test_card *test)
+{
+        unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
+                                 1 << 7, 1 << 8, 1 << 9};
+        struct mmc_test_multiple_rw test_data = {
+                .sg_len = sg_len,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(sg_len),
+                .do_write = true,
+                .do_nonblock_req = false,
+                .prepare = MMC_TEST_PREP_ERASE,
+        };
+
+        return mmc_test_rw_multiple_sg_len(test, &test_data);
+};
+
+/*
+ * Multiple non-blocking write 1 to 512 sg elements
+ */
+static int mmc_test_profile_sglen_wr_nonblock_perf(struct mmc_test_card *test)
+{
+        unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
+                                 1 << 7, 1 << 8, 1 << 9};
+        struct mmc_test_multiple_rw test_data = {
+                .sg_len = sg_len,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(sg_len),
+                .do_write = true,
+                .do_nonblock_req = true,
+                .prepare = MMC_TEST_PREP_ERASE,
+        };
+
+        return mmc_test_rw_multiple_sg_len(test, &test_data);
+}
+
+/*
+ * Multiple blocking read 1 to 512 sg elements
+ */
+static int mmc_test_profile_sglen_r_blocking_perf(struct mmc_test_card *test)
+{
+        unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
+                                 1 << 7, 1 << 8, 1 << 9};
+        struct mmc_test_multiple_rw test_data = {
+                .sg_len = sg_len,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(sg_len),
+                .do_write = false,
+                .do_nonblock_req = false,
+                .prepare = MMC_TEST_PREP_NONE,
+        };
+
+        return mmc_test_rw_multiple_sg_len(test, &test_data);
+}
+
+/*
+ * Multiple non-blocking read 1 to 512 sg elements
+ */
+static int mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card *test)
+{
+        unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
+                                 1 << 7, 1 << 8, 1 << 9};
+        struct mmc_test_multiple_rw test_data = {
+                .sg_len = sg_len,
+                .size = TEST_AREA_MAX_SIZE,
+                .len = ARRAY_SIZE(sg_len),
+                .do_write = false,
+                .do_nonblock_req = true,
+                .prepare = MMC_TEST_PREP_NONE,
+        };
+
+        return mmc_test_rw_multiple_sg_len(test, &test_data);
+}
+
 static const struct mmc_test_case mmc_test_cases[] = {
         {
                 .name = "Basic write (no data verification)",
@@ -2221,6 +2685,61 @@ static const struct mmc_test_case mmc_test_cases[] = {
                 .cleanup = mmc_test_area_cleanup,
         },
 
+        {
+                .name = "Write performance with blocking req 4k to 4MB",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_mult_write_blocking_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Write performance with non-blocking req 4k to 4MB",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_mult_write_nonblock_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Read performance with blocking req 4k to 4MB",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_mult_read_blocking_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Read performance with non-blocking req 4k to 4MB",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_mult_read_nonblock_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Write performance blocking req 1 to 512 sg elems",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_sglen_wr_blocking_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Write performance non-blocking req 1 to 512 sg elems",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_sglen_wr_nonblock_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Read performance blocking req 1 to 512 sg elems",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_sglen_r_blocking_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Read performance non-blocking req 1 to 512 sg elems",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_sglen_r_nonblock_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
 };
 
 static DEFINE_MUTEX(mmc_test_lock);
@@ -2236,6 +2755,8 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
 
         mmc_claim_host(test->card->host);
 
+        mmc_test_set_parameters(test);
+
         for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
                 struct mmc_test_general_result *gr;
 
@@ -2348,6 +2869,23 @@ static void mmc_test_free_result(struct mmc_card *card)
 
 static LIST_HEAD(mmc_test_file_test);
 
+static void mmc_test_usage(struct seq_file *sf)
+{
+        int i = 0;
+
+        seq_printf(sf, "\nHow to run test:"
+                        "\necho <testcase> [[param1 value1].... ] > test"
+                        "\nExample:: echo 1 -b 4 -c 2500000 -t 2"
+                        "\n\nSupported parameters in sequence\n");
+
+        for (i = 0; i < ARRAY_SIZE(mmc_test_parameter); i++) {
+                seq_printf(sf, "Parameter%d Name:[%s] option:[%s]\n",
+                        i + 1, mmc_test_parameter[i].name,
+                        mmc_test_parameter[i].input);
+        }
+        seq_printf(sf, "\'-1\' passed to take default value\n\n\n");
+}
+
 static int mtf_test_show(struct seq_file *sf, void *data)
 {
         struct mmc_card *card = (struct mmc_card *)sf->private;
@@ -2382,24 +2920,92 @@ static int mtf_test_open(struct inode *inode, struct file *file)
         return single_open(file, mtf_test_show, inode->i_private);
 }
 
+static int mmc_test_extract_parameters(char *data_buf)
+{
+        char *running = NULL;
+        char *token = NULL;
+        const char delimiters[] = " ";
+        long value;
+        int i;
+        int set = 0;
+
+        running = data_buf;
+
+        /*Example:
+         * echo <testcasenumber> [[param1 value1] [param1 value1]] > test
+         * $] echo 1 > test | Execute testcase 1
+         * $] echo 1 -c 2500000 | execute tesecase 1 and set clock to 2500000
+         * $] echo 1 -b 4 -c 2500000 -t 2 |
+         *      execute tesecase 1, set clock to 2500000, set bus_width 4,
+         *      and set timing to 2
+        */
+
+        while ((token = strsep(&running, delimiters))) {
+                if (strict_strtol(token, 10, &value)) {
+                        /* [Param1 value1] combination
+                         * Compare with available param list
+                         */
+                        for (i = 0; i < ARRAY_SIZE(mmc_test_parameter); i++) {
+                                if (!strcmp(mmc_test_parameter[i].input,
+                                                token)) {
+                                        /* Valid Option, extract following
+                                         * value and save it
+                                         */
+                                        token = strsep(&running, delimiters);
+                                        if (strict_strtol(token, 10,
+                                            &(mmc_test_parameter[i].value))) {
+
+                                                printk(KERN_ERR "wrong parameter value\n");
+                                                return -EINVAL;
+                                        } else {
+                                                break;
+                                        }
+                                }
+                        }
+                        if (i == ARRAY_SIZE(mmc_test_parameter)) {
+                                printk(KERN_ERR "uknown mmc_test option\n");
+                                return -EINVAL;
+                        }
+                } else {
+                        /* Testcase number */
+                        if (!set) {
+                                mmc_test_parameter[0].value = value;
+                                set = 1;
+                        } else {
+                                printk(KERN_ERR "invalid options");
+                                return -EINVAL;
+                        }
+                }
+        }
+        return 0;
+}
+
 static ssize_t mtf_test_write(struct file *file, const char __user *buf,
         size_t count, loff_t *pos)
 {
         struct seq_file *sf = (struct seq_file *)file->private_data;
         struct mmc_card *card = (struct mmc_card *)sf->private;
         struct mmc_test_card *test;
-        char lbuf[12];
+        char *data_buf = NULL;
         long testcase;
 
-        if (count >= sizeof(lbuf))
-                return -EINVAL;
+        data_buf = kzalloc(count, GFP_KERNEL);
+        if (data_buf == NULL)
+                return -ENOMEM;
 
-        if (copy_from_user(lbuf, buf, count))
+        if (copy_from_user(data_buf, buf, count)) {
+                kfree(data_buf);
+                return -EFAULT;
+        }
+        data_buf[strlen(data_buf) - 1] = '\0';
+        if (mmc_test_extract_parameters(data_buf)) {
+                mmc_test_usage(sf);
                 return -EFAULT;
-        lbuf[count] = '\0';
+        }
 
-        if (strict_strtol(lbuf, 10, &testcase))
-                return -EINVAL;
+        kfree(data_buf);
+
+        testcase = mmc_test_parameter[0].value;
 
         test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
         if (!test)
@@ -2445,7 +3051,33 @@ static const struct file_operations mmc_test_fops_test = {
         .release        = single_release,
 };
 
-static void mmc_test_free_file_test(struct mmc_card *card)
+static int mtf_testlist_show(struct seq_file *sf, void *data)
+{
+        int i;
+
+        mutex_lock(&mmc_test_lock);
+
+        for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++)
+                seq_printf(sf, "%d:\t%s\n", i+1, mmc_test_cases[i].name);
+
+        mutex_unlock(&mmc_test_lock);
+
+        return 0;
+}
+
+static int mtf_testlist_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mtf_testlist_show, inode->i_private);
+}
+
+static const struct file_operations mmc_test_fops_testlist = {
+        .open           = mtf_testlist_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void mmc_test_free_dbgfs_file(struct mmc_card *card)
 {
         struct mmc_test_dbgfs_file *df, *dfs;
 
@@ -2462,23 +3094,21 @@ static void mmc_test_free_file_test(struct mmc_card *card)
         mutex_unlock(&mmc_test_lock);
 }
 
-static int mmc_test_register_file_test(struct mmc_card *card)
+static int __mmc_test_register_dbgfs_file(struct mmc_card *card,
+        const char *name, mode_t mode, const struct file_operations *fops)
 {
         struct dentry *file = NULL;
         struct mmc_test_dbgfs_file *df;
-        int ret = 0;
-
-        mutex_lock(&mmc_test_lock);
 
         if (card->debugfs_root)
-                file = debugfs_create_file("test", S_IWUSR | S_IRUGO,
-                        card->debugfs_root, card, &mmc_test_fops_test);
+                file = debugfs_create_file(name, mode, card->debugfs_root,
+                        card, fops);
 
         if (IS_ERR_OR_NULL(file)) {
                 dev_err(&card->dev,
-                        "Can't create file. Perhaps debugfs is disabled.\n");
-                ret = -ENODEV;
-                goto err;
+                        "Can't create %s. Perhaps debugfs is disabled.\n",
+                        name);
+                return -ENODEV;
         }
 
         df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
@@ -2486,14 +3116,31 @@ static int mmc_test_register_file_test(struct mmc_card *card)
                 debugfs_remove(file);
                 dev_err(&card->dev,
                         "Can't allocate memory for internal usage.\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         df->card = card;
         df->file = file;
 
         list_add(&df->link, &mmc_test_file_test);
+        return 0;
+}
+
+static int mmc_test_register_dbgfs_file(struct mmc_card *card)
+{
+        int ret;
+
+        mutex_lock(&mmc_test_lock);
+
+        ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO,
+                &mmc_test_fops_test);
+        if (ret)
+                goto err;
+
+        ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO,
+                &mmc_test_fops_testlist);
+        if (ret)
+                goto err;
 
 err:
         mutex_unlock(&mmc_test_lock);
@@ -2508,7 +3155,7 @@ static int mmc_test_probe(struct mmc_card *card)
         if (!mmc_card_mmc(card) && !mmc_card_sd(card))
                 return -ENODEV;
 
-        ret = mmc_test_register_file_test(card);
+        ret = mmc_test_register_dbgfs_file(card);
         if (ret)
                 return ret;
 
@@ -2520,7 +3167,7 @@ static int mmc_test_probe(struct mmc_card *card)
 static void mmc_test_remove(struct mmc_card *card)
 {
         mmc_test_free_result(card);
-        mmc_test_free_file_test(card);
+        mmc_test_free_dbgfs_file(card);
 }
 
 static struct mmc_driver mmc_driver = {
@@ -2540,7 +3187,7 @@ static void __exit mmc_test_exit(void)
 {
         /* Clear stalled data if card is still plugged */
         mmc_test_free_result(NULL);
-        mmc_test_free_file_test(NULL);
+        mmc_test_free_dbgfs_file(NULL);
 
         mmc_unregister_driver(&mmc_driver);
 }
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 6413afa318d..5db38cbcea6 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -52,14 +52,24 @@ static int mmc_queue_thread(void *d)
         down(&mq->thread_sem);
         do {
                 struct request *req = NULL;
+                struct mmc_queue_req *tmp;
 
                 spin_lock_irq(q->queue_lock);
                 set_current_state(TASK_INTERRUPTIBLE);
                 req = blk_fetch_request(q);
-                mq->req = req;
+                mq->mqrq_cur->req = req;
                 spin_unlock_irq(q->queue_lock);
 
-                if (!req) {
+                if (req || mq->mqrq_prev->req) {
+                        set_current_state(TASK_RUNNING);
+                        mq->issue_fn(mq, req);
+                } else {
+                        /*
+                         * Since the queue is empty, start synchronous
+                         * background ops if there is a request for it.
+                         */
+                        if (mmc_card_need_bkops(mq->card))
+                                mmc_bkops_start(mq->card, true);
                         if (kthread_should_stop()) {
                                 set_current_state(TASK_RUNNING);
                                 break;
@@ -67,11 +77,14 @@ static int mmc_queue_thread(void *d)
                         up(&mq->thread_sem);
                         schedule();
                         down(&mq->thread_sem);
-                        continue;
                 }
-                set_current_state(TASK_RUNNING);
 
-                mq->issue_fn(mq, req);
+                /* Current request becomes previous request and vice versa. */
+                mq->mqrq_prev->brq.mrq.data = NULL;
+                mq->mqrq_prev->req = NULL;
+                tmp = mq->mqrq_prev;
+                mq->mqrq_prev = mq->mqrq_cur;
+                mq->mqrq_cur = tmp;
         } while (1);
         up(&mq->thread_sem);
 
@@ -97,10 +110,46 @@ static void mmc_request(struct request_queue *q)
                 return;
         }
 
-        if (!mq->req)
+        if (!mq->mqrq_cur->req && !mq->mqrq_prev->req)
                 wake_up_process(mq->thread);
 }
 
+struct scatterlist *mmc_alloc_sg(int sg_len, int *err)
+{
+        struct scatterlist *sg;
+
+        sg = kmalloc(sizeof(struct scatterlist)*sg_len, GFP_KERNEL);
+        if (!sg)
+                *err = -ENOMEM;
+        else {
+                *err = 0;
+                sg_init_table(sg, sg_len);
+        }
+
+        return sg;
+}
+
+static void mmc_queue_setup_discard(struct request_queue *q,
+                                    struct mmc_card *card)
+{
+        unsigned max_discard;
+
+        max_discard = mmc_calc_max_discard(card);
+        if (!max_discard)
+                return;
+
+        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
+        q->limits.max_discard_sectors = max_discard;
+        if (card->erased_byte == 0)
+                q->limits.discard_zeroes_data = 1;
+        q->limits.discard_granularity = card->pref_erase << 9;
+        /* granularity must not be greater than max. discard */
+        if (card->pref_erase > max_discard)
+                q->limits.discard_granularity = 0;
+        if (mmc_can_secure_erase_trim(card))
+                queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD, q);
+}
+
 /**
  * mmc_init_queue - initialise a queue structure.
  * @mq: mmc queue
@@ -116,6 +165,8 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         struct mmc_host *host = card->host;
         u64 limit = BLK_BOUNCE_HIGH;
         int ret;
+        struct mmc_queue_req *mqrq_cur = &mq->mqrq[0];
+        struct mmc_queue_req *mqrq_prev = &mq->mqrq[1];
 
         if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
                 limit = *mmc_dev(host)->dma_mask;
@@ -125,21 +176,16 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         if (!mq->queue)
                 return -ENOMEM;
 
+        memset(&mq->mqrq_cur, 0, sizeof(mq->mqrq_cur));
+        memset(&mq->mqrq_prev, 0, sizeof(mq->mqrq_prev));
+        mq->mqrq_cur = mqrq_cur;
+        mq->mqrq_prev = mqrq_prev;
         mq->queue->queuedata = mq;
-        mq->req = NULL;
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
-        if (mmc_can_erase(card)) {
-                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mq->queue);
-                mq->queue->limits.max_discard_sectors = UINT_MAX;
-                if (card->erased_byte == 0)
-                        mq->queue->limits.discard_zeroes_data = 1;
-                mq->queue->limits.discard_granularity = card->pref_erase << 9;
-                if (mmc_can_secure_erase_trim(card))
-                        queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD,
-                                                mq->queue);
-        }
+        if (mmc_can_erase(card))
+                mmc_queue_setup_discard(mq->queue, card);
 
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
         if (host->max_segs == 1) {
@@ -155,53 +201,64 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                         bouncesz = host->max_blk_count * 512;
 
                 if (bouncesz > 512) {
-                        mq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
-                        if (!mq->bounce_buf) {
+                        mqrq_cur->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
+                        if (!mqrq_cur->bounce_buf) {
+                                printk(KERN_WARNING "%s: unable to "
+                                        "allocate bounce cur buffer\n",
+                                        mmc_card_name(card));
+                        }
+                        mqrq_prev->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
+                        if (!mqrq_prev->bounce_buf) {
                                 printk(KERN_WARNING "%s: unable to "
-                                        "allocate bounce buffer\n",
+                                        "allocate bounce prev buffer\n",
                                         mmc_card_name(card));
+                                kfree(mqrq_cur->bounce_buf);
+                                mqrq_cur->bounce_buf = NULL;
                         }
                 }
 
-                if (mq->bounce_buf) {
+                if (mqrq_cur->bounce_buf && mqrq_prev->bounce_buf) {
                         blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
                         blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
                         blk_queue_max_segments(mq->queue, bouncesz / 512);
                         blk_queue_max_segment_size(mq->queue, bouncesz);
 
-                        mq->sg = kmalloc(sizeof(struct scatterlist),
-                                GFP_KERNEL);
-                        if (!mq->sg) {
-                                ret = -ENOMEM;
+                        mqrq_cur->sg = mmc_alloc_sg(1, &ret);
+                        if (ret)
                                 goto cleanup_queue;
-                        }
-                        sg_init_table(mq->sg, 1);
 
-                        mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
-                                bouncesz / 512, GFP_KERNEL);
-                        if (!mq->bounce_sg) {
-                                ret = -ENOMEM;
+                        mqrq_cur->bounce_sg =
+                                mmc_alloc_sg(bouncesz / 512, &ret);
+                        if (ret)
+                                goto cleanup_queue;
+
+                        mqrq_prev->sg = mmc_alloc_sg(1, &ret);
+                        if (ret)
+                                goto cleanup_queue;
+
+                        mqrq_prev->bounce_sg =
+                                mmc_alloc_sg(bouncesz / 512, &ret);
+                        if (ret)
                                 goto cleanup_queue;
-                        }
-                        sg_init_table(mq->bounce_sg, bouncesz / 512);
                 }
         }
 #endif
 
-        if (!mq->bounce_buf) {
+        if (!mqrq_cur->bounce_buf && !mqrq_prev->bounce_buf) {
                 blk_queue_bounce_limit(mq->queue, limit);
                 blk_queue_max_hw_sectors(mq->queue,
                         min(host->max_blk_count, host->max_req_size / 512));
                 blk_queue_max_segments(mq->queue, host->max_segs);
                 blk_queue_max_segment_size(mq->queue, host->max_seg_size);
 
-                mq->sg = kmalloc(sizeof(struct scatterlist) *
-                        host->max_segs, GFP_KERNEL);
-                if (!mq->sg) {
-                        ret = -ENOMEM;
+                mqrq_cur->sg = mmc_alloc_sg(host->max_segs, &ret);
+                if (ret)
+                        goto cleanup_queue;
+
+
+                mqrq_prev->sg = mmc_alloc_sg(host->max_segs, &ret);
+                if (ret)
                         goto cleanup_queue;
-                }
-                sg_init_table(mq->sg, host->max_segs);
         }
 
         sema_init(&mq->thread_sem, 1);
@@ -216,16 +273,22 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
 
         return 0;
  free_bounce_sg:
-        if (mq->bounce_sg)
-                kfree(mq->bounce_sg);
-        mq->bounce_sg = NULL;
+        kfree(mqrq_cur->bounce_sg);
+        mqrq_cur->bounce_sg = NULL;
+        kfree(mqrq_prev->bounce_sg);
+        mqrq_prev->bounce_sg = NULL;
+
  cleanup_queue:
-        if (mq->sg)
-                kfree(mq->sg);
-        mq->sg = NULL;
-        if (mq->bounce_buf)
-                kfree(mq->bounce_buf);
-        mq->bounce_buf = NULL;
+        kfree(mqrq_cur->sg);
+        mqrq_cur->sg = NULL;
+        kfree(mqrq_cur->bounce_buf);
+        mqrq_cur->bounce_buf = NULL;
+
+        kfree(mqrq_prev->sg);
+        mqrq_prev->sg = NULL;
+        kfree(mqrq_prev->bounce_buf);
+        mqrq_prev->bounce_buf = NULL;
+
         blk_cleanup_queue(mq->queue);
         return ret;
 }
@@ -234,6 +297,8 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
 {
         struct request_queue *q = mq->queue;
         unsigned long flags;
+        struct mmc_queue_req *mqrq_cur = mq->mqrq_cur;
+        struct mmc_queue_req *mqrq_prev = mq->mqrq_prev;
 
         /* Make sure the queue isn't suspended, as that will deadlock */
         mmc_queue_resume(mq);
@@ -247,16 +312,23 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
         blk_start_queue(q);
         spin_unlock_irqrestore(q->queue_lock, flags);
 
-        if (mq->bounce_sg)
-                kfree(mq->bounce_sg);
-        mq->bounce_sg = NULL;
+        kfree(mqrq_cur->bounce_sg);
+        mqrq_cur->bounce_sg = NULL;
 
-        kfree(mq->sg);
-        mq->sg = NULL;
+        kfree(mqrq_cur->sg);
+        mqrq_cur->sg = NULL;
 
-        if (mq->bounce_buf)
-                kfree(mq->bounce_buf);
-        mq->bounce_buf = NULL;
+        kfree(mqrq_cur->bounce_buf);
+        mqrq_cur->bounce_buf = NULL;
+
+        kfree(mqrq_prev->bounce_sg);
+        mqrq_prev->bounce_sg = NULL;
+
+        kfree(mqrq_prev->sg);
+        mqrq_prev->sg = NULL;
+
+        kfree(mqrq_prev->bounce_buf);
+        mqrq_prev->bounce_buf = NULL;
 
         mq->card = NULL;
 }
@@ -309,27 +381,27 @@ void mmc_queue_resume(struct mmc_queue *mq)
 /*
  * Prepare the sg list(s) to be handed of to the host driver
  */
-unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
+unsigned int mmc_queue_map_sg(struct mmc_queue *mq, struct mmc_queue_req *mqrq)
 {
         unsigned int sg_len;
         size_t buflen;
         struct scatterlist *sg;
         int i;
 
-        if (!mq->bounce_buf)
-                return blk_rq_map_sg(mq->queue, mq->req, mq->sg);
+        if (!mqrq->bounce_buf)
+                return blk_rq_map_sg(mq->queue, mqrq->req, mqrq->sg);
 
-        BUG_ON(!mq->bounce_sg);
+        BUG_ON(!mqrq->bounce_sg);
 
-        sg_len = blk_rq_map_sg(mq->queue, mq->req, mq->bounce_sg);
+        sg_len = blk_rq_map_sg(mq->queue, mqrq->req, mqrq->bounce_sg);
 
-        mq->bounce_sg_len = sg_len;
+        mqrq->bounce_sg_len = sg_len;
 
         buflen = 0;
-        for_each_sg(mq->bounce_sg, sg, sg_len, i)
+        for_each_sg(mqrq->bounce_sg, sg, sg_len, i)
                 buflen += sg->length;
 
-        sg_init_one(mq->sg, mq->bounce_buf, buflen);
+        sg_init_one(mqrq->sg, mqrq->bounce_buf, buflen);
 
         return 1;
 }
@@ -338,31 +410,30 @@ unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
  * If writing, bounce the data to the buffer before the request
  * is sent to the host driver
  */
-void mmc_queue_bounce_pre(struct mmc_queue *mq)
+void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
 {
-        if (!mq->bounce_buf)
+        if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mq->req) != WRITE)
+        if (rq_data_dir(mqrq->req) != WRITE)
                 return;
 
-        sg_copy_to_buffer(mq->bounce_sg, mq->bounce_sg_len,
-                mq->bounce_buf, mq->sg[0].length);
+        sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
+                mqrq->bounce_buf, mqrq->sg[0].length);
 }
 
 /*
  * If reading, bounce the data from the buffer after the request
  * has been handled by the host driver
  */
-void mmc_queue_bounce_post(struct mmc_queue *mq)
+void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
 {
-        if (!mq->bounce_buf)
+        if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mq->req) != READ)
+        if (rq_data_dir(mqrq->req) != READ)
                 return;
 
-        sg_copy_from_buffer(mq->bounce_sg, mq->bounce_sg_len,
-                mq->bounce_buf, mq->sg[0].length);
+        sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
+                mqrq->bounce_buf, mqrq->sg[0].length);
 }
-
diff --git a/drivers/mmc/card/queue.h b/drivers/mmc/card/queue.h
index 6223ef8dc9c..d2a1eb4b9f9 100644
--- a/drivers/mmc/card/queue.h
+++ b/drivers/mmc/card/queue.h
@@ -4,19 +4,35 @@
 struct request;
 struct task_struct;
 
+struct mmc_blk_request {
+        struct mmc_request      mrq;
+        struct mmc_command      sbc;
+        struct mmc_command      cmd;
+        struct mmc_command      stop;
+        struct mmc_data         data;
+};
+
+struct mmc_queue_req {
+        struct request          *req;
+        struct mmc_blk_request  brq;
+        struct scatterlist      *sg;
+        char                    *bounce_buf;
+        struct scatterlist      *bounce_sg;
+        unsigned int            bounce_sg_len;
+        struct mmc_async_req    mmc_active;
+};
+
 struct mmc_queue {
         struct mmc_card         *card;
         struct task_struct      *thread;
         struct semaphore        thread_sem;
         unsigned int            flags;
-        struct request          *req;
         int                     (*issue_fn)(struct mmc_queue *, struct request *);
         void                    *data;
         struct request_queue    *queue;
-        struct scatterlist      *sg;
-        char                    *bounce_buf;
-        struct scatterlist      *bounce_sg;
-        unsigned int            bounce_sg_len;
+        struct mmc_queue_req    mqrq[2];
+        struct mmc_queue_req    *mqrq_cur;
+        struct mmc_queue_req    *mqrq_prev;
 };
 
 extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *,
@@ -25,8 +41,9 @@ extern void mmc_cleanup_queue(struct mmc_queue *);
 extern void mmc_queue_suspend(struct mmc_queue *);
 extern void mmc_queue_resume(struct mmc_queue *);
 
-extern unsigned int mmc_queue_map_sg(struct mmc_queue *);
-extern void mmc_queue_bounce_pre(struct mmc_queue *);
-extern void mmc_queue_bounce_post(struct mmc_queue *);
+extern unsigned int mmc_queue_map_sg(struct mmc_queue *,
+                                     struct mmc_queue_req *);
+extern void mmc_queue_bounce_pre(struct mmc_queue_req *);
+extern void mmc_queue_bounce_post(struct mmc_queue_req *);
 
 #endif
diff --git a/drivers/mmc/core/Kconfig b/drivers/mmc/core/Kconfig
index ef103871517..85c2e1acd15 100644
--- a/drivers/mmc/core/Kconfig
+++ b/drivers/mmc/core/Kconfig
@@ -27,3 +27,20 @@ config MMC_CLKGATE
           support handling this in order for it to be of any use.
 
           If unsure, say N.
+
+config MMC_EMBEDDED_SDIO
+        boolean "MMC embedded SDIO device support (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        help
+          If you say Y here, support will be added for embedded SDIO
+          devices which do not contain the necessary enumeration
+          support in hardware to be properly detected.
+
+config MMC_PARANOID_SD_INIT
+        bool "Enable paranoid SD card initialization (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        help
+          If you say Y here, the MMC layer will be extra paranoid
+          about re-trying SD init requests. This can be a useful
+          work-around for buggy controllers and hardware. Enable
+          if you are experiencing issues with SD detection.
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 393d817ed04..f4bdbe6982c 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -25,6 +25,10 @@
 
 #define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
 
+#ifdef CONFIG_MMC_TEST
+static struct mmc_driver *mmc_test_drv;
+#endif
+
 static ssize_t mmc_type_show(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
@@ -107,6 +111,13 @@ static int mmc_bus_probe(struct device *dev)
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
 
+#ifdef CONFIG_MMC_TEST
+        /*
+         * Hack: Explicitly invoking mmc_test probe to co-exist with mmcblk driver.
+         */
+        mmc_test_drv->probe(card);
+#endif
+
         return drv->probe(card);
 }
 
@@ -120,18 +131,19 @@ 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_pm_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;
+        pm_message_t state = { PM_EVENT_SUSPEND };
 
         if (dev->driver && drv->suspend)
                 ret = drv->suspend(card, state);
         return ret;
 }
 
-static int mmc_bus_resume(struct device *dev)
+static int mmc_bus_pm_resume(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
@@ -143,7 +155,6 @@ static int mmc_bus_resume(struct device *dev)
 }
 
 #ifdef CONFIG_PM_RUNTIME
-
 static int mmc_runtime_suspend(struct device *dev)
 {
         struct mmc_card *card = mmc_dev_to_card(dev);
@@ -162,21 +173,13 @@ 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_SYSTEM_SLEEP_PM_OPS(mmc_bus_pm_suspend, mmc_bus_pm_resume)
+        SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, mmc_runtime_idle)
 };
 
-#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,
@@ -184,9 +187,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)
@@ -206,6 +207,10 @@ void mmc_unregister_bus(void)
 int mmc_register_driver(struct mmc_driver *drv)
 {
         drv->drv.bus = &mmc_bus_type;
+#ifdef CONFIG_MMC_TEST
+        if (!strcmp(drv->drv.name, "mmc_test"))
+                mmc_test_drv = drv;
+#endif
         return driver_register(&drv->drv);
 }
 
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 7843efe2235..2a288e936a8 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -5,6 +5,7 @@
  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
  *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
+ *  Copyright (c) 2012 NVIDIA Corporation, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -23,6 +24,8 @@
 #include <linux/log2.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
+#include <linux/suspend.h>
+#include <linux/wakelock.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -106,6 +109,11 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 
                 cmd->retries--;
                 cmd->error = 0;
+                if (mrq->data) {
+                        mrq->data->error = 0;
+                        if (mrq->stop)
+                                mrq->stop->error = 0;
+                }
                 host->ops->request(host, mrq);
         } else {
                 led_trigger_event(host->led, LED_OFF);
@@ -132,7 +140,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
                 if (mrq->done)
                         mrq->done(mrq);
 
-                mmc_host_clk_gate(host);
+                mmc_host_clk_release(host);
         }
 }
 
@@ -191,17 +199,117 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
-        mmc_host_clk_ungate(host);
+        mmc_host_clk_hold(host);
         led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
 
 static void mmc_wait_done(struct mmc_request *mrq)
 {
-        complete(mrq->done_data);
+        complete(&mrq->completion);
+}
+
+static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
+{
+        init_completion(&mrq->completion);
+        mrq->done = mmc_wait_done;
+        mmc_start_request(host, mrq);
+}
+
+static void mmc_wait_for_req_done(struct mmc_host *host,
+                                  struct mmc_request *mrq)
+{
+        wait_for_completion(&mrq->completion);
+}
+
+/**
+ *      mmc_pre_req - Prepare for a new request
+ *      @host: MMC host to prepare command
+ *      @mrq: MMC request to prepare for
+ *      @is_first_req: true if there is no previous started request
+ *                     that may run in parellel to this call, otherwise false
+ *
+ *      mmc_pre_req() is called in prior to mmc_start_req() to let
+ *      host prepare for the new request. Preparation of a request may be
+ *      performed while another request is running on the host.
+ */
+static void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq,
+                 bool is_first_req)
+{
+        if (host->ops->pre_req)
+                host->ops->pre_req(host, mrq, is_first_req);
+}
+
+/**
+ *      mmc_post_req - Post process a completed request
+ *      @host: MMC host to post process command
+ *      @mrq: MMC request to post process for
+ *      @err: Error, if non zero, clean up any resources made in pre_req
+ *
+ *      Let the host post process a completed request. Post processing of
+ *      a request may be performed while another reuqest is running.
+ */
+static void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq,
+                         int err)
+{
+        if (host->ops->post_req)
+                host->ops->post_req(host, mrq, err);
 }
 
 /**
+ *      mmc_start_req - start a non-blocking request
+ *      @host: MMC host to start command
+ *      @areq: async request to start
+ *      @error: out parameter returns 0 for success, otherwise non zero
+ *
+ *      Start a new MMC custom command request for a host.
+ *      If there is on ongoing async request wait for completion
+ *      of that request and start the new one and return.
+ *      Does not wait for the new request to complete.
+ *
+ *      Returns the completed request, NULL in case of none completed.
+ *      Wait for the an ongoing request (previoulsy started) to complete and
+ *      return the completed request. If there is no ongoing request, NULL
+ *      is returned without waiting. NULL is not an error condition.
+ */
+struct mmc_async_req *mmc_start_req(struct mmc_host *host,
+                                    struct mmc_async_req *areq, int *error)
+{
+        int err = 0;
+        struct mmc_async_req *data = host->areq;
+
+        /* Prepare a new request */
+        if (areq)
+                mmc_pre_req(host, areq->mrq, !host->areq);
+
+        if (host->areq) {
+                mmc_wait_for_req_done(host, host->areq->mrq);
+                err = host->areq->err_check(host->card, host->areq);
+                if (err) {
+                        mmc_post_req(host, host->areq->mrq, 0);
+                        if (areq)
+                                mmc_post_req(host, areq->mrq, -EINVAL);
+
+                        host->areq = NULL;
+                        goto out;
+                }
+        }
+
+        if (areq)
+                __mmc_start_req(host, areq->mrq);
+
+        if (host->areq)
+                mmc_post_req(host, host->areq->mrq, 0);
+
+        host->areq = areq;
+ out:
+        if (error)
+                *error = err;
+        return data;
+}
+EXPORT_SYMBOL(mmc_start_req);
+
+/**
  *      mmc_wait_for_req - start a request and wait for completion
  *      @host: MMC host to start command
  *      @mrq: MMC request to start
@@ -212,17 +320,114 @@ static void mmc_wait_done(struct mmc_request *mrq)
  */
 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
 {
-        DECLARE_COMPLETION_ONSTACK(complete);
+        __mmc_start_req(host, mrq);
+        mmc_wait_for_req_done(host, mrq);
+}
+EXPORT_SYMBOL(mmc_wait_for_req);
 
-        mrq->done_data = &complete;
-        mrq->done = mmc_wait_done;
+/**
+ *      mmc_bkops_start - Issue start for mmc background ops
+ *      @card: the MMC card associated with bkops
+ *      @is_synchronous: is the backops synchronous
+ *
+ *      Issued background ops without the busy wait.
+ */
+int mmc_bkops_start(struct mmc_card *card, bool is_synchronous)
+{
+        int err;
+        unsigned long flags;
 
-        mmc_start_request(host, mrq);
+        BUG_ON(!card);
+
+        if (!card->ext_csd.bk_ops_en || mmc_card_doing_bkops(card))
+                return 1;
+
+        mmc_claim_host(card->host);
+        err = mmc_send_bk_ops_cmd(card, is_synchronous);
+        if (err)
+                pr_err("%s: abort bk ops (%d error)\n",
+                        mmc_hostname(card->host), err);
 
-        wait_for_completion(&complete);
+        /*
+         * Incase of asynchronous backops, set card state
+         * to doing bk ops to ensure that HPI is issued before
+         * handling any new request in the queue.
+         */
+                spin_lock_irqsave(&card->host->lock, flags);
+                mmc_card_clr_need_bkops(card);
+                if (!is_synchronous)
+                        mmc_card_set_doing_bkops(card);
+                spin_unlock_irqrestore(&card->host->lock, flags);
+
+        mmc_release_host(card->host);
+
+        return err;
 }
+EXPORT_SYMBOL(mmc_bkops_start);
 
-EXPORT_SYMBOL(mmc_wait_for_req);
+/**
+ *      mmc_interrupt_hpi - Issue for High priority Interrupt
+ *      @card: the MMC card associated with the HPI transfer
+ *
+ *      Issued High Priority Interrupt, and check for card status
+ *      util out-of prg-state.
+ */
+int mmc_interrupt_hpi(struct mmc_card *card)
+{
+        int err;
+        u32 status;
+        unsigned long flags;
+
+        BUG_ON(!card);
+
+        if (!mmc_card_mmc(card))
+                return 1;
+
+        if (!card->ext_csd.hpi_en) {
+                pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
+                return 1;
+        }
+
+        mmc_claim_host(card->host);
+        err = mmc_send_status(card, &status);
+        if (err) {
+                pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
+                goto out;
+        }
+
+        /*
+         * If the card status is in PRG-state, we can send the HPI command.
+         */
+        if (R1_CURRENT_STATE(status) == R1_STATE_PRG) {
+                do {
+                        /*
+                         * We don't know when the HPI command will finish
+                         * processing, so we need to resend HPI until out
+                         * of prg-state, and keep checking the card status
+                         * with SEND_STATUS.  If a timeout error occurs when
+                         * sending the HPI command, we are already out of
+                         * prg-state.
+                         */
+                        err = mmc_send_hpi_cmd(card, &status);
+                        if (err)
+                                pr_debug("%s: abort HPI (%d error)\n",
+                                         mmc_hostname(card->host), err);
+
+                        err = mmc_send_status(card, &status);
+                        if (err)
+                                break;
+                } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
+        } else
+                pr_debug("%s: Left prg-state\n", mmc_hostname(card->host));
+
+out:
+        spin_lock_irqsave(&card->host->lock, flags);
+        mmc_card_clr_doing_bkops(card);
+        spin_unlock_irqrestore(&card->host->lock, flags);
+        mmc_release_host(card->host);
+        return err;
+}
+EXPORT_SYMBOL(mmc_interrupt_hpi);
 
 /**
  *      mmc_wait_for_cmd - start a command and wait for completion
@@ -634,15 +839,17 @@ static inline void mmc_set_ios(struct mmc_host *host)
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.chip_select = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
-void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
         WARN_ON(hz < host->f_min);
 
@@ -653,6 +860,13 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+{
+        mmc_host_clk_hold(host);
+        __mmc_set_clock(host, hz);
+        mmc_host_clk_release(host);
+}
+
 #ifdef CONFIG_MMC_CLKGATE
 /*
  * This gates the clock by setting it to 0 Hz.
@@ -685,7 +899,7 @@ void mmc_ungate_clock(struct mmc_host *host)
         if (host->clk_old) {
                 BUG_ON(host->ios.clock);
                 /* This call will also set host->clk_gated to false */
-                mmc_set_clock(host, host->clk_old);
+                __mmc_set_clock(host, host->clk_old);
         }
 }
 
@@ -713,8 +927,10 @@ void mmc_set_ungated(struct mmc_host *host)
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_mode = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -722,8 +938,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_width = width;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /**
@@ -921,8 +1139,10 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 
                 ocr &= 3 << bit;
 
+                mmc_host_clk_hold(host);
                 host->ios.vdd = bit;
                 mmc_set_ios(host);
+                mmc_host_clk_release(host);
         } else {
                 pr_warning("%s: host doesn't support card's voltages\n",
                                 mmc_hostname(host));
@@ -969,8 +1189,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
+        mmc_host_clk_hold(host);
         host->ios.timing = timing;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -978,8 +1200,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
  */
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
 {
+        mmc_host_clk_hold(host);
         host->ios.drv_type = drv_type;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -997,6 +1221,8 @@ static void mmc_power_up(struct mmc_host *host)
 {
         int bit;
 
+        mmc_host_clk_hold(host);
+
         /* If ocr is set, we use it */
         if (host->ocr)
                 bit = ffs(host->ocr) - 1;
@@ -1032,10 +1258,14 @@ static void mmc_power_up(struct mmc_host *host)
          * time required to reach a stable voltage.
          */
         mmc_delay(10);
+
+        mmc_host_clk_release(host);
 }
 
-static void mmc_power_off(struct mmc_host *host)
+void mmc_power_off(struct mmc_host *host)
 {
+        mmc_host_clk_hold(host);
+
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
@@ -1053,6 +1283,8 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ios.timing = MMC_TIMING_LEGACY;
         mmc_set_ios(host);
+
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1094,6 +1326,36 @@ static inline void mmc_bus_put(struct mmc_host *host)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+int mmc_resume_bus(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        if (!mmc_bus_needs_resume(host))
+                return -EINVAL;
+
+        printk("%s: Starting deferred resume\n", mmc_hostname(host));
+        spin_lock_irqsave(&host->lock, flags);
+        host->bus_resume_flags &= ~MMC_BUSRESUME_NEEDS_RESUME;
+        host->rescan_disable = 0;
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        mmc_bus_get(host);
+        if (host->bus_ops && !host->bus_dead) {
+                mmc_power_up(host);
+                BUG_ON(!host->bus_ops->resume);
+                host->bus_ops->resume(host);
+        }
+
+        if (host->bus_ops->detect && !host->bus_dead)
+                host->bus_ops->detect(host);
+
+        mmc_bus_put(host);
+        printk("%s: Deferred resume completed\n", mmc_hostname(host));
+        return 0;
+}
+
+EXPORT_SYMBOL(mmc_resume_bus);
+
 /*
  * Assign a mmc bus handler to a host. Only one bus handler may control a
  * host at any given time.
@@ -1120,8 +1382,7 @@ void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 }
 
 /*
- * Remove the current bus handler from a host. Assumes that there are
- * no interesting cards left, so the bus is powered down.
+ * Remove the current bus handler from a host.
  */
 void mmc_detach_bus(struct mmc_host *host)
 {
@@ -1138,8 +1399,6 @@ void mmc_detach_bus(struct mmc_host *host)
 
         spin_unlock_irqrestore(&host->lock, flags);
 
-        mmc_power_off(host);
-
         mmc_bus_put(host);
 }
 
@@ -1162,6 +1421,7 @@ void mmc_detect_change(struct mmc_host *host, unsigned long delay)
         spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
+        wake_lock(&host->detect_wake_lock);
         mmc_schedule_delayed_work(&host->detect, delay);
 }
 
@@ -1408,7 +1668,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                         goto out;
                 }
         } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
-                 R1_CURRENT_STATE(cmd.resp[0]) == 7);
+                 R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
 out:
         return err;
 }
@@ -1516,6 +1776,82 @@ int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
 }
 EXPORT_SYMBOL(mmc_erase_group_aligned);
 
+static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
+                                            unsigned int arg)
+{
+        struct mmc_host *host = card->host;
+        unsigned int max_discard, x, y, qty = 0, max_qty, timeout;
+        unsigned int last_timeout = 0;
+
+        if (card->erase_shift)
+                max_qty = UINT_MAX >> card->erase_shift;
+        else if (mmc_card_sd(card))
+                max_qty = UINT_MAX;
+        else
+                max_qty = UINT_MAX / card->erase_size;
+
+        /* Find the largest qty with an OK timeout */
+        do {
+                y = 0;
+                for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
+                        timeout = mmc_erase_timeout(card, arg, qty + x);
+                        if (timeout > host->max_discard_to)
+                                break;
+                        if (timeout < last_timeout)
+                                break;
+                        last_timeout = timeout;
+                        y = x;
+                }
+                qty += y;
+        } while (y);
+
+        if (!qty)
+                return 0;
+
+        if (qty == 1)
+                return 1;
+
+        /* Convert qty to sectors */
+        if (card->erase_shift)
+                max_discard = --qty << card->erase_shift;
+        else if (mmc_card_sd(card))
+                max_discard = qty;
+        else
+                max_discard = --qty * card->erase_size;
+
+        return max_discard;
+}
+
+unsigned int mmc_calc_max_discard(struct mmc_card *card)
+{
+        struct mmc_host *host = card->host;
+        unsigned int max_discard, max_trim;
+
+        if (!host->max_discard_to)
+                return UINT_MAX;
+
+        /*
+         * Without erase_group_def set, MMC erase timeout depends on clock
+         * frequence which can change.  In that case, the best choice is
+         * just the preferred erase size.
+         */
+        if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
+                return card->pref_erase;
+
+        max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
+        if (mmc_can_trim(card)) {
+                max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
+                if (max_trim < max_discard)
+                        max_discard = max_trim;
+        } else if (max_discard < card->erase_size) {
+                max_discard = 0;
+        }
+        pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
+                 mmc_hostname(host), max_discard, host->max_discard_to);
+        return max_discard;
+}
+EXPORT_SYMBOL(mmc_calc_max_discard);
+
 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
 {
         struct mmc_command cmd = {0};
@@ -1568,6 +1904,7 @@ void mmc_rescan(struct work_struct *work)
         struct mmc_host *host =
                 container_of(work, struct mmc_host, detect.work);
         int i;
+        bool extend_wakelock = false;
 
         if (host->rescan_disable)
                 return;
@@ -1582,6 +1919,12 @@ void mmc_rescan(struct work_struct *work)
             && !(host->caps & MMC_CAP_NONREMOVABLE))
                 host->bus_ops->detect(host);
 
+        /* If the card was removed the bus will be marked
+         * as dead - extend the wakelock so userspace
+         * can respond */
+        if (host->bus_dead)
+                extend_wakelock = 1;
+
         /*
          * Let mmc_bus_put() free the bus/bus_ops if we've found that
          * the card is no longer present.
@@ -1606,16 +1949,24 @@ void mmc_rescan(struct work_struct *work)
 
         mmc_claim_host(host);
         for (i = 0; i < ARRAY_SIZE(freqs); i++) {
-                if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
+                if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) {
+                        extend_wakelock = true;
                         break;
+                }
                 if (freqs[i] <= host->f_min)
                         break;
         }
         mmc_release_host(host);
 
  out:
-        if (host->caps & MMC_CAP_NEEDS_POLL)
+        if (extend_wakelock)
+                wake_lock_timeout(&host->detect_wake_lock, HZ / 2);
+        else
+                wake_unlock(&host->detect_wake_lock);
+        if (host->caps & MMC_CAP_NEEDS_POLL) {
+                wake_lock(&host->detect_wake_lock);
                 mmc_schedule_delayed_work(&host->detect, HZ);
+        }
 }
 
 void mmc_start_host(struct mmc_host *host)
@@ -1635,7 +1986,8 @@ void mmc_stop_host(struct mmc_host *host)
 
         if (host->caps & MMC_CAP_DISABLE)
                 cancel_delayed_work(&host->disable);
-        cancel_delayed_work_sync(&host->detect);
+        if (cancel_delayed_work_sync(&host->detect))
+                wake_unlock(&host->detect_wake_lock);
         mmc_flush_scheduled_work();
 
         /* clear pm flags now and let card drivers set them as needed */
@@ -1648,6 +2000,7 @@ void mmc_stop_host(struct mmc_host *host)
 
                 mmc_claim_host(host);
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
                 mmc_bus_put(host);
                 return;
@@ -1663,6 +2016,10 @@ int mmc_power_save_host(struct mmc_host *host)
 {
         int ret = 0;
 
+#ifdef CONFIG_MMC_DEBUG
+        pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
+#endif
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
@@ -1685,6 +2042,10 @@ int mmc_power_restore_host(struct mmc_host *host)
 {
         int ret;
 
+#ifdef CONFIG_MMC_DEBUG
+        pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
+#endif
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
@@ -1751,9 +2112,17 @@ int mmc_suspend_host(struct mmc_host *host)
 {
         int err = 0;
 
+        if (mmc_bus_needs_resume(host))
+                return 0;
+
+        if (mmc_card_mmc(host->card) && mmc_card_doing_bkops(host->card))
+                mmc_interrupt_hpi(host->card);
+        mmc_card_clr_need_bkops(host->card);
+
         if (host->caps & MMC_CAP_DISABLE)
                 cancel_delayed_work(&host->disable);
-        cancel_delayed_work(&host->detect);
+        if (cancel_delayed_work(&host->detect))
+                wake_unlock(&host->detect_wake_lock);
         mmc_flush_scheduled_work();
 
         mmc_bus_get(host);
@@ -1769,6 +2138,7 @@ int mmc_suspend_host(struct mmc_host *host)
                                 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;
@@ -1793,6 +2163,12 @@ int mmc_resume_host(struct mmc_host *host)
         int err = 0;
 
         mmc_bus_get(host);
+        if (mmc_bus_manual_resume(host)) {
+                host->bus_resume_flags |= MMC_BUSRESUME_NEEDS_RESUME;
+                mmc_bus_put(host);
+                return 0;
+        }
+
         if (host->bus_ops && !host->bus_dead) {
                 if (!mmc_card_keep_power(host)) {
                         mmc_power_up(host);
@@ -1843,9 +2219,14 @@ int mmc_pm_notify(struct notifier_block *notify_block,
         case PM_SUSPEND_PREPARE:
 
                 spin_lock_irqsave(&host->lock, flags);
+                if (mmc_bus_needs_resume(host)) {
+                        spin_unlock_irqrestore(&host->lock, flags);
+                        break;
+                }
                 host->rescan_disable = 1;
                 spin_unlock_irqrestore(&host->lock, flags);
-                cancel_delayed_work_sync(&host->detect);
+                if (cancel_delayed_work_sync(&host->detect))
+                        wake_unlock(&host->detect_wake_lock);
 
                 if (!host->bus_ops || host->bus_ops->suspend)
                         break;
@@ -1856,6 +2237,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
                         host->bus_ops->remove(host);
 
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
                 host->pm_flags = 0;
                 break;
@@ -1865,6 +2247,10 @@ int mmc_pm_notify(struct notifier_block *notify_block,
         case PM_POST_RESTORE:
 
                 spin_lock_irqsave(&host->lock, flags);
+                if (mmc_bus_manual_resume(host)) {
+                        spin_unlock_irqrestore(&host->lock, flags);
+                        break;
+                }
                 host->rescan_disable = 0;
                 spin_unlock_irqrestore(&host->lock, flags);
                 mmc_detect_change(host, 0);
@@ -1875,6 +2261,22 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 }
 #endif
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+void mmc_set_embedded_sdio_data(struct mmc_host *host,
+                                struct sdio_cis *cis,
+                                struct sdio_cccr *cccr,
+                                struct sdio_embedded_func *funcs,
+                                int num_funcs)
+{
+        host->embedded_sdio_data.cis = cis;
+        host->embedded_sdio_data.cccr = cccr;
+        host->embedded_sdio_data.funcs = funcs;
+        host->embedded_sdio_data.num_funcs = num_funcs;
+}
+
+EXPORT_SYMBOL(mmc_set_embedded_sdio_data);
+#endif
+
 static int __init mmc_init(void)
 {
         int ret;
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index d9411ed2a39..14664f1fb16 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -43,6 +43,7 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage,
                            bool cmd11);
 void mmc_set_timing(struct mmc_host *host, unsigned int timing);
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type);
+void mmc_power_off(struct mmc_host *host);
 
 static inline void mmc_delay(unsigned int ms)
 {
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index b29d3e8fd3a..e09f0a7eb65 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -119,14 +119,14 @@ static void mmc_host_clk_gate_work(struct work_struct *work)
 }
 
 /**
- *      mmc_host_clk_ungate - ungate hardware MCI clocks
+ *      mmc_host_clk_hold - ungate hardware MCI clocks
  *      @host: host to ungate.
  *
  *      Makes sure the host ios.clock is restored to a non-zero value
  *      past this call. Increase clock reference count and ungate clock
  *      if we're the first user.
  */
-void mmc_host_clk_ungate(struct mmc_host *host)
+void mmc_host_clk_hold(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -164,14 +164,14 @@ static bool mmc_host_may_gate_card(struct mmc_card *card)
 }
 
 /**
- *      mmc_host_clk_gate - gate off hardware MCI clocks
+ *      mmc_host_clk_release - gate off hardware MCI clocks
  *      @host: host to gate.
  *
  *      Calls the host driver with ios.clock set to zero as often as possible
  *      in order to gate off hardware MCI clocks. Decrease clock reference
  *      count and schedule disabling of clock.
  */
-void mmc_host_clk_gate(struct mmc_host *host)
+void mmc_host_clk_release(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -179,7 +179,7 @@ void mmc_host_clk_gate(struct mmc_host *host)
         host->clk_requests--;
         if (mmc_host_may_gate_card(host->card) &&
             !host->clk_requests)
-                schedule_work(&host->clk_gate_work);
+                queue_work(system_nrt_wq, &host->clk_gate_work);
         spin_unlock_irqrestore(&host->clk_lock, flags);
 }
 
@@ -231,7 +231,7 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
         if (cancel_work_sync(&host->clk_gate_work))
                 mmc_host_clk_gate_delayed(host);
         if (host->clk_gated)
-                mmc_host_clk_ungate(host);
+                mmc_host_clk_hold(host);
         /* There should be only one user now */
         WARN_ON(host->clk_requests > 1);
 }
@@ -284,6 +284,8 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
 
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
+        wake_lock_init(&host->detect_wake_lock, WAKE_LOCK_SUSPEND,
+                kasprintf(GFP_KERNEL, "%s_detect", mmc_hostname(host)));
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
         INIT_DELAYED_WORK_DEFERRABLE(&host->disable, mmc_host_deeper_disable);
 #ifdef CONFIG_PM
@@ -336,7 +338,8 @@ int mmc_add_host(struct mmc_host *host)
 #endif
 
         mmc_start_host(host);
-        register_pm_notifier(&host->pm_notify);
+        if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY))
+                register_pm_notifier(&host->pm_notify);
 
         return 0;
 }
@@ -353,7 +356,9 @@ EXPORT_SYMBOL(mmc_add_host);
  */
 void mmc_remove_host(struct mmc_host *host)
 {
-        unregister_pm_notifier(&host->pm_notify);
+        if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY))
+                unregister_pm_notifier(&host->pm_notify);
+
         mmc_stop_host(host);
 
 #ifdef CONFIG_DEBUG_FS
@@ -380,6 +385,7 @@ void mmc_free_host(struct mmc_host *host)
         spin_lock(&mmc_host_lock);
         idr_remove(&mmc_host_idr, host->index);
         spin_unlock(&mmc_host_lock);
+        wake_lock_destroy(&host->detect_wake_lock);
 
         put_device(&host->class_dev);
 }
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index de199f91192..fb8a5cd2e4a 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -16,16 +16,16 @@ int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
 
 #ifdef CONFIG_MMC_CLKGATE
-void mmc_host_clk_ungate(struct mmc_host *host);
-void mmc_host_clk_gate(struct mmc_host *host);
+void mmc_host_clk_hold(struct mmc_host *host);
+void mmc_host_clk_release(struct mmc_host *host);
 unsigned int mmc_host_clk_rate(struct mmc_host *host);
 
 #else
-static inline void mmc_host_clk_ungate(struct mmc_host *host)
+static inline void mmc_host_clk_hold(struct mmc_host *host)
 {
 }
 
-static inline void mmc_host_clk_gate(struct mmc_host *host)
+static inline void mmc_host_clk_release(struct mmc_host *host)
 {
 }
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index aa7d1d79b8c..69fb2275845 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -4,6 +4,7 @@
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
+ *  Copyright (c) 2012 NVIDIA Corporation, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -259,7 +260,7 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
 
         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
-        if (card->ext_csd.rev > 5) {
+        if (card->ext_csd.rev > 6) {
                 printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n",
                         mmc_hostname(card->host), card->ext_csd.rev);
                 err = -EINVAL;
@@ -359,6 +360,7 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                  * card has the Enhanced area enabled.  If so, export enhanced
                  * area offset and size to user by adding sysfs interface.
                  */
+                card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
                 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
                     (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
                         u8 hc_erase_grp_sz =
@@ -402,8 +404,28 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                         ext_csd[EXT_CSD_TRIM_MULT];
         }
 
-        if (card->ext_csd.rev >= 5)
+        card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
+        if (card->ext_csd.rev >= 5) {
                 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
+                /* check whether the eMMC card supports HPI */
+                if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
+                        card->ext_csd.hpi = 1;
+                        if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
+                                card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
+                        else
+                                card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
+                        /*
+                         * Indicate the maximum timeout to close
+                         * a command interrupted by HPI
+                         */
+                        card->ext_csd.out_of_int_time =
+                                ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
+                }
+
+                /* Check whether the eMMC card supports background ops */
+                if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1)
+                        card->ext_csd.bk_ops = 1;
+        }
 
         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
                 card->erased_byte = 0xFF;
@@ -726,6 +748,40 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         }
 
         /*
+         * Enable HPI feature (if supported)
+         */
+        if (card->ext_csd.hpi && (card->host->caps & MMC_CAP_BKOPS)) {
+                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;
+                }
+        }
+
+        /*
+         * Enable Background ops feature (if supported)
+         */
+        if (card->ext_csd.bk_ops && (card->host->caps & MMC_CAP_BKOPS)) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                        EXT_CSD_BKOPS_EN, 1, 0);
+                if (err && err != -EBADMSG)
+                        goto free_card;
+                if (err) {
+                        pr_warning("%s: Enabling BK ops failed\n",
+                                   mmc_hostname(card->host));
+                        err = 0;
+                } else {
+                        card->ext_csd.bk_ops_en = 1;
+                }
+        }
+
+        /*
          * Compute bus speed.
          */
         max_dtr = (unsigned int)-1;
@@ -891,6 +947,7 @@ static void mmc_detect(struct mmc_host *host)
 
                 mmc_claim_host(host);
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
         }
 }
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 845ce7c533b..330b968393d 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -407,7 +407,7 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
                         break;
                 if (mmc_host_is_spi(card->host))
                         break;
-        } while (R1_CURRENT_STATE(status) == 7);
+        } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
 
         if (mmc_host_is_spi(card->host)) {
                 if (status & R1_SPI_ILLEGAL_COMMAND)
@@ -547,3 +547,73 @@ int mmc_bus_test(struct mmc_card *card, u8 bus_width)
         err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
         return err;
 }
+
+int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
+{
+        struct mmc_command cmd = {0};
+        unsigned int opcode;
+        unsigned int flags;
+        int err;
+
+        opcode = card->ext_csd.hpi_cmd;
+        flags = MMC_RSP_R1 | MMC_CMD_AC;
+
+        cmd.opcode = opcode;
+        cmd.arg = card->rca << 16 | 1;
+        cmd.flags = flags;
+
+        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        if (err) {
+                pr_warn("%s: error %d interrupting operation. "
+                        "HPI command response %#x\n", mmc_hostname(card->host),
+                        err, cmd.resp[0]);
+                return err;
+        }
+        if (status)
+                *status = cmd.resp[0];
+
+        return 0;
+}
+
+int mmc_send_bk_ops_cmd(struct mmc_card *card, bool is_synchronous)
+{
+        int err;
+        struct mmc_command cmd;
+        u32 status;
+
+        BUG_ON(!card);
+        BUG_ON(!card->host);
+
+        memset(&cmd, 0, sizeof(struct mmc_command));
+
+        cmd.opcode = MMC_SWITCH;
+        cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
+                (EXT_CSD_BKOPS_EN << 16) |
+                (1 << 8) |
+                EXT_CSD_CMD_SET_NORMAL;
+        if (is_synchronous)
+                cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
+        else
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+
+        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
+        if (err)
+                return err;
+
+        /* Must check status to be sure of no errors */
+        do {
+                err = mmc_send_status(card, &status);
+                if (err)
+                        return err;
+                if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
+                        break;
+        } while (R1_CURRENT_STATE(status) == 7);
+
+        if (status & 0xFDFFA000)
+                printk(KERN_ERR "%s: unexpected status %#x after "
+                           "switch", mmc_hostname(card->host), status);
+        if (status & R1_SWITCH_ERROR)
+                return -EBADMSG;
+
+        return 0;
+}
diff --git a/drivers/mmc/core/mmc_ops.h b/drivers/mmc/core/mmc_ops.h
index 9276946fa5b..d8f157dee14 100644
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -2,6 +2,7 @@
  *  linux/drivers/mmc/core/mmc_ops.h
  *
  *  Copyright 2006-2007 Pierre Ossman
+ *  Copyright (c) 2012 NVIDIA Corporation, All Rights Reserved.
  *
  * 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
@@ -26,6 +27,8 @@ int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp);
 int mmc_spi_set_crc(struct mmc_host *host, int use_crc);
 int mmc_card_sleepawake(struct mmc_host *host, int sleep);
 int mmc_bus_test(struct mmc_card *card, u8 bus_width);
+int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status);
+int mmc_send_bk_ops_cmd(struct mmc_card *card, bool is_synchronous);
 
 #endif
 
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index ff2774128aa..cb2a9d4d451 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -348,11 +348,11 @@ static int mmc_read_switch(struct mmc_card *card)
                 }
 
                 card->sw_caps.sd3_curr_limit = status[7];
-        } else {
-                if (status[13] & 0x02)
-                        card->sw_caps.hs_max_dtr = 50000000;
         }
 
+        if (status[13] & 0x02)
+                card->sw_caps.hs_max_dtr = 50000000;
+
 out:
         kfree(status);
 
@@ -409,110 +409,141 @@ out:
 
 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 {
-        int host_drv_type = 0, card_drv_type = 0;
+        int host_drv_type = SD_DRIVER_TYPE_B;
+        int card_drv_type = SD_DRIVER_TYPE_B;
+        int drive_strength;
         int err;
 
         /*
          * If the host doesn't support any of the Driver Types A,C or D,
-         * default Driver Type B is used.
+         * or there is no board specific handler then default Driver
+         * Type B is used.
          */
         if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
             | MMC_CAP_DRIVER_TYPE_D)))
                 return 0;
 
-        if (card->host->caps & MMC_CAP_DRIVER_TYPE_A) {
-                host_drv_type = MMC_SET_DRIVER_TYPE_A;
-                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_A;
-                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_B)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_B;
-                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
-        } else if (card->host->caps & MMC_CAP_DRIVER_TYPE_C) {
-                host_drv_type = MMC_SET_DRIVER_TYPE_C;
-                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
-        } else if (!(card->host->caps & MMC_CAP_DRIVER_TYPE_D)) {
-                /*
-                 * If we are here, that means only the default driver type
-                 * B is supported by the host.
-                 */
-                host_drv_type = MMC_SET_DRIVER_TYPE_B;
-                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_B)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_B;
-                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
-                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
-        }
+        if (!card->host->ops->select_drive_strength)
+                return 0;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
+                host_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
+                host_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
+                host_drv_type |= SD_DRIVER_TYPE_D;
 
-        err = mmc_sd_switch(card, 1, 2, card_drv_type, status);
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
+                card_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                card_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
+                card_drv_type |= SD_DRIVER_TYPE_D;
+
+        /*
+         * The drive strength that the hardware can support
+         * depends on the board design.  Pass the appropriate
+         * information and let the hardware specific code
+         * return what is possible given the options
+         */
+        drive_strength = card->host->ops->select_drive_strength(
+                card->sw_caps.uhs_max_dtr,
+                host_drv_type, card_drv_type);
+
+        err = mmc_sd_switch(card, 1, 2, drive_strength, status);
         if (err)
                 return err;
 
-        if ((status[15] & 0xF) != card_drv_type) {
-                printk(KERN_WARNING "%s: Problem setting driver strength!\n",
+        if ((status[15] & 0xF) != drive_strength) {
+                printk(KERN_WARNING "%s: Problem setting drive strength!\n",
                         mmc_hostname(card->host));
                 return 0;
         }
 
-        mmc_set_driver_type(card->host, host_drv_type);
+        mmc_set_driver_type(card->host, drive_strength);
 
         return 0;
 }
 
-static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+static void sd_update_bus_speed_mode(struct mmc_card *card)
 {
-        unsigned int bus_speed = 0, timing = 0;
-        int err;
-
         /*
          * If the host doesn't support any of the UHS-I modes, fallback on
          * default speed.
          */
         if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
-            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
-                return 0;
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) {
+                card->sd_bus_speed = 0;
+                return;
+        }
 
         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
-                        bus_speed = UHS_SDR104_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR104;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
-                        bus_speed = UHS_DDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_DDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR50)) {
-                        bus_speed = UHS_SDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
-                        bus_speed = UHS_SDR25_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR25;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR12)) {
-                        bus_speed = UHS_SDR12_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR12;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
+        }
+}
+
+static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+{
+        int err;
+        unsigned int timing = 0;
+
+        switch (card->sd_bus_speed) {
+        case UHS_SDR104_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR104;
+                card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                break;
+        case UHS_DDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_DDR50;
+                card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                break;
+        case UHS_SDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR50;
+                card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                break;
+        case UHS_SDR25_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR25;
+                card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                break;
+        case UHS_SDR12_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR12;
+                card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                break;
+        default:
+                return 0;
         }
 
-        card->sd_bus_speed = bus_speed;
-        err = mmc_sd_switch(card, 1, 0, bus_speed, status);
+        err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
         if (err)
                 return err;
 
-        if ((status[16] & 0xF) != bus_speed)
+        if ((status[16] & 0xF) != card->sd_bus_speed)
                 printk(KERN_WARNING "%s: Problem setting bus speed mode!\n",
                         mmc_hostname(card->host));
         else {
                 mmc_set_timing(card->host, timing);
+                if (timing == MMC_TIMING_UHS_DDR50)
+                        mmc_card_set_ddr_mode(card);
                 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
         }
 
@@ -608,18 +639,24 @@ static int mmc_sd_init_uhs_card(struct mmc_card *card)
                 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
         }
 
+        /*
+         * Select the bus speed mode depending on host
+         * and card capability.
+         */
+        sd_update_bus_speed_mode(card);
+
         /* Set the driver strength for the card */
         err = sd_select_driver_type(card, status);
         if (err)
                 goto out;
 
-        /* Set bus speed mode of the card */
-        err = sd_set_bus_speed_mode(card, status);
+        /* Set current limit for the card */
+        err = sd_set_current_limit(card, status);
         if (err)
                 goto out;
 
-        /* Set current limit for the card */
-        err = sd_set_current_limit(card, status);
+        /* Set bus speed mode of the card */
+        err = sd_set_bus_speed_mode(card, status);
         if (err)
                 goto out;
 
@@ -764,6 +801,9 @@ int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
         bool reinit)
 {
         int err;
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        int retries;
+#endif
 
         if (!reinit) {
                 /*
@@ -790,7 +830,26 @@ int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
                 /*
                  * Fetch switch information from card.
                  */
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+                for (retries = 1; retries <= 3; retries++) {
+                        err = mmc_read_switch(card);
+                        if (!err) {
+                                if (retries > 1) {
+                                        printk(KERN_WARNING
+                                               "%s: recovered\n", 
+                                               mmc_hostname(host));
+                                }
+                                break;
+                        } else {
+                                printk(KERN_WARNING
+                                       "%s: read switch failed (attempt %d)\n",
+                                       mmc_hostname(host), retries);
+                        }
+                }
+#else
                 err = mmc_read_switch(card);
+#endif
+
                 if (err)
                         return err;
         }
@@ -989,18 +1048,36 @@ static void mmc_sd_remove(struct mmc_host *host)
  */
 static void mmc_sd_detect(struct mmc_host *host)
 {
-        int err;
+        int err = 0;
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        int retries = 5;
+#endif
 
         BUG_ON(!host);
         BUG_ON(!host->card);
-
+       
         mmc_claim_host(host);
 
         /*
          * Just check if our card has been removed.
          */
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        while(retries) {
+                err = mmc_send_status(host->card, NULL);
+                if (err) {
+                        retries--;
+                        udelay(5);
+                        continue;
+                }
+                break;
+        }
+        if (!retries) {
+                printk(KERN_ERR "%s(%s): Unable to re-detect card (%d)\n",
+                       __func__, mmc_hostname(host), err);
+        }
+#else
         err = mmc_send_status(host->card, NULL);
-
+#endif
         mmc_release_host(host);
 
         if (err) {
@@ -1008,6 +1085,7 @@ static void mmc_sd_detect(struct mmc_host *host)
 
                 mmc_claim_host(host);
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
         }
 }
@@ -1038,12 +1116,31 @@ static int mmc_sd_suspend(struct mmc_host *host)
 static int mmc_sd_resume(struct mmc_host *host)
 {
         int err;
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        int retries;
+#endif
 
         BUG_ON(!host);
         BUG_ON(!host->card);
 
         mmc_claim_host(host);
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        retries = 5;
+        while (retries) {
+                err = mmc_sd_init_card(host, host->ocr, host->card);
+
+                if (err) {
+                        printk(KERN_ERR "%s: Re-init card rc = %d (retries = %d)\n",
+                               mmc_hostname(host), err, retries);
+                        mdelay(5);
+                        retries--;
+                        continue;
+                }
+                break;
+        }
+#else
         err = mmc_sd_init_card(host, host->ocr, host->card);
+#endif
         mmc_release_host(host);
 
         return err;
@@ -1095,6 +1192,9 @@ int mmc_attach_sd(struct mmc_host *host)
 {
         int err;
         u32 ocr;
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        int retries;
+#endif
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -1159,9 +1259,27 @@ int mmc_attach_sd(struct mmc_host *host)
         /*
          * Detect and init the card.
          */
+#ifdef CONFIG_MMC_PARANOID_SD_INIT
+        retries = 5;
+        while (retries) {
+                err = mmc_sd_init_card(host, host->ocr, NULL);
+                if (err) {
+                        retries--;
+                        continue;
+                }
+                break;
+        }
+
+        if (!retries) {
+                printk(KERN_ERR "%s: mmc_sd_init_card() failure (err = %d)\n",
+                       mmc_hostname(host), err);
+                goto err;
+        }
+#else
         err = mmc_sd_init_card(host, host->ocr, NULL);
         if (err)
                 goto err;
+#endif
 
         mmc_release_host(host);
         err = mmc_add_card(host->card);
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 262fff01917..3d8a5e41a48 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -27,6 +27,10 @@
 #include "sdio_ops.h"
 #include "sdio_cis.h"
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+#include <linux/mmc/sdio_ids.h>
+#endif
+
 static int sdio_read_fbr(struct sdio_func *func)
 {
         int ret;
@@ -102,6 +106,7 @@ static int sdio_read_cccr(struct mmc_card *card)
         int ret;
         int cccr_vsn;
         unsigned char data;
+        unsigned char speed;
 
         memset(&card->cccr, 0, sizeof(struct sdio_cccr));
 
@@ -111,8 +116,8 @@ static int sdio_read_cccr(struct mmc_card *card)
 
         cccr_vsn = data & 0x0f;
 
-        if (cccr_vsn > SDIO_CCCR_REV_1_20) {
-                printk(KERN_ERR "%s: unrecognised CCCR structure version %d\n",
+        if (cccr_vsn > SDIO_CCCR_REV_3_00) {
+                pr_err("%s: unrecognised CCCR structure version %d\n",
                         mmc_hostname(card->host), cccr_vsn);
                 return -EINVAL;
         }
@@ -140,12 +145,60 @@ static int sdio_read_cccr(struct mmc_card *card)
         }
 
         if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
-                ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &data);
+                ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
                 if (ret)
                         goto out;
 
-                if (data & SDIO_SPEED_SHS)
-                        card->cccr.high_speed = 1;
+                card->scr.sda_spec3 = 0;
+                card->sw_caps.sd3_bus_mode = 0;
+                card->sw_caps.sd3_drv_type = 0;
+                if (cccr_vsn >= SDIO_CCCR_REV_3_00) {
+                        card->scr.sda_spec3 = 1;
+                        ret = mmc_io_rw_direct(card, 0, 0,
+                                SDIO_CCCR_UHS, 0, &data);
+                        if (ret)
+                                goto out;
+
+                        if (card->host->caps &
+                                (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+                                 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
+                                 MMC_CAP_UHS_DDR50)) {
+                                if (data & SDIO_UHS_DDR50)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_DDR50;
+
+                                if (data & SDIO_UHS_SDR50)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_SDR50;
+
+                                if (data & SDIO_UHS_SDR104)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_SDR104;
+                        }
+
+                        ret = mmc_io_rw_direct(card, 0, 0,
+                                SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
+                        if (ret)
+                                goto out;
+
+                        if (data & SDIO_DRIVE_SDTA)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
+                        if (data & SDIO_DRIVE_SDTC)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
+                        if (data & SDIO_DRIVE_SDTD)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
+                }
+
+                /* if no uhs mode ensure we check for high speed */
+                if (!card->sw_caps.sd3_bus_mode) {
+                        if (speed & SDIO_SPEED_SHS) {
+                                card->cccr.high_speed = 1;
+                                card->sw_caps.hs_max_dtr = 50000000;
+                        } else {
+                                card->cccr.high_speed = 0;
+                                card->sw_caps.hs_max_dtr = 25000000;
+                        }
+                }
         }
 
 out:
@@ -327,6 +380,193 @@ static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
         return max_dtr;
 }
 
+static unsigned char host_drive_to_sdio_drive(int host_strength)
+{
+        switch (host_strength) {
+        case MMC_SET_DRIVER_TYPE_A:
+                return SDIO_DTSx_SET_TYPE_A;
+        case MMC_SET_DRIVER_TYPE_B:
+                return SDIO_DTSx_SET_TYPE_B;
+        case MMC_SET_DRIVER_TYPE_C:
+                return SDIO_DTSx_SET_TYPE_C;
+        case MMC_SET_DRIVER_TYPE_D:
+                return SDIO_DTSx_SET_TYPE_D;
+        default:
+                return SDIO_DTSx_SET_TYPE_B;
+        }
+}
+
+static void sdio_select_driver_type(struct mmc_card *card)
+{
+        int host_drv_type = SD_DRIVER_TYPE_B;
+        int card_drv_type = SD_DRIVER_TYPE_B;
+        int drive_strength;
+        unsigned char card_strength;
+        int err;
+
+        /*
+         * If the host doesn't support any of the Driver Types A,C or D,
+         * or there is no board specific handler then default Driver
+         * Type B is used.
+         */
+        if (!(card->host->caps &
+                (MMC_CAP_DRIVER_TYPE_A |
+                 MMC_CAP_DRIVER_TYPE_C |
+                 MMC_CAP_DRIVER_TYPE_D)))
+                return;
+
+        if (!card->host->ops->select_drive_strength)
+                return;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
+                host_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
+                host_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
+                host_drv_type |= SD_DRIVER_TYPE_D;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
+                card_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                card_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
+                card_drv_type |= SD_DRIVER_TYPE_D;
+
+        /*
+         * The drive strength that the hardware can support
+         * depends on the board design.  Pass the appropriate
+         * information and let the hardware specific code
+         * return what is possible given the options
+         */
+        drive_strength = card->host->ops->select_drive_strength(
+                card->sw_caps.uhs_max_dtr,
+                host_drv_type, card_drv_type);
+
+        /* if error just use default for drive strength B */
+        err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
+                &card_strength);
+        if (err)
+                return;
+
+        card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
+        card_strength |= host_drive_to_sdio_drive(drive_strength);
+
+        err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
+                card_strength, NULL);
+
+        /* if error default to drive strength B */
+        if (!err)
+                mmc_set_driver_type(card->host, drive_strength);
+}
+
+
+static int sdio_set_bus_speed_mode(struct mmc_card *card)
+{
+        unsigned int bus_speed, timing;
+        int err;
+        unsigned char speed;
+
+        /*
+         * If the host doesn't support any of the UHS-I modes, fallback on
+         * default speed.
+         */
+        if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
+                return 0;
+
+        bus_speed = SDIO_SPEED_SDR12;
+        timing = MMC_TIMING_UHS_SDR12;
+        if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
+            (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
+                        bus_speed = SDIO_SPEED_SDR104;
+                        timing = MMC_TIMING_UHS_SDR104;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+        } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
+                        bus_speed = SDIO_SPEED_DDR50;
+                        timing = MMC_TIMING_UHS_DDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR50)) {
+                        bus_speed = SDIO_SPEED_SDR50;
+                        timing = MMC_TIMING_UHS_SDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
+                        bus_speed = SDIO_SPEED_SDR25;
+                        timing = MMC_TIMING_UHS_SDR25;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
+                    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR12)) {
+                        bus_speed = SDIO_SPEED_SDR12;
+                        timing = MMC_TIMING_UHS_SDR12;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+        }
+
+        err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
+        if (err)
+                return err;
+
+        speed &= ~SDIO_SPEED_BSS_MASK;
+        speed |= bus_speed;
+        err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
+        if (err)
+                return err;
+
+        if (bus_speed) {
+                mmc_set_timing(card->host, timing);
+                mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
+        }
+
+        return 0;
+}
+
+/*
+ * UHS-I specific initialization procedure
+ */
+static int mmc_sdio_init_uhs_card(struct mmc_card *card)
+{
+        int err;
+
+        if (!card->scr.sda_spec3)
+                return 0;
+
+        /*
+         * Switch to wider bus (if supported).
+         */
+        if (card->host->caps & MMC_CAP_4_BIT_DATA) {
+                err = sdio_enable_4bit_bus(card);
+                if (err > 0) {
+                        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+                        err = 0;
+                }
+        }
+
+        /* Set the driver strength for the card */
+        sdio_select_driver_type(card);
+
+        /* Set bus speed mode of the card */
+        err = sdio_set_bus_speed_mode(card);
+        if (err)
+                goto out;
+
+        /* Initialize and start re-tuning timer */
+        if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
+                err = card->host->ops->execute_tuning(card->host);
+
+out:
+
+        return err;
+}
+
 /*
  * Handle the detection and initialisation of a card.
  *
@@ -394,6 +634,29 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 host->ops->init_card(host, card);
 
         /*
+         * If the host and card support UHS-I mode request the card
+         * to switch to 1.8V signaling level.  No 1.8v signalling if
+         * UHS mode is not enabled to maintain compatibilty and some
+         * systems that claim 1.8v signalling in fact do not support
+         * it.
+         */
+        if ((ocr & R4_18V_PRESENT) &&
+                (host->caps &
+                        (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+                         MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
+                         MMC_CAP_UHS_DDR50))) {
+                err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true);
+                if (err) {
+                        ocr &= ~R4_18V_PRESENT;
+                        host->ocr &= ~R4_18V_PRESENT;
+                }
+                err = 0;
+        } else {
+                ocr &= ~R4_18V_PRESENT;
+                host->ocr &= ~R4_18V_PRESENT;
+        }
+
+        /*
          * For native busses:  set card RCA and quit open drain mode.
          */
         if (!powered_resume && !mmc_host_is_spi(host)) {
@@ -449,19 +712,35 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 goto finish;
         }
 
-        /*
-         * Read the common registers.
-         */
-        err = sdio_read_cccr(card);
-        if (err)
-                goto remove;
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        if (host->embedded_sdio_data.cccr)
+                memcpy(&card->cccr, host->embedded_sdio_data.cccr, sizeof(struct sdio_cccr));
+        else {
+#endif
+                /*
+                 * Read the common registers.
+                 */
+                err = sdio_read_cccr(card);
+                if (err)
+                        goto remove;
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        }
+#endif
 
-        /*
-         * Read the common CIS tuples.
-         */
-        err = sdio_read_common_cis(card);
-        if (err)
-                goto remove;
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        if (host->embedded_sdio_data.cis)
+                memcpy(&card->cis, host->embedded_sdio_data.cis, sizeof(struct sdio_cis));
+        else {
+#endif
+                /*
+                 * Read the common CIS tuples.
+                 */
+                err = sdio_read_common_cis(card);
+                if (err)
+                        goto remove;
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        }
+#endif
 
         if (oldcard) {
                 int same = (card->cis.vendor == oldcard->cis.vendor &&
@@ -494,29 +773,39 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
         if (err)
                 goto remove;
 
-        /*
-         * Switch to high-speed (if supported).
-         */
-        err = sdio_enable_hs(card);
-        if (err > 0)
-                mmc_sd_go_highspeed(card);
-        else if (err)
-                goto remove;
+        /* Initialization sequence for UHS-I cards */
+        /* Only if card supports 1.8v and UHS signaling */
+        if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
+                err = mmc_sdio_init_uhs_card(card);
+                if (err)
+                        goto remove;
 
-        /*
-         * Change to the card's maximum speed.
-         */
-        mmc_set_clock(host, mmc_sdio_get_max_clock(card));
+                /* Card is an ultra-high-speed card */
+                mmc_sd_card_set_uhs(card);
+        } else {
+                /*
+                 * Switch to high-speed (if supported).
+                 */
+                err = sdio_enable_hs(card);
+                if (err > 0)
+                        mmc_sd_go_highspeed(card);
+                else if (err)
+                        goto remove;
 
-        /*
-         * Switch to wider bus (if supported).
-         */
-        err = sdio_enable_4bit_bus(card);
-        if (err > 0)
-                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
-        else if (err)
-                goto remove;
+                /*
+                 * Change to the card's maximum speed.
+                 */
+                mmc_set_clock(host, mmc_sdio_get_max_clock(card));
 
+                /*
+                 * Switch to wider bus (if supported).
+                 */
+                err = sdio_enable_4bit_bus(card);
+                if (err > 0)
+                        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+                else if (err)
+                        goto remove;
+        }
 finish:
         if (!oldcard)
                 host->card = card;
@@ -597,6 +886,7 @@ out:
 
                 mmc_claim_host(host);
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
         }
 }
@@ -798,8 +1088,17 @@ int mmc_attach_sdio(struct mmc_host *host)
          * Detect and init the card.
          */
         err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
-        if (err)
-                goto err;
+        if (err) {
+                if (err == -EAGAIN) {
+                        /*
+                         * Retry initialization with S18R set to 0.
+                         */
+                        host->ocr &= ~R4_18V_PRESENT;
+                        err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
+                }
+                if (err)
+                        goto err;
+        }
         card = host->card;
 
         /*
@@ -826,14 +1125,36 @@ int mmc_attach_sdio(struct mmc_host *host)
         funcs = (ocr & 0x70000000) >> 28;
         card->sdio_funcs = 0;
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        if (host->embedded_sdio_data.funcs)
+                card->sdio_funcs = funcs = host->embedded_sdio_data.num_funcs;
+#endif
+
         /*
          * Initialize (but don't add) all present functions.
          */
         for (i = 0; i < funcs; i++, card->sdio_funcs++) {
-                err = sdio_init_func(host->card, i + 1);
-                if (err)
-                        goto remove;
-
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+                if (host->embedded_sdio_data.funcs) {
+                        struct sdio_func *tmp;
+
+                        tmp = sdio_alloc_func(host->card);
+                        if (IS_ERR(tmp))
+                                goto remove;
+                        tmp->num = (i + 1);
+                        card->sdio_func[i] = tmp;
+                        tmp->class = host->embedded_sdio_data.funcs[i].f_class;
+                        tmp->max_blksize = host->embedded_sdio_data.funcs[i].f_maxblksize;
+                        tmp->vendor = card->cis.vendor;
+                        tmp->device = card->cis.device;
+                } else {
+#endif
+                        err = sdio_init_func(host->card, i + 1);
+                        if (err)
+                                goto remove;
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+                }
+#endif
                 /*
                  * Enable Runtime PM for this func (if supported)
                  */
@@ -881,3 +1202,77 @@ err:
         return err;
 }
 
+int sdio_reset_comm(struct mmc_card *card)
+{
+        struct mmc_host *host = card->host;
+        u32 ocr;
+        int err;
+
+        printk("%s():\n", __func__);
+        mmc_claim_host(host);
+
+        mmc_go_idle(host);
+
+        mmc_set_clock(host, host->f_min);
+
+        err = mmc_send_io_op_cond(host, 0, &ocr);
+        if (err)
+                goto err;
+
+        host->ocr = mmc_select_voltage(host, ocr);
+        if (!host->ocr) {
+                err = -EINVAL;
+                goto err;
+        }
+
+        err = mmc_send_io_op_cond(host, host->ocr, &ocr);
+        if (err)
+                goto err;
+
+        if (mmc_host_is_spi(host)) {
+                err = mmc_spi_set_crc(host, use_spi_crc);
+                if (err)
+                        goto err;
+        }
+
+        if (!mmc_host_is_spi(host)) {
+                err = mmc_send_relative_addr(host, &card->rca);
+                if (err)
+                        goto err;
+                mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+        }
+        if (!mmc_host_is_spi(host)) {
+                err = mmc_select_card(card);
+                if (err)
+                        goto err;
+        }
+
+        /*
+         * Switch to high-speed (if supported).
+         */
+        err = sdio_enable_hs(card);
+        if (err > 0)
+                mmc_sd_go_highspeed(card);
+        else if (err)
+                goto err;
+
+        /*
+         * Change to the card's maximum speed.
+         */
+        mmc_set_clock(host, mmc_sdio_get_max_clock(card));
+
+        err = sdio_enable_4bit_bus(card);
+        if (err > 0)
+                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+        else if (err)
+                goto err;
+
+        mmc_release_host(host);
+        return 0;
+err:
+        printk("%s: Error resetting SDIO communications (%d)\n",
+               mmc_hostname(host), err);
+        mmc_release_host(host);
+        return err;
+}
+EXPORT_SYMBOL(sdio_reset_comm);
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index d2565df8a7f..ca58c307a12 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -23,6 +23,10 @@
 #include "sdio_cis.h"
 #include "sdio_bus.h"
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+#include <linux/mmc/host.h>
+#endif
+
 /* show configuration fields */
 #define sdio_config_attr(field, format_string)                          \
 static ssize_t                                                          \
@@ -167,11 +171,8 @@ static int sdio_bus_remove(struct device *dev)
         int ret = 0;
 
         /* Make sure card is powered before invoking ->remove() */
-        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
-                ret = pm_runtime_get_sync(dev);
-                if (ret < 0)
-                        goto out;
-        }
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_get_sync(dev);
 
         drv->remove(func);
 
@@ -191,7 +192,6 @@ static int sdio_bus_remove(struct device *dev)
         if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
                 pm_runtime_put_sync(dev);
 
-out:
         return ret;
 }
 
@@ -260,7 +260,14 @@ static void sdio_release_func(struct device *dev)
 {
         struct sdio_func *func = dev_to_sdio_func(dev);
 
-        sdio_free_func_cis(func);
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        /*
+         * If this device is embedded then we never allocated
+         * cis tables for this func
+         */
+        if (!func->card->host->embedded_sdio_data.funcs)
+#endif
+                sdio_free_func_cis(func);
 
         if (func->info)
                 kfree(func->info);
diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index 0f687cdeb06..549a3414464 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -383,6 +383,39 @@ u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret)
 EXPORT_SYMBOL_GPL(sdio_readb);
 
 /**
+ *      sdio_readb_ext - read a single byte from a SDIO function
+ *      @func: SDIO function to access
+ *      @addr: address to read
+ *      @err_ret: optional status value from transfer
+ *      @in: value to add to argument
+ *
+ *      Reads a single byte from the address space of a given SDIO
+ *      function. If there is a problem reading the address, 0xff
+ *      is returned and @err_ret will contain the error code.
+ */
+unsigned char sdio_readb_ext(struct sdio_func *func, unsigned int addr,
+        int *err_ret, unsigned in)
+{
+        int ret;
+        unsigned char val;
+
+        BUG_ON(!func);
+
+        if (err_ret)
+                *err_ret = 0;
+
+        ret = mmc_io_rw_direct(func->card, 0, func->num, addr, (u8)in, &val);
+        if (ret) {
+                if (err_ret)
+                        *err_ret = ret;
+                return 0xFF;
+        }
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(sdio_readb_ext);
+
+/**
  *      sdio_writeb - write a single byte to a SDIO function
  *      @func: SDIO function to access
  *      @b: byte to write
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 56dbf3f6ad0..8c87096531e 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -81,28 +81,32 @@ config MMC_RICOH_MMC
 
           If unsure, say Y.
 
-config MMC_SDHCI_OF
-        tristate "SDHCI support on OpenFirmware platforms"
-        depends on MMC_SDHCI && OF
+config MMC_SDHCI_PLTFM
+        tristate "SDHCI platform and OF driver helper"
+        depends on MMC_SDHCI
         help
-          This selects the OF support for Secure Digital Host Controller
-          Interfaces.
+          This selects the common helper functions support for Secure Digital
+          Host Controller Interface based platform and OF drivers.
+
+          If you have a controller with this interface, say Y or M here.
 
           If unsure, say N.
 
 config MMC_SDHCI_OF_ESDHC
-        bool "SDHCI OF support for the Freescale eSDHC controller"
-        depends on MMC_SDHCI_OF
+        tristate "SDHCI OF support for the Freescale eSDHC controller"
+        depends on MMC_SDHCI_PLTFM
         depends on PPC_OF
         select MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
         help
           This selects the Freescale eSDHC controller support.
 
+          If you have a controller with this interface, say Y or M here.
+
           If unsure, say N.
 
 config MMC_SDHCI_OF_HLWD
-        bool "SDHCI OF support for the Nintendo Wii SDHCI controllers"
-        depends on MMC_SDHCI_OF
+        tristate "SDHCI OF support for the Nintendo Wii SDHCI controllers"
+        depends on MMC_SDHCI_PLTFM
         depends on PPC_OF
         select MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
         help
@@ -110,40 +114,36 @@ config MMC_SDHCI_OF_HLWD
           found in the "Hollywood" chipset of the Nintendo Wii video game
           console.
 
-          If unsure, say N.
-
-config MMC_SDHCI_PLTFM
-        tristate "SDHCI support on the platform specific bus"
-        depends on MMC_SDHCI
-        help
-          This selects the platform specific bus support for Secure Digital Host
-          Controller Interface.
-
           If you have a controller with this interface, say Y or M here.
 
           If unsure, say N.
 
 config MMC_SDHCI_CNS3XXX
-        bool "SDHCI support on the Cavium Networks CNS3xxx SoC"
+        tristate "SDHCI support on the Cavium Networks CNS3xxx SoC"
         depends on ARCH_CNS3XXX
         depends on MMC_SDHCI_PLTFM
         help
           This selects the SDHCI support for CNS3xxx System-on-Chip devices.
 
+          If you have a controller with this interface, say Y or M here.
+
           If unsure, say N.
 
 config MMC_SDHCI_ESDHC_IMX
-        bool "SDHCI platform support for the Freescale eSDHC i.MX controller"
-        depends on MMC_SDHCI_PLTFM && (ARCH_MX25 || ARCH_MX35 || ARCH_MX5)
+        tristate "SDHCI platform support for the Freescale eSDHC i.MX controller"
+        depends on ARCH_MX25 || ARCH_MX35 || ARCH_MX5
+        depends on MMC_SDHCI_PLTFM
         select MMC_SDHCI_IO_ACCESSORS
         help
           This selects the Freescale eSDHC controller support on the platform
           bus, found on platforms like mx35/51.
 
+          If you have a controller with this interface, say Y or M here.
+
           If unsure, say N.
 
 config MMC_SDHCI_DOVE
-        bool "SDHCI support on Marvell's Dove SoC"
+        tristate "SDHCI support on Marvell's Dove SoC"
         depends on ARCH_DOVE
         depends on MMC_SDHCI_PLTFM
         select MMC_SDHCI_IO_ACCESSORS
@@ -151,11 +151,14 @@ config MMC_SDHCI_DOVE
           This selects the Secure Digital Host Controller Interface in
           Marvell's Dove SoC.
 
+          If you have a controller with this interface, say Y or M here.
+
           If unsure, say N.
 
 config MMC_SDHCI_TEGRA
-        bool "SDHCI platform support for the Tegra SD/MMC Controller"
-        depends on MMC_SDHCI_PLTFM && ARCH_TEGRA
+        tristate "SDHCI platform support for the Tegra SD/MMC Controller"
+        depends on ARCH_TEGRA
+        depends on MMC_SDHCI_PLTFM
         select MMC_SDHCI_IO_ACCESSORS
         help
           This selects the Tegra SD/MMC controller. If you have a Tegra
@@ -178,14 +181,28 @@ config MMC_SDHCI_S3C
 
           If unsure, say N.
 
-config MMC_SDHCI_PXA
-        tristate "Marvell PXA168/PXA910/MMP2 SD Host Controller support"
-        depends on ARCH_PXA || ARCH_MMP
+config MMC_SDHCI_PXAV3
+        tristate "Marvell MMP2 SD Host Controller support (PXAV3)"
+        depends on CLKDEV_LOOKUP
         select MMC_SDHCI
-        select MMC_SDHCI_IO_ACCESSORS
+        select MMC_SDHCI_PLTFM
+        default CPU_MMP2
+        help
+          This selects the Marvell(R) PXAV3 SD Host Controller.
+          If you have a MMP2 platform with SD Host Controller
+          and a card slot, say Y or M here.
+
+          If unsure, say N.
+
+config MMC_SDHCI_PXAV2
+        tristate "Marvell PXA9XX SD Host Controller support (PXAV2)"
+        depends on CLKDEV_LOOKUP
+        select MMC_SDHCI
+        select MMC_SDHCI_PLTFM
+        default CPU_PXA910
         help
-          This selects the Marvell(R) PXA168/PXA910/MMP2 SD Host Controller.
-          If you have a PXA168/PXA910/MMP2 platform with SD Host Controller
+          This selects the Marvell(R) PXAV2 SD Host Controller.
+          If you have a PXA9XX platform with SD Host Controller
           and a card slot, say Y or M here.
 
           If unsure, say N.
@@ -281,13 +298,12 @@ config MMC_ATMELMCI
 endchoice
 
 config MMC_ATMELMCI_DMA
-        bool "Atmel MCI DMA support (EXPERIMENTAL)"
-        depends on MMC_ATMELMCI && (AVR32 || ARCH_AT91SAM9G45) && DMA_ENGINE && EXPERIMENTAL
+        bool "Atmel MCI DMA support"
+        depends on MMC_ATMELMCI && (AVR32 || ARCH_AT91SAM9G45) && DMA_ENGINE
         help
           Say Y here to have the Atmel MCI driver use a DMA engine to
           do data transfers and thus increase the throughput and
-          reduce the CPU utilization. Note that this is highly
-          experimental and may cause the driver to lock up.
+          reduce the CPU utilization.
 
           If unsure, say N.
 
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 58a5cf73d6e..f5ea51bd0ed 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -1,6 +1,7 @@
 #
 # Makefile for MMC/SD host controller drivers
 #
+GCOV_PROFILE_sdhci-tegra.o := y
 
 obj-$(CONFIG_MMC_ARMMMCI)       += mmci.o
 obj-$(CONFIG_MMC_PXA)           += pxamci.o
@@ -9,7 +10,8 @@ obj-$(CONFIG_MMC_MXC)		+= mxcmmc.o
 obj-$(CONFIG_MMC_MXS)           += mxs-mmc.o
 obj-$(CONFIG_MMC_SDHCI)         += sdhci.o
 obj-$(CONFIG_MMC_SDHCI_PCI)     += sdhci-pci.o
-obj-$(CONFIG_MMC_SDHCI_PXA)     += sdhci-pxa.o
+obj-$(CONFIG_MMC_SDHCI_PXAV3)   += sdhci-pxav3.o
+obj-$(CONFIG_MMC_SDHCI_PXAV2)   += sdhci-pxav2.o
 obj-$(CONFIG_MMC_SDHCI_S3C)     += sdhci-s3c.o
 obj-$(CONFIG_MMC_SDHCI_SPEAR)   += sdhci-spear.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
@@ -31,9 +33,7 @@ obj-$(CONFIG_MMC_SDRICOH_CS)	+= sdricoh_cs.o
 obj-$(CONFIG_MMC_TMIO)          += tmio_mmc.o
 obj-$(CONFIG_MMC_TMIO_CORE)     += tmio_mmc_core.o
 tmio_mmc_core-y                 := tmio_mmc_pio.o
-ifneq ($(CONFIG_MMC_SDHI),n)
-tmio_mmc_core-y                 += tmio_mmc_dma.o
-endif
+tmio_mmc_core-$(subst m,y,$(CONFIG_MMC_SDHI))   += tmio_mmc_dma.o
 obj-$(CONFIG_MMC_SDHI)          += sh_mobile_sdhi.o
 obj-$(CONFIG_MMC_CB710)         += cb710-mmc.o
 obj-$(CONFIG_MMC_VIA_SDMMC)     += via-sdmmc.o
@@ -44,17 +44,13 @@ obj-$(CONFIG_MMC_JZ4740)	+= jz4740_mmc.o
 obj-$(CONFIG_MMC_VUB300)        += vub300.o
 obj-$(CONFIG_MMC_USHC)          += ushc.o
 
-obj-$(CONFIG_MMC_SDHCI_PLTFM)                   += sdhci-platform.o
-sdhci-platform-y                                := sdhci-pltfm.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_CNS3XXX)      += sdhci-cns3xxx.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_ESDHC_IMX)    += sdhci-esdhc-imx.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_DOVE)         += sdhci-dove.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_TEGRA)        += sdhci-tegra.o
-
-obj-$(CONFIG_MMC_SDHCI_OF)      += sdhci-of.o
-sdhci-of-y                              := sdhci-of-core.o
-sdhci-of-$(CONFIG_MMC_SDHCI_OF_ESDHC)   += sdhci-of-esdhc.o
-sdhci-of-$(CONFIG_MMC_SDHCI_OF_HLWD)    += sdhci-of-hlwd.o
+obj-$(CONFIG_MMC_SDHCI_PLTFM)           += sdhci-pltfm.o
+obj-$(CONFIG_MMC_SDHCI_CNS3XXX)         += sdhci-cns3xxx.o
+obj-$(CONFIG_MMC_SDHCI_ESDHC_IMX)       += sdhci-esdhc-imx.o
+obj-$(CONFIG_MMC_SDHCI_DOVE)            += sdhci-dove.o
+obj-$(CONFIG_MMC_SDHCI_TEGRA)           += sdhci-tegra.o
+obj-$(CONFIG_MMC_SDHCI_OF_ESDHC)        += sdhci-of-esdhc.o
+obj-$(CONFIG_MMC_SDHCI_OF_HLWD)         += sdhci-of-hlwd.o
 
 ifeq ($(CONFIG_CB710_DEBUG),y)
         CFLAGS-cb710-mmc        += -DDEBUG
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index d3e6a962f42..a4aa3af86fe 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -77,7 +77,8 @@
 
 #include <mach/board.h>
 #include <mach/cpu.h>
-#include <mach/at91_mci.h>
+
+#include "at91_mci.h"
 
 #define DRIVER_NAME "at91_mci"
 
diff --git a/drivers/mmc/host/at91_mci.h b/drivers/mmc/host/at91_mci.h
new file mode 100644
index 00000000000..eec3a6b1c2b
--- /dev/null
+++ b/drivers/mmc/host/at91_mci.h
@@ -0,0 +1,115 @@
+/*
+ * drivers/mmc/host/at91_mci.h
+ *
+ * Copyright (C) 2005 Ivan Kokshaysky
+ * Copyright (C) SAN People
+ *
+ * MultiMedia Card Interface (MCI) registers.
+ * Based on AT91RM9200 datasheet revision F.
+ *
+ * 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.
+ */
+
+#ifndef AT91_MCI_H
+#define AT91_MCI_H
+
+#define AT91_MCI_CR             0x00            /* Control Register */
+#define         AT91_MCI_MCIEN          (1 <<  0)       /* Multi-Media Interface Enable */
+#define         AT91_MCI_MCIDIS         (1 <<  1)       /* Multi-Media Interface Disable */
+#define         AT91_MCI_PWSEN          (1 <<  2)       /* Power Save Mode Enable */
+#define         AT91_MCI_PWSDIS         (1 <<  3)       /* Power Save Mode Disable */
+#define         AT91_MCI_SWRST          (1 <<  7)       /* Software Reset */
+
+#define AT91_MCI_MR             0x04            /* Mode Register */
+#define         AT91_MCI_CLKDIV         (0xff  <<  0)   /* Clock Divider */
+#define         AT91_MCI_PWSDIV         (7     <<  8)   /* Power Saving Divider */
+#define         AT91_MCI_RDPROOF        (1     << 11)   /* Read Proof Enable [SAM926[03] only] */
+#define         AT91_MCI_WRPROOF        (1     << 12)   /* Write Proof Enable [SAM926[03] only] */
+#define         AT91_MCI_PDCFBYTE       (1     << 13)   /* PDC Force Byte Transfer [SAM926[03] only] */
+#define         AT91_MCI_PDCPADV        (1     << 14)   /* PDC Padding Value */
+#define         AT91_MCI_PDCMODE        (1     << 15)   /* PDC-orientated Mode */
+#define         AT91_MCI_BLKLEN         (0xfff << 18)   /* Data Block Length */
+
+#define AT91_MCI_DTOR           0x08            /* Data Timeout Register */
+#define         AT91_MCI_DTOCYC         (0xf << 0)      /* Data Timeout Cycle Number */
+#define         AT91_MCI_DTOMUL         (7   << 4)      /* Data Timeout Multiplier */
+#define         AT91_MCI_DTOMUL_1               (0 <<  4)
+#define         AT91_MCI_DTOMUL_16              (1 <<  4)
+#define         AT91_MCI_DTOMUL_128             (2 <<  4)
+#define         AT91_MCI_DTOMUL_256             (3 <<  4)
+#define         AT91_MCI_DTOMUL_1K              (4 <<  4)
+#define         AT91_MCI_DTOMUL_4K              (5 <<  4)
+#define         AT91_MCI_DTOMUL_64K             (6 <<  4)
+#define         AT91_MCI_DTOMUL_1M              (7 <<  4)
+
+#define AT91_MCI_SDCR           0x0c            /* SD Card Register */
+#define         AT91_MCI_SDCSEL         (3 << 0)        /* SD Card Selector */
+#define         AT91_MCI_SDCBUS         (1 << 7)        /* 1-bit or 4-bit bus */
+
+#define AT91_MCI_ARGR           0x10            /* Argument Register */
+
+#define AT91_MCI_CMDR           0x14            /* Command Register */
+#define         AT91_MCI_CMDNB          (0x3f << 0)     /* Command Number */
+#define         AT91_MCI_RSPTYP         (3    << 6)     /* Response Type */
+#define                 AT91_MCI_RSPTYP_NONE    (0 <<  6)
+#define                 AT91_MCI_RSPTYP_48      (1 <<  6)
+#define                 AT91_MCI_RSPTYP_136     (2 <<  6)
+#define         AT91_MCI_SPCMD          (7    << 8)     /* Special Command */
+#define                 AT91_MCI_SPCMD_NONE     (0 <<  8)
+#define                 AT91_MCI_SPCMD_INIT     (1 <<  8)
+#define                 AT91_MCI_SPCMD_SYNC     (2 <<  8)
+#define                 AT91_MCI_SPCMD_ICMD     (4 <<  8)
+#define                 AT91_MCI_SPCMD_IRESP    (5 <<  8)
+#define         AT91_MCI_OPDCMD         (1 << 11)       /* Open Drain Command */
+#define         AT91_MCI_MAXLAT         (1 << 12)       /* Max Latency for Command to Response */
+#define         AT91_MCI_TRCMD          (3 << 16)       /* Transfer Command */
+#define                 AT91_MCI_TRCMD_NONE     (0 << 16)
+#define                 AT91_MCI_TRCMD_START    (1 << 16)
+#define                 AT91_MCI_TRCMD_STOP     (2 << 16)
+#define         AT91_MCI_TRDIR          (1 << 18)       /* Transfer Direction */
+#define         AT91_MCI_TRTYP          (3 << 19)       /* Transfer Type */
+#define                 AT91_MCI_TRTYP_BLOCK    (0 << 19)
+#define                 AT91_MCI_TRTYP_MULTIPLE (1 << 19)
+#define                 AT91_MCI_TRTYP_STREAM   (2 << 19)
+#define                 AT91_MCI_TRTYP_SDIO_BYTE        (4 << 19)
+#define                 AT91_MCI_TRTYP_SDIO_BLOCK       (5 << 19)
+
+#define AT91_MCI_BLKR           0x18            /* Block Register */
+#define         AT91_MCI_BLKR_BCNT(n)   ((0xffff & (n)) << 0)   /* Block count */
+#define         AT91_MCI_BLKR_BLKLEN(n) ((0xffff & (n)) << 16)  /* Block length */
+
+#define AT91_MCI_RSPR(n)        (0x20 + ((n) * 4))      /* Response Registers 0-3 */
+#define AT91_MCR_RDR            0x30            /* Receive Data Register */
+#define AT91_MCR_TDR            0x34            /* Transmit Data Register */
+
+#define AT91_MCI_SR             0x40            /* Status Register */
+#define         AT91_MCI_CMDRDY         (1 <<  0)       /* Command Ready */
+#define         AT91_MCI_RXRDY          (1 <<  1)       /* Receiver Ready */
+#define         AT91_MCI_TXRDY          (1 <<  2)       /* Transmit Ready */
+#define         AT91_MCI_BLKE           (1 <<  3)       /* Data Block Ended */
+#define         AT91_MCI_DTIP           (1 <<  4)       /* Data Transfer in Progress */
+#define         AT91_MCI_NOTBUSY        (1 <<  5)       /* Data Not Busy */
+#define         AT91_MCI_ENDRX          (1 <<  6)       /* End of RX Buffer */
+#define         AT91_MCI_ENDTX          (1 <<  7)       /* End fo TX Buffer */
+#define         AT91_MCI_SDIOIRQA       (1 <<  8)       /* SDIO Interrupt for Slot A */
+#define         AT91_MCI_SDIOIRQB       (1 <<  9)       /* SDIO Interrupt for Slot B */
+#define         AT91_MCI_RXBUFF         (1 << 14)       /* RX Buffer Full */
+#define         AT91_MCI_TXBUFE         (1 << 15)       /* TX Buffer Empty */
+#define         AT91_MCI_RINDE          (1 << 16)       /* Response Index Error */
+#define         AT91_MCI_RDIRE          (1 << 17)       /* Response Direction Error */
+#define         AT91_MCI_RCRCE          (1 << 18)       /* Response CRC Error */
+#define         AT91_MCI_RENDE          (1 << 19)       /* Response End Bit Error */
+#define         AT91_MCI_RTOE           (1 << 20)       /* Response Time-out Error */
+#define         AT91_MCI_DCRCE          (1 << 21)       /* Data CRC Error */
+#define         AT91_MCI_DTOE           (1 << 22)       /* Data Time-out Error */
+#define         AT91_MCI_OVRE           (1 << 30)       /* Overrun */
+#define         AT91_MCI_UNRE           (1 << 31)       /* Underrun */
+
+#define AT91_MCI_IER            0x44            /* Interrupt Enable Register */
+#define AT91_MCI_IDR            0x48            /* Interrupt Disable Register */
+#define AT91_MCI_IMR            0x4c            /* Interrupt Mask Register */
+
+#endif
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index aa8039f473c..fa8cae1d700 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -203,6 +203,7 @@ struct atmel_mci_slot {
 #define ATMCI_CARD_PRESENT      0
 #define ATMCI_CARD_NEED_INIT    1
 #define ATMCI_SHUTDOWN          2
+#define ATMCI_SUSPENDED         3
 
         int                     detect_pin;
         int                     wp_pin;
@@ -1878,10 +1879,72 @@ static int __exit atmci_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int atmci_suspend(struct device *dev)
+{
+        struct atmel_mci *host = dev_get_drvdata(dev);
+        int i;
+
+         for (i = 0; i < ATMEL_MCI_MAX_NR_SLOTS; i++) {
+                struct atmel_mci_slot *slot = host->slot[i];
+                int ret;
+
+                if (!slot)
+                        continue;
+                ret = mmc_suspend_host(slot->mmc);
+                if (ret < 0) {
+                        while (--i >= 0) {
+                                slot = host->slot[i];
+                                if (slot
+                                && test_bit(ATMCI_SUSPENDED, &slot->flags)) {
+                                        mmc_resume_host(host->slot[i]->mmc);
+                                        clear_bit(ATMCI_SUSPENDED, &slot->flags);
+                                }
+                        }
+                        return ret;
+                } else {
+                        set_bit(ATMCI_SUSPENDED, &slot->flags);
+                }
+        }
+
+        return 0;
+}
+
+static int atmci_resume(struct device *dev)
+{
+        struct atmel_mci *host = dev_get_drvdata(dev);
+        int i;
+        int ret = 0;
+
+        for (i = 0; i < ATMEL_MCI_MAX_NR_SLOTS; i++) {
+                struct atmel_mci_slot *slot = host->slot[i];
+                int err;
+
+                slot = host->slot[i];
+                if (!slot)
+                        continue;
+                if (!test_bit(ATMCI_SUSPENDED, &slot->flags))
+                        continue;
+                err = mmc_resume_host(slot->mmc);
+                if (err < 0)
+                        ret = err;
+                else
+                        clear_bit(ATMCI_SUSPENDED, &slot->flags);
+        }
+
+        return ret;
+}
+static SIMPLE_DEV_PM_OPS(atmci_pm, atmci_suspend, atmci_resume);
+#define ATMCI_PM_OPS    (&atmci_pm)
+#else
+#define ATMCI_PM_OPS    NULL
+#endif
+
 static struct platform_driver atmci_driver = {
         .remove         = __exit_p(atmci_remove),
         .driver         = {
                 .name           = "atmel_mci",
+                .pm             = ATMCI_PM_OPS,
         },
 };
 
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 66dcddb9c20..ff0f714b012 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -33,6 +33,7 @@
 #include <linux/mmc/dw_mmc.h>
 #include <linux/bitops.h>
 #include <linux/regulator/consumer.h>
+#include <linux/workqueue.h>
 
 #include "dw_mmc.h"
 
@@ -61,7 +62,7 @@ struct idmac_desc {
 
         u32             des1;   /* Buffer sizes */
 #define IDMAC_SET_BUFFER1_SIZE(d, s) \
-        ((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff))
+        ((d)->des1 = ((d)->des1 & 0x03ffe000) | ((s) & 0x1fff))
 
         u32             des2;   /* buffer 1 physical address */
 
@@ -100,6 +101,8 @@ struct dw_mci_slot {
         int                     last_detect_state;
 };
 
+static struct workqueue_struct *dw_mci_card_workqueue;
+
 #if defined(CONFIG_DEBUG_FS)
 static int dw_mci_req_show(struct seq_file *s, void *v)
 {
@@ -284,7 +287,7 @@ static void send_stop_cmd(struct dw_mci *host, struct mmc_data *data)
 /* DMA interface functions */
 static void dw_mci_stop_dma(struct dw_mci *host)
 {
-        if (host->use_dma) {
+        if (host->using_dma) {
                 host->dma_ops->stop(host);
                 host->dma_ops->cleanup(host);
         } else {
@@ -432,6 +435,8 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
         unsigned int i, direction, 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;
@@ -451,6 +456,8 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
                         return -EINVAL;
         }
 
+        host->using_dma = 1;
+
         if (data->flags & MMC_DATA_READ)
                 direction = DMA_FROM_DEVICE;
         else
@@ -489,14 +496,18 @@ static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data)
         host->sg = NULL;
         host->data = data;
 
+        if (data->flags & MMC_DATA_READ)
+                host->dir_status = DW_MCI_RECV_STATUS;
+        else
+                host->dir_status = DW_MCI_SEND_STATUS;
+
         if (dw_mci_submit_data_dma(host, data)) {
                 host->sg = data->sg;
                 host->pio_offset = 0;
-                if (data->flags & MMC_DATA_READ)
-                        host->dir_status = DW_MCI_RECV_STATUS;
-                else
-                        host->dir_status = DW_MCI_SEND_STATUS;
+                host->part_buf_start = 0;
+                host->part_buf_count = 0;
 
+                mci_writel(host, RINTSTS, SDMMC_INT_TXDR | SDMMC_INT_RXDR);
                 temp = mci_readl(host, INTMASK);
                 temp |= SDMMC_INT_TXDR | SDMMC_INT_RXDR;
                 mci_writel(host, INTMASK, temp);
@@ -574,7 +585,7 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
         }
 
         /* Set the current slot bus width */
-        mci_writel(host, CTYPE, slot->ctype);
+        mci_writel(host, CTYPE, (slot->ctype << slot->id));
 }
 
 static void dw_mci_start_request(struct dw_mci *host,
@@ -624,13 +635,13 @@ static void dw_mci_start_request(struct dw_mci *host,
                 host->stop_cmdr = dw_mci_prepare_command(slot->mmc, mrq->stop);
 }
 
+/* must be called with host->lock held */
 static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
                                  struct mmc_request *mrq)
 {
         dev_vdbg(&slot->mmc->class_dev, "queue request: state=%d\n",
                  host->state);
 
-        spin_lock_bh(&host->lock);
         slot->mrq = mrq;
 
         if (host->state == STATE_IDLE) {
@@ -639,8 +650,6 @@ static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
         } else {
                 list_add_tail(&slot->queue_node, &host->queue);
         }
-
-        spin_unlock_bh(&host->lock);
 }
 
 static void dw_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
@@ -650,14 +659,23 @@ static void dw_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         WARN_ON(slot->mrq);
 
+        /*
+         * The check for card presence and queueing of the request must be
+         * atomic, otherwise the card could be removed in between and the
+         * request wouldn't fail until another card was inserted.
+         */
+        spin_lock_bh(&host->lock);
+
         if (!test_bit(DW_MMC_CARD_PRESENT, &slot->flags)) {
+                spin_unlock_bh(&host->lock);
                 mrq->cmd->error = -ENOMEDIUM;
                 mmc_request_done(mmc, mrq);
                 return;
         }
 
-        /* We don't support multiple blocks of weird lengths. */
         dw_mci_queue_request(host, slot, mrq);
+
+        spin_unlock_bh(&host->lock);
 }
 
 static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
@@ -681,7 +699,7 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         }
 
         /* DDR mode set */
-        if (ios->ddr) {
+        if (ios->timing == MMC_TIMING_UHS_DDR50) {
                 regs = mci_readl(slot->host, UHS_REG);
                 regs |= (0x1 << slot->id) << 16;
                 mci_writel(slot->host, UHS_REG, regs);
@@ -831,7 +849,7 @@ static void dw_mci_tasklet_func(unsigned long priv)
         struct mmc_command *cmd;
         enum dw_mci_state state;
         enum dw_mci_state prev_state;
-        u32 status;
+        u32 status, ctrl;
 
         spin_lock(&host->lock);
 
@@ -891,13 +909,19 @@ static void dw_mci_tasklet_func(unsigned long priv)
 
                         if (status & DW_MCI_DATA_ERROR_FLAGS) {
                                 if (status & SDMMC_INT_DTO) {
-                                        dev_err(&host->pdev->dev,
-                                                "data timeout error\n");
                                         data->error = -ETIMEDOUT;
                                 } else if (status & SDMMC_INT_DCRC) {
-                                        dev_err(&host->pdev->dev,
-                                                "data CRC error\n");
                                         data->error = -EILSEQ;
+                                } else if (status & SDMMC_INT_EBE &&
+                                           host->dir_status ==
+                                                        DW_MCI_SEND_STATUS) {
+                                        /*
+                                         * No data CRC status was returned.
+                                         * The number of bytes transferred will
+                                         * be exaggerated in PIO mode.
+                                         */
+                                        data->bytes_xfered = 0;
+                                        data->error = -ETIMEDOUT;
                                 } else {
                                         dev_err(&host->pdev->dev,
                                                 "data FIFO error "
@@ -905,6 +929,16 @@ static void dw_mci_tasklet_func(unsigned long priv)
                                                 status);
                                         data->error = -EIO;
                                 }
+                                /*
+                                 * After an error, there may be data lingering
+                                 * in the FIFO, so reset it - doing so
+                                 * generates a block interrupt, hence setting
+                                 * the scatter-gather pointer to NULL.
+                                 */
+                                host->sg = NULL;
+                                ctrl = mci_readl(host, CTRL);
+                                ctrl |= SDMMC_CTRL_FIFO_RESET;
+                                mci_writel(host, CTRL, ctrl);
                         } else {
                                 data->bytes_xfered = data->blocks * data->blksz;
                                 data->error = 0;
@@ -946,84 +980,278 @@ unlock:
 
 }
 
-static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
+/* push final bytes to part_buf, only use during push */
+static void dw_mci_set_part_bytes(struct dw_mci *host, void *buf, int cnt)
 {
-        u16 *pdata = (u16 *)buf;
+        memcpy((void *)&host->part_buf, buf, cnt);
+        host->part_buf_count = cnt;
+}
 
-        WARN_ON(cnt % 2 != 0);
+/* append bytes to part_buf, only use during push */
+static int dw_mci_push_part_bytes(struct dw_mci *host, void *buf, int cnt)
+{
+        cnt = min(cnt, (1 << host->data_shift) - host->part_buf_count);
+        memcpy((void *)&host->part_buf + host->part_buf_count, buf, cnt);
+        host->part_buf_count += cnt;
+        return cnt;
+}
 
-        cnt = cnt >> 1;
-        while (cnt > 0) {
-                mci_writew(host, DATA, *pdata++);
-                cnt--;
+/* pull first bytes from part_buf, only use during pull */
+static int dw_mci_pull_part_bytes(struct dw_mci *host, void *buf, int cnt)
+{
+        cnt = min(cnt, (int)host->part_buf_count);
+        if (cnt) {
+                memcpy(buf, (void *)&host->part_buf + host->part_buf_start,
+                       cnt);
+                host->part_buf_count -= cnt;
+                host->part_buf_start += cnt;
         }
+        return cnt;
 }
 
-static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
+/* pull final bytes from the part_buf, assuming it's just been filled */
+static void dw_mci_pull_final_bytes(struct dw_mci *host, void *buf, int cnt)
 {
-        u16 *pdata = (u16 *)buf;
+        memcpy(buf, &host->part_buf, cnt);
+        host->part_buf_start = cnt;
+        host->part_buf_count = (1 << host->data_shift) - cnt;
+}
 
-        WARN_ON(cnt % 2 != 0);
+static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
+{
+        /* try and push anything in the part_buf */
+        if (unlikely(host->part_buf_count)) {
+                int len = dw_mci_push_part_bytes(host, buf, cnt);
+                buf += len;
+                cnt -= len;
+                if (!sg_next(host->sg) || host->part_buf_count == 2) {
+                        mci_writew(host, DATA, host->part_buf16);
+                        host->part_buf_count = 0;
+                }
+        }
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x1)) {
+                while (cnt >= 2) {
+                        u16 aligned_buf[64];
+                        int len = min(cnt & -2, (int)sizeof(aligned_buf));
+                        int items = len >> 1;
+                        int i;
+                        /* memcpy from input buffer into aligned buffer */
+                        memcpy(aligned_buf, buf, len);
+                        buf += len;
+                        cnt -= len;
+                        /* push data from aligned buffer into fifo */
+                        for (i = 0; i < items; ++i)
+                                mci_writew(host, DATA, aligned_buf[i]);
+                }
+        } else
+#endif
+        {
+                u16 *pdata = buf;
+                for (; cnt >= 2; cnt -= 2)
+                        mci_writew(host, DATA, *pdata++);
+                buf = pdata;
+        }
+        /* put anything remaining in the part_buf */
+        if (cnt) {
+                dw_mci_set_part_bytes(host, buf, cnt);
+                if (!sg_next(host->sg))
+                        mci_writew(host, DATA, host->part_buf16);
+        }
+}
 
-        cnt = cnt >> 1;
-        while (cnt > 0) {
-                *pdata++ = mci_readw(host, DATA);
-                cnt--;
+static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
+{
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x1)) {
+                while (cnt >= 2) {
+                        /* pull data from fifo into aligned buffer */
+                        u16 aligned_buf[64];
+                        int len = min(cnt & -2, (int)sizeof(aligned_buf));
+                        int items = len >> 1;
+                        int i;
+                        for (i = 0; i < items; ++i)
+                                aligned_buf[i] = mci_readw(host, DATA);
+                        /* memcpy from aligned buffer into output buffer */
+                        memcpy(buf, aligned_buf, len);
+                        buf += len;
+                        cnt -= len;
+                }
+        } else
+#endif
+        {
+                u16 *pdata = buf;
+                for (; cnt >= 2; cnt -= 2)
+                        *pdata++ = mci_readw(host, DATA);
+                buf = pdata;
+        }
+        if (cnt) {
+                host->part_buf16 = mci_readw(host, DATA);
+                dw_mci_pull_final_bytes(host, buf, cnt);
         }
 }
 
 static void dw_mci_push_data32(struct dw_mci *host, void *buf, int cnt)
 {
-        u32 *pdata = (u32 *)buf;
-
-        WARN_ON(cnt % 4 != 0);
-        WARN_ON((unsigned long)pdata & 0x3);
-
-        cnt = cnt >> 2;
-        while (cnt > 0) {
-                mci_writel(host, DATA, *pdata++);
-                cnt--;
+        /* try and push anything in the part_buf */
+        if (unlikely(host->part_buf_count)) {
+                int len = dw_mci_push_part_bytes(host, buf, cnt);
+                buf += len;
+                cnt -= len;
+                if (!sg_next(host->sg) || host->part_buf_count == 4) {
+                        mci_writel(host, DATA, host->part_buf32);
+                        host->part_buf_count = 0;
+                }
+        }
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x3)) {
+                while (cnt >= 4) {
+                        u32 aligned_buf[32];
+                        int len = min(cnt & -4, (int)sizeof(aligned_buf));
+                        int items = len >> 2;
+                        int i;
+                        /* memcpy from input buffer into aligned buffer */
+                        memcpy(aligned_buf, buf, len);
+                        buf += len;
+                        cnt -= len;
+                        /* push data from aligned buffer into fifo */
+                        for (i = 0; i < items; ++i)
+                                mci_writel(host, DATA, aligned_buf[i]);
+                }
+        } else
+#endif
+        {
+                u32 *pdata = buf;
+                for (; cnt >= 4; cnt -= 4)
+                        mci_writel(host, DATA, *pdata++);
+                buf = pdata;
+        }
+        /* put anything remaining in the part_buf */
+        if (cnt) {
+                dw_mci_set_part_bytes(host, buf, cnt);
+                if (!sg_next(host->sg))
+                        mci_writel(host, DATA, host->part_buf32);
         }
 }
 
 static void dw_mci_pull_data32(struct dw_mci *host, void *buf, int cnt)
 {
-        u32 *pdata = (u32 *)buf;
-
-        WARN_ON(cnt % 4 != 0);
-        WARN_ON((unsigned long)pdata & 0x3);
-
-        cnt = cnt >> 2;
-        while (cnt > 0) {
-                *pdata++ = mci_readl(host, DATA);
-                cnt--;
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x3)) {
+                while (cnt >= 4) {
+                        /* pull data from fifo into aligned buffer */
+                        u32 aligned_buf[32];
+                        int len = min(cnt & -4, (int)sizeof(aligned_buf));
+                        int items = len >> 2;
+                        int i;
+                        for (i = 0; i < items; ++i)
+                                aligned_buf[i] = mci_readl(host, DATA);
+                        /* memcpy from aligned buffer into output buffer */
+                        memcpy(buf, aligned_buf, len);
+                        buf += len;
+                        cnt -= len;
+                }
+        } else
+#endif
+        {
+                u32 *pdata = buf;
+                for (; cnt >= 4; cnt -= 4)
+                        *pdata++ = mci_readl(host, DATA);
+                buf = pdata;
+        }
+        if (cnt) {
+                host->part_buf32 = mci_readl(host, DATA);
+                dw_mci_pull_final_bytes(host, buf, cnt);
         }
 }
 
 static void dw_mci_push_data64(struct dw_mci *host, void *buf, int cnt)
 {
-        u64 *pdata = (u64 *)buf;
-
-        WARN_ON(cnt % 8 != 0);
-
-        cnt = cnt >> 3;
-        while (cnt > 0) {
-                mci_writeq(host, DATA, *pdata++);
-                cnt--;
+        /* try and push anything in the part_buf */
+        if (unlikely(host->part_buf_count)) {
+                int len = dw_mci_push_part_bytes(host, buf, cnt);
+                buf += len;
+                cnt -= len;
+                if (!sg_next(host->sg) || host->part_buf_count == 8) {
+                        mci_writew(host, DATA, host->part_buf);
+                        host->part_buf_count = 0;
+                }
+        }
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x7)) {
+                while (cnt >= 8) {
+                        u64 aligned_buf[16];
+                        int len = min(cnt & -8, (int)sizeof(aligned_buf));
+                        int items = len >> 3;
+                        int i;
+                        /* memcpy from input buffer into aligned buffer */
+                        memcpy(aligned_buf, buf, len);
+                        buf += len;
+                        cnt -= len;
+                        /* push data from aligned buffer into fifo */
+                        for (i = 0; i < items; ++i)
+                                mci_writeq(host, DATA, aligned_buf[i]);
+                }
+        } else
+#endif
+        {
+                u64 *pdata = buf;
+                for (; cnt >= 8; cnt -= 8)
+                        mci_writeq(host, DATA, *pdata++);
+                buf = pdata;
+        }
+        /* put anything remaining in the part_buf */
+        if (cnt) {
+                dw_mci_set_part_bytes(host, buf, cnt);
+                if (!sg_next(host->sg))
+                        mci_writeq(host, DATA, host->part_buf);
         }
 }
 
 static void dw_mci_pull_data64(struct dw_mci *host, void *buf, int cnt)
 {
-        u64 *pdata = (u64 *)buf;
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (unlikely((unsigned long)buf & 0x7)) {
+                while (cnt >= 8) {
+                        /* pull data from fifo into aligned buffer */
+                        u64 aligned_buf[16];
+                        int len = min(cnt & -8, (int)sizeof(aligned_buf));
+                        int items = len >> 3;
+                        int i;
+                        for (i = 0; i < items; ++i)
+                                aligned_buf[i] = mci_readq(host, DATA);
+                        /* memcpy from aligned buffer into output buffer */
+                        memcpy(buf, aligned_buf, len);
+                        buf += len;
+                        cnt -= len;
+                }
+        } else
+#endif
+        {
+                u64 *pdata = buf;
+                for (; cnt >= 8; cnt -= 8)
+                        *pdata++ = mci_readq(host, DATA);
+                buf = pdata;
+        }
+        if (cnt) {
+                host->part_buf = mci_readq(host, DATA);
+                dw_mci_pull_final_bytes(host, buf, cnt);
+        }
+}
 
-        WARN_ON(cnt % 8 != 0);
+static void dw_mci_pull_data(struct dw_mci *host, void *buf, int cnt)
+{
+        int len;
 
-        cnt = cnt >> 3;
-        while (cnt > 0) {
-                *pdata++ = mci_readq(host, DATA);
-                cnt--;
-        }
+        /* get remaining partial bytes */
+        len = dw_mci_pull_part_bytes(host, buf, cnt);
+        if (unlikely(len == cnt))
+                return;
+        buf += len;
+        cnt -= len;
+
+        /* get the rest of the data */
+        host->pull_data(host, buf, cnt);
 }
 
 static void dw_mci_read_data_pio(struct dw_mci *host)
@@ -1037,9 +1265,10 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
         unsigned int nbytes = 0, len;
 
         do {
-                len = SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift;
+                len = host->part_buf_count +
+                        (SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
                 if (offset + len <= sg->length) {
-                        host->pull_data(host, (void *)(buf + offset), len);
+                        dw_mci_pull_data(host, (void *)(buf + offset), len);
 
                         offset += len;
                         nbytes += len;
@@ -1055,8 +1284,8 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
                         }
                 } else {
                         unsigned int remaining = sg->length - offset;
-                        host->pull_data(host, (void *)(buf + offset),
-                                        remaining);
+                        dw_mci_pull_data(host, (void *)(buf + offset),
+                                         remaining);
                         nbytes += remaining;
 
                         flush_dcache_page(sg_page(sg));
@@ -1066,7 +1295,7 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
 
                         offset = len - remaining;
                         buf = sg_virt(sg);
-                        host->pull_data(host, buf, offset);
+                        dw_mci_pull_data(host, buf, offset);
                         nbytes += offset;
                 }
 
@@ -1083,7 +1312,6 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
                         return;
                 }
         } while (status & SDMMC_INT_RXDR); /*if the RXDR is ready read again*/
-        len = SDMMC_GET_FCNT(mci_readl(host, STATUS));
         host->pio_offset = offset;
         data->bytes_xfered += nbytes;
         return;
@@ -1105,8 +1333,9 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
         unsigned int nbytes = 0, len;
 
         do {
-                len = SDMMC_FIFO_SZ -
-                        (SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
+                len = ((host->fifo_depth -
+                        SDMMC_GET_FCNT(mci_readl(host, STATUS))) << shift)
+                        - host->part_buf_count;
                 if (offset + len <= sg->length) {
                         host->push_data(host, (void *)(buf + offset), len);
 
@@ -1151,10 +1380,8 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
                         return;
                 }
         } while (status & SDMMC_INT_TXDR); /* if TXDR write again */
-
         host->pio_offset = offset;
         data->bytes_xfered += nbytes;
-
         return;
 
 done:
@@ -1202,7 +1429,6 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
                         host->cmd_status = status;
                         smp_wmb();
                         set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
-                        tasklet_schedule(&host->tasklet);
                 }
 
                 if (pending & DW_MCI_DATA_ERROR_FLAGS) {
@@ -1211,7 +1437,9 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
                         host->data_status = status;
                         smp_wmb();
                         set_bit(EVENT_DATA_ERROR, &host->pending_events);
-                        tasklet_schedule(&host->tasklet);
+                        if (!(pending & (SDMMC_INT_DTO | SDMMC_INT_DCRC |
+                                         SDMMC_INT_SBE | SDMMC_INT_EBE)))
+                                tasklet_schedule(&host->tasklet);
                 }
 
                 if (pending & SDMMC_INT_DATA_OVER) {
@@ -1229,13 +1457,13 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 
                 if (pending & SDMMC_INT_RXDR) {
                         mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
-                        if (host->sg)
+                        if (host->dir_status == DW_MCI_RECV_STATUS && host->sg)
                                 dw_mci_read_data_pio(host);
                 }
 
                 if (pending & SDMMC_INT_TXDR) {
                         mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
-                        if (host->sg)
+                        if (host->dir_status == DW_MCI_SEND_STATUS && host->sg)
                                 dw_mci_write_data_pio(host);
                 }
 
@@ -1246,7 +1474,7 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 
                 if (pending & SDMMC_INT_CD) {
                         mci_writel(host, RINTSTS, SDMMC_INT_CD);
-                        tasklet_schedule(&host->card_tasklet);
+                        queue_work(dw_mci_card_workqueue, &host->card_work);
                 }
 
         } while (pass_count++ < 5);
@@ -1265,9 +1493,9 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static void dw_mci_tasklet_card(unsigned long data)
+static void dw_mci_work_routine_card(struct work_struct *work)
 {
-        struct dw_mci *host = (struct dw_mci *)data;
+        struct dw_mci *host = container_of(work, struct dw_mci, card_work);
         int i;
 
         for (i = 0; i < host->num_slots; i++) {
@@ -1279,22 +1507,21 @@ static void dw_mci_tasklet_card(unsigned long data)
 
                 present = dw_mci_get_cd(mmc);
                 while (present != slot->last_detect_state) {
-                        spin_lock(&host->lock);
-
                         dev_dbg(&slot->mmc->class_dev, "card %s\n",
                                 present ? "inserted" : "removed");
 
+                        /* Power up slot (before spin_lock, may sleep) */
+                        if (present != 0 && host->pdata->setpower)
+                                host->pdata->setpower(slot->id, mmc->ocr_avail);
+
+                        spin_lock_bh(&host->lock);
+
                         /* Card change detected */
                         slot->last_detect_state = present;
 
-                        /* Power up slot */
-                        if (present != 0) {
-                                if (host->pdata->setpower)
-                                        host->pdata->setpower(slot->id,
-                                                              mmc->ocr_avail);
-
+                        /* Mark card as present if applicable */
+                        if (present != 0)
                                 set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
-                        }
 
                         /* Clean up queue if present */
                         mrq = slot->mrq;
@@ -1344,8 +1571,6 @@ static void dw_mci_tasklet_card(unsigned long data)
 
                         /* Power down slot */
                         if (present == 0) {
-                                if (host->pdata->setpower)
-                                        host->pdata->setpower(slot->id, 0);
                                 clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
 
                                 /*
@@ -1367,7 +1592,12 @@ static void dw_mci_tasklet_card(unsigned long data)
 
                         }
 
-                        spin_unlock(&host->lock);
+                        spin_unlock_bh(&host->lock);
+
+                        /* Power down slot (after spin_unlock, may sleep) */
+                        if (present == 0 && host->pdata->setpower)
+                                host->pdata->setpower(slot->id, 0);
+
                         present = dw_mci_get_cd(mmc);
                 }
 
@@ -1416,7 +1646,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
                         mmc->caps |= MMC_CAP_4_BIT_DATA;
 
         if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
-                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
 #ifdef CONFIG_MMC_DW_IDMAC
         mmc->max_segs = host->ring_size;
@@ -1467,7 +1697,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
          * Card may have been plugged in prior to boot so we
          * need to run the detect tasklet
          */
-        tasklet_schedule(&host->card_tasklet);
+        queue_work(dw_mci_card_workqueue, &host->card_work);
 
         return 0;
 }
@@ -1595,7 +1825,7 @@ static int dw_mci_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&host->queue);
 
         ret = -ENOMEM;
-        host->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        host->regs = ioremap(regs->start, resource_size(regs));
         if (!host->regs)
                 goto err_freehost;
 
@@ -1645,8 +1875,19 @@ static int dw_mci_probe(struct platform_device *pdev)
          * FIFO threshold settings  RxMark  = fifo_size / 2 - 1,
          *                          Tx Mark = fifo_size / 2 DMA Size = 8
          */
-        fifo_size = mci_readl(host, FIFOTH);
-        fifo_size = (fifo_size >> 16) & 0x7ff;
+        if (!host->pdata->fifo_depth) {
+                /*
+                 * Power-on value of RX_WMark is FIFO_DEPTH-1, but this may
+                 * have been overwritten by the bootloader, just like we're
+                 * about to do, so if you know the value for your hardware, you
+                 * should put it in the platform data.
+                 */
+                fifo_size = mci_readl(host, FIFOTH);
+                fifo_size = 1 + ((fifo_size >> 16) & 0x7ff);
+        } else {
+                fifo_size = host->pdata->fifo_depth;
+        }
+        host->fifo_depth = fifo_size;
         host->fifoth_val = ((0x2 << 28) | ((fifo_size/2 - 1) << 16) |
                         ((fifo_size/2) << 0));
         mci_writel(host, FIFOTH, host->fifoth_val);
@@ -1656,12 +1897,15 @@ static int dw_mci_probe(struct platform_device *pdev)
         mci_writel(host, CLKSRC, 0);
 
         tasklet_init(&host->tasklet, dw_mci_tasklet_func, (unsigned long)host);
-        tasklet_init(&host->card_tasklet,
-                     dw_mci_tasklet_card, (unsigned long)host);
+        dw_mci_card_workqueue = alloc_workqueue("dw-mci-card",
+                        WQ_MEM_RECLAIM | WQ_NON_REENTRANT, 1);
+        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);
         if (ret)
-                goto err_dmaunmap;
+                goto err_workqueue;
 
         platform_set_drvdata(pdev, host);
 
@@ -1690,7 +1934,9 @@ static int dw_mci_probe(struct platform_device *pdev)
         mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
 
         dev_info(&pdev->dev, "DW MMC controller at irq %d, "
-                 "%d bit host data width\n", irq, width);
+                 "%d bit host data width, "
+                 "%u deep fifo\n",
+                 irq, width, fifo_size);
         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
                 dev_info(&pdev->dev, "Internal DMAC interrupt fix enabled.\n");
 
@@ -1705,6 +1951,9 @@ err_init_slot:
         }
         free_irq(irq, host);
 
+err_workqueue:
+        destroy_workqueue(dw_mci_card_workqueue);
+
 err_dmaunmap:
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
@@ -1744,6 +1993,7 @@ static int __exit dw_mci_remove(struct platform_device *pdev)
         mci_writel(host, CLKSRC, 0);
 
         free_irq(platform_get_irq(pdev, 0), host);
+        destroy_workqueue(dw_mci_card_workqueue);
         dma_free_coherent(&pdev->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
 
         if (host->use_dma && host->dma_ops->exit)
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
index 23c662af561..027d3773539 100644
--- a/drivers/mmc/host/dw_mmc.h
+++ b/drivers/mmc/host/dw_mmc.h
@@ -118,7 +118,6 @@
 #define SDMMC_CMD_INDX(n)               ((n) & 0x1F)
 /* Status register defines */
 #define SDMMC_GET_FCNT(x)               (((x)>>17) & 0x1FF)
-#define SDMMC_FIFO_SZ                   32
 /* Internal DMAC interrupt defines */
 #define SDMMC_IDMAC_INT_AI              BIT(9)
 #define SDMMC_IDMAC_INT_NI              BIT(8)
@@ -134,22 +133,22 @@
 
 /* Register access macros */
 #define mci_readl(dev, reg)                     \
-        __raw_readl(dev->regs + SDMMC_##reg)
+        __raw_readl((dev)->regs + SDMMC_##reg)
 #define mci_writel(dev, reg, value)                     \
-        __raw_writel((value), dev->regs + SDMMC_##reg)
+        __raw_writel((value), (dev)->regs + SDMMC_##reg)
 
 /* 16-bit FIFO access macros */
 #define mci_readw(dev, reg)                     \
-        __raw_readw(dev->regs + SDMMC_##reg)
+        __raw_readw((dev)->regs + SDMMC_##reg)
 #define mci_writew(dev, reg, value)                     \
-        __raw_writew((value), dev->regs + SDMMC_##reg)
+        __raw_writew((value), (dev)->regs + SDMMC_##reg)
 
 /* 64-bit FIFO access macros */
 #ifdef readq
 #define mci_readq(dev, reg)                     \
-        __raw_readq(dev->regs + SDMMC_##reg)
+        __raw_readq((dev)->regs + SDMMC_##reg)
 #define mci_writeq(dev, reg, value)                     \
-        __raw_writeq((value), dev->regs + SDMMC_##reg)
+        __raw_writeq((value), (dev)->regs + SDMMC_##reg)
 #else
 /*
  * Dummy readq implementation for architectures that don't define it.
@@ -160,9 +159,9 @@
  * rest of the code free from ifdefs.
  */
 #define mci_readq(dev, reg)                     \
-        (*(volatile u64 __force *)(dev->regs + SDMMC_##reg))
+        (*(volatile u64 __force *)((dev)->regs + SDMMC_##reg))
 #define mci_writeq(dev, reg, value)                     \
-        (*(volatile u64 __force *)(dev->regs + SDMMC_##reg) = value)
+        (*(volatile u64 __force *)((dev)->regs + SDMMC_##reg) = (value))
 #endif
 
 #endif /* _DW_MMC_H_ */
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index fe140724a02..d8eac248ee4 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -226,6 +226,9 @@ static void __devinit mmci_dma_setup(struct mmci_host *host)
                 return;
         }
 
+        /* initialize pre request cookie */
+        host->next_data.cookie = 1;
+
         /* Try to acquire a generic DMA engine slave channel */
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
@@ -335,7 +338,8 @@ static void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)
                 dir = DMA_FROM_DEVICE;
         }
 
-        dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, dir);
+        if (!data->host_cookie)
+                dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, dir);
 
         /*
          * Use of DMA with scatter-gather is impossible.
@@ -353,7 +357,8 @@ static void mmci_dma_data_error(struct mmci_host *host)
         dmaengine_terminate_all(host->dma_current);
 }
 
-static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
+static int mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data,
+                              struct mmci_host_next *next)
 {
         struct variant_data *variant = host->variant;
         struct dma_slave_config conf = {
@@ -364,13 +369,20 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
                 .src_maxburst = variant->fifohalfsize >> 2, /* # of words */
                 .dst_maxburst = variant->fifohalfsize >> 2, /* # of words */
         };
-        struct mmc_data *data = host->data;
         struct dma_chan *chan;
         struct dma_device *device;
         struct dma_async_tx_descriptor *desc;
         int nr_sg;
 
-        host->dma_current = NULL;
+        /* Check if next job is already prepared */
+        if (data->host_cookie && !next &&
+            host->dma_current && host->dma_desc_current)
+                return 0;
+
+        if (!next) {
+                host->dma_current = NULL;
+                host->dma_desc_current = NULL;
+        }
 
         if (data->flags & MMC_DATA_READ) {
                 conf.direction = DMA_FROM_DEVICE;
@@ -385,7 +397,7 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
                 return -EINVAL;
 
         /* If less than or equal to the fifo size, don't bother with DMA */
-        if (host->size <= variant->fifosize)
+        if (data->blksz * data->blocks <= variant->fifosize)
                 return -EINVAL;
 
         device = chan->device;
@@ -399,14 +411,38 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
         if (!desc)
                 goto unmap_exit;
 
-        /* Okay, go for it. */
-        host->dma_current = chan;
+        if (next) {
+                next->dma_chan = chan;
+                next->dma_desc = desc;
+        } else {
+                host->dma_current = chan;
+                host->dma_desc_current = desc;
+        }
+
+        return 0;
 
+ unmap_exit:
+        if (!next)
+                dmaengine_terminate_all(chan);
+        dma_unmap_sg(device->dev, data->sg, data->sg_len, conf.direction);
+        return -ENOMEM;
+}
+
+static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
+{
+        int ret;
+        struct mmc_data *data = host->data;
+
+        ret = mmci_dma_prep_data(host, host->data, NULL);
+        if (ret)
+                return ret;
+
+        /* Okay, go for it. */
         dev_vdbg(mmc_dev(host->mmc),
                  "Submit MMCI DMA job, sglen %d blksz %04x blks %04x flags %08x\n",
                  data->sg_len, data->blksz, data->blocks, data->flags);
-        dmaengine_submit(desc);
-        dma_async_issue_pending(chan);
+        dmaengine_submit(host->dma_desc_current);
+        dma_async_issue_pending(host->dma_current);
 
         datactrl |= MCI_DPSM_DMAENABLE;
 
@@ -421,14 +457,90 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
         writel(readl(host->base + MMCIMASK0) | MCI_DATAENDMASK,
                host->base + MMCIMASK0);
         return 0;
+}
 
-unmap_exit:
-        dmaengine_terminate_all(chan);
-        dma_unmap_sg(device->dev, data->sg, data->sg_len, conf.direction);
-        return -ENOMEM;
+static void mmci_get_next_data(struct mmci_host *host, struct mmc_data *data)
+{
+        struct mmci_host_next *next = &host->next_data;
+
+        if (data->host_cookie && data->host_cookie != next->cookie) {
+                printk(KERN_WARNING "[%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;
+        }
+
+        if (!data->host_cookie)
+                return;
+
+        host->dma_desc_current = next->dma_desc;
+        host->dma_current = next->dma_chan;
+
+        next->dma_desc = NULL;
+        next->dma_chan = NULL;
 }
+
+static void mmci_pre_request(struct mmc_host *mmc, struct mmc_request *mrq,
+                             bool is_first_req)
+{
+        struct mmci_host *host = mmc_priv(mmc);
+        struct mmc_data *data = mrq->data;
+        struct mmci_host_next *nd = &host->next_data;
+
+        if (!data)
+                return;
+
+        if (data->host_cookie) {
+                data->host_cookie = 0;
+                return;
+        }
+
+        /* if config for dma */
+        if (((data->flags & MMC_DATA_WRITE) && host->dma_tx_channel) ||
+            ((data->flags & MMC_DATA_READ) && host->dma_rx_channel)) {
+                if (mmci_dma_prep_data(host, data, nd))
+                        data->host_cookie = 0;
+                else
+                        data->host_cookie = ++nd->cookie < 0 ? 1 : nd->cookie;
+        }
+}
+
+static void mmci_post_request(struct mmc_host *mmc, struct mmc_request *mrq,
+                              int err)
+{
+        struct mmci_host *host = mmc_priv(mmc);
+        struct mmc_data *data = mrq->data;
+        struct dma_chan *chan;
+        enum dma_data_direction dir;
+
+        if (!data)
+                return;
+
+        if (data->flags & MMC_DATA_READ) {
+                dir = DMA_FROM_DEVICE;
+                chan = host->dma_rx_channel;
+        } else {
+                dir = DMA_TO_DEVICE;
+                chan = host->dma_tx_channel;
+        }
+
+
+        /* if config for dma */
+        if (chan) {
+                if (err)
+                        dmaengine_terminate_all(chan);
+                if (err || data->host_cookie)
+                        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
+                                     data->sg_len, dir);
+                mrq->data->host_cookie = 0;
+        }
+}
+
 #else
 /* Blank functions if the DMA engine is not available */
+static void mmci_get_next_data(struct mmci_host *host, struct mmc_data *data)
+{
+}
 static inline void mmci_dma_setup(struct mmci_host *host)
 {
 }
@@ -449,6 +561,10 @@ static inline int mmci_dma_start_data(struct mmci_host *host, unsigned int datac
 {
         return -ENOSYS;
 }
+
+#define mmci_pre_request NULL
+#define mmci_post_request NULL
+
 #endif
 
 static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
@@ -557,7 +673,8 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
               unsigned int status)
 {
         /* First check for errors */
-        if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
+        if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_STARTBITERR|
+                      MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
                 u32 remain, success;
 
                 /* Terminate the DMA transfer */
@@ -636,8 +753,12 @@ mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
         }
 
         if (!cmd->data || cmd->error) {
-                if (host->data)
+                if (host->data) {
+                        /* Terminate the DMA transfer */
+                        if (dma_inprogress(host))
+                                mmci_dma_data_error(host);
                         mmci_stop_data(host);
+                }
                 mmci_request_end(host, cmd->mrq);
         } else if (!(cmd->data->flags & MMC_DATA_READ)) {
                 mmci_start_data(host, cmd->data);
@@ -837,8 +958,9 @@ static irqreturn_t mmci_irq(int irq, void *dev_id)
                 dev_dbg(mmc_dev(host->mmc), "irq0 (data+cmd) %08x\n", status);
 
                 data = host->data;
-                if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|
-                              MCI_RXOVERRUN|MCI_DATAEND|MCI_DATABLOCKEND) && data)
+                if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_STARTBITERR|
+                              MCI_TXUNDERRUN|MCI_RXOVERRUN|MCI_DATAEND|
+                              MCI_DATABLOCKEND) && data)
                         mmci_data_irq(host, data, status);
 
                 cmd = host->cmd;
@@ -872,6 +994,9 @@ static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         host->mrq = mrq;
 
+        if (mrq->data)
+                mmci_get_next_data(host, mrq->data);
+
         if (mrq->data && mrq->data->flags & MMC_DATA_READ)
                 mmci_start_data(host, mrq->data);
 
@@ -986,6 +1111,8 @@ static irqreturn_t mmci_cd_irq(int irq, void *dev_id)
 
 static const struct mmc_host_ops mmci_ops = {
         .request        = mmci_request,
+        .pre_req        = mmci_pre_request,
+        .post_req       = mmci_post_request,
         .set_ios        = mmci_set_ios,
         .get_ro         = mmci_get_ro,
         .get_cd         = mmci_get_cd,
@@ -1063,7 +1190,15 @@ static int __devinit mmci_probe(struct amba_device *dev,
         }
 
         mmc->ops = &mmci_ops;
-        mmc->f_min = (host->mclk + 511) / 512;
+        /*
+         * The ARM and ST versions of the block have slightly different
+         * clock divider equations which means that the minimum divider
+         * differs too.
+         */
+        if (variant->st_clkdiv)
+                mmc->f_min = DIV_ROUND_UP(host->mclk, 257);
+        else
+                mmc->f_min = DIV_ROUND_UP(host->mclk, 512);
         /*
          * If the platform data supplies a maximum operating
          * frequency, this takes precedence. Else, we fall back
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 2164e8c6476..79e4143ab9d 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -166,6 +166,12 @@ struct clk;
 struct variant_data;
 struct dma_chan;
 
+struct mmci_host_next {
+        struct dma_async_tx_descriptor  *dma_desc;
+        struct dma_chan                 *dma_chan;
+        s32                             cookie;
+};
+
 struct mmci_host {
         phys_addr_t             phybase;
         void __iomem            *base;
@@ -203,6 +209,8 @@ struct mmci_host {
         struct dma_chan         *dma_current;
         struct dma_chan         *dma_rx_channel;
         struct dma_chan         *dma_tx_channel;
+        struct dma_async_tx_descriptor  *dma_desc_current;
+        struct mmci_host_next   next_data;
 
 #define dma_inprogress(host)    ((host)->dma_current)
 #else
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index cc20e025932..b87143d0aeb 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -715,13 +715,13 @@ static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         int burstlen, ret;
 
         /*
-         * use burstlen of 64 in 4 bit mode (--> reg value  0)
-         * use burstlen of 16 in 1 bit mode (--> reg value 16)
+         * use burstlen of 64 (16 words) in 4 bit mode (--> reg value  0)
+         * use burstlen of 16 (4 words) in 1 bit mode (--> reg value 16)
          */
         if (ios->bus_width == MMC_BUS_WIDTH_4)
-                burstlen = 64;
-        else
                 burstlen = 16;
+        else
+                burstlen = 4;
 
         if (mxcmci_use_dma(host) && burstlen != host->burstlen) {
                 host->burstlen = burstlen;
@@ -731,6 +731,7 @@ static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                                 "failed to config DMA channel. Falling back to PIO\n");
                         dma_release_channel(host->dma);
                         host->do_dma = 0;
+                        host->dma = NULL;
                 }
         }
 
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 99d39a6a103..d513d47364d 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -564,40 +564,38 @@ static void mxs_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
 static void mxs_mmc_set_clk_rate(struct mxs_mmc_host *host, unsigned int rate)
 {
-        unsigned int ssp_rate, bit_rate;
-        u32 div1, div2;
+        unsigned int ssp_clk, ssp_sck;
+        u32 clock_divide, clock_rate;
         u32 val;
 
-        ssp_rate = clk_get_rate(host->clk);
+        ssp_clk = clk_get_rate(host->clk);
 
-        for (div1 = 2; div1 < 254; div1 += 2) {
-                div2 = ssp_rate / rate / div1;
-                if (div2 < 0x100)
+        for (clock_divide = 2; clock_divide <= 254; clock_divide += 2) {
+                clock_rate = DIV_ROUND_UP(ssp_clk, rate * clock_divide);
+                clock_rate = (clock_rate > 0) ? clock_rate - 1 : 0;
+                if (clock_rate <= 255)
                         break;
         }
 
-        if (div1 >= 254) {
+        if (clock_divide > 254) {
                 dev_err(mmc_dev(host->mmc),
                         "%s: cannot set clock to %d\n", __func__, rate);
                 return;
         }
 
-        if (div2 == 0)
-                bit_rate = ssp_rate / div1;
-        else
-                bit_rate = ssp_rate / div1 / div2;
+        ssp_sck = ssp_clk / clock_divide / (1 + clock_rate);
 
         val = readl(host->base + HW_SSP_TIMING);
         val &= ~(BM_SSP_TIMING_CLOCK_DIVIDE | BM_SSP_TIMING_CLOCK_RATE);
-        val |= BF_SSP(div1, TIMING_CLOCK_DIVIDE);
-        val |= BF_SSP(div2 - 1, TIMING_CLOCK_RATE);
+        val |= BF_SSP(clock_divide, TIMING_CLOCK_DIVIDE);
+        val |= BF_SSP(clock_rate, TIMING_CLOCK_RATE);
         writel(val, host->base + HW_SSP_TIMING);
 
-        host->clk_rate = bit_rate;
+        host->clk_rate = ssp_sck;
 
         dev_dbg(mmc_dev(host->mmc),
-                "%s: div1 %d, div2 %d, ssp %d, bit %d, rate %d\n",
-                __func__, div1, div2, ssp_rate, bit_rate, rate);
+                "%s: clock_divide %d, clock_rate %d, ssp_clk %d, rate_actual %d, rate_requested %d\n",
+                __func__, clock_divide, clock_rate, ssp_clk, ssp_sck, rate);
 }
 
 static void mxs_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index dedf3dab8a3..21e4a799df4 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -17,6 +17,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/kernel.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
@@ -33,6 +34,7 @@
 #include <linux/semaphore.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 #include <plat/dma.h>
 #include <mach/hardware.h>
 #include <plat/board.h>
@@ -116,15 +118,13 @@
 #define OMAP_MMC4_DEVID         3
 #define OMAP_MMC5_DEVID         4
 
+#define MMC_AUTOSUSPEND_DELAY   100
 #define MMC_TIMEOUT_MS          20
 #define OMAP_MMC_MASTER_CLOCK   96000000
+#define OMAP_MMC_MIN_CLOCK      400000
+#define OMAP_MMC_MAX_CLOCK      52000000
 #define DRIVER_NAME             "omap_hsmmc"
 
-/* Timeouts for entering power saving states on inactivity, msec */
-#define OMAP_MMC_DISABLED_TIMEOUT       100
-#define OMAP_MMC_SLEEP_TIMEOUT          1000
-#define OMAP_MMC_OFF_TIMEOUT            8000
-
 /*
  * One controller can have multiple slots, like on some omap boards using
  * omap.c controller driver. Luckily this is not currently done on any known
@@ -141,6 +141,11 @@
 #define OMAP_HSMMC_WRITE(base, reg, val) \
         __raw_writel((val), (base) + OMAP_HSMMC_##reg)
 
+struct omap_hsmmc_next {
+        unsigned int    dma_len;
+        s32             cookie;
+};
+
 struct omap_hsmmc_host {
         struct  device          *dev;
         struct  mmc_host        *mmc;
@@ -148,7 +153,6 @@ struct omap_hsmmc_host {
         struct  mmc_command     *cmd;
         struct  mmc_data        *data;
         struct  clk             *fclk;
-        struct  clk             *iclk;
         struct  clk             *dbclk;
         /*
          * vcc == configured supply
@@ -184,6 +188,7 @@ struct omap_hsmmc_host {
         int                     reqs_blocked;
         int                     use_reg;
         int                     req_in_progress;
+        struct omap_hsmmc_next  next_data;
 
         struct  omap_mmc_platform_data  *pdata;
 };
@@ -548,6 +553,15 @@ static void omap_hsmmc_gpio_free(struct omap_mmc_platform_data *pdata)
 }
 
 /*
+ * Start clock to the card
+ */
+static void omap_hsmmc_start_clock(struct omap_hsmmc_host *host)
+{
+        OMAP_HSMMC_WRITE(host->base, SYSCTL,
+                OMAP_HSMMC_READ(host->base, SYSCTL) | CEN);
+}
+
+/*
  * Stop clock to the card
  */
 static void omap_hsmmc_stop_clock(struct omap_hsmmc_host *host)
@@ -584,6 +598,81 @@ static void omap_hsmmc_disable_irq(struct omap_hsmmc_host *host)
         OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
 }
 
+/* Calculate divisor for the given clock frequency */
+static u16 calc_divisor(struct mmc_ios *ios)
+{
+        u16 dsor = 0;
+
+        if (ios->clock) {
+                dsor = DIV_ROUND_UP(OMAP_MMC_MASTER_CLOCK, ios->clock);
+                if (dsor > 250)
+                        dsor = 250;
+        }
+
+        return dsor;
+}
+
+static void omap_hsmmc_set_clock(struct omap_hsmmc_host *host)
+{
+        struct mmc_ios *ios = &host->mmc->ios;
+        unsigned long regval;
+        unsigned long timeout;
+
+        dev_dbg(mmc_dev(host->mmc), "Set clock to %uHz\n", ios->clock);
+
+        omap_hsmmc_stop_clock(host);
+
+        regval = OMAP_HSMMC_READ(host->base, SYSCTL);
+        regval = regval & ~(CLKD_MASK | DTO_MASK);
+        regval = regval | (calc_divisor(ios) << 6) | (DTO << 16);
+        OMAP_HSMMC_WRITE(host->base, SYSCTL, regval);
+        OMAP_HSMMC_WRITE(host->base, SYSCTL,
+                OMAP_HSMMC_READ(host->base, SYSCTL) | ICE);
+
+        /* Wait till the ICS bit is set */
+        timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
+        while ((OMAP_HSMMC_READ(host->base, SYSCTL) & ICS) != ICS
+                && time_before(jiffies, timeout))
+                cpu_relax();
+
+        omap_hsmmc_start_clock(host);
+}
+
+static void omap_hsmmc_set_bus_width(struct omap_hsmmc_host *host)
+{
+        struct mmc_ios *ios = &host->mmc->ios;
+        u32 con;
+
+        con = OMAP_HSMMC_READ(host->base, CON);
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_8:
+                OMAP_HSMMC_WRITE(host->base, CON, con | DW8);
+                break;
+        case MMC_BUS_WIDTH_4:
+                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
+                OMAP_HSMMC_WRITE(host->base, HCTL,
+                        OMAP_HSMMC_READ(host->base, HCTL) | FOUR_BIT);
+                break;
+        case MMC_BUS_WIDTH_1:
+                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
+                OMAP_HSMMC_WRITE(host->base, HCTL,
+                        OMAP_HSMMC_READ(host->base, HCTL) & ~FOUR_BIT);
+                break;
+        }
+}
+
+static void omap_hsmmc_set_bus_mode(struct omap_hsmmc_host *host)
+{
+        struct mmc_ios *ios = &host->mmc->ios;
+        u32 con;
+
+        con = OMAP_HSMMC_READ(host->base, CON);
+        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
+                OMAP_HSMMC_WRITE(host->base, CON, con | OD);
+        else
+                OMAP_HSMMC_WRITE(host->base, CON, con & ~OD);
+}
+
 #ifdef CONFIG_PM
 
 /*
@@ -595,8 +684,7 @@ static int omap_hsmmc_context_restore(struct omap_hsmmc_host *host)
         struct mmc_ios *ios = &host->mmc->ios;
         struct omap_mmc_platform_data *pdata = host->pdata;
         int context_loss = 0;
-        u32 hctl, capa, con;
-        u16 dsor = 0;
+        u32 hctl, capa;
         unsigned long timeout;
 
         if (pdata->get_context_loss_count) {
@@ -658,54 +746,12 @@ static int omap_hsmmc_context_restore(struct omap_hsmmc_host *host)
         if (host->power_mode == MMC_POWER_OFF)
                 goto out;
 
-        con = OMAP_HSMMC_READ(host->base, CON);
-        switch (ios->bus_width) {
-        case MMC_BUS_WIDTH_8:
-                OMAP_HSMMC_WRITE(host->base, CON, con | DW8);
-                break;
-        case MMC_BUS_WIDTH_4:
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
-                OMAP_HSMMC_WRITE(host->base, HCTL,
-                        OMAP_HSMMC_READ(host->base, HCTL) | FOUR_BIT);
-                break;
-        case MMC_BUS_WIDTH_1:
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
-                OMAP_HSMMC_WRITE(host->base, HCTL,
-                        OMAP_HSMMC_READ(host->base, HCTL) & ~FOUR_BIT);
-                break;
-        }
-
-        if (ios->clock) {
-                dsor = OMAP_MMC_MASTER_CLOCK / ios->clock;
-                if (dsor < 1)
-                        dsor = 1;
-
-                if (OMAP_MMC_MASTER_CLOCK / dsor > ios->clock)
-                        dsor++;
-
-                if (dsor > 250)
-                        dsor = 250;
-        }
-
-        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                OMAP_HSMMC_READ(host->base, SYSCTL) & ~CEN);
-        OMAP_HSMMC_WRITE(host->base, SYSCTL, (dsor << 6) | (DTO << 16));
-        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                OMAP_HSMMC_READ(host->base, SYSCTL) | ICE);
+        omap_hsmmc_set_bus_width(host);
 
-        timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
-        while ((OMAP_HSMMC_READ(host->base, SYSCTL) & ICS) != ICS
-                && time_before(jiffies, timeout))
-                ;
+        omap_hsmmc_set_clock(host);
 
-        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                OMAP_HSMMC_READ(host->base, SYSCTL) | CEN);
+        omap_hsmmc_set_bus_mode(host);
 
-        con = OMAP_HSMMC_READ(host->base, CON);
-        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
-                OMAP_HSMMC_WRITE(host->base, CON, con | OD);
-        else
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~OD);
 out:
         host->context_loss = context_loss;
 
@@ -973,14 +1019,14 @@ static void omap_hsmmc_dma_cleanup(struct omap_hsmmc_host *host, int errno)
  * Readable error output
  */
 #ifdef CONFIG_MMC_DEBUG
-static void omap_hsmmc_report_irq(struct omap_hsmmc_host *host, u32 status)
+static void omap_hsmmc_dbg_report_irq(struct omap_hsmmc_host *host, u32 status)
 {
         /* --- means reserved bit without definition at documentation */
         static const char *omap_hsmmc_status_bits[] = {
-                "CC", "TC", "BGE", "---", "BWR", "BRR", "---", "---", "CIRQ",
-                "OBI", "---", "---", "---", "---", "---", "ERRI", "CTO", "CCRC",
-                "CEB", "CIE", "DTO", "DCRC", "DEB", "---", "ACE", "---",
-                "---", "---", "---", "CERR", "CERR", "BADA", "---", "---", "---"
+                "CC"  , "TC"  , "BGE", "---", "BWR" , "BRR" , "---" , "---" ,
+                "CIRQ", "OBI" , "---", "---", "---" , "---" , "---" , "ERRI",
+                "CTO" , "CCRC", "CEB", "CIE", "DTO" , "DCRC", "DEB" , "---" ,
+                "ACE" , "---" , "---", "---", "CERR", "BADA", "---" , "---"
         };
         char res[256];
         char *buf = res;
@@ -997,6 +1043,11 @@ static void omap_hsmmc_report_irq(struct omap_hsmmc_host *host, u32 status)
 
         dev_dbg(mmc_dev(host->mmc), "%s\n", res);
 }
+#else
+static inline void omap_hsmmc_dbg_report_irq(struct omap_hsmmc_host *host,
+                                             u32 status)
+{
+}
 #endif  /* CONFIG_MMC_DEBUG */
 
 /*
@@ -1055,9 +1106,7 @@ static void omap_hsmmc_do_irq(struct omap_hsmmc_host *host, int status)
         dev_dbg(mmc_dev(host->mmc), "IRQ Status is %x\n", status);
 
         if (status & ERR) {
-#ifdef CONFIG_MMC_DEBUG
-                omap_hsmmc_report_irq(host, status);
-#endif
+                omap_hsmmc_dbg_report_irq(host, status);
                 if ((status & CMD_TIMEOUT) ||
                         (status & CMD_CRC)) {
                         if (host->cmd) {
@@ -1155,8 +1204,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
         int ret;
 
         /* Disable the clocks */
-        clk_disable(host->fclk);
-        clk_disable(host->iclk);
+        pm_runtime_put_sync(host->dev);
         if (host->got_dbclk)
                 clk_disable(host->dbclk);
 
@@ -1167,8 +1215,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
         if (!ret)
                 ret = mmc_slot(host).set_power(host->dev, host->slot_id, 1,
                                                vdd);
-        clk_enable(host->iclk);
-        clk_enable(host->fclk);
+        pm_runtime_get_sync(host->dev);
         if (host->got_dbclk)
                 clk_enable(host->dbclk);
 
@@ -1322,7 +1369,7 @@ static void omap_hsmmc_config_dma_params(struct omap_hsmmc_host *host,
 static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
 {
         struct omap_hsmmc_host *host = cb_data;
-        struct mmc_data *data = host->mrq->data;
+        struct mmc_data *data;
         int dma_ch, req_in_progress;
 
         if (!(ch_status & OMAP_DMA_BLOCK_IRQ)) {
@@ -1337,6 +1384,7 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
                 return;
         }
 
+        data = host->mrq->data;
         host->dma_sg_idx++;
         if (host->dma_sg_idx < host->dma_len) {
                 /* Fire up the next transfer. */
@@ -1346,8 +1394,9 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
                 return;
         }
 
-        dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
-                omap_hsmmc_get_dma_dir(host, data));
+        if (!data->host_cookie)
+                dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
+                             omap_hsmmc_get_dma_dir(host, data));
 
         req_in_progress = host->req_in_progress;
         dma_ch = host->dma_ch;
@@ -1365,6 +1414,45 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
         }
 }
 
+static int omap_hsmmc_pre_dma_transfer(struct omap_hsmmc_host *host,
+                                       struct mmc_data *data,
+                                       struct omap_hsmmc_next *next)
+{
+        int dma_len;
+
+        if (!next && data->host_cookie &&
+            data->host_cookie != host->next_data.cookie) {
+                printk(KERN_WARNING "[%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;
+        }
+
+        /* Check if next job is already prepared */
+        if (next ||
+            (!next && data->host_cookie != host->next_data.cookie)) {
+                dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
+                                     data->sg_len,
+                                     omap_hsmmc_get_dma_dir(host, data));
+
+        } else {
+                dma_len = host->next_data.dma_len;
+                host->next_data.dma_len = 0;
+        }
+
+
+        if (dma_len == 0)
+                return -EINVAL;
+
+        if (next) {
+                next->dma_len = dma_len;
+                data->host_cookie = ++next->cookie < 0 ? 1 : next->cookie;
+        } else
+                host->dma_len = dma_len;
+
+        return 0;
+}
+
 /*
  * Routine to configure and start DMA for the MMC card
  */
@@ -1398,9 +1486,10 @@ static int omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host,
                         mmc_hostname(host->mmc), ret);
                 return ret;
         }
+        ret = omap_hsmmc_pre_dma_transfer(host, data, NULL);
+        if (ret)
+                return ret;
 
-        host->dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
-                        data->sg_len, omap_hsmmc_get_dma_dir(host, data));
         host->dma_ch = dma_ch;
         host->dma_sg_idx = 0;
 
@@ -1480,6 +1569,35 @@ omap_hsmmc_prepare_data(struct omap_hsmmc_host *host, struct mmc_request *req)
         return 0;
 }
 
+static void omap_hsmmc_post_req(struct mmc_host *mmc, struct mmc_request *mrq,
+                                int err)
+{
+        struct omap_hsmmc_host *host = mmc_priv(mmc);
+        struct mmc_data *data = mrq->data;
+
+        if (host->use_dma) {
+                dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
+                             omap_hsmmc_get_dma_dir(host, data));
+                data->host_cookie = 0;
+        }
+}
+
+static void omap_hsmmc_pre_req(struct mmc_host *mmc, struct mmc_request *mrq,
+                               bool is_first_req)
+{
+        struct omap_hsmmc_host *host = mmc_priv(mmc);
+
+        if (mrq->data->host_cookie) {
+                mrq->data->host_cookie = 0;
+                return ;
+        }
+
+        if (host->use_dma)
+                if (omap_hsmmc_pre_dma_transfer(host, mrq->data,
+                                                &host->next_data))
+                        mrq->data->host_cookie = 0;
+}
+
 /*
  * Request function. for read/write operation
  */
@@ -1528,13 +1646,9 @@ static void omap_hsmmc_request(struct mmc_host *mmc, struct mmc_request *req)
 static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
-        u16 dsor = 0;
-        unsigned long regval;
-        unsigned long timeout;
-        u32 con;
         int do_send_init_stream = 0;
 
-        mmc_host_enable(host->mmc);
+        pm_runtime_get_sync(host->dev);
 
         if (ios->power_mode != host->power_mode) {
                 switch (ios->power_mode) {
@@ -1557,22 +1671,7 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         /* FIXME: set registers based only on changes to ios */
 
-        con = OMAP_HSMMC_READ(host->base, CON);
-        switch (mmc->ios.bus_width) {
-        case MMC_BUS_WIDTH_8:
-                OMAP_HSMMC_WRITE(host->base, CON, con | DW8);
-                break;
-        case MMC_BUS_WIDTH_4:
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
-                OMAP_HSMMC_WRITE(host->base, HCTL,
-                        OMAP_HSMMC_READ(host->base, HCTL) | FOUR_BIT);
-                break;
-        case MMC_BUS_WIDTH_1:
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~DW8);
-                OMAP_HSMMC_WRITE(host->base, HCTL,
-                        OMAP_HSMMC_READ(host->base, HCTL) & ~FOUR_BIT);
-                break;
-        }
+        omap_hsmmc_set_bus_width(host);
 
         if (host->pdata->controller_flags & OMAP_HSMMC_SUPPORTS_DUAL_VOLT) {
                 /* Only MMC1 can interface at 3V without some flavor
@@ -1592,47 +1691,14 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 }
         }
 
-        if (ios->clock) {
-                dsor = OMAP_MMC_MASTER_CLOCK / ios->clock;
-                if (dsor < 1)
-                        dsor = 1;
-
-                if (OMAP_MMC_MASTER_CLOCK / dsor > ios->clock)
-                        dsor++;
-
-                if (dsor > 250)
-                        dsor = 250;
-        }
-        omap_hsmmc_stop_clock(host);
-        regval = OMAP_HSMMC_READ(host->base, SYSCTL);
-        regval = regval & ~(CLKD_MASK);
-        regval = regval | (dsor << 6) | (DTO << 16);
-        OMAP_HSMMC_WRITE(host->base, SYSCTL, regval);
-        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                OMAP_HSMMC_READ(host->base, SYSCTL) | ICE);
-
-        /* Wait till the ICS bit is set */
-        timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
-        while ((OMAP_HSMMC_READ(host->base, SYSCTL) & ICS) != ICS
-                && time_before(jiffies, timeout))
-                msleep(1);
-
-        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                OMAP_HSMMC_READ(host->base, SYSCTL) | CEN);
+        omap_hsmmc_set_clock(host);
 
         if (do_send_init_stream)
                 send_init_stream(host);
 
-        con = OMAP_HSMMC_READ(host->base, CON);
-        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
-                OMAP_HSMMC_WRITE(host->base, CON, con | OD);
-        else
-                OMAP_HSMMC_WRITE(host->base, CON, con & ~OD);
+        omap_hsmmc_set_bus_mode(host);
 
-        if (host->power_mode == MMC_POWER_OFF)
-                mmc_host_disable(host->mmc);
-        else
-                mmc_host_lazy_disable(host->mmc);
+        pm_runtime_put_autosuspend(host->dev);
 }
 
 static int omap_hsmmc_get_cd(struct mmc_host *mmc)
@@ -1688,230 +1754,12 @@ static void omap_hsmmc_conf_bus_power(struct omap_hsmmc_host *host)
         set_sd_bus_power(host);
 }
 
-/*
- * Dynamic power saving handling, FSM:
- *   ENABLED -> DISABLED -> CARDSLEEP / REGSLEEP -> OFF
- *     ^___________|          |                      |
- *     |______________________|______________________|
- *
- * ENABLED:   mmc host is fully functional
- * DISABLED:  fclk is off
- * CARDSLEEP: fclk is off, card is asleep, voltage regulator is asleep
- * REGSLEEP:  fclk is off, voltage regulator is asleep
- * OFF:       fclk is off, voltage regulator is off
- *
- * Transition handlers return the timeout for the next state transition
- * or negative error.
- */
-
-enum {ENABLED = 0, DISABLED, CARDSLEEP, REGSLEEP, OFF};
-
-/* Handler for [ENABLED -> DISABLED] transition */
-static int omap_hsmmc_enabled_to_disabled(struct omap_hsmmc_host *host)
-{
-        omap_hsmmc_context_save(host);
-        clk_disable(host->fclk);
-        host->dpm_state = DISABLED;
-
-        dev_dbg(mmc_dev(host->mmc), "ENABLED -> DISABLED\n");
-
-        if (host->power_mode == MMC_POWER_OFF)
-                return 0;
-
-        return OMAP_MMC_SLEEP_TIMEOUT;
-}
-
-/* Handler for [DISABLED -> REGSLEEP / CARDSLEEP] transition */
-static int omap_hsmmc_disabled_to_sleep(struct omap_hsmmc_host *host)
-{
-        int err, new_state;
-
-        if (!mmc_try_claim_host(host->mmc))
-                return 0;
-
-        clk_enable(host->fclk);
-        omap_hsmmc_context_restore(host);
-        if (mmc_card_can_sleep(host->mmc)) {
-                err = mmc_card_sleep(host->mmc);
-                if (err < 0) {
-                        clk_disable(host->fclk);
-                        mmc_release_host(host->mmc);
-                        return err;
-                }
-                new_state = CARDSLEEP;
-        } else {
-                new_state = REGSLEEP;
-        }
-        if (mmc_slot(host).set_sleep)
-                mmc_slot(host).set_sleep(host->dev, host->slot_id, 1, 0,
-                                         new_state == CARDSLEEP);
-        /* FIXME: turn off bus power and perhaps interrupts too */
-        clk_disable(host->fclk);
-        host->dpm_state = new_state;
-
-        mmc_release_host(host->mmc);
-
-        dev_dbg(mmc_dev(host->mmc), "DISABLED -> %s\n",
-                host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");
-
-        if (mmc_slot(host).no_off)
-                return 0;
-
-        if ((host->mmc->caps & MMC_CAP_NONREMOVABLE) ||
-            mmc_slot(host).card_detect ||
-            (mmc_slot(host).get_cover_state &&
-             mmc_slot(host).get_cover_state(host->dev, host->slot_id)))
-                return OMAP_MMC_OFF_TIMEOUT;
-
-        return 0;
-}
-
-/* Handler for [REGSLEEP / CARDSLEEP -> OFF] transition */
-static int omap_hsmmc_sleep_to_off(struct omap_hsmmc_host *host)
-{
-        if (!mmc_try_claim_host(host->mmc))
-                return 0;
-
-        if (mmc_slot(host).no_off)
-                return 0;
-
-        if (!((host->mmc->caps & MMC_CAP_NONREMOVABLE) ||
-              mmc_slot(host).card_detect ||
-              (mmc_slot(host).get_cover_state &&
-               mmc_slot(host).get_cover_state(host->dev, host->slot_id)))) {
-                mmc_release_host(host->mmc);
-                return 0;
-        }
-
-        mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
-        host->vdd = 0;
-        host->power_mode = MMC_POWER_OFF;
-
-        dev_dbg(mmc_dev(host->mmc), "%s -> OFF\n",
-                host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");
-
-        host->dpm_state = OFF;
-
-        mmc_release_host(host->mmc);
-
-        return 0;
-}
-
-/* Handler for [DISABLED -> ENABLED] transition */
-static int omap_hsmmc_disabled_to_enabled(struct omap_hsmmc_host *host)
-{
-        int err;
-
-        err = clk_enable(host->fclk);
-        if (err < 0)
-                return err;
-
-        omap_hsmmc_context_restore(host);
-        host->dpm_state = ENABLED;
-
-        dev_dbg(mmc_dev(host->mmc), "DISABLED -> ENABLED\n");
-
-        return 0;
-}
-
-/* Handler for [SLEEP -> ENABLED] transition */
-static int omap_hsmmc_sleep_to_enabled(struct omap_hsmmc_host *host)
-{
-        if (!mmc_try_claim_host(host->mmc))
-                return 0;
-
-        clk_enable(host->fclk);
-        omap_hsmmc_context_restore(host);
-        if (mmc_slot(host).set_sleep)
-                mmc_slot(host).set_sleep(host->dev, host->slot_id, 0,
-                         host->vdd, host->dpm_state == CARDSLEEP);
-        if (mmc_card_can_sleep(host->mmc))
-                mmc_card_awake(host->mmc);
-
-        dev_dbg(mmc_dev(host->mmc), "%s -> ENABLED\n",
-                host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");
-
-        host->dpm_state = ENABLED;
-
-        mmc_release_host(host->mmc);
-
-        return 0;
-}
-
-/* Handler for [OFF -> ENABLED] transition */
-static int omap_hsmmc_off_to_enabled(struct omap_hsmmc_host *host)
-{
-        clk_enable(host->fclk);
-
-        omap_hsmmc_context_restore(host);
-        omap_hsmmc_conf_bus_power(host);
-        mmc_power_restore_host(host->mmc);
-
-        host->dpm_state = ENABLED;
-
-        dev_dbg(mmc_dev(host->mmc), "OFF -> ENABLED\n");
-
-        return 0;
-}
-
-/*
- * Bring MMC host to ENABLED from any other PM state.
- */
-static int omap_hsmmc_enable(struct mmc_host *mmc)
-{
-        struct omap_hsmmc_host *host = mmc_priv(mmc);
-
-        switch (host->dpm_state) {
-        case DISABLED:
-                return omap_hsmmc_disabled_to_enabled(host);
-        case CARDSLEEP:
-        case REGSLEEP:
-                return omap_hsmmc_sleep_to_enabled(host);
-        case OFF:
-                return omap_hsmmc_off_to_enabled(host);
-        default:
-                dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");
-                return -EINVAL;
-        }
-}
-
-/*
- * Bring MMC host in PM state (one level deeper).
- */
-static int omap_hsmmc_disable(struct mmc_host *mmc, int lazy)
-{
-        struct omap_hsmmc_host *host = mmc_priv(mmc);
-
-        switch (host->dpm_state) {
-        case ENABLED: {
-                int delay;
-
-                delay = omap_hsmmc_enabled_to_disabled(host);
-                if (lazy || delay < 0)
-                        return delay;
-                return 0;
-        }
-        case DISABLED:
-                return omap_hsmmc_disabled_to_sleep(host);
-        case CARDSLEEP:
-        case REGSLEEP:
-                return omap_hsmmc_sleep_to_off(host);
-        default:
-                dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");
-                return -EINVAL;
-        }
-}
-
 static int omap_hsmmc_enable_fclk(struct mmc_host *mmc)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
-        int err;
 
-        err = clk_enable(host->fclk);
-        if (err)
-                return err;
-        dev_dbg(mmc_dev(host->mmc), "mmc_fclk: enabled\n");
-        omap_hsmmc_context_restore(host);
+        pm_runtime_get_sync(host->dev);
+
         return 0;
 }
 
@@ -1919,26 +1767,17 @@ static int omap_hsmmc_disable_fclk(struct mmc_host *mmc, int lazy)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
-        omap_hsmmc_context_save(host);
-        clk_disable(host->fclk);
-        dev_dbg(mmc_dev(host->mmc), "mmc_fclk: disabled\n");
+        pm_runtime_mark_last_busy(host->dev);
+        pm_runtime_put_autosuspend(host->dev);
+
         return 0;
 }
 
 static const struct mmc_host_ops omap_hsmmc_ops = {
         .enable = omap_hsmmc_enable_fclk,
         .disable = omap_hsmmc_disable_fclk,
-        .request = omap_hsmmc_request,
-        .set_ios = omap_hsmmc_set_ios,
-        .get_cd = omap_hsmmc_get_cd,
-        .get_ro = omap_hsmmc_get_ro,
-        .init_card = omap_hsmmc_init_card,
-        /* NYET -- enable_sdio_irq */
-};
-
-static const struct mmc_host_ops omap_hsmmc_ps_ops = {
-        .enable = omap_hsmmc_enable,
-        .disable = omap_hsmmc_disable,
+        .post_req = omap_hsmmc_post_req,
+        .pre_req = omap_hsmmc_pre_req,
         .request = omap_hsmmc_request,
         .set_ios = omap_hsmmc_set_ios,
         .get_cd = omap_hsmmc_get_cd,
@@ -1968,15 +1807,12 @@ static int omap_hsmmc_regs_show(struct seq_file *s, void *data)
                         host->dpm_state, mmc->nesting_cnt,
                         host->context_loss, context_loss);
 
-        if (host->suspended || host->dpm_state == OFF) {
+        if (host->suspended) {
                 seq_printf(s, "host suspended, can't read registers\n");
                 return 0;
         }
 
-        if (clk_enable(host->fclk) != 0) {
-                seq_printf(s, "can't read the regs\n");
-                return 0;
-        }
+        pm_runtime_get_sync(host->dev);
 
         seq_printf(s, "SYSCONFIG:\t0x%08x\n",
                         OMAP_HSMMC_READ(host->base, SYSCONFIG));
@@ -1993,7 +1829,8 @@ static int omap_hsmmc_regs_show(struct seq_file *s, void *data)
         seq_printf(s, "CAPA:\t\t0x%08x\n",
                         OMAP_HSMMC_READ(host->base, CAPA));
 
-        clk_disable(host->fclk);
+        pm_runtime_mark_last_busy(host->dev);
+        pm_runtime_put_autosuspend(host->dev);
 
         return 0;
 }
@@ -2077,14 +1914,12 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         host->mapbase   = res->start;
         host->base      = ioremap(host->mapbase, SZ_4K);
         host->power_mode = MMC_POWER_OFF;
+        host->next_data.cookie = 1;
 
         platform_set_drvdata(pdev, host);
         INIT_WORK(&host->mmc_carddetect_work, omap_hsmmc_detect);
 
-        if (mmc_slot(host).power_saving)
-                mmc->ops        = &omap_hsmmc_ps_ops;
-        else
-                mmc->ops        = &omap_hsmmc_ops;
+        mmc->ops        = &omap_hsmmc_ops;
 
         /*
          * If regulator_disable can only put vcc_aux to sleep then there is
@@ -2093,44 +1928,26 @@ 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      = 400000;
-        mmc->f_max      = 52000000;
+        mmc->f_min      = OMAP_MMC_MIN_CLOCK;
+        mmc->f_max      = OMAP_MMC_MAX_CLOCK;
 
         spin_lock_init(&host->irq_lock);
 
-        host->iclk = clk_get(&pdev->dev, "ick");
-        if (IS_ERR(host->iclk)) {
-                ret = PTR_ERR(host->iclk);
-                host->iclk = NULL;
-                goto err1;
-        }
         host->fclk = clk_get(&pdev->dev, "fck");
         if (IS_ERR(host->fclk)) {
                 ret = PTR_ERR(host->fclk);
                 host->fclk = NULL;
-                clk_put(host->iclk);
                 goto err1;
         }
 
         omap_hsmmc_context_save(host);
 
         mmc->caps |= MMC_CAP_DISABLE;
-        mmc_set_disable_delay(mmc, OMAP_MMC_DISABLED_TIMEOUT);
-        /* we start off in DISABLED state */
-        host->dpm_state = DISABLED;
 
-        if (clk_enable(host->iclk) != 0) {
-                clk_put(host->iclk);
-                clk_put(host->fclk);
-                goto err1;
-        }
-
-        if (mmc_host_enable(host->mmc) != 0) {
-                clk_disable(host->iclk);
-                clk_put(host->iclk);
-                clk_put(host->fclk);
-                goto err1;
-        }
+        pm_runtime_enable(host->dev);
+        pm_runtime_get_sync(host->dev);
+        pm_runtime_set_autosuspend_delay(host->dev, MMC_AUTOSUSPEND_DELAY);
+        pm_runtime_use_autosuspend(host->dev);
 
         if (cpu_is_omap2430()) {
                 host->dbclk = clk_get(&pdev->dev, "mmchsdb_fck");
@@ -2240,8 +2057,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
 
         omap_hsmmc_disable_irq(host);
 
-        mmc_host_lazy_disable(host->mmc);
-
         omap_hsmmc_protect_card(host);
 
         mmc_add_host(mmc);
@@ -2259,6 +2074,8 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         }
 
         omap_hsmmc_debugfs(mmc);
+        pm_runtime_mark_last_busy(host->dev);
+        pm_runtime_put_autosuspend(host->dev);
 
         return 0;
 
@@ -2274,10 +2091,9 @@ err_reg:
 err_irq_cd_init:
         free_irq(host->irq, host);
 err_irq:
-        mmc_host_disable(host->mmc);
-        clk_disable(host->iclk);
+        pm_runtime_mark_last_busy(host->dev);
+        pm_runtime_put_autosuspend(host->dev);
         clk_put(host->fclk);
-        clk_put(host->iclk);
         if (host->got_dbclk) {
                 clk_disable(host->dbclk);
                 clk_put(host->dbclk);
@@ -2299,7 +2115,7 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
         struct resource *res;
 
         if (host) {
-                mmc_host_enable(host->mmc);
+                pm_runtime_get_sync(host->dev);
                 mmc_remove_host(host->mmc);
                 if (host->use_reg)
                         omap_hsmmc_reg_put(host);
@@ -2310,10 +2126,9 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
                         free_irq(mmc_slot(host).card_detect_irq, host);
                 flush_work_sync(&host->mmc_carddetect_work);
 
-                mmc_host_disable(host->mmc);
-                clk_disable(host->iclk);
+                pm_runtime_put_sync(host->dev);
+                pm_runtime_disable(host->dev);
                 clk_put(host->fclk);
-                clk_put(host->iclk);
                 if (host->got_dbclk) {
                         clk_disable(host->dbclk);
                         clk_put(host->dbclk);
@@ -2343,6 +2158,7 @@ static int omap_hsmmc_suspend(struct device *dev)
                 return 0;
 
         if (host) {
+                pm_runtime_get_sync(host->dev);
                 host->suspended = 1;
                 if (host->pdata->suspend) {
                         ret = host->pdata->suspend(&pdev->dev,
@@ -2357,13 +2173,11 @@ static int omap_hsmmc_suspend(struct device *dev)
                 }
                 cancel_work_sync(&host->mmc_carddetect_work);
                 ret = mmc_suspend_host(host->mmc);
-                mmc_host_enable(host->mmc);
+
                 if (ret == 0) {
                         omap_hsmmc_disable_irq(host);
                         OMAP_HSMMC_WRITE(host->base, HCTL,
                                 OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
-                        mmc_host_disable(host->mmc);
-                        clk_disable(host->iclk);
                         if (host->got_dbclk)
                                 clk_disable(host->dbclk);
                 } else {
@@ -2375,9 +2189,8 @@ static int omap_hsmmc_suspend(struct device *dev)
                                         dev_dbg(mmc_dev(host->mmc),
                                                 "Unmask interrupt failed\n");
                         }
-                        mmc_host_disable(host->mmc);
                 }
-
+                pm_runtime_put_sync(host->dev);
         }
         return ret;
 }
@@ -2393,14 +2206,7 @@ static int omap_hsmmc_resume(struct device *dev)
                 return 0;
 
         if (host) {
-                ret = clk_enable(host->iclk);
-                if (ret)
-                        goto clk_en_err;
-
-                if (mmc_host_enable(host->mmc) != 0) {
-                        clk_disable(host->iclk);
-                        goto clk_en_err;
-                }
+                pm_runtime_get_sync(host->dev);
 
                 if (host->got_dbclk)
                         clk_enable(host->dbclk);
@@ -2421,15 +2227,12 @@ static int omap_hsmmc_resume(struct device *dev)
                 if (ret == 0)
                         host->suspended = 0;
 
-                mmc_host_lazy_disable(host->mmc);
+                pm_runtime_mark_last_busy(host->dev);
+                pm_runtime_put_autosuspend(host->dev);
         }
 
         return ret;
 
-clk_en_err:
-        dev_dbg(mmc_dev(host->mmc),
-                "Failed to enable MMC clocks during resume\n");
-        return ret;
 }
 
 #else
@@ -2437,9 +2240,33 @@ clk_en_err:
 #define omap_hsmmc_resume               NULL
 #endif
 
+static int omap_hsmmc_runtime_suspend(struct device *dev)
+{
+        struct omap_hsmmc_host *host;
+
+        host = platform_get_drvdata(to_platform_device(dev));
+        omap_hsmmc_context_save(host);
+        dev_dbg(mmc_dev(host->mmc), "disabled\n");
+
+        return 0;
+}
+
+static int omap_hsmmc_runtime_resume(struct device *dev)
+{
+        struct omap_hsmmc_host *host;
+
+        host = platform_get_drvdata(to_platform_device(dev));
+        omap_hsmmc_context_restore(host);
+        dev_dbg(mmc_dev(host->mmc), "enabled\n");
+
+        return 0;
+}
+
 static struct dev_pm_ops omap_hsmmc_dev_pm_ops = {
         .suspend        = omap_hsmmc_suspend,
         .resume         = omap_hsmmc_resume,
+        .runtime_suspend = omap_hsmmc_runtime_suspend,
+        .runtime_resume = omap_hsmmc_runtime_resume,
 };
 
 static struct platform_driver omap_hsmmc_driver = {
diff --git a/drivers/mmc/host/sdhci-cns3xxx.c b/drivers/mmc/host/sdhci-cns3xxx.c
index 9ebd1d7759d..4b920b7621c 100644
--- a/drivers/mmc/host/sdhci-cns3xxx.c
+++ b/drivers/mmc/host/sdhci-cns3xxx.c
@@ -15,9 +15,7 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/mmc/host.h>
-#include <linux/mmc/sdhci-pltfm.h>
 #include <mach/cns3xxx.h>
-#include "sdhci.h"
 #include "sdhci-pltfm.h"
 
 static unsigned int sdhci_cns3xxx_get_max_clk(struct sdhci_host *host)
@@ -86,7 +84,7 @@ static struct sdhci_ops sdhci_cns3xxx_ops = {
         .set_clock      = sdhci_cns3xxx_set_clock,
 };
 
-struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
+static struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
         .ops = &sdhci_cns3xxx_ops,
         .quirks = SDHCI_QUIRK_BROKEN_DMA |
                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
@@ -95,3 +93,43 @@ struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
                   SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                   SDHCI_QUIRK_NONSTANDARD_CLOCK,
 };
+
+static int __devinit sdhci_cns3xxx_probe(struct platform_device *pdev)
+{
+        return sdhci_pltfm_register(pdev, &sdhci_cns3xxx_pdata);
+}
+
+static int __devexit sdhci_cns3xxx_remove(struct platform_device *pdev)
+{
+        return sdhci_pltfm_unregister(pdev);
+}
+
+static struct platform_driver sdhci_cns3xxx_driver = {
+        .driver         = {
+                .name   = "sdhci-cns3xxx",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_cns3xxx_probe,
+        .remove         = __devexit_p(sdhci_cns3xxx_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
+};
+
+static int __init sdhci_cns3xxx_init(void)
+{
+        return platform_driver_register(&sdhci_cns3xxx_driver);
+}
+module_init(sdhci_cns3xxx_init);
+
+static void __exit sdhci_cns3xxx_exit(void)
+{
+        platform_driver_unregister(&sdhci_cns3xxx_driver);
+}
+module_exit(sdhci_cns3xxx_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for CNS3xxx");
+MODULE_AUTHOR("Scott Shu, "
+              "Anton Vorontsov <avorontsov@mvista.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index 2aeef4ffed8..f2d29dca442 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -22,7 +22,6 @@
 #include <linux/io.h>
 #include <linux/mmc/host.h>
 
-#include "sdhci.h"
 #include "sdhci-pltfm.h"
 
 static u16 sdhci_dove_readw(struct sdhci_host *host, int reg)
@@ -61,10 +60,50 @@ static struct sdhci_ops sdhci_dove_ops = {
         .read_l = sdhci_dove_readl,
 };
 
-struct sdhci_pltfm_data sdhci_dove_pdata = {
+static struct sdhci_pltfm_data sdhci_dove_pdata = {
         .ops    = &sdhci_dove_ops,
         .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                   SDHCI_QUIRK_NO_BUSY_IRQ |
                   SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                   SDHCI_QUIRK_FORCE_DMA,
 };
+
+static int __devinit sdhci_dove_probe(struct platform_device *pdev)
+{
+        return sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+}
+
+static int __devexit sdhci_dove_remove(struct platform_device *pdev)
+{
+        return sdhci_pltfm_unregister(pdev);
+}
+
+static struct platform_driver sdhci_dove_driver = {
+        .driver         = {
+                .name   = "sdhci-dove",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_dove_probe,
+        .remove         = __devexit_p(sdhci_dove_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
+};
+
+static int __init sdhci_dove_init(void)
+{
+        return platform_driver_register(&sdhci_dove_driver);
+}
+module_init(sdhci_dove_init);
+
+static void __exit sdhci_dove_exit(void)
+{
+        platform_driver_unregister(&sdhci_dove_driver);
+}
+module_exit(sdhci_dove_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Dove");
+MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, "
+              "Mike Rapoport <mike@compulab.co.il>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index a19967d0bfc..4dc0028086a 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -16,22 +16,23 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mmc/host.h>
-#include <linux/mmc/sdhci-pltfm.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
-#include <mach/hardware.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <mach/esdhc.h>
-#include "sdhci.h"
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
+#define SDHCI_CTRL_D3CD                 0x08
 /* VENDOR SPEC register */
 #define SDHCI_VENDOR_SPEC               0xC0
 #define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
 
-#define ESDHC_FLAG_GPIO_FOR_CD_WP       (1 << 0)
 /*
  * The CMDTYPE of the CMD register (offset 0xE) should be set to
  * "11" when the STOP CMD12 is issued on imx53 to abort one
@@ -45,11 +46,68 @@
  */
 #define ESDHC_FLAG_MULTIBLK_NO_INT      (1 << 1)
 
+enum imx_esdhc_type {
+        IMX25_ESDHC,
+        IMX35_ESDHC,
+        IMX51_ESDHC,
+        IMX53_ESDHC,
+};
+
 struct pltfm_imx_data {
         int flags;
         u32 scratchpad;
+        enum imx_esdhc_type devtype;
+        struct esdhc_platform_data boarddata;
 };
 
+static struct platform_device_id imx_esdhc_devtype[] = {
+        {
+                .name = "sdhci-esdhc-imx25",
+                .driver_data = IMX25_ESDHC,
+        }, {
+                .name = "sdhci-esdhc-imx35",
+                .driver_data = IMX35_ESDHC,
+        }, {
+                .name = "sdhci-esdhc-imx51",
+                .driver_data = IMX51_ESDHC,
+        }, {
+                .name = "sdhci-esdhc-imx53",
+                .driver_data = IMX53_ESDHC,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(platform, imx_esdhc_devtype);
+
+static const struct of_device_id imx_esdhc_dt_ids[] = {
+        { .compatible = "fsl,imx25-esdhc", .data = &imx_esdhc_devtype[IMX25_ESDHC], },
+        { .compatible = "fsl,imx35-esdhc", .data = &imx_esdhc_devtype[IMX35_ESDHC], },
+        { .compatible = "fsl,imx51-esdhc", .data = &imx_esdhc_devtype[IMX51_ESDHC], },
+        { .compatible = "fsl,imx53-esdhc", .data = &imx_esdhc_devtype[IMX53_ESDHC], },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_esdhc_dt_ids);
+
+static inline int is_imx25_esdhc(struct pltfm_imx_data *data)
+{
+        return data->devtype == IMX25_ESDHC;
+}
+
+static inline int is_imx35_esdhc(struct pltfm_imx_data *data)
+{
+        return data->devtype == IMX35_ESDHC;
+}
+
+static inline int is_imx51_esdhc(struct pltfm_imx_data *data)
+{
+        return data->devtype == IMX51_ESDHC;
+}
+
+static inline int is_imx53_esdhc(struct pltfm_imx_data *data)
+{
+        return data->devtype == IMX53_ESDHC;
+}
+
 static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, int reg)
 {
         void __iomem *base = host->ioaddr + (reg & ~0x3);
@@ -62,19 +120,16 @@ static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
+        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
 
-        /* fake CARD_PRESENT flag on mx25/35 */
+        /* fake CARD_PRESENT flag */
         u32 val = readl(host->ioaddr + reg);
 
         if (unlikely((reg == SDHCI_PRESENT_STATE)
-                        && (imx_data->flags & ESDHC_FLAG_GPIO_FOR_CD_WP))) {
-                struct esdhc_platform_data *boarddata =
-                                host->mmc->parent->platform_data;
-
-                if (boarddata && gpio_is_valid(boarddata->cd_gpio)
-                                && gpio_get_value(boarddata->cd_gpio))
+                        && gpio_is_valid(boarddata->cd_gpio))) {
+                if (gpio_get_value(boarddata->cd_gpio))
                         /* no card, if a valid gpio says so... */
-                        val &= SDHCI_CARD_PRESENT;
+                        val &= ~SDHCI_CARD_PRESENT;
                 else
                         /* ... in all other cases assume card is present */
                         val |= SDHCI_CARD_PRESENT;
@@ -87,14 +142,33 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
-
-        if (unlikely((reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)
-                        && (imx_data->flags & ESDHC_FLAG_GPIO_FOR_CD_WP)))
-                /*
-                 * these interrupts won't work with a custom card_detect gpio
-                 * (only applied to mx25/35)
-                 */
-                val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
+        u32 data;
+
+        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
+                if (boarddata->cd_type == ESDHC_CD_GPIO)
+                        /*
+                         * These interrupts won't work with a custom
+                         * card_detect gpio (only applied to mx25/35)
+                         */
+                        val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+
+                if (val & SDHCI_INT_CARD_INT) {
+                        /*
+                         * Clear and then set D3CD bit to avoid missing the
+                         * card interrupt.  This is a eSDHC controller problem
+                         * so we need to apply the following workaround: clear
+                         * and set D3CD bit will make eSDHC re-sample the card
+                         * interrupt. In case a card interrupt was lost,
+                         * re-sample it by the following steps.
+                         */
+                        data = readl(host->ioaddr + SDHCI_HOST_CONTROL);
+                        data &= ~SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                        data |= SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                }
+        }
 
         if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
                                 && (reg == SDHCI_INT_STATUS)
@@ -164,8 +238,10 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                  */
                 return;
         case SDHCI_HOST_CONTROL:
-                /* FSL messed up here, so we can just keep those two */
-                new_val = val & (SDHCI_CTRL_LED | SDHCI_CTRL_4BITBUS);
+                /* FSL messed up here, so we can just keep those three */
+                new_val = val & (SDHCI_CTRL_LED | \
+                                SDHCI_CTRL_4BITBUS | \
+                                SDHCI_CTRL_D3CD);
                 /* ensure the endianess */
                 new_val |= ESDHC_HOST_CONTROL_LE;
                 /* DMA mode bits are shifted */
@@ -175,6 +251,17 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                 return;
         }
         esdhc_clrset_le(host, 0xff, val, reg);
+
+        /*
+         * The esdhc has a design violation to SDHC spec which tells
+         * that software reset should not affect card detection circuit.
+         * But esdhc clears its SYSCTL register bits [0..2] during the
+         * software reset.  This will stop those clocks that card detection
+         * circuit relies on.  To work around it, we turn the clocks on back
+         * to keep card detection circuit functional.
+         */
+        if ((reg == SDHCI_SOFTWARE_RESET) && (val & 1))
+                esdhc_clrset_le(host, 0x7, 0x7, ESDHC_SYSTEM_CONTROL);
 }
 
 static unsigned int esdhc_pltfm_get_max_clock(struct sdhci_host *host)
@@ -193,12 +280,22 @@ static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
 
 static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
 {
-        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
+
+        switch (boarddata->wp_type) {
+        case ESDHC_WP_GPIO:
+                if (gpio_is_valid(boarddata->wp_gpio))
+                        return gpio_get_value(boarddata->wp_gpio);
+        case ESDHC_WP_CONTROLLER:
+                return !(readl(host->ioaddr + SDHCI_PRESENT_STATE) &
+                               SDHCI_WRITE_PROTECT);
+        case ESDHC_WP_NONE:
+                break;
+        }
 
-        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
-                return gpio_get_value(boarddata->wp_gpio);
-        else
-                return -ENOSYS;
+        return -ENOSYS;
 }
 
 static struct sdhci_ops sdhci_esdhc_ops = {
@@ -210,6 +307,14 @@ static struct sdhci_ops sdhci_esdhc_ops = {
         .set_clock = esdhc_set_clock,
         .get_max_clock = esdhc_pltfm_get_max_clock,
         .get_min_clock = esdhc_pltfm_get_min_clock,
+        .get_ro = esdhc_pltfm_get_ro,
+};
+
+static struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
+        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
+                        | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+        /* ADMA has issues. Might be fixable */
+        .ops = &sdhci_esdhc_ops,
 };
 
 static irqreturn_t cd_irq(int irq, void *data)
@@ -220,112 +325,228 @@ static irqreturn_t cd_irq(int irq, void *data)
         return IRQ_HANDLED;
 };
 
-static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pdata)
+#ifdef CONFIG_OF
+static int __devinit
+sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
+                         struct esdhc_platform_data *boarddata)
 {
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+        struct device_node *np = pdev->dev.of_node;
+
+        if (!np)
+                return -ENODEV;
+
+        if (of_get_property(np, "fsl,card-wired", NULL))
+                boarddata->cd_type = ESDHC_CD_PERMANENT;
+
+        if (of_get_property(np, "fsl,cd-controller", NULL))
+                boarddata->cd_type = ESDHC_CD_CONTROLLER;
+
+        if (of_get_property(np, "fsl,wp-controller", NULL))
+                boarddata->wp_type = ESDHC_WP_CONTROLLER;
+
+        boarddata->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
+        if (gpio_is_valid(boarddata->cd_gpio))
+                boarddata->cd_type = ESDHC_CD_GPIO;
+
+        boarddata->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+        if (gpio_is_valid(boarddata->wp_gpio))
+                boarddata->wp_type = ESDHC_WP_GPIO;
+
+        return 0;
+}
+#else
+static inline int
+sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
+                         struct esdhc_platform_data *boarddata)
+{
+        return -ENODEV;
+}
+#endif
+
+static int __devinit sdhci_esdhc_imx_probe(struct platform_device *pdev)
+{
+        const struct of_device_id *of_id =
+                        of_match_device(imx_esdhc_dt_ids, &pdev->dev);
+        struct sdhci_pltfm_host *pltfm_host;
+        struct sdhci_host *host;
+        struct esdhc_platform_data *boarddata;
         struct clk *clk;
         int err;
         struct pltfm_imx_data *imx_data;
 
+        host = sdhci_pltfm_init(pdev, &sdhci_esdhc_imx_pdata);
+        if (IS_ERR(host))
+                return PTR_ERR(host);
+
+        pltfm_host = sdhci_priv(host);
+
+        imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
+        if (!imx_data) {
+                err = -ENOMEM;
+                goto err_imx_data;
+        }
+
+        if (of_id)
+                pdev->id_entry = of_id->data;
+        imx_data->devtype = pdev->id_entry->driver_data;
+        pltfm_host->priv = imx_data;
+
         clk = clk_get(mmc_dev(host->mmc), NULL);
         if (IS_ERR(clk)) {
                 dev_err(mmc_dev(host->mmc), "clk err\n");
-                return PTR_ERR(clk);
+                err = PTR_ERR(clk);
+                goto err_clk_get;
         }
         clk_enable(clk);
         pltfm_host->clk = clk;
 
-        imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
-        if (!imx_data) {
-                clk_disable(pltfm_host->clk);
-                clk_put(pltfm_host->clk);
-                return -ENOMEM;
-        }
-        pltfm_host->priv = imx_data;
-
-        if (!cpu_is_mx25())
+        if (!is_imx25_esdhc(imx_data))
                 host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
-        if (cpu_is_mx25() || cpu_is_mx35()) {
+        if (is_imx25_esdhc(imx_data) || is_imx35_esdhc(imx_data))
                 /* Fix errata ENGcm07207 present on i.MX25 and i.MX35 */
                 host->quirks |= SDHCI_QUIRK_NO_MULTIBLOCK;
-                /* write_protect can't be routed to controller, use gpio */
-                sdhci_esdhc_ops.get_ro = esdhc_pltfm_get_ro;
-        }
 
-        if (!(cpu_is_mx25() || cpu_is_mx35() || cpu_is_mx51()))
+        if (is_imx53_esdhc(imx_data))
                 imx_data->flags |= ESDHC_FLAG_MULTIBLK_NO_INT;
 
-        if (boarddata) {
+        boarddata = &imx_data->boarddata;
+        if (sdhci_esdhc_imx_probe_dt(pdev, boarddata) < 0) {
+                if (!host->mmc->parent->platform_data) {
+                        dev_err(mmc_dev(host->mmc), "no board data!\n");
+                        err = -EINVAL;
+                        goto no_board_data;
+                }
+                imx_data->boarddata = *((struct esdhc_platform_data *)
+                                        host->mmc->parent->platform_data);
+        }
+
+        /* write_protect */
+        if (boarddata->wp_type == ESDHC_WP_GPIO) {
                 err = gpio_request_one(boarddata->wp_gpio, GPIOF_IN, "ESDHC_WP");
                 if (err) {
                         dev_warn(mmc_dev(host->mmc),
-                                "no write-protect pin available!\n");
-                        boarddata->wp_gpio = err;
+                                 "no write-protect pin available!\n");
+                        boarddata->wp_gpio = -EINVAL;
                 }
+        } else {
+                boarddata->wp_gpio = -EINVAL;
+        }
 
+        /* card_detect */
+        if (boarddata->cd_type != ESDHC_CD_GPIO)
+                boarddata->cd_gpio = -EINVAL;
+
+        switch (boarddata->cd_type) {
+        case ESDHC_CD_GPIO:
                 err = gpio_request_one(boarddata->cd_gpio, GPIOF_IN, "ESDHC_CD");
                 if (err) {
-                        dev_warn(mmc_dev(host->mmc),
+                        dev_err(mmc_dev(host->mmc),
                                 "no card-detect pin available!\n");
                         goto no_card_detect_pin;
                 }
 
-                /* i.MX5x has issues to be researched */
-                if (!cpu_is_mx25() && !cpu_is_mx35())
-                        goto not_supported;
-
                 err = request_irq(gpio_to_irq(boarddata->cd_gpio), cd_irq,
                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                                  mmc_hostname(host->mmc), host);
                 if (err) {
-                        dev_warn(mmc_dev(host->mmc), "request irq error\n");
+                        dev_err(mmc_dev(host->mmc), "request irq error\n");
                         goto no_card_detect_irq;
                 }
+                /* fall through */
 
-                imx_data->flags |= ESDHC_FLAG_GPIO_FOR_CD_WP;
-                /* Now we have a working card_detect again */
+        case ESDHC_CD_CONTROLLER:
+                /* we have a working card_detect back */
                 host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+                break;
+
+        case ESDHC_CD_PERMANENT:
+                host->mmc->caps = MMC_CAP_NONREMOVABLE;
+                break;
+
+        case ESDHC_CD_NONE:
+                break;
         }
 
+        err = sdhci_add_host(host);
+        if (err)
+                goto err_add_host;
+
         return 0;
 
- no_card_detect_irq:
-        gpio_free(boarddata->cd_gpio);
- no_card_detect_pin:
-        boarddata->cd_gpio = err;
- not_supported:
+err_add_host:
+        if (gpio_is_valid(boarddata->cd_gpio))
+                free_irq(gpio_to_irq(boarddata->cd_gpio), host);
+no_card_detect_irq:
+        if (gpio_is_valid(boarddata->cd_gpio))
+                gpio_free(boarddata->cd_gpio);
+        if (gpio_is_valid(boarddata->wp_gpio))
+                gpio_free(boarddata->wp_gpio);
+no_card_detect_pin:
+no_board_data:
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+err_clk_get:
         kfree(imx_data);
-        return 0;
+err_imx_data:
+        sdhci_pltfm_free(pdev);
+        return err;
 }
 
-static void esdhc_pltfm_exit(struct sdhci_host *host)
+static int __devexit sdhci_esdhc_imx_remove(struct platform_device *pdev)
 {
+        struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
+        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
+        int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+        sdhci_remove_host(host, dead);
 
-        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+        if (gpio_is_valid(boarddata->wp_gpio))
                 gpio_free(boarddata->wp_gpio);
 
-        if (boarddata && gpio_is_valid(boarddata->cd_gpio)) {
+        if (gpio_is_valid(boarddata->cd_gpio)) {
+                free_irq(gpio_to_irq(boarddata->cd_gpio), host);
                 gpio_free(boarddata->cd_gpio);
-
-                if (!(host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION))
-                        free_irq(gpio_to_irq(boarddata->cd_gpio), host);
         }
 
         clk_disable(pltfm_host->clk);
         clk_put(pltfm_host->clk);
         kfree(imx_data);
+
+        sdhci_pltfm_free(pdev);
+
+        return 0;
 }
 
-struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
-        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
-                        | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
-        /* ADMA has issues. Might be fixable */
-        .ops = &sdhci_esdhc_ops,
-        .init = esdhc_pltfm_init,
-        .exit = esdhc_pltfm_exit,
+static struct platform_driver sdhci_esdhc_imx_driver = {
+        .driver         = {
+                .name   = "sdhci-esdhc-imx",
+                .owner  = THIS_MODULE,
+                .of_match_table = imx_esdhc_dt_ids,
+        },
+        .id_table       = imx_esdhc_devtype,
+        .probe          = sdhci_esdhc_imx_probe,
+        .remove         = __devexit_p(sdhci_esdhc_imx_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
 };
+
+static int __init sdhci_esdhc_imx_init(void)
+{
+        return platform_driver_register(&sdhci_esdhc_imx_driver);
+}
+module_init(sdhci_esdhc_imx_init);
+
+static void __exit sdhci_esdhc_imx_exit(void)
+{
+        platform_driver_unregister(&sdhci_esdhc_imx_driver);
+}
+module_exit(sdhci_esdhc_imx_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Freescale i.MX eSDHC");
+MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-of-core.c b/drivers/mmc/host/sdhci-of-core.c
deleted file mode 100644
index 60e4186a434..00000000000
--- a/drivers/mmc/host/sdhci-of-core.c
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * OpenFirmware bindings for Secure Digital Host Controller Interface.
- *
- * Copyright (c) 2007 Freescale Semiconductor, Inc.
- * Copyright (c) 2009 MontaVista Software, Inc.
- *
- * Authors: Xiaobo Xie <X.Xie@freescale.com>
- *          Anton Vorontsov <avorontsov@ru.mvista.com>
- *
- * 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/err.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/interrupt.h>
-#include <linux/delay.h>
-#include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/of_address.h>
-#include <linux/of_irq.h>
-#include <linux/mmc/host.h>
-#ifdef CONFIG_PPC
-#include <asm/machdep.h>
-#endif
-#include "sdhci-of.h"
-#include "sdhci.h"
-
-#ifdef CONFIG_MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
-
-/*
- * These accessors are designed for big endian hosts doing I/O to
- * little endian controllers incorporating a 32-bit hardware byte swapper.
- */
-
-u32 sdhci_be32bs_readl(struct sdhci_host *host, int reg)
-{
-        return in_be32(host->ioaddr + reg);
-}
-
-u16 sdhci_be32bs_readw(struct sdhci_host *host, int reg)
-{
-        return in_be16(host->ioaddr + (reg ^ 0x2));
-}
-
-u8 sdhci_be32bs_readb(struct sdhci_host *host, int reg)
-{
-        return in_8(host->ioaddr + (reg ^ 0x3));
-}
-
-void sdhci_be32bs_writel(struct sdhci_host *host, u32 val, int reg)
-{
-        out_be32(host->ioaddr + reg, val);
-}
-
-void sdhci_be32bs_writew(struct sdhci_host *host, u16 val, int reg)
-{
-        struct sdhci_of_host *of_host = sdhci_priv(host);
-        int base = reg & ~0x3;
-        int shift = (reg & 0x2) * 8;
-
-        switch (reg) {
-        case SDHCI_TRANSFER_MODE:
-                /*
-                 * Postpone this write, we must do it together with a
-                 * command write that is down below.
-                 */
-                of_host->xfer_mode_shadow = val;
-                return;
-        case SDHCI_COMMAND:
-                sdhci_be32bs_writel(host, val << 16 | of_host->xfer_mode_shadow,
-                                    SDHCI_TRANSFER_MODE);
-                return;
-        }
-        clrsetbits_be32(host->ioaddr + base, 0xffff << shift, val << shift);
-}
-
-void sdhci_be32bs_writeb(struct sdhci_host *host, u8 val, int reg)
-{
-        int base = reg & ~0x3;
-        int shift = (reg & 0x3) * 8;
-
-        clrsetbits_be32(host->ioaddr + base , 0xff << shift, val << shift);
-}
-#endif /* CONFIG_MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER */
-
-#ifdef CONFIG_PM
-
-static int sdhci_of_suspend(struct platform_device *ofdev, pm_message_t state)
-{
-        struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
-
-        return mmc_suspend_host(host->mmc);
-}
-
-static int sdhci_of_resume(struct platform_device *ofdev)
-{
-        struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
-
-        return mmc_resume_host(host->mmc);
-}
-
-#else
-
-#define sdhci_of_suspend NULL
-#define sdhci_of_resume NULL
-
-#endif
-
-static bool __devinit sdhci_of_wp_inverted(struct device_node *np)
-{
-        if (of_get_property(np, "sdhci,wp-inverted", NULL))
-                return true;
-
-        /* Old device trees don't have the wp-inverted property. */
-#ifdef CONFIG_PPC
-        return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds);
-#else
-        return false;
-#endif
-}
-
-static const struct of_device_id sdhci_of_match[];
-static int __devinit sdhci_of_probe(struct platform_device *ofdev)
-{
-        const struct of_device_id *match;
-        struct device_node *np = ofdev->dev.of_node;
-        struct sdhci_of_data *sdhci_of_data;
-        struct sdhci_host *host;
-        struct sdhci_of_host *of_host;
-        const __be32 *clk;
-        int size;
-        int ret;
-
-        match = of_match_device(sdhci_of_match, &ofdev->dev);
-        if (!match)
-                return -EINVAL;
-        sdhci_of_data = match->data;
-
-        if (!of_device_is_available(np))
-                return -ENODEV;
-
-        host = sdhci_alloc_host(&ofdev->dev, sizeof(*of_host));
-        if (IS_ERR(host))
-                return -ENOMEM;
-
-        of_host = sdhci_priv(host);
-        dev_set_drvdata(&ofdev->dev, host);
-
-        host->ioaddr = of_iomap(np, 0);
-        if (!host->ioaddr) {
-                ret = -ENOMEM;
-                goto err_addr_map;
-        }
-
-        host->irq = irq_of_parse_and_map(np, 0);
-        if (!host->irq) {
-                ret = -EINVAL;
-                goto err_no_irq;
-        }
-
-        host->hw_name = dev_name(&ofdev->dev);
-        if (sdhci_of_data) {
-                host->quirks = sdhci_of_data->quirks;
-                host->ops = &sdhci_of_data->ops;
-        }
-
-        if (of_get_property(np, "sdhci,auto-cmd12", NULL))
-                host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
-
-
-        if (of_get_property(np, "sdhci,1-bit-only", NULL))
-                host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA;
-
-        if (sdhci_of_wp_inverted(np))
-                host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
-
-        clk = of_get_property(np, "clock-frequency", &size);
-        if (clk && size == sizeof(*clk) && *clk)
-                of_host->clock = be32_to_cpup(clk);
-
-        ret = sdhci_add_host(host);
-        if (ret)
-                goto err_add_host;
-
-        return 0;
-
-err_add_host:
-        irq_dispose_mapping(host->irq);
-err_no_irq:
-        iounmap(host->ioaddr);
-err_addr_map:
-        sdhci_free_host(host);
-        return ret;
-}
-
-static int __devexit sdhci_of_remove(struct platform_device *ofdev)
-{
-        struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
-
-        sdhci_remove_host(host, 0);
-        sdhci_free_host(host);
-        irq_dispose_mapping(host->irq);
-        iounmap(host->ioaddr);
-        return 0;
-}
-
-static const struct of_device_id sdhci_of_match[] = {
-#ifdef CONFIG_MMC_SDHCI_OF_ESDHC
-        { .compatible = "fsl,mpc8379-esdhc", .data = &sdhci_esdhc, },
-        { .compatible = "fsl,mpc8536-esdhc", .data = &sdhci_esdhc, },
-        { .compatible = "fsl,esdhc", .data = &sdhci_esdhc, },
-#endif
-#ifdef CONFIG_MMC_SDHCI_OF_HLWD
-        { .compatible = "nintendo,hollywood-sdhci", .data = &sdhci_hlwd, },
-#endif
-        { .compatible = "generic-sdhci", },
-        {},
-};
-MODULE_DEVICE_TABLE(of, sdhci_of_match);
-
-static struct platform_driver sdhci_of_driver = {
-        .driver = {
-                .name = "sdhci-of",
-                .owner = THIS_MODULE,
-                .of_match_table = sdhci_of_match,
-        },
-        .probe = sdhci_of_probe,
-        .remove = __devexit_p(sdhci_of_remove),
-        .suspend = sdhci_of_suspend,
-        .resume = sdhci_of_resume,
-};
-
-static int __init sdhci_of_init(void)
-{
-        return platform_driver_register(&sdhci_of_driver);
-}
-module_init(sdhci_of_init);
-
-static void __exit sdhci_of_exit(void)
-{
-        platform_driver_unregister(&sdhci_of_driver);
-}
-module_exit(sdhci_of_exit);
-
-MODULE_DESCRIPTION("Secure Digital Host Controller Interface OF driver");
-MODULE_AUTHOR("Xiaobo Xie <X.Xie@freescale.com>, "
-              "Anton Vorontsov <avorontsov@ru.mvista.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index ba40d6d035c..fe604df6501 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -16,8 +16,7 @@
 #include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/mmc/host.h>
-#include "sdhci-of.h"
-#include "sdhci.h"
+#include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
 static u16 esdhc_readw(struct sdhci_host *host, int reg)
@@ -60,32 +59,83 @@ static int esdhc_of_enable_dma(struct sdhci_host *host)
 
 static unsigned int esdhc_of_get_max_clock(struct sdhci_host *host)
 {
-        struct sdhci_of_host *of_host = sdhci_priv(host);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 
-        return of_host->clock;
+        return pltfm_host->clock;
 }
 
 static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host)
 {
-        struct sdhci_of_host *of_host = sdhci_priv(host);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 
-        return of_host->clock / 256 / 16;
+        return pltfm_host->clock / 256 / 16;
 }
 
-struct sdhci_of_data sdhci_esdhc = {
+static struct sdhci_ops sdhci_esdhc_ops = {
+        .read_l = sdhci_be32bs_readl,
+        .read_w = esdhc_readw,
+        .read_b = sdhci_be32bs_readb,
+        .write_l = sdhci_be32bs_writel,
+        .write_w = esdhc_writew,
+        .write_b = esdhc_writeb,
+        .set_clock = esdhc_set_clock,
+        .enable_dma = esdhc_of_enable_dma,
+        .get_max_clock = esdhc_of_get_max_clock,
+        .get_min_clock = esdhc_of_get_min_clock,
+};
+
+static struct sdhci_pltfm_data sdhci_esdhc_pdata = {
         /* card detection could be handled via GPIO */
         .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_CARD_DETECTION
                 | SDHCI_QUIRK_NO_CARD_NO_RESET,
-        .ops = {
-                .read_l = sdhci_be32bs_readl,
-                .read_w = esdhc_readw,
-                .read_b = sdhci_be32bs_readb,
-                .write_l = sdhci_be32bs_writel,
-                .write_w = esdhc_writew,
-                .write_b = esdhc_writeb,
-                .set_clock = esdhc_set_clock,
-                .enable_dma = esdhc_of_enable_dma,
-                .get_max_clock = esdhc_of_get_max_clock,
-                .get_min_clock = esdhc_of_get_min_clock,
+        .ops = &sdhci_esdhc_ops,
+};
+
+static int __devinit sdhci_esdhc_probe(struct platform_device *pdev)
+{
+        return sdhci_pltfm_register(pdev, &sdhci_esdhc_pdata);
+}
+
+static int __devexit sdhci_esdhc_remove(struct platform_device *pdev)
+{
+        return sdhci_pltfm_unregister(pdev);
+}
+
+static const struct of_device_id sdhci_esdhc_of_match[] = {
+        { .compatible = "fsl,mpc8379-esdhc" },
+        { .compatible = "fsl,mpc8536-esdhc" },
+        { .compatible = "fsl,esdhc" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, sdhci_esdhc_of_match);
+
+static struct platform_driver sdhci_esdhc_driver = {
+        .driver = {
+                .name = "sdhci-esdhc",
+                .owner = THIS_MODULE,
+                .of_match_table = sdhci_esdhc_of_match,
         },
+        .probe = sdhci_esdhc_probe,
+        .remove = __devexit_p(sdhci_esdhc_remove),
+#ifdef CONFIG_PM
+        .suspend = sdhci_pltfm_suspend,
+        .resume = sdhci_pltfm_resume,
+#endif
 };
+
+static int __init sdhci_esdhc_init(void)
+{
+        return platform_driver_register(&sdhci_esdhc_driver);
+}
+module_init(sdhci_esdhc_init);
+
+static void __exit sdhci_esdhc_exit(void)
+{
+        platform_driver_unregister(&sdhci_esdhc_driver);
+}
+module_exit(sdhci_esdhc_exit);
+
+MODULE_DESCRIPTION("SDHCI OF driver for Freescale MPC eSDHC");
+MODULE_AUTHOR("Xiaobo Xie <X.Xie@freescale.com>, "
+              "Anton Vorontsov <avorontsov@ru.mvista.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-of-hlwd.c b/drivers/mmc/host/sdhci-of-hlwd.c
index 68ddb7546ae..735be131dca 100644
--- a/drivers/mmc/host/sdhci-of-hlwd.c
+++ b/drivers/mmc/host/sdhci-of-hlwd.c
@@ -21,8 +21,7 @@
 
 #include <linux/delay.h>
 #include <linux/mmc/host.h>
-#include "sdhci-of.h"
-#include "sdhci.h"
+#include "sdhci-pltfm.h"
 
 /*
  * Ops and quirks for the Nintendo Wii SDHCI controllers.
@@ -51,15 +50,63 @@ static void sdhci_hlwd_writeb(struct sdhci_host *host, u8 val, int reg)
         udelay(SDHCI_HLWD_WRITE_DELAY);
 }
 
-struct sdhci_of_data sdhci_hlwd = {
+static struct sdhci_ops sdhci_hlwd_ops = {
+        .read_l = sdhci_be32bs_readl,
+        .read_w = sdhci_be32bs_readw,
+        .read_b = sdhci_be32bs_readb,
+        .write_l = sdhci_hlwd_writel,
+        .write_w = sdhci_hlwd_writew,
+        .write_b = sdhci_hlwd_writeb,
+};
+
+static struct sdhci_pltfm_data sdhci_hlwd_pdata = {
         .quirks = SDHCI_QUIRK_32BIT_DMA_ADDR |
                   SDHCI_QUIRK_32BIT_DMA_SIZE,
-        .ops = {
-                .read_l = sdhci_be32bs_readl,
-                .read_w = sdhci_be32bs_readw,
-                .read_b = sdhci_be32bs_readb,
-                .write_l = sdhci_hlwd_writel,
-                .write_w = sdhci_hlwd_writew,
-                .write_b = sdhci_hlwd_writeb,
+        .ops = &sdhci_hlwd_ops,
+};
+
+static int __devinit sdhci_hlwd_probe(struct platform_device *pdev)
+{
+        return sdhci_pltfm_register(pdev, &sdhci_hlwd_pdata);
+}
+
+static int __devexit sdhci_hlwd_remove(struct platform_device *pdev)
+{
+        return sdhci_pltfm_unregister(pdev);
+}
+
+static const struct of_device_id sdhci_hlwd_of_match[] = {
+        { .compatible = "nintendo,hollywood-sdhci" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, sdhci_hlwd_of_match);
+
+static struct platform_driver sdhci_hlwd_driver = {
+        .driver = {
+                .name = "sdhci-hlwd",
+                .owner = THIS_MODULE,
+                .of_match_table = sdhci_hlwd_of_match,
         },
+        .probe = sdhci_hlwd_probe,
+        .remove = __devexit_p(sdhci_hlwd_remove),
+#ifdef CONFIG_PM
+        .suspend = sdhci_pltfm_suspend,
+        .resume = sdhci_pltfm_resume,
+#endif
 };
+
+static int __init sdhci_hlwd_init(void)
+{
+        return platform_driver_register(&sdhci_hlwd_driver);
+}
+module_init(sdhci_hlwd_init);
+
+static void __exit sdhci_hlwd_exit(void)
+{
+        platform_driver_unregister(&sdhci_hlwd_driver);
+}
+module_exit(sdhci_hlwd_exit);
+
+MODULE_DESCRIPTION("Nintendo Wii SDHCI OF driver");
+MODULE_AUTHOR("The GameCube Linux Team, Albert Herranz");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-of.h b/drivers/mmc/host/sdhci-of.h
deleted file mode 100644
index ad09ad9915d..00000000000
--- a/drivers/mmc/host/sdhci-of.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * OpenFirmware bindings for Secure Digital Host Controller Interface.
- *
- * Copyright (c) 2007 Freescale Semiconductor, Inc.
- * Copyright (c) 2009 MontaVista Software, Inc.
- *
- * Authors: Xiaobo Xie <X.Xie@freescale.com>
- *          Anton Vorontsov <avorontsov@ru.mvista.com>
- *
- * 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.
- */
-
-#ifndef __SDHCI_OF_H
-#define __SDHCI_OF_H
-
-#include <linux/types.h>
-#include "sdhci.h"
-
-struct sdhci_of_data {
-        unsigned int quirks;
-        struct sdhci_ops ops;
-};
-
-struct sdhci_of_host {
-        unsigned int clock;
-        u16 xfer_mode_shadow;
-};
-
-extern u32 sdhci_be32bs_readl(struct sdhci_host *host, int reg);
-extern u16 sdhci_be32bs_readw(struct sdhci_host *host, int reg);
-extern u8 sdhci_be32bs_readb(struct sdhci_host *host, int reg);
-extern void sdhci_be32bs_writel(struct sdhci_host *host, u32 val, int reg);
-extern void sdhci_be32bs_writew(struct sdhci_host *host, u16 val, int reg);
-extern void sdhci_be32bs_writeb(struct sdhci_host *host, u8 val, int reg);
-
-extern struct sdhci_of_data sdhci_esdhc;
-extern struct sdhci_of_data sdhci_hlwd;
-
-#endif /* __SDHCI_OF_H */
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 936bbca19c0..26c528648f3 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -143,6 +143,12 @@ static const struct sdhci_pci_fixes sdhci_cafe = {
                           SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
 };
 
+static int mrst_hc_probe_slot(struct sdhci_pci_slot *slot)
+{
+        slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+        return 0;
+}
+
 /*
  * ADMA operation is disabled for Moorestown platform due to
  * hardware bugs.
@@ -157,8 +163,15 @@ static int mrst_hc_probe(struct sdhci_pci_chip *chip)
         return 0;
 }
 
+static int mfd_emmc_probe_slot(struct sdhci_pci_slot *slot)
+{
+        slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+        return 0;
+}
+
 static const struct sdhci_pci_fixes sdhci_intel_mrst_hc0 = {
         .quirks         = SDHCI_QUIRK_BROKEN_ADMA | SDHCI_QUIRK_NO_HISPD_BIT,
+        .probe_slot     = mrst_hc_probe_slot,
 };
 
 static const struct sdhci_pci_fixes sdhci_intel_mrst_hc1_hc2 = {
@@ -170,8 +183,13 @@ static const struct sdhci_pci_fixes sdhci_intel_mfd_sd = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
 };
 
-static const struct sdhci_pci_fixes sdhci_intel_mfd_emmc_sdio = {
+static const struct sdhci_pci_fixes sdhci_intel_mfd_sdio = {
+        .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
+};
+
+static const struct sdhci_pci_fixes sdhci_intel_mfd_emmc = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
+        .probe_slot     = mfd_emmc_probe_slot,
 };
 
 /* O2Micro extra registers */
@@ -682,7 +700,7 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .device         = PCI_DEVICE_ID_INTEL_MFD_SDIO1,
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
-                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc_sdio,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_sdio,
         },
 
         {
@@ -690,7 +708,7 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .device         = PCI_DEVICE_ID_INTEL_MFD_SDIO2,
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
-                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc_sdio,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_sdio,
         },
 
         {
@@ -698,7 +716,7 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .device         = PCI_DEVICE_ID_INTEL_MFD_EMMC0,
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
-                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc_sdio,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc,
         },
 
         {
@@ -706,7 +724,7 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .device         = PCI_DEVICE_ID_INTEL_MFD_EMMC1,
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
-                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc_sdio,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_emmc,
         },
 
         {
@@ -789,8 +807,34 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
         return 0;
 }
 
+static int sdhci_pci_8bit_width(struct sdhci_host *host, int width)
+{
+        u8 ctrl;
+
+        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
+
+        switch (width) {
+        case MMC_BUS_WIDTH_8:
+                ctrl |= SDHCI_CTRL_8BITBUS;
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                break;
+        case MMC_BUS_WIDTH_4:
+                ctrl |= SDHCI_CTRL_4BITBUS;
+                ctrl &= ~SDHCI_CTRL_8BITBUS;
+                break;
+        default:
+                ctrl &= ~(SDHCI_CTRL_8BITBUS | SDHCI_CTRL_4BITBUS);
+                break;
+        }
+
+        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+
+        return 0;
+}
+
 static struct sdhci_ops sdhci_pci_ops = {
         .enable_dma     = sdhci_pci_enable_dma,
+        .platform_8bit_width    = sdhci_pci_8bit_width,
 };
 
 /*****************************************************************************\
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index dbab0407f4b..1179f1be431 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -2,6 +2,12 @@
  * sdhci-pltfm.c Support for SDHCI platform devices
  * Copyright (c) 2009 Intel Corporation
  *
+ * Copyright (c) 2007 Freescale Semiconductor, Inc.
+ * Copyright (c) 2009 MontaVista Software, Inc.
+ *
+ * Authors: Xiaobo Xie <X.Xie@freescale.com>
+ *          Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
@@ -22,48 +28,67 @@
  * Inspired by sdhci-pci.c, by Pierre Ossman
  */
 
-#include <linux/delay.h>
-#include <linux/highmem.h>
-#include <linux/mod_devicetable.h>
-#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/of.h>
+#ifdef CONFIG_PPC
+#include <asm/machdep.h>
+#endif
+#include "sdhci-pltfm.h"
 
-#include <linux/mmc/host.h>
+static struct sdhci_ops sdhci_pltfm_ops = {
+};
 
-#include <linux/io.h>
-#include <linux/mmc/sdhci-pltfm.h>
+#ifdef CONFIG_OF
+static bool sdhci_of_wp_inverted(struct device_node *np)
+{
+        if (of_get_property(np, "sdhci,wp-inverted", NULL))
+                return true;
 
-#include "sdhci.h"
-#include "sdhci-pltfm.h"
+        /* Old device trees don't have the wp-inverted property. */
+#ifdef CONFIG_PPC
+        return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds);
+#else
+        return false;
+#endif /* CONFIG_PPC */
+}
 
-/*****************************************************************************\
- *                                                                           *
- * SDHCI core callbacks                                                      *
- *                                                                           *
-\*****************************************************************************/
+void sdhci_get_of_property(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        const __be32 *clk;
+        int size;
 
-static struct sdhci_ops sdhci_pltfm_ops = {
-};
+        if (of_device_is_available(np)) {
+                if (of_get_property(np, "sdhci,auto-cmd12", NULL))
+                        host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
 
-/*****************************************************************************\
- *                                                                           *
- * Device probing/removal                                                    *
- *                                                                           *
-\*****************************************************************************/
+                if (of_get_property(np, "sdhci,1-bit-only", NULL))
+                        host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA;
+
+                if (sdhci_of_wp_inverted(np))
+                        host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
+
+                clk = of_get_property(np, "clock-frequency", &size);
+                if (clk && size == sizeof(*clk) && *clk)
+                        pltfm_host->clock = be32_to_cpup(clk);
+        }
+}
+#else
+void sdhci_get_of_property(struct platform_device *pdev) {}
+#endif /* CONFIG_OF */
+EXPORT_SYMBOL_GPL(sdhci_get_of_property);
 
-static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
+struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
+                                    struct sdhci_pltfm_data *pdata)
 {
-        const struct platform_device_id *platid = platform_get_device_id(pdev);
-        struct sdhci_pltfm_data *pdata;
         struct sdhci_host *host;
         struct sdhci_pltfm_host *pltfm_host;
+        struct device_node *np = pdev->dev.of_node;
         struct resource *iomem;
         int ret;
 
-        if (platid && platid->driver_data)
-                pdata = (void *)platid->driver_data;
-        else
-                pdata = pdev->dev.platform_data;
-
         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!iomem) {
                 ret = -ENOMEM;
@@ -71,11 +96,10 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
         }
 
         if (resource_size(iomem) < 0x100)
-                dev_err(&pdev->dev, "Invalid iomem size. You may "
-                        "experience problems.\n");
+                dev_err(&pdev->dev, "Invalid iomem size!\n");
 
         /* Some PCI-based MFD need the parent here */
-        if (pdev->dev.parent != &platform_bus)
+        if (pdev->dev.parent != &platform_bus && !np)
                 host = sdhci_alloc_host(pdev->dev.parent, sizeof(*pltfm_host));
         else
                 host = sdhci_alloc_host(&pdev->dev, sizeof(*pltfm_host));
@@ -87,7 +111,7 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
 
         pltfm_host = sdhci_priv(host);
 
-        host->hw_name = "platform";
+        host->hw_name = dev_name(&pdev->dev);
         if (pdata && pdata->ops)
                 host->ops = pdata->ops;
         else
@@ -110,126 +134,121 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
                 goto err_remap;
         }
 
-        if (pdata && pdata->init) {
-                ret = pdata->init(host, pdata);
-                if (ret)
-                        goto err_plat_init;
-        }
-
-        ret = sdhci_add_host(host);
-        if (ret)
-                goto err_add_host;
-
         platform_set_drvdata(pdev, host);
 
-        return 0;
+        return host;
 
-err_add_host:
-        if (pdata && pdata->exit)
-                pdata->exit(host);
-err_plat_init:
-        iounmap(host->ioaddr);
 err_remap:
         release_mem_region(iomem->start, resource_size(iomem));
 err_request:
         sdhci_free_host(host);
 err:
-        printk(KERN_ERR"Probing of sdhci-pltfm failed: %d\n", ret);
-        return ret;
+        dev_err(&pdev->dev, "%s failed %d\n", __func__, ret);
+        return ERR_PTR(ret);
 }
+EXPORT_SYMBOL_GPL(sdhci_pltfm_init);
 
-static int __devexit sdhci_pltfm_remove(struct platform_device *pdev)
+void sdhci_pltfm_free(struct platform_device *pdev)
 {
-        struct sdhci_pltfm_data *pdata = pdev->dev.platform_data;
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        int dead;
-        u32 scratch;
-
-        dead = 0;
-        scratch = readl(host->ioaddr + SDHCI_INT_STATUS);
-        if (scratch == (u32)-1)
-                dead = 1;
 
-        sdhci_remove_host(host, dead);
-        if (pdata && pdata->exit)
-                pdata->exit(host);
         iounmap(host->ioaddr);
         release_mem_region(iomem->start, resource_size(iomem));
         sdhci_free_host(host);
         platform_set_drvdata(pdev, NULL);
+}
+EXPORT_SYMBOL_GPL(sdhci_pltfm_free);
 
-        return 0;
+int sdhci_pltfm_register(struct platform_device *pdev,
+                         struct sdhci_pltfm_data *pdata)
+{
+        struct sdhci_host *host;
+        int ret = 0;
+
+        host = sdhci_pltfm_init(pdev, pdata);
+        if (IS_ERR(host))
+                return PTR_ERR(host);
+
+        sdhci_get_of_property(pdev);
+
+        ret = sdhci_add_host(host);
+        if (ret)
+                sdhci_pltfm_free(pdev);
+
+        return ret;
 }
+EXPORT_SYMBOL_GPL(sdhci_pltfm_register);
 
-static const struct platform_device_id sdhci_pltfm_ids[] = {
-        { "sdhci", },
-#ifdef CONFIG_MMC_SDHCI_CNS3XXX
-        { "sdhci-cns3xxx", (kernel_ulong_t)&sdhci_cns3xxx_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_ESDHC_IMX
-        { "sdhci-esdhc-imx", (kernel_ulong_t)&sdhci_esdhc_imx_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_DOVE
-        { "sdhci-dove", (kernel_ulong_t)&sdhci_dove_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_TEGRA
-        { "sdhci-tegra", (kernel_ulong_t)&sdhci_tegra_pdata },
-#endif
-        { },
-};
-MODULE_DEVICE_TABLE(platform, sdhci_pltfm_ids);
+int sdhci_pltfm_unregister(struct platform_device *pdev)
+{
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+        sdhci_remove_host(host, dead);
+        sdhci_pltfm_free(pdev);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister);
 
 #ifdef CONFIG_PM
-static int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state)
+int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state)
 {
         struct sdhci_host *host = platform_get_drvdata(dev);
+        int ret;
+
+        ret = sdhci_suspend_host(host, state);
+        if (ret) {
+                dev_err(&dev->dev, "suspend failed, error = %d\n", ret);
+                return ret;
+        }
+
+        if (host->ops && host->ops->suspend)
+                ret = host->ops->suspend(host, state);
+        if (ret) {
+                dev_err(&dev->dev, "suspend hook failed, error = %d\n", ret);
+                sdhci_resume_host(host);
+        }
 
-        return sdhci_suspend_host(host, state);
+        return ret;
 }
+EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend);
 
-static int sdhci_pltfm_resume(struct platform_device *dev)
+int sdhci_pltfm_resume(struct platform_device *dev)
 {
         struct sdhci_host *host = platform_get_drvdata(dev);
+        int ret = 0;
 
-        return sdhci_resume_host(host);
-}
-#else
-#define sdhci_pltfm_suspend     NULL
-#define sdhci_pltfm_resume      NULL
-#endif  /* CONFIG_PM */
+        if (host->ops && host->ops->resume)
+                ret = host->ops->resume(host);
+        if (ret) {
+                dev_err(&dev->dev, "resume hook failed, error = %d\n", ret);
+                return ret;
+        }
 
-static struct platform_driver sdhci_pltfm_driver = {
-        .driver = {
-                .name   = "sdhci",
-                .owner  = THIS_MODULE,
-        },
-        .probe          = sdhci_pltfm_probe,
-        .remove         = __devexit_p(sdhci_pltfm_remove),
-        .id_table       = sdhci_pltfm_ids,
-        .suspend        = sdhci_pltfm_suspend,
-        .resume         = sdhci_pltfm_resume,
-};
+        ret = sdhci_resume_host(host);
+        if (ret)
+                dev_err(&dev->dev, "resume failed, error = %d\n", ret);
 
-/*****************************************************************************\
- *                                                                           *
- * Driver init/exit                                                          *
- *                                                                           *
-\*****************************************************************************/
+        return ret;
+}
+EXPORT_SYMBOL_GPL(sdhci_pltfm_resume);
+#endif  /* CONFIG_PM */
 
-static int __init sdhci_drv_init(void)
+static int __init sdhci_pltfm_drv_init(void)
 {
-        return platform_driver_register(&sdhci_pltfm_driver);
+        pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n");
+
+        return 0;
 }
+module_init(sdhci_pltfm_drv_init);
 
-static void __exit sdhci_drv_exit(void)
+static void __exit sdhci_pltfm_drv_exit(void)
 {
-        platform_driver_unregister(&sdhci_pltfm_driver);
 }
+module_exit(sdhci_pltfm_drv_exit);
 
-module_init(sdhci_drv_init);
-module_exit(sdhci_drv_exit);
-
-MODULE_DESCRIPTION("Secure Digital Host Controller Interface platform driver");
-MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
+MODULE_DESCRIPTION("SDHCI platform and OF driver helper");
+MODULE_AUTHOR("Intel Corporation");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-pltfm.h b/drivers/mmc/host/sdhci-pltfm.h
index 2b37016ad0a..b92c7f29a4e 100644
--- a/drivers/mmc/host/sdhci-pltfm.h
+++ b/drivers/mmc/host/sdhci-pltfm.h
@@ -12,17 +12,95 @@
 #define _DRIVERS_MMC_SDHCI_PLTFM_H
 
 #include <linux/clk.h>
-#include <linux/types.h>
-#include <linux/mmc/sdhci-pltfm.h>
+#include <linux/platform_device.h>
+#include "sdhci.h"
+
+struct sdhci_pltfm_data {
+        struct sdhci_ops *ops;
+        u64 quirks;
+};
 
 struct sdhci_pltfm_host {
         struct clk *clk;
         void *priv; /* to handle quirks across io-accessor calls */
+
+        /* migrate from sdhci_of_host */
+        unsigned int clock;
+        u16 xfer_mode_shadow;
 };
 
-extern struct sdhci_pltfm_data sdhci_cns3xxx_pdata;
-extern struct sdhci_pltfm_data sdhci_esdhc_imx_pdata;
-extern struct sdhci_pltfm_data sdhci_dove_pdata;
-extern struct sdhci_pltfm_data sdhci_tegra_pdata;
+#ifdef CONFIG_MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
+/*
+ * These accessors are designed for big endian hosts doing I/O to
+ * little endian controllers incorporating a 32-bit hardware byte swapper.
+ */
+static inline u32 sdhci_be32bs_readl(struct sdhci_host *host, int reg)
+{
+        return in_be32(host->ioaddr + reg);
+}
+
+static inline u16 sdhci_be32bs_readw(struct sdhci_host *host, int reg)
+{
+        return in_be16(host->ioaddr + (reg ^ 0x2));
+}
+
+static inline u8 sdhci_be32bs_readb(struct sdhci_host *host, int reg)
+{
+        return in_8(host->ioaddr + (reg ^ 0x3));
+}
+
+static inline void sdhci_be32bs_writel(struct sdhci_host *host,
+                                       u32 val, int reg)
+{
+        out_be32(host->ioaddr + reg, val);
+}
+
+static inline void sdhci_be32bs_writew(struct sdhci_host *host,
+                                       u16 val, int reg)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        int base = reg & ~0x3;
+        int shift = (reg & 0x2) * 8;
+
+        switch (reg) {
+        case SDHCI_TRANSFER_MODE:
+                /*
+                 * Postpone this write, we must do it together with a
+                 * command write that is down below.
+                 */
+                pltfm_host->xfer_mode_shadow = val;
+                return;
+        case SDHCI_COMMAND:
+                sdhci_be32bs_writel(host,
+                                    val << 16 | pltfm_host->xfer_mode_shadow,
+                                    SDHCI_TRANSFER_MODE);
+                return;
+        }
+        clrsetbits_be32(host->ioaddr + base, 0xffff << shift, val << shift);
+}
+
+static inline void sdhci_be32bs_writeb(struct sdhci_host *host, u8 val, int reg)
+{
+        int base = reg & ~0x3;
+        int shift = (reg & 0x3) * 8;
+
+        clrsetbits_be32(host->ioaddr + base , 0xff << shift, val << shift);
+}
+#endif /* CONFIG_MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER */
+
+extern void sdhci_get_of_property(struct platform_device *pdev);
+
+extern struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
+                                           struct sdhci_pltfm_data *pdata);
+extern void sdhci_pltfm_free(struct platform_device *pdev);
+
+extern int sdhci_pltfm_register(struct platform_device *pdev,
+                                struct sdhci_pltfm_data *pdata);
+extern int sdhci_pltfm_unregister(struct platform_device *pdev);
+
+#ifdef CONFIG_PM
+extern int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state);
+extern int sdhci_pltfm_resume(struct platform_device *dev);
+#endif
 
 #endif /* _DRIVERS_MMC_SDHCI_PLTFM_H */
diff --git a/drivers/mmc/host/sdhci-pxa.c b/drivers/mmc/host/sdhci-pxa.c
deleted file mode 100644
index 089c9a68b7b..00000000000
--- a/drivers/mmc/host/sdhci-pxa.c
+++ /dev/null
@@ -1,303 +0,0 @@
-/* linux/drivers/mmc/host/sdhci-pxa.c
- *
- * Copyright (C) 2010 Marvell International Ltd.
- *              Zhangfei Gao <zhangfei.gao@marvell.com>
- *              Kevin Wang <dwang4@marvell.com>
- *              Mingwei Wang <mwwang@marvell.com>
- *              Philip Rakity <prakity@marvell.com>
- *              Mark Brown <markb@marvell.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/* Supports:
- * SDHCI support for MMP2/PXA910/PXA168
- *
- * Refer to sdhci-s3c.c.
- */
-
-#include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/mmc/host.h>
-#include <linux/clk.h>
-#include <linux/io.h>
-#include <linux/err.h>
-#include <plat/sdhci.h>
-#include "sdhci.h"
-
-#define DRIVER_NAME     "sdhci-pxa"
-
-#define SD_FIFO_PARAM           0x104
-#define DIS_PAD_SD_CLK_GATE     0x400
-
-struct sdhci_pxa {
-        struct sdhci_host               *host;
-        struct sdhci_pxa_platdata       *pdata;
-        struct clk                      *clk;
-        struct resource                 *res;
-
-        u8 clk_enable;
-};
-
-/*****************************************************************************\
- *                                                                           *
- * SDHCI core callbacks                                                      *
- *                                                                           *
-\*****************************************************************************/
-static void set_clock(struct sdhci_host *host, unsigned int clock)
-{
-        struct sdhci_pxa *pxa = sdhci_priv(host);
-        u32 tmp = 0;
-
-        if (clock == 0) {
-                if (pxa->clk_enable) {
-                        clk_disable(pxa->clk);
-                        pxa->clk_enable = 0;
-                }
-        } else {
-                if (0 == pxa->clk_enable) {
-                        if (pxa->pdata->flags & PXA_FLAG_DISABLE_CLOCK_GATING) {
-                                tmp = readl(host->ioaddr + SD_FIFO_PARAM);
-                                tmp |= DIS_PAD_SD_CLK_GATE;
-                                writel(tmp, host->ioaddr + SD_FIFO_PARAM);
-                        }
-                        clk_enable(pxa->clk);
-                        pxa->clk_enable = 1;
-                }
-        }
-}
-
-static int set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
-{
-        u16 ctrl_2;
-
-        /*
-         * Set V18_EN -- UHS modes do not work without this.
-         * does not change signaling voltage
-         */
-        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-
-        /* Select Bus Speed Mode for host */
-        ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
-        switch (uhs) {
-        case MMC_TIMING_UHS_SDR12:
-                ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
-                break;
-        case MMC_TIMING_UHS_SDR25:
-                ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
-                break;
-        case MMC_TIMING_UHS_SDR50:
-                ctrl_2 |= SDHCI_CTRL_UHS_SDR50 | SDHCI_CTRL_VDD_180;
-                break;
-        case MMC_TIMING_UHS_SDR104:
-                ctrl_2 |= SDHCI_CTRL_UHS_SDR104 | SDHCI_CTRL_VDD_180;
-                break;
-        case MMC_TIMING_UHS_DDR50:
-                ctrl_2 |= SDHCI_CTRL_UHS_DDR50 | SDHCI_CTRL_VDD_180;
-                break;
-        }
-
-        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
-        pr_debug("%s:%s uhs = %d, ctrl_2 = %04X\n",
-                __func__, mmc_hostname(host->mmc), uhs, ctrl_2);
-
-        return 0;
-}
-
-static struct sdhci_ops sdhci_pxa_ops = {
-        .set_uhs_signaling = set_uhs_signaling,
-        .set_clock = set_clock,
-};
-
-/*****************************************************************************\
- *                                                                           *
- * Device probing/removal                                                    *
- *                                                                           *
-\*****************************************************************************/
-
-static int __devinit sdhci_pxa_probe(struct platform_device *pdev)
-{
-        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
-        struct device *dev = &pdev->dev;
-        struct sdhci_host *host = NULL;
-        struct resource *iomem = NULL;
-        struct sdhci_pxa *pxa = NULL;
-        int ret, irq;
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(dev, "no irq specified\n");
-                return irq;
-        }
-
-        iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!iomem) {
-                dev_err(dev, "no memory specified\n");
-                return -ENOENT;
-        }
-
-        host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pxa));
-        if (IS_ERR(host)) {
-                dev_err(dev, "failed to alloc host\n");
-                return PTR_ERR(host);
-        }
-
-        pxa = sdhci_priv(host);
-        pxa->host = host;
-        pxa->pdata = pdata;
-        pxa->clk_enable = 0;
-
-        pxa->clk = clk_get(dev, "PXA-SDHCLK");
-        if (IS_ERR(pxa->clk)) {
-                dev_err(dev, "failed to get io clock\n");
-                ret = PTR_ERR(pxa->clk);
-                goto out;
-        }
-
-        pxa->res = request_mem_region(iomem->start, resource_size(iomem),
-                                      mmc_hostname(host->mmc));
-        if (!pxa->res) {
-                dev_err(&pdev->dev, "cannot request region\n");
-                ret = -EBUSY;
-                goto out;
-        }
-
-        host->ioaddr = ioremap(iomem->start, resource_size(iomem));
-        if (!host->ioaddr) {
-                dev_err(&pdev->dev, "failed to remap registers\n");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        host->hw_name = "MMC";
-        host->ops = &sdhci_pxa_ops;
-        host->irq = irq;
-        host->quirks = SDHCI_QUIRK_BROKEN_ADMA
-                | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
-                | SDHCI_QUIRK_32BIT_DMA_ADDR
-                | SDHCI_QUIRK_32BIT_DMA_SIZE
-                | SDHCI_QUIRK_32BIT_ADMA_SIZE
-                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
-
-        if (pdata->quirks)
-                host->quirks |= pdata->quirks;
-
-        /* enable 1/8V DDR capable */
-        host->mmc->caps |= MMC_CAP_1_8V_DDR;
-
-        /* If slot design supports 8 bit data, indicate this to MMC. */
-        if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
-                host->mmc->caps |= MMC_CAP_8_BIT_DATA;
-
-        ret = sdhci_add_host(host);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add host\n");
-                goto out;
-        }
-
-        if (pxa->pdata->max_speed)
-                host->mmc->f_max = pxa->pdata->max_speed;
-
-        platform_set_drvdata(pdev, host);
-
-        return 0;
-out:
-        if (host) {
-                clk_put(pxa->clk);
-                if (host->ioaddr)
-                        iounmap(host->ioaddr);
-                if (pxa->res)
-                        release_mem_region(pxa->res->start,
-                                           resource_size(pxa->res));
-                sdhci_free_host(host);
-        }
-
-        return ret;
-}
-
-static int __devexit sdhci_pxa_remove(struct platform_device *pdev)
-{
-        struct sdhci_host *host = platform_get_drvdata(pdev);
-        struct sdhci_pxa *pxa = sdhci_priv(host);
-        int dead = 0;
-        u32 scratch;
-
-        if (host) {
-                scratch = readl(host->ioaddr + SDHCI_INT_STATUS);
-                if (scratch == (u32)-1)
-                        dead = 1;
-
-                sdhci_remove_host(host, dead);
-
-                if (host->ioaddr)
-                        iounmap(host->ioaddr);
-                if (pxa->res)
-                        release_mem_region(pxa->res->start,
-                                           resource_size(pxa->res));
-                if (pxa->clk_enable) {
-                        clk_disable(pxa->clk);
-                        pxa->clk_enable = 0;
-                }
-                clk_put(pxa->clk);
-
-                sdhci_free_host(host);
-                platform_set_drvdata(pdev, NULL);
-        }
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int sdhci_pxa_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct sdhci_host *host = platform_get_drvdata(dev);
-
-        return sdhci_suspend_host(host, state);
-}
-
-static int sdhci_pxa_resume(struct platform_device *dev)
-{
-        struct sdhci_host *host = platform_get_drvdata(dev);
-
-        return sdhci_resume_host(host);
-}
-#else
-#define sdhci_pxa_suspend       NULL
-#define sdhci_pxa_resume        NULL
-#endif
-
-static struct platform_driver sdhci_pxa_driver = {
-        .probe          = sdhci_pxa_probe,
-        .remove         = __devexit_p(sdhci_pxa_remove),
-        .suspend        = sdhci_pxa_suspend,
-        .resume         = sdhci_pxa_resume,
-        .driver         = {
-                .name   = DRIVER_NAME,
-                .owner  = THIS_MODULE,
-        },
-};
-
-/*****************************************************************************\
- *                                                                           *
- * Driver init/exit                                                          *
- *                                                                           *
-\*****************************************************************************/
-
-static int __init sdhci_pxa_init(void)
-{
-        return platform_driver_register(&sdhci_pxa_driver);
-}
-
-static void __exit sdhci_pxa_exit(void)
-{
-        platform_driver_unregister(&sdhci_pxa_driver);
-}
-
-module_init(sdhci_pxa_init);
-module_exit(sdhci_pxa_exit);
-
-MODULE_DESCRIPTION("SDH controller driver for PXA168/PXA910/MMP2");
-MODULE_AUTHOR("Zhangfei Gao <zhangfei.gao@marvell.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
new file mode 100644
index 00000000000..38f58994f79
--- /dev/null
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2010 Marvell International Ltd.
+ *              Zhangfei Gao <zhangfei.gao@marvell.com>
+ *              Kevin Wang <dwang4@marvell.com>
+ *              Jun Nie <njun@marvell.com>
+ *              Qiming Wu <wuqm@marvell.com>
+ *              Philip Rakity <prakity@marvell.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
+#include <linux/platform_data/pxa_sdhci.h>
+#include <linux/slab.h>
+#include "sdhci.h"
+#include "sdhci-pltfm.h"
+
+#define SD_FIFO_PARAM           0xe0
+#define DIS_PAD_SD_CLK_GATE     0x0400 /* Turn on/off Dynamic SD Clock Gating */
+#define CLK_GATE_ON             0x0200 /* Disable/enable Clock Gate */
+#define CLK_GATE_CTL            0x0100 /* Clock Gate Control */
+#define CLK_GATE_SETTING_BITS   (DIS_PAD_SD_CLK_GATE | \
+                CLK_GATE_ON | CLK_GATE_CTL)
+
+#define SD_CLOCK_BURST_SIZE_SETUP       0xe6
+#define SDCLK_SEL_SHIFT         8
+#define SDCLK_SEL_MASK          0x3
+#define SDCLK_DELAY_SHIFT       10
+#define SDCLK_DELAY_MASK        0x3c
+
+#define SD_CE_ATA_2             0xea
+#define MMC_CARD                0x1000
+#define MMC_WIDTH               0x0100
+
+static void pxav2_set_private_registers(struct sdhci_host *host, u8 mask)
+{
+        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
+
+        if (mask == SDHCI_RESET_ALL) {
+                u16 tmp = 0;
+
+                /*
+                 * tune timing of read data/command when crc error happen
+                 * no performance impact
+                 */
+                if (pdata->clk_delay_sel == 1) {
+                        tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
+
+                        tmp &= ~(SDCLK_DELAY_MASK << SDCLK_DELAY_SHIFT);
+                        tmp |= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK)
+                                << SDCLK_DELAY_SHIFT;
+                        tmp &= ~(SDCLK_SEL_MASK << SDCLK_SEL_SHIFT);
+                        tmp |= (1 & SDCLK_SEL_MASK) << SDCLK_SEL_SHIFT;
+
+                        writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
+                }
+
+                if (pdata->flags & PXA_FLAG_ENABLE_CLOCK_GATING) {
+                        tmp = readw(host->ioaddr + SD_FIFO_PARAM);
+                        tmp &= ~CLK_GATE_SETTING_BITS;
+                        writew(tmp, host->ioaddr + SD_FIFO_PARAM);
+                } else {
+                        tmp = readw(host->ioaddr + SD_FIFO_PARAM);
+                        tmp &= ~CLK_GATE_SETTING_BITS;
+                        tmp |= CLK_GATE_SETTING_BITS;
+                        writew(tmp, host->ioaddr + SD_FIFO_PARAM);
+                }
+        }
+}
+
+static int pxav2_mmc_set_width(struct sdhci_host *host, int width)
+{
+        u8 ctrl;
+        u16 tmp;
+
+        ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL);
+        tmp = readw(host->ioaddr + SD_CE_ATA_2);
+        if (width == MMC_BUS_WIDTH_8) {
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                tmp |= MMC_CARD | MMC_WIDTH;
+        } else {
+                tmp &= ~(MMC_CARD | MMC_WIDTH);
+                if (width == MMC_BUS_WIDTH_4)
+                        ctrl |= SDHCI_CTRL_4BITBUS;
+                else
+                        ctrl &= ~SDHCI_CTRL_4BITBUS;
+        }
+        writew(tmp, host->ioaddr + SD_CE_ATA_2);
+        writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
+
+        return 0;
+}
+
+static u32 pxav2_get_max_clock(struct sdhci_host *host)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+
+        return clk_get_rate(pltfm_host->clk);
+}
+
+static struct sdhci_ops pxav2_sdhci_ops = {
+        .get_max_clock = pxav2_get_max_clock,
+        .platform_reset_exit = pxav2_set_private_registers,
+        .platform_8bit_width = pxav2_mmc_set_width,
+};
+
+static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
+{
+        struct sdhci_pltfm_host *pltfm_host;
+        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct sdhci_host *host = NULL;
+        struct sdhci_pxa *pxa = NULL;
+        int ret;
+        struct clk *clk;
+
+        pxa = kzalloc(sizeof(struct sdhci_pxa), GFP_KERNEL);
+        if (!pxa)
+                return -ENOMEM;
+
+        host = sdhci_pltfm_init(pdev, NULL);
+        if (IS_ERR(host)) {
+                kfree(pxa);
+                return PTR_ERR(host);
+        }
+        pltfm_host = sdhci_priv(host);
+        pltfm_host->priv = pxa;
+
+        clk = clk_get(dev, "PXA-SDHCLK");
+        if (IS_ERR(clk)) {
+                dev_err(dev, "failed to get io clock\n");
+                ret = PTR_ERR(clk);
+                goto err_clk_get;
+        }
+        pltfm_host->clk = clk;
+        clk_enable(clk);
+
+        host->quirks = SDHCI_QUIRK_BROKEN_ADMA
+                | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
+                | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;
+
+        if (pdata) {
+                if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
+                        /* on-chip device */
+                        host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+                        host->mmc->caps |= MMC_CAP_NONREMOVABLE;
+                }
+
+                /* If slot design supports 8 bit data, indicate this to MMC. */
+                if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
+                        host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+
+                if (pdata->quirks)
+                        host->quirks |= pdata->quirks;
+                if (pdata->host_caps)
+                        host->mmc->caps |= pdata->host_caps;
+                if (pdata->pm_caps)
+                        host->mmc->pm_caps |= pdata->pm_caps;
+        }
+
+        host->ops = &pxav2_sdhci_ops;
+
+        ret = sdhci_add_host(host);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add host\n");
+                goto err_add_host;
+        }
+
+        platform_set_drvdata(pdev, host);
+
+        return 0;
+
+err_add_host:
+        clk_disable(clk);
+        clk_put(clk);
+err_clk_get:
+        sdhci_pltfm_free(pdev);
+        kfree(pxa);
+        return ret;
+}
+
+static int __devexit sdhci_pxav2_remove(struct platform_device *pdev)
+{
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
+
+        sdhci_remove_host(host, 1);
+
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+        sdhci_pltfm_free(pdev);
+        kfree(pxa);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver sdhci_pxav2_driver = {
+        .driver         = {
+                .name   = "sdhci-pxav2",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_pxav2_probe,
+        .remove         = __devexit_p(sdhci_pxav2_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
+};
+static int __init sdhci_pxav2_init(void)
+{
+        return platform_driver_register(&sdhci_pxav2_driver);
+}
+
+static void __exit sdhci_pxav2_exit(void)
+{
+        platform_driver_unregister(&sdhci_pxav2_driver);
+}
+
+module_init(sdhci_pxav2_init);
+module_exit(sdhci_pxav2_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for pxav2");
+MODULE_AUTHOR("Marvell International Ltd.");
+MODULE_LICENSE("GPL v2");
+
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
new file mode 100644
index 00000000000..fc7e4a51562
--- /dev/null
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -0,0 +1,290 @@
+/*
+ * Copyright (C) 2010 Marvell International Ltd.
+ *              Zhangfei Gao <zhangfei.gao@marvell.com>
+ *              Kevin Wang <dwang4@marvell.com>
+ *              Mingwei Wang <mwwang@marvell.com>
+ *              Philip Rakity <prakity@marvell.com>
+ *              Mark Brown <markb@marvell.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
+#include <linux/platform_data/pxa_sdhci.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include "sdhci.h"
+#include "sdhci-pltfm.h"
+
+#define SD_CLOCK_BURST_SIZE_SETUP               0x10A
+#define SDCLK_SEL       0x100
+#define SDCLK_DELAY_SHIFT       9
+#define SDCLK_DELAY_MASK        0x1f
+
+#define SD_CFG_FIFO_PARAM       0x100
+#define SDCFG_GEN_PAD_CLK_ON    (1<<6)
+#define SDCFG_GEN_PAD_CLK_CNT_MASK      0xFF
+#define SDCFG_GEN_PAD_CLK_CNT_SHIFT     24
+
+#define SD_SPI_MODE          0x108
+#define SD_CE_ATA_1          0x10C
+
+#define SD_CE_ATA_2          0x10E
+#define SDCE_MISC_INT           (1<<2)
+#define SDCE_MISC_INT_EN        (1<<1)
+
+static void pxav3_set_private_registers(struct sdhci_host *host, u8 mask)
+{
+        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
+
+        if (mask == SDHCI_RESET_ALL) {
+                /*
+                 * tune timing of read data/command when crc error happen
+                 * no performance impact
+                 */
+                if (pdata && 0 != pdata->clk_delay_cycles) {
+                        u16 tmp;
+
+                        tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
+                        tmp |= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK)
+                                << SDCLK_DELAY_SHIFT;
+                        tmp |= SDCLK_SEL;
+                        writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
+                }
+        }
+}
+
+#define MAX_WAIT_COUNT 5
+static void pxav3_gen_init_74_clocks(struct sdhci_host *host, u8 power_mode)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
+        u16 tmp;
+        int count;
+
+        if (pxa->power_mode == MMC_POWER_UP
+                        && power_mode == MMC_POWER_ON) {
+
+                dev_dbg(mmc_dev(host->mmc),
+                                "%s: slot->power_mode = %d,"
+                                "ios->power_mode = %d\n",
+                                __func__,
+                                pxa->power_mode,
+                                power_mode);
+
+                /* set we want notice of when 74 clocks are sent */
+                tmp = readw(host->ioaddr + SD_CE_ATA_2);
+                tmp |= SDCE_MISC_INT_EN;
+                writew(tmp, host->ioaddr + SD_CE_ATA_2);
+
+                /* start sending the 74 clocks */
+                tmp = readw(host->ioaddr + SD_CFG_FIFO_PARAM);
+                tmp |= SDCFG_GEN_PAD_CLK_ON;
+                writew(tmp, host->ioaddr + SD_CFG_FIFO_PARAM);
+
+                /* slowest speed is about 100KHz or 10usec per clock */
+                udelay(740);
+                count = 0;
+
+                while (count++ < MAX_WAIT_COUNT) {
+                        if ((readw(host->ioaddr + SD_CE_ATA_2)
+                                                & SDCE_MISC_INT) == 0)
+                                break;
+                        udelay(10);
+                }
+
+                if (count == MAX_WAIT_COUNT)
+                        dev_warn(mmc_dev(host->mmc), "74 clock interrupt not cleared\n");
+
+                /* clear the interrupt bit if posted */
+                tmp = readw(host->ioaddr + SD_CE_ATA_2);
+                tmp |= SDCE_MISC_INT;
+                writew(tmp, host->ioaddr + SD_CE_ATA_2);
+        }
+        pxa->power_mode = power_mode;
+}
+
+static int pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
+{
+        u16 ctrl_2;
+
+        /*
+         * Set V18_EN -- UHS modes do not work without this.
+         * does not change signaling voltage
+         */
+        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+        /* Select Bus Speed Mode for host */
+        ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
+        switch (uhs) {
+        case MMC_TIMING_UHS_SDR12:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
+                break;
+        case MMC_TIMING_UHS_SDR25:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
+                break;
+        case MMC_TIMING_UHS_SDR50:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR50 | SDHCI_CTRL_VDD_180;
+                break;
+        case MMC_TIMING_UHS_SDR104:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR104 | SDHCI_CTRL_VDD_180;
+                break;
+        case MMC_TIMING_UHS_DDR50:
+                ctrl_2 |= SDHCI_CTRL_UHS_DDR50 | SDHCI_CTRL_VDD_180;
+                break;
+        }
+
+        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
+        dev_dbg(mmc_dev(host->mmc),
+                "%s uhs = %d, ctrl_2 = %04X\n",
+                __func__, uhs, ctrl_2);
+
+        return 0;
+}
+
+static struct sdhci_ops pxav3_sdhci_ops = {
+        .platform_reset_exit = pxav3_set_private_registers,
+        .set_uhs_signaling = pxav3_set_uhs_signaling,
+        .platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
+};
+
+static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
+{
+        struct sdhci_pltfm_host *pltfm_host;
+        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct sdhci_host *host = NULL;
+        struct sdhci_pxa *pxa = NULL;
+        int ret;
+        struct clk *clk;
+
+        pxa = kzalloc(sizeof(struct sdhci_pxa), GFP_KERNEL);
+        if (!pxa)
+                return -ENOMEM;
+
+        host = sdhci_pltfm_init(pdev, NULL);
+        if (IS_ERR(host)) {
+                kfree(pxa);
+                return PTR_ERR(host);
+        }
+        pltfm_host = sdhci_priv(host);
+        pltfm_host->priv = pxa;
+
+        clk = clk_get(dev, "PXA-SDHCLK");
+        if (IS_ERR(clk)) {
+                dev_err(dev, "failed to get io clock\n");
+                ret = PTR_ERR(clk);
+                goto err_clk_get;
+        }
+        pltfm_host->clk = clk;
+        clk_enable(clk);
+
+        host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
+                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
+                | SDHCI_QUIRK_32BIT_ADMA_SIZE;
+
+        /* enable 1/8V DDR capable */
+        host->mmc->caps |= MMC_CAP_1_8V_DDR;
+
+        if (pdata) {
+                if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
+                        /* on-chip device */
+                        host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+                        host->mmc->caps |= MMC_CAP_NONREMOVABLE;
+                }
+
+                /* If slot design supports 8 bit data, indicate this to MMC. */
+                if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
+                        host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+
+                if (pdata->quirks)
+                        host->quirks |= pdata->quirks;
+                if (pdata->host_caps)
+                        host->mmc->caps |= pdata->host_caps;
+                if (pdata->pm_caps)
+                        host->mmc->pm_caps |= pdata->pm_caps;
+        }
+
+        host->ops = &pxav3_sdhci_ops;
+
+        ret = sdhci_add_host(host);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add host\n");
+                goto err_add_host;
+        }
+
+        platform_set_drvdata(pdev, host);
+
+        return 0;
+
+err_add_host:
+        clk_disable(clk);
+        clk_put(clk);
+err_clk_get:
+        sdhci_pltfm_free(pdev);
+        kfree(pxa);
+        return ret;
+}
+
+static int __devexit sdhci_pxav3_remove(struct platform_device *pdev)
+{
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
+
+        sdhci_remove_host(host, 1);
+
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+        sdhci_pltfm_free(pdev);
+        kfree(pxa);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver sdhci_pxav3_driver = {
+        .driver         = {
+                .name   = "sdhci-pxav3",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_pxav3_probe,
+        .remove         = __devexit_p(sdhci_pxav3_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
+};
+static int __init sdhci_pxav3_init(void)
+{
+        return platform_driver_register(&sdhci_pxav3_driver);
+}
+
+static void __exit sdhci_pxav3_exit(void)
+{
+        platform_driver_unregister(&sdhci_pxav3_driver);
+}
+
+module_init(sdhci_pxav3_init);
+module_exit(sdhci_pxav3_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for pxav3");
+MODULE_AUTHOR("Marvell International Ltd.");
+MODULE_LICENSE("GPL v2");
+
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 69e3ee321eb..fe886d6c474 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -19,6 +19,7 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 
 #include <linux/mmc/host.h>
 
@@ -301,6 +302,8 @@ static int sdhci_s3c_platform_8bit_width(struct sdhci_host *host, int width)
                 ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         default:
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         }
 
@@ -502,6 +505,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         /* This host supports the Auto CMD12 */
         host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
 
+        /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
+        host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC;
+
         if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
             pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
@@ -612,16 +618,14 @@ static int sdhci_s3c_suspend(struct platform_device *dev, pm_message_t pm)
 {
         struct sdhci_host *host = platform_get_drvdata(dev);
 
-        sdhci_suspend_host(host, pm);
-        return 0;
+        return sdhci_suspend_host(host, pm);
 }
 
 static int sdhci_s3c_resume(struct platform_device *dev)
 {
         struct sdhci_host *host = platform_get_drvdata(dev);
 
-        sdhci_resume_host(host);
-        return 0;
+        return sdhci_resume_host(host);
 }
 
 #else
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index 343c97edba3..67950782e09 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -1,6 +1,8 @@
 /*
  * Copyright (C) 2010 Google, Inc.
  *
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
@@ -18,15 +20,100 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/sd.h>
+#include <linux/regulator/consumer.h>
+#include <linux/delay.h>
 
 #include <mach/gpio.h>
 #include <mach/sdhci.h>
+#include <mach/io_dpd.h>
 
-#include "sdhci.h"
 #include "sdhci-pltfm.h"
 
+#define SDHCI_VENDOR_CLOCK_CNTRL        0x100
+#define SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK      0x1
+#define SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE 0x8
+#define SDHCI_VENDOR_CLOCK_CNTRL_SPI_MODE_CLKEN_OVERRIDE        0x4
+#define SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT    8
+#define SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT        16
+#define SDHCI_VENDOR_CLOCK_CNTRL_SDR50_TUNING           0x20
+
+#define SDHCI_VENDOR_MISC_CNTRL         0x120
+#define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT   0x8
+#define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT    0x10
+#define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0   0x20
+
+#define SDMMC_SDMEMCOMPPADCTRL  0x1E0
+#define SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK    0xF
+
+#define SDMMC_AUTO_CAL_CONFIG   0x1E4
+#define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE   0x20000000
+#define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT  0x8
+#define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET        0x70
+#define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET        0x62
+
+#define SDHOST_1V8_OCR_MASK     0x8
+#define SDHOST_HIGH_VOLT_MIN    2700000
+#define SDHOST_HIGH_VOLT_MAX    3600000
+#define SDHOST_LOW_VOLT_MIN     1800000
+#define SDHOST_LOW_VOLT_MAX     1800000
+
+#define TEGRA_SDHOST_MIN_FREQ   50000000
+#define TEGRA2_SDHOST_STD_FREQ  50000000
+#define TEGRA3_SDHOST_STD_FREQ  104000000
+
+#define SD_SEND_TUNING_PATTERN  19
+#define MAX_TAP_VALUES  256
+
+static unsigned int tegra_sdhost_min_freq;
+static unsigned int tegra_sdhost_std_freq;
+static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock);
+static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci);
+
+static unsigned int tegra3_sdhost_max_clk[4] = {
+        208000000,      104000000,      208000000,      104000000 };
+
+struct tegra_sdhci_hw_ops{
+        /* Set the internal clk and card clk.*/
+        void    (*set_card_clock)(struct sdhci_host *sdhci, unsigned int clock);
+        /* Post reset vendor registers configuration */
+        void    (*sdhost_init)(struct sdhci_host *sdhci);
+};
+
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+static struct tegra_sdhci_hw_ops tegra_2x_sdhci_ops = {
+};
+#endif
+
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+static struct tegra_sdhci_hw_ops tegra_3x_sdhci_ops = {
+        .set_card_clock = tegra_3x_sdhci_set_card_clock,
+        .sdhost_init = tegra3_sdhci_post_reset_init,
+};
+#endif
+
+struct tegra_sdhci_host {
+        bool    clk_enabled;
+        struct regulator *vdd_io_reg;
+        struct regulator *vdd_slot_reg;
+        /* Pointer to the chip specific HW ops */
+        struct tegra_sdhci_hw_ops *hw_ops;
+        /* Host controller instance */
+        unsigned int instance;
+        /* vddio_min */
+        unsigned int vddio_min_uv;
+        /* vddio_max */
+        unsigned int vddio_max_uv;
+        /* max clk supported by the platform */
+        unsigned int max_clk_limit;
+        struct tegra_io_dpd *dpd;
+        bool card_present;
+        bool is_rail_enabled;
+};
+
 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
 {
         u32 val;
@@ -42,11 +129,12 @@ static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
 
 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
 {
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
         if (unlikely(reg == SDHCI_HOST_VERSION)) {
                 /* Erratum: Version register is invalid in HW. */
                 return SDHCI_SPEC_200;
         }
-
+#endif
         return readw(host->ioaddr + reg);
 }
 
@@ -61,6 +149,7 @@ static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
 
         writel(val, host->ioaddr + reg);
 
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
         if (unlikely(reg == SDHCI_INT_ENABLE)) {
                 /* Erratum: Must enable block gap interrupt detection */
                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
@@ -70,6 +159,15 @@ static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
                         gap_ctrl &= ~0x8;
                 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
         }
+#endif
+}
+
+static unsigned int tegra_sdhci_get_cd(struct sdhci_host *sdhci)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+
+        return tegra_host->card_present;
 }
 
 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
@@ -85,9 +183,150 @@ static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
         return gpio_get_value(plat->wp_gpio);
 }
 
+static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci)
+{
+        u16 misc_ctrl;
+        u32 vendor_ctrl;
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+        struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
+        struct tegra_sdhci_platform_data *plat;
+
+        plat = pdev->dev.platform_data;
+        /* Set the base clock frequency */
+        vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
+        vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT);
+        vendor_ctrl |= (tegra3_sdhost_max_clk[tegra_host->instance] / 1000000) <<
+                SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT;
+        vendor_ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE;
+        vendor_ctrl &= ~SDHCI_VENDOR_CLOCK_CNTRL_SPI_MODE_CLKEN_OVERRIDE;
+
+        /* Set tap delay */
+        if (plat->tap_delay) {
+                vendor_ctrl &= ~(0xFF <<
+                        SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
+                vendor_ctrl |= (plat->tap_delay <<
+                        SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
+        }
+        /* Enable frequency tuning for SDR50 mode */
+        vendor_ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDR50_TUNING;
+        sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
+
+        /* Enable SDHOST v3.0 support */
+        misc_ctrl = sdhci_readw(sdhci, SDHCI_VENDOR_MISC_CNTRL);
+        misc_ctrl |= SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0 |
+                SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT |
+                SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT;
+        sdhci_writew(sdhci, misc_ctrl, SDHCI_VENDOR_MISC_CNTRL);
+}
+
+static int tegra_sdhci_set_uhs_signaling(struct sdhci_host *host,
+                unsigned int uhs)
+{
+        u16 clk, ctrl_2;
+        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+        /* Select Bus Speed Mode for host */
+        ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
+        switch (uhs) {
+        case MMC_TIMING_UHS_SDR12:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
+                break;
+        case MMC_TIMING_UHS_SDR25:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
+                break;
+        case MMC_TIMING_UHS_SDR50:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
+                break;
+        case MMC_TIMING_UHS_SDR104:
+                ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
+                break;
+        case MMC_TIMING_UHS_DDR50:
+                ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
+                break;
+        }
+
+        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
+
+        if (uhs == MMC_TIMING_UHS_DDR50) {
+                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                clk &= ~(0xFF << SDHCI_DIVIDER_SHIFT);
+                clk |= 1 << SDHCI_DIVIDER_SHIFT;
+                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+        }
+        return 0;
+}
+
+static void tegra_sdhci_reset_exit(struct sdhci_host *sdhci, u8 mask)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+
+        if (mask & SDHCI_RESET_ALL) {
+                if (tegra_host->hw_ops->sdhost_init)
+                        tegra_host->hw_ops->sdhost_init(sdhci);
+        }
+}
+
+static void sdhci_status_notify_cb(int card_present, void *dev_id)
+{
+        struct sdhci_host *sdhci = (struct sdhci_host *)dev_id;
+        struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
+        struct tegra_sdhci_platform_data *plat;
+        unsigned int status, oldstat;
+
+        pr_debug("%s: card_present %d\n", mmc_hostname(sdhci->mmc),
+                card_present);
+
+        plat = pdev->dev.platform_data;
+        if (!plat->mmc_data.status) {
+                mmc_detect_change(sdhci->mmc, 0);
+                return;
+        }
+
+        status = plat->mmc_data.status(mmc_dev(sdhci->mmc));
+
+        oldstat = plat->mmc_data.card_present;
+        plat->mmc_data.card_present = status;
+        if (status ^ oldstat) {
+                pr_debug("%s: Slot status change detected (%d -> %d)\n",
+                        mmc_hostname(sdhci->mmc), oldstat, status);
+                if (status && !plat->mmc_data.built_in)
+                        mmc_detect_change(sdhci->mmc, (5 * HZ) / 2);
+                else
+                        mmc_detect_change(sdhci->mmc, 0);
+        }
+}
+
 static irqreturn_t carddetect_irq(int irq, void *data)
 {
         struct sdhci_host *sdhost = (struct sdhci_host *)data;
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhost);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+        struct platform_device *pdev = to_platform_device(mmc_dev(sdhost->mmc));
+        struct tegra_sdhci_platform_data *plat;
+
+        plat = pdev->dev.platform_data;
+
+        tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
+
+        if (tegra_host->card_present) {
+                if (!tegra_host->is_rail_enabled) {
+                        if (tegra_host->vdd_slot_reg)
+                                regulator_enable(tegra_host->vdd_slot_reg);
+                        if (tegra_host->vdd_io_reg)
+                                regulator_enable(tegra_host->vdd_io_reg);
+                        tegra_host->is_rail_enabled = 1;
+                }
+        } /* else {
+                if (tegra_host->is_rail_enabled) {
+                        if (tegra_host->vdd_io_reg)
+                                regulator_disable(tegra_host->vdd_io_reg);
+                        if (tegra_host->vdd_slot_reg)
+                                regulator_disable(tegra_host->vdd_slot_reg);
+                        tegra_host->is_rail_enabled = 0;
+                }
+        } */
 
         tasklet_schedule(&sdhost->card_tasklet);
         return IRQ_HANDLED;
@@ -116,28 +355,597 @@ static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
         return 0;
 }
 
+static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
+        unsigned int clock)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+        unsigned int clk_rate;
+
+        if (sdhci->mmc->card &&
+                mmc_card_ddr_mode(sdhci->mmc->card)) {
+                /*
+                 * In ddr mode, tegra sdmmc controller clock frequency
+                 * should be double the card clock frequency.
+                 */
+                 clk_rate = clock * 2;
+        } else {
+                if (clock <= tegra_sdhost_min_freq)
+                        clk_rate = tegra_sdhost_min_freq;
+                else if (clock <= tegra_sdhost_std_freq)
+                        clk_rate = tegra_sdhost_std_freq;
+                else
+                        clk_rate = clock;
+
+                /*
+                 * In SDR50 mode, run the sdmmc controller at 208MHz to ensure
+                 * the core voltage is at 1.2V. If the core voltage is below 1.2V, CRC
+                 * errors would occur during data transfers.
+                 */
+                if ((sdhci->mmc->ios.timing == MMC_TIMING_UHS_SDR50) &&
+                        (clk_rate == tegra_sdhost_std_freq))
+                        clk_rate <<= 1;
+        }
+
+        if (tegra_host->max_clk_limit &&
+                (clk_rate > tegra_host->max_clk_limit))
+                clk_rate = tegra_host->max_clk_limit;
+
+        clk_set_rate(pltfm_host->clk, clk_rate);
+        sdhci->max_clk = clk_get_rate(pltfm_host->clk);
+}
+
+static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock)
+{
+        int div;
+        u16 clk;
+        unsigned long timeout;
+        u8 ctrl;
+
+        if (clock && clock == sdhci->clock)
+                return;
+
+        sdhci_writew(sdhci, 0, SDHCI_CLOCK_CONTROL);
+
+        if (clock == 0)
+                goto out;
+        if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
+                div = 1;
+                goto set_clk;
+        }
+
+        if (sdhci->version >= SDHCI_SPEC_300) {
+                /* Version 3.00 divisors must be a multiple of 2. */
+                if (sdhci->max_clk <= clock) {
+                        div = 1;
+                } else {
+                        for (div = 2; div < SDHCI_MAX_DIV_SPEC_300; div += 2) {
+                                if ((sdhci->max_clk / div) <= clock)
+                                        break;
+                        }
+                }
+        } else {
+                /* Version 2.00 divisors must be a power of 2. */
+                for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
+                        if ((sdhci->max_clk / div) <= clock)
+                                break;
+                }
+        }
+        div >>= 1;
+
+        /*
+         * Tegra3 sdmmc controller internal clock will not be stabilized when
+         * we use a clock divider value greater than 4. The WAR is as follows.
+         * - Enable internal clock.
+         * - Wait for 5 usec and do a dummy write.
+         * - Poll for clk stable.
+         */
+set_clk:
+        clk = (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
+        clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
+                << SDHCI_DIVIDER_HI_SHIFT;
+        clk |= SDHCI_CLOCK_INT_EN;
+        sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
+
+        /* Wait for 5 usec */
+        udelay(5);
+
+        /* Do a dummy write */
+        ctrl = sdhci_readb(sdhci, SDHCI_CAPABILITIES);
+        ctrl |= 1;
+        sdhci_writeb(sdhci, ctrl, SDHCI_CAPABILITIES);
+
+        /* Wait max 20 ms */
+        timeout = 20;
+        while (!((clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL))
+                & SDHCI_CLOCK_INT_STABLE)) {
+                if (timeout == 0) {
+                        dev_err(mmc_dev(sdhci->mmc), "Internal clock never stabilised\n");
+                        return;
+                }
+                timeout--;
+                mdelay(1);
+        }
+
+        clk |= SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
+out:
+        sdhci->clock = clock;
+}
+
+static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+        u8 ctrl;
+
+        pr_debug("%s %s %u enabled=%u\n", __func__,
+                mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
 
-static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
-                                  struct sdhci_pltfm_data *pdata)
+        if (clock) {
+                /* bring out sd instance from io dpd mode */
+                tegra_io_dpd_disable(tegra_host->dpd);
+
+                if (!tegra_host->clk_enabled) {
+                        clk_enable(pltfm_host->clk);
+                        ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
+                        ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
+                        sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
+                        tegra_host->clk_enabled = true;
+                }
+                tegra_sdhci_set_clk_rate(sdhci, clock);
+                if (tegra_host->hw_ops->set_card_clock)
+                        tegra_host->hw_ops->set_card_clock(sdhci, clock);
+        } else if (!clock && tegra_host->clk_enabled) {
+                if (tegra_host->hw_ops->set_card_clock)
+                        tegra_host->hw_ops->set_card_clock(sdhci, clock);
+                ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
+                ctrl &= ~SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
+                sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
+                clk_disable(pltfm_host->clk);
+                tegra_host->clk_enabled = false;
+                /* io dpd enable call for sd instance */
+                tegra_io_dpd_enable(tegra_host->dpd);
+        }
+}
+
+static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
+        unsigned int signal_voltage)
 {
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+        unsigned int min_uV = SDHOST_HIGH_VOLT_MIN;
+        unsigned int max_uV = SDHOST_HIGH_VOLT_MAX;
+        unsigned int rc = 0;
+        u16 clk, ctrl;
+        unsigned int val;
+
+        /* Switch OFF the card clock to prevent glitches on the clock line */
+        clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL);
+        clk &= ~SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
+
+        ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
+        if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
+                ctrl |= SDHCI_CTRL_VDD_180;
+                min_uV = SDHOST_LOW_VOLT_MIN;
+                max_uV = SDHOST_LOW_VOLT_MAX;
+        } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
+                if (ctrl & SDHCI_CTRL_VDD_180)
+                        ctrl &= ~SDHCI_CTRL_VDD_180;
+        }
+        sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
+
+        /* Switch the I/O rail voltage */
+        if (tegra_host->vdd_io_reg) {
+                rc = regulator_set_voltage(tegra_host->vdd_io_reg,
+                        min_uV, max_uV);
+                if (rc) {
+                        dev_err(mmc_dev(sdhci->mmc), "switching to 1.8V"
+                        "failed . Switching back to 3.3V\n");
+                        regulator_set_voltage(tegra_host->vdd_io_reg,
+                                SDHOST_HIGH_VOLT_MIN,
+                                SDHOST_HIGH_VOLT_MAX);
+                        goto out;
+                }
+        }
+
+        /* Wait for 10 msec for the voltage to be switched */
+        mdelay(10);
+
+        /* Enable the card clock */
+        clk |= SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
+
+        /* Wait for 1 msec after enabling clock */
+        mdelay(1);
+
+        if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
+                /* Do Auto Calibration for 1.8V signal voltage */
+                val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
+                val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
+                /* Program Auto cal PD offset(bits 8:14) */
+                val &= ~(0x7F <<
+                        SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
+                val |= (SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET <<
+                        SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
+                /* Program Auto cal PU offset(bits 0:6) */
+                val &= ~0x7F;
+                val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET;
+                sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
+
+                val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
+                val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
+                val |= 0x7;
+                sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
+        }
+
+        return rc;
+out:
+        /* Enable the card clock */
+        clk |= SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
+
+        /* Wait for 1 msec for the clock to stabilize */
+        mdelay(1);
+
+        return rc;
+}
+
+static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
+{
+        unsigned long timeout;
+
+        sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
+
+        /* Wait max 100 ms */
+        timeout = 100;
+
+        /* hw clears the bit when it's done */
+        while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
+                if (timeout == 0) {
+                        dev_err(mmc_dev(sdhci->mmc), "Reset 0x%x never"
+                                "completed.\n", (int)mask);
+                        return;
+                }
+                timeout--;
+                mdelay(1);
+        }
+}
+
+static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
+        unsigned int tap_delay)
+{
+        u32 vendor_ctrl;
+
+        /* Max tap delay value is 255 */
+        BUG_ON(tap_delay > MAX_TAP_VALUES);
+
+        vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
+        vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
+        vendor_ctrl |= (tap_delay << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
+        sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
+}
+
+static void sdhci_tegra_clear_set_irqs(struct sdhci_host *host,
+        u32 clear, u32 set)
+{
+        u32 ier;
+
+        ier = sdhci_readl(host, SDHCI_INT_ENABLE);
+        ier &= ~clear;
+        ier |= set;
+        sdhci_writel(host, ier, SDHCI_INT_ENABLE);
+        sdhci_writel(host, ier, SDHCI_SIGNAL_ENABLE);
+}
+
+static int sdhci_tegra_run_frequency_tuning(struct sdhci_host *sdhci)
+{
+        int err = 0;
+        u8 ctrl;
+        u32 ier;
+        u32 mask;
+        unsigned int timeout = 10;
+        int flags;
+        u32 intstatus;
+
+        /*
+         * As per the Host Controller spec v3.00, tuning command
+         * generates Buffer Read Ready interrupt only, so enable that.
+         */
+        ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
+        sdhci_tegra_clear_set_irqs(sdhci, ier, SDHCI_INT_DATA_AVAIL |
+                SDHCI_INT_DATA_CRC);
+
+        mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
+        while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
+                if (timeout == 0) {
+                        dev_err(mmc_dev(sdhci->mmc), "Controller never"
+                                "released inhibit bit(s).\n");
+                        err = -ETIMEDOUT;
+                        goto out;
+                }
+                timeout--;
+                mdelay(1);
+        }
+
+        ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
+        ctrl &= ~SDHCI_CTRL_TUNED_CLK;
+        sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
+
+        ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
+        ctrl |= SDHCI_CTRL_EXEC_TUNING;
+        sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
+
+        /*
+         * In response to CMD19, the card sends 64 bytes of tuning
+         * block to the Host Controller. So we set the block size
+         * to 64 here.
+         */
+        sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, 64), SDHCI_BLOCK_SIZE);
+
+        sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
+
+        sdhci_writeb(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
+
+        sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
+
+        /* Set the cmd flags */
+        flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
+        /* Issue the command */
+        sdhci_writew(sdhci, SDHCI_MAKE_CMD(
+                SD_SEND_TUNING_PATTERN, flags), SDHCI_COMMAND);
+
+        timeout = 5;
+        do {
+                timeout--;
+                mdelay(1);
+                intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
+                if (intstatus) {
+                        sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
+                        break;
+                }
+        } while(timeout);
+
+        if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
+                !(intstatus & SDHCI_INT_DATA_CRC)) {
+                err = 0;
+                sdhci->tuning_done = 1;
+        } else {
+                tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
+                tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
+                err = -EIO;
+        }
+
+        if (sdhci->tuning_done) {
+                sdhci->tuning_done = 0;
+                ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
+                if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
+                        (ctrl & SDHCI_CTRL_TUNED_CLK))
+                        err = 0;
+                else
+                        err = -EIO;
+        }
+        mdelay(1);
+out:
+        sdhci_tegra_clear_set_irqs(sdhci, SDHCI_INT_DATA_AVAIL, ier);
+        return err;
+}
+
+static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci)
+{
+        int err;
+        u16 ctrl_2;
+        u8 *tap_delay_status;
+        unsigned int i = 0;
+        unsigned int temp_low_pass_tap = 0;
+        unsigned int temp_pass_window = 0;
+        unsigned int best_low_pass_tap = 0;
+        unsigned int best_pass_window = 0;
+
+        /* Tuning is valid only in SDR104 and SDR50 modes */
+        ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
+        if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
+                (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
+                (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
+                        return 0;
+
+        tap_delay_status = kzalloc(MAX_TAP_VALUES, GFP_KERNEL);
+        if (tap_delay_status == NULL) {
+                dev_err(mmc_dev(sdhci->mmc), "failed to allocate memory"
+                        "for storing tap_delay_status\n");
+                err = -ENOMEM;
+                goto out;
+        }
+
+        /*
+         * Set each tap delay value and run frequency tuning. After each
+         * run, update the tap delay status as working or not working.
+         */
+        do {
+                /* Set the tap delay */
+                sdhci_tegra_set_tap_delay(sdhci, i);
+
+                /* Run frequency tuning */
+                err = sdhci_tegra_run_frequency_tuning(sdhci);
+
+                /* Update whether the tap delay worked or not */
+                tap_delay_status[i] = (err) ? 0: 1;
+                i++;
+        } while (i < 0xFF);
+
+        /* Find the best possible tap range */
+        for (i = 0; i < 0xFF; i++) {
+                temp_pass_window = 0;
+
+                /* Find the first passing tap in the current window */
+                if (tap_delay_status[i]) {
+                        temp_low_pass_tap = i;
+
+                        /* Find the pass window */
+                        do {
+                                temp_pass_window++;
+                                i++;
+                                if (i > 0xFF)
+                                        break;
+                        } while (tap_delay_status[i]);
+
+                        if ((temp_pass_window > best_pass_window) && (temp_pass_window > 1)){
+                                best_low_pass_tap = temp_low_pass_tap;
+                                best_pass_window = temp_pass_window;
+                        }
+                }
+        }
+
+
+        pr_debug("%s: best pass tap window: start %d, end %d\n",
+                mmc_hostname(sdhci->mmc), best_low_pass_tap,
+                (best_low_pass_tap + best_pass_window));
+
+        /* Set the best tap */
+        sdhci_tegra_set_tap_delay(sdhci,
+                (best_low_pass_tap + ((best_pass_window * 3) / 4)));
+
+        /* Run frequency tuning */
+        err = sdhci_tegra_run_frequency_tuning(sdhci);
+
+out:
+        if (tap_delay_status)
+                kfree(tap_delay_status);
+
+        return err;
+}
+
+static int tegra_sdhci_suspend(struct sdhci_host *sdhci, pm_message_t state)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+
+        tegra_sdhci_set_clock(sdhci, 0);
+
+        /* Disable the power rails if any */
+        if (tegra_host->card_present) {
+                if (tegra_host->is_rail_enabled) {
+                        if (tegra_host->vdd_io_reg)
+                                regulator_disable(tegra_host->vdd_io_reg);
+                        if (tegra_host->vdd_slot_reg)
+                                regulator_disable(tegra_host->vdd_slot_reg);
+                        tegra_host->is_rail_enabled = 0;
+                }
+        }
+
+        return 0;
+}
+
+static int tegra_sdhci_resume(struct sdhci_host *sdhci)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
+
+        /* Enable the power rails if any */
+        if (tegra_host->card_present) {
+                if (!tegra_host->is_rail_enabled) {
+                        if (tegra_host->vdd_slot_reg)
+                                regulator_enable(tegra_host->vdd_slot_reg);
+                        if (tegra_host->vdd_io_reg) {
+                                regulator_enable(tegra_host->vdd_io_reg);
+                                tegra_sdhci_signal_voltage_switch(sdhci, MMC_SIGNAL_VOLTAGE_330);
+                        }
+                        tegra_host->is_rail_enabled = 1;
+                }
+        }
+        /* Setting the min identification clock of freq 400KHz */
+        tegra_sdhci_set_clock(sdhci, 400000);
+
+        /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
+        if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
+                tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
+                sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
+                sdhci->pwr = 0;
+        }
+
+        return 0;
+}
+
+static struct sdhci_ops tegra_sdhci_ops = {
+        .get_ro     = tegra_sdhci_get_ro,
+        .get_cd     = tegra_sdhci_get_cd,
+        .read_l     = tegra_sdhci_readl,
+        .read_w     = tegra_sdhci_readw,
+        .write_l    = tegra_sdhci_writel,
+        .platform_8bit_width = tegra_sdhci_8bit,
+        .set_clock  = tegra_sdhci_set_clock,
+        .suspend    = tegra_sdhci_suspend,
+        .resume     = tegra_sdhci_resume,
+        .platform_reset_exit = tegra_sdhci_reset_exit,
+        .set_uhs_signaling = tegra_sdhci_set_uhs_signaling,
+        .switch_signal_voltage = tegra_sdhci_signal_voltage_switch,
+        .execute_freq_tuning = sdhci_tegra_execute_tuning,
+};
+
+static struct sdhci_pltfm_data sdhci_tegra_pdata = {
+        .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+                  SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
+                  SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING |
+#endif
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+                  SDHCI_QUIRK_NONSTANDARD_CLOCK |
+                  SDHCI_QUIRK_NON_STANDARD_TUNING |
+#endif
+                  SDHCI_QUIRK_SINGLE_POWER_WRITE |
+                  SDHCI_QUIRK_NO_HISPD_BIT |
+                  SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC |
+                  SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO |
+                  SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+        .ops  = &tegra_sdhci_ops,
+};
+
+static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
+{
+        struct sdhci_pltfm_host *pltfm_host;
         struct tegra_sdhci_platform_data *plat;
+        struct sdhci_host *host;
+        struct tegra_sdhci_host *tegra_host;
         struct clk *clk;
         int rc;
 
+        host = sdhci_pltfm_init(pdev, &sdhci_tegra_pdata);
+        if (IS_ERR(host))
+                return PTR_ERR(host);
+
+        pltfm_host = sdhci_priv(host);
+
         plat = pdev->dev.platform_data;
+
         if (plat == NULL) {
                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
-                return -ENXIO;
+                rc = -ENXIO;
+                goto err_no_plat;
+        }
+
+        tegra_host = kzalloc(sizeof(struct tegra_sdhci_host), GFP_KERNEL);
+        if (tegra_host == NULL) {
+                dev_err(mmc_dev(host->mmc), "failed to allocate tegra host\n");
+                rc = -ENOMEM;
+                goto err_no_mem;
         }
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        if (plat->mmc_data.embedded_sdio)
+                mmc_set_embedded_sdio_data(host->mmc,
+                        &plat->mmc_data.embedded_sdio->cis,
+                        &plat->mmc_data.embedded_sdio->cccr,
+                        plat->mmc_data.embedded_sdio->funcs,
+                        plat->mmc_data.embedded_sdio->num_funcs);
+#endif
+
         if (gpio_is_valid(plat->power_gpio)) {
                 rc = gpio_request(plat->power_gpio, "sdhci_power");
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate power gpio\n");
-                        goto out;
+                        goto err_power_req;
                 }
                 tegra_gpio_enable(plat->power_gpio);
                 gpio_direction_output(plat->power_gpio, 1);
@@ -148,20 +956,34 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate cd gpio\n");
-                        goto out_power;
+                        goto err_cd_req;
                 }
                 tegra_gpio_enable(plat->cd_gpio);
                 gpio_direction_input(plat->cd_gpio);
 
-                rc = request_irq(gpio_to_irq(plat->cd_gpio), carddetect_irq,
+                tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
+
+                rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
+                                 carddetect_irq,
                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                                  mmc_hostname(host->mmc), host);
 
                 if (rc) {
                         dev_err(mmc_dev(host->mmc), "request irq error\n");
-                        goto out_cd;
+                        goto err_cd_irq_req;
                 }
+                rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
+                if (rc < 0)
+                        dev_err(mmc_dev(host->mmc),
+                                "SD card wake-up event registration"
+                                        "failed with eroor: %d\n", rc);
+
+        } else if (plat->mmc_data.register_status_notify) {
+                plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
+        }
 
+        if (plat->mmc_data.status) {
+                plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
         }
 
         if (gpio_is_valid(plat->wp_gpio)) {
@@ -169,61 +991,167 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
                 if (rc) {
                         dev_err(mmc_dev(host->mmc),
                                 "failed to allocate wp gpio\n");
-                        goto out_irq;
+                        goto err_wp_req;
                 }
                 tegra_gpio_enable(plat->wp_gpio);
                 gpio_direction_input(plat->wp_gpio);
         }
 
+        /*
+         * If there is no card detect gpio, assume that the
+         * card is always present.
+         */
+        if (!gpio_is_valid(plat->cd_gpio))
+                tegra_host->card_present = 1;
+
+        if (!plat->mmc_data.built_in) {
+                if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
+                        tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
+                        tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
+                } else {
+                        /*
+                         * Set the minV and maxV to default
+                         * voltage range of 2.7V - 3.6V
+                         */
+                        tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
+                        tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
+                }
+                tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc), "vddio_sdmmc");
+                if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
+                        dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
+                                "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
+                        tegra_host->vdd_io_reg = NULL;
+                } else {
+                        rc = regulator_set_voltage(tegra_host->vdd_io_reg,
+                                tegra_host->vddio_min_uv,
+                                tegra_host->vddio_max_uv);
+                        if (rc) {
+                                dev_err(mmc_dev(host->mmc), "%s regulator_set_voltage failed: %d",
+                                        "vddio_sdmmc", rc);
+                        }
+                }
+
+                tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc), "vddio_sd_slot");
+                if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
+                        dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
+                                "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
+                        tegra_host->vdd_slot_reg = NULL;
+                }
+
+                if (tegra_host->card_present) {
+                        if (tegra_host->vdd_slot_reg)
+                                regulator_enable(tegra_host->vdd_slot_reg);
+                        if (tegra_host->vdd_io_reg)
+                                regulator_enable(tegra_host->vdd_io_reg);
+                        tegra_host->is_rail_enabled = 1;
+                }
+        }
+
         clk = clk_get(mmc_dev(host->mmc), NULL);
         if (IS_ERR(clk)) {
                 dev_err(mmc_dev(host->mmc), "clk err\n");
                 rc = PTR_ERR(clk);
-                goto out_wp;
+                goto err_clk_get;
         }
-        clk_enable(clk);
+        rc = clk_enable(clk);
+        if (rc != 0)
+                goto err_clk_put;
         pltfm_host->clk = clk;
+        pltfm_host->priv = tegra_host;
+        tegra_host->clk_enabled = true;
+        tegra_host->max_clk_limit = plat->max_clk_limit;
+        tegra_host->instance = pdev->id;
+        tegra_host->dpd = tegra_io_dpd_get(mmc_dev(host->mmc));
 
-        host->mmc->pm_caps = plat->pm_flags;
+        host->mmc->pm_caps |= plat->pm_caps;
+        host->mmc->pm_flags |= plat->pm_flags;
 
+        host->mmc->caps |= MMC_CAP_ERASE;
+        host->mmc->caps |= MMC_CAP_DISABLE;
+        /* enable 1/8V DDR capable */
+        host->mmc->caps |= MMC_CAP_1_8V_DDR;
         if (plat->is_8bit)
                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+        host->mmc->caps |= MMC_CAP_SDIO_IRQ;
+
+        host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
+        if (plat->mmc_data.built_in) {
+                host->mmc->caps |= MMC_CAP_NONREMOVABLE;
+                host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
+        }
+        /* Do not turn OFF embedded sdio cards as it support Wake on Wireless */
+        if (plat->mmc_data.embedded_sdio)
+                host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
+
+        tegra_sdhost_min_freq = TEGRA_SDHOST_MIN_FREQ;
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+        tegra_host->hw_ops = &tegra_2x_sdhci_ops;
+        tegra_sdhost_std_freq = TEGRA2_SDHOST_STD_FREQ;
+#else
+        tegra_host->hw_ops = &tegra_3x_sdhci_ops;
+        tegra_sdhost_std_freq = TEGRA3_SDHOST_STD_FREQ;
+#endif
+
+        rc = sdhci_add_host(host);
+        if (rc)
+                goto err_add_host;
 
         return 0;
 
-out_wp:
+err_add_host:
+        clk_disable(pltfm_host->clk);
+err_clk_put:
+        clk_put(pltfm_host->clk);
+err_clk_get:
         if (gpio_is_valid(plat->wp_gpio)) {
                 tegra_gpio_disable(plat->wp_gpio);
                 gpio_free(plat->wp_gpio);
         }
-
-out_irq:
+err_wp_req:
         if (gpio_is_valid(plat->cd_gpio))
                 free_irq(gpio_to_irq(plat->cd_gpio), host);
-out_cd:
+err_cd_irq_req:
         if (gpio_is_valid(plat->cd_gpio)) {
                 tegra_gpio_disable(plat->cd_gpio);
                 gpio_free(plat->cd_gpio);
         }
-
-out_power:
+err_cd_req:
         if (gpio_is_valid(plat->power_gpio)) {
                 tegra_gpio_disable(plat->power_gpio);
                 gpio_free(plat->power_gpio);
         }
-
-out:
+err_power_req:
+err_no_mem:
+        kfree(tegra_host);
+err_no_plat:
+        sdhci_pltfm_free(pdev);
         return rc;
 }
 
-static void tegra_sdhci_pltfm_exit(struct sdhci_host *host)
+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 platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
         struct tegra_sdhci_platform_data *plat;
+        int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+        sdhci_remove_host(host, dead);
 
         plat = pdev->dev.platform_data;
 
+        disable_irq_wake(gpio_to_irq(plat->cd_gpio));
+
+        if (tegra_host->vdd_slot_reg) {
+                regulator_disable(tegra_host->vdd_slot_reg);
+                regulator_put(tegra_host->vdd_slot_reg);
+        }
+
+        if (tegra_host->vdd_io_reg) {
+                regulator_disable(tegra_host->vdd_io_reg);
+                regulator_put(tegra_host->vdd_io_reg);
+        }
+
         if (gpio_is_valid(plat->wp_gpio)) {
                 tegra_gpio_disable(plat->wp_gpio);
                 gpio_free(plat->wp_gpio);
@@ -240,24 +1168,41 @@ static void tegra_sdhci_pltfm_exit(struct sdhci_host *host)
                 gpio_free(plat->power_gpio);
         }
 
-        clk_disable(pltfm_host->clk);
+        if (tegra_host->clk_enabled)
+                clk_disable(pltfm_host->clk);
         clk_put(pltfm_host->clk);
+
+        sdhci_pltfm_free(pdev);
+        kfree(tegra_host);
+
+        return 0;
 }
 
-static struct sdhci_ops tegra_sdhci_ops = {
-        .get_ro     = tegra_sdhci_get_ro,
-        .read_l     = tegra_sdhci_readl,
-        .read_w     = tegra_sdhci_readw,
-        .write_l    = tegra_sdhci_writel,
-        .platform_8bit_width = tegra_sdhci_8bit,
+static struct platform_driver sdhci_tegra_driver = {
+        .driver         = {
+                .name   = "sdhci-tegra",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_tegra_probe,
+        .remove         = __devexit_p(sdhci_tegra_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
 };
 
-struct sdhci_pltfm_data sdhci_tegra_pdata = {
-        .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
-                  SDHCI_QUIRK_SINGLE_POWER_WRITE |
-                  SDHCI_QUIRK_NO_HISPD_BIT |
-                  SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC,
-        .ops  = &tegra_sdhci_ops,
-        .init = tegra_sdhci_pltfm_init,
-        .exit = tegra_sdhci_pltfm_exit,
-};
+static int __init sdhci_tegra_init(void)
+{
+        return platform_driver_register(&sdhci_tegra_driver);
+}
+module_init(sdhci_tegra_init);
+
+static void __exit sdhci_tegra_exit(void)
+{
+        platform_driver_unregister(&sdhci_tegra_driver);
+}
+module_exit(sdhci_tegra_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Tegra");
+MODULE_AUTHOR(" Google, Inc.");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 58d5436ff64..c6822c39541 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -25,6 +25,7 @@
 
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 
 #include "sdhci.h"
 
@@ -127,11 +128,15 @@ static void sdhci_mask_irqs(struct sdhci_host *host, u32 irqs)
 
 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
 {
-        u32 irqs = SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT;
+        u32 present, irqs;
 
         if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
                 return;
 
+        present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
+                              SDHCI_CARD_PRESENT;
+        irqs = present ? SDHCI_INT_CARD_REMOVE : SDHCI_INT_CARD_INSERT;
+
         if (enable)
                 sdhci_unmask_irqs(host, irqs);
         else
@@ -624,12 +629,11 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
         /* timeout in us */
         if (!data)
                 target_timeout = cmd->cmd_timeout_ms * 1000;
-        else
-                target_timeout = data->timeout_ns / 1000 +
-                        data->timeout_clks / host->clock;
-
-        if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
-                host->timeout_clk = host->clock / 1000;
+        else {
+                target_timeout = data->timeout_ns / 1000;
+                if (host->clock)
+                        target_timeout += data->timeout_clks / host->clock;
+        }
 
         /*
          * Figure out needed cycles.
@@ -641,7 +645,6 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
          *     =>
          *     (1) / (2) > 2^6
          */
-        BUG_ON(!host->timeout_clk);
         count = 0;
         current_timeout = (1 << 13) * 1000 / host->timeout_clk;
         while (current_timeout < target_timeout) {
@@ -1044,14 +1047,11 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
         u16 clk = 0;
         unsigned long timeout;
 
-        if (clock == host->clock)
+        if (clock && clock == host->clock)
                 return;
 
-        if (host->ops->set_clock) {
-                host->ops->set_clock(host, clock);
-                if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
-                        return;
-        }
+        if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
+                return;
 
         sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
 
@@ -1229,11 +1229,15 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         host->mrq = mrq;
 
         /* If polling, assume that the card is always present. */
-        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
-                present = true;
-        else
+        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) {
+                if (host->ops->get_cd)
+                        present = host->ops->get_cd(host);
+                else
+                        present = true;
+        } else {
                 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
                                 SDHCI_CARD_PRESENT;
+        }
 
         if (!present || host->flags & SDHCI_DEVICE_DEAD) {
                 host->mrq->cmd->error = -ENOMEDIUM;
@@ -1275,6 +1279,20 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         host = mmc_priv(mmc);
 
+        /*
+         * Controller registers should not be updated without the
+         * controller clock enabled. Set the minimum controller
+         * clock if there is no clock.
+         */
+        if (host->ops->set_clock) {
+                if (!host->clock && !ios->clock) {
+                        host->ops->set_clock(host, host->mmc->f_min);
+                        host->clock = host->mmc->f_min;
+                } else if (ios->clock && (ios->clock != host->clock)) {
+                        host->ops->set_clock(host, ios->clock);
+                }
+        }
+
         spin_lock_irqsave(&host->lock, flags);
 
         if (host->flags & SDHCI_DEVICE_DEAD)
@@ -1289,13 +1307,13 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 sdhci_reinit(host);
         }
 
-        sdhci_set_clock(host, ios->clock);
-
         if (ios->power_mode == MMC_POWER_OFF)
                 sdhci_set_power(host, -1);
         else
                 sdhci_set_power(host, ios->vdd);
 
+        sdhci_set_clock(host, ios->clock);
+
         if (host->ops->platform_send_init_74_clocks)
                 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
 
@@ -1337,11 +1355,12 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 unsigned int clock;
 
                 /* In case of UHS-I modes, set High Speed Enable */
-                if ((ios->timing == MMC_TIMING_UHS_SDR50) ||
+                if (((ios->timing == MMC_TIMING_UHS_SDR50) ||
                     (ios->timing == MMC_TIMING_UHS_SDR104) ||
                     (ios->timing == MMC_TIMING_UHS_DDR50) ||
                     (ios->timing == MMC_TIMING_UHS_SDR25) ||
                     (ios->timing == MMC_TIMING_UHS_SDR12))
+                    && !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
                         ctrl |= SDHCI_CTRL_HISPD;
 
                 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
@@ -1374,9 +1393,9 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
                         /* Re-enable SD Clock */
-                        clock = host->clock;
-                        host->clock = 0;
-                        sdhci_set_clock(host, clock);
+                        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                        clk |= SDHCI_CLOCK_CARD_EN;
+                        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
                 }
 
 
@@ -1405,9 +1424,9 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 }
 
                 /* Re-enable SD Clock */
-                clock = host->clock;
-                host->clock = 0;
-                sdhci_set_clock(host, clock);
+                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                clk |= SDHCI_CLOCK_CARD_EN;
+                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
         } else
                 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
@@ -1422,6 +1441,12 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 out:
         mmiowb();
         spin_unlock_irqrestore(&host->lock, flags);
+        /*
+         * Controller clock should only be disabled after all the register
+         * writes are done.
+         */
+        if (!ios->clock && host->ops->set_clock)
+                host->ops->set_clock(host, ios->clock);
 }
 
 static int check_ro(struct sdhci_host *host)
@@ -1508,6 +1533,12 @@ static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
         if (host->version < SDHCI_SPEC_300)
                 return 0;
 
+        if (host->quirks & SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING) {
+                if (host->ops->switch_signal_voltage)
+                        return host->ops->switch_signal_voltage(
+                                host, ios->signal_voltage);
+        }
+
         /*
          * We first check whether the request is to set signalling voltage
          * to 3.3V. If so, we change the voltage to 3.3V and return quickly.
@@ -1550,7 +1581,6 @@ static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
 
                         /* Wait for 5ms */
                         usleep_range(5000, 5500);
-
                         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
                         if (ctrl & SDHCI_CTRL_VDD_180) {
                                 /* Provide SDCLK again and wait for 1ms*/
@@ -1607,6 +1637,14 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
         disable_irq(host->irq);
         spin_lock(&host->lock);
 
+        if ((host->quirks & SDHCI_QUIRK_NON_STANDARD_TUNING) &&
+                host->ops->execute_freq_tuning) {
+                err = host->ops->execute_freq_tuning(host);
+                spin_unlock(&host->lock);
+                enable_irq(host->irq);
+                return err;
+        }
+
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 
         /*
@@ -1780,6 +1818,16 @@ static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
         if (host->version < SDHCI_SPEC_300)
                 return;
 
+        /*
+         * Enabling preset value would make programming clock
+         * divider ineffective. The controller would use the
+         * values present in the preset value registers. In
+         * case of non-standard clock, let the platform driver
+         * decide whether to enable preset or not.
+         */
+        if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
+                return;
+
         spin_lock_irqsave(&host->lock, flags);
 
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
@@ -1799,10 +1847,42 @@ static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+int sdhci_enable(struct mmc_host *mmc)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+
+        if (!mmc->card || mmc->card->type == MMC_TYPE_SDIO)
+                return 0;
+
+        if (mmc->ios.clock) {
+                if (host->ops->set_clock)
+                        host->ops->set_clock(host, mmc->ios.clock);
+                sdhci_set_clock(host, mmc->ios.clock);
+        }
+
+        return 0;
+}
+
+int sdhci_disable(struct mmc_host *mmc, int lazy)
+{
+        struct sdhci_host *host = mmc_priv(mmc);
+
+        if (!mmc->card || mmc->card->type == MMC_TYPE_SDIO)
+                return 0;
+
+        sdhci_set_clock(host, 0);
+        if (host->ops->set_clock)
+                host->ops->set_clock(host, 0);
+
+        return 0;
+}
+
 static const struct mmc_host_ops sdhci_ops = {
         .request        = sdhci_request,
         .set_ios        = sdhci_set_ios,
         .get_ro         = sdhci_get_ro,
+        .enable         = sdhci_enable,
+        .disable        = sdhci_disable,
         .enable_sdio_irq = sdhci_enable_sdio_irq,
         .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,
         .execute_tuning                 = sdhci_execute_tuning,
@@ -1863,9 +1943,6 @@ static void sdhci_tasklet_finish(unsigned long param)
 
         del_timer(&host->timer);
 
-        if (host->version >= SDHCI_SPEC_300)
-                del_timer(&host->tuning_timer);
-
         mrq = host->mrq;
 
         /*
@@ -1885,6 +1962,8 @@ static void sdhci_tasklet_finish(unsigned long param)
                         /* This is to force an update */
                         clock = host->clock;
                         host->clock = 0;
+                        if (host->ops->set_clock)
+                                host->ops->set_clock(host, clock);
                         sdhci_set_clock(host, clock);
                 }
 
@@ -2154,13 +2233,30 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
                 mmc_hostname(host->mmc), intmask);
 
         if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
+                u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
+                              SDHCI_CARD_PRESENT;
+
+                /*
+                 * There is a observation on i.mx esdhc.  INSERT bit will be
+                 * immediately set again when it gets cleared, if a card is
+                 * inserted.  We have to mask the irq to prevent interrupt
+                 * storm which will freeze the system.  And the REMOVE gets
+                 * the same situation.
+                 *
+                 * More testing are needed here to ensure it works for other
+                 * platforms though.
+                 */
+                sdhci_mask_irqs(host, present ? SDHCI_INT_CARD_INSERT :
+                                                SDHCI_INT_CARD_REMOVE);
+                sdhci_unmask_irqs(host, present ? SDHCI_INT_CARD_REMOVE :
+                                                  SDHCI_INT_CARD_INSERT);
+
                 sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
-                        SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
+                             SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
+                intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE);
                 tasklet_schedule(&host->card_tasklet);
         }
 
-        intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE);
-
         if (intmask & SDHCI_INT_CMD_MASK) {
                 sdhci_writel(host, intmask & SDHCI_INT_CMD_MASK,
                         SDHCI_INT_STATUS);
@@ -2223,7 +2319,8 @@ out:
 
 int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state)
 {
-        int ret;
+        int ret = 0;
+        struct mmc_host *mmc = host->mmc;
 
         sdhci_disable_card_detection(host);
 
@@ -2235,15 +2332,21 @@ int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state)
                         host->tuning_count * HZ);
         }
 
-        ret = mmc_suspend_host(host->mmc);
-        if (ret)
-                return ret;
+        if (mmc->card)
+                ret = mmc_suspend_host(host->mmc);
 
-        free_irq(host->irq, host);
+        if (mmc->pm_flags & MMC_PM_KEEP_POWER)
+                host->card_int_set = sdhci_readl(host, SDHCI_INT_ENABLE) &
+                        SDHCI_INT_CARD_INT;
+
+        sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
 
         if (host->vmmc)
                 ret = regulator_disable(host->vmmc);
 
+        if (host->irq)
+                disable_irq(host->irq);
+
         return ret;
 }
 
@@ -2251,7 +2354,8 @@ EXPORT_SYMBOL_GPL(sdhci_suspend_host);
 
 int sdhci_resume_host(struct sdhci_host *host)
 {
-        int ret;
+        int ret = 0;
+        struct mmc_host *mmc = host->mmc;
 
         if (host->vmmc) {
                 int ret = regulator_enable(host->vmmc);
@@ -2265,15 +2369,21 @@ int sdhci_resume_host(struct sdhci_host *host)
                         host->ops->enable_dma(host);
         }
 
-        ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
-                          mmc_hostname(host->mmc), host);
-        if (ret)
-                return ret;
+        if (host->irq)
+                enable_irq(host->irq);
 
         sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
         mmiowb();
 
-        ret = mmc_resume_host(host->mmc);
+        if (mmc->card) {
+                ret = mmc_resume_host(host->mmc);
+                /* Enable card interrupt as it is overwritten in sdhci_init */
+                if ((mmc->caps & MMC_CAP_SDIO_IRQ) &&
+                        (mmc->pm_flags & MMC_PM_KEEP_POWER))
+                                if (host->card_int_set)
+                                        mmc->ops->enable_sdio_irq(mmc, true);
+        }
+
         sdhci_enable_card_detection(host);
 
         /* Set the re-tuning expiration flag */
@@ -2440,22 +2550,6 @@ int sdhci_add_host(struct sdhci_host *host)
                 host->max_clk = host->ops->get_max_clock(host);
         }
 
-        host->timeout_clk =
-                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
-        if (host->timeout_clk == 0) {
-                if (host->ops->get_timeout_clock) {
-                        host->timeout_clk = host->ops->get_timeout_clock(host);
-                } else if (!(host->quirks &
-                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
-                        printk(KERN_ERR
-                               "%s: Hardware doesn't specify timeout clock "
-                               "frequency.\n", mmc_hostname(mmc));
-                        return -ENODEV;
-                }
-        }
-        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
-                host->timeout_clk *= 1000;
-
         /*
          * In case of Host Controller v3.00, find out whether clock
          * multiplier is supported.
@@ -2488,7 +2582,27 @@ int sdhci_add_host(struct sdhci_host *host)
         } else
                 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
 
-        mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
+        host->timeout_clk =
+                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
+        if (host->timeout_clk == 0) {
+                if (host->ops->get_timeout_clock) {
+                        host->timeout_clk = host->ops->get_timeout_clock(host);
+                } else if (!(host->quirks &
+                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
+                        printk(KERN_ERR
+                               "%s: Hardware doesn't specify timeout clock "
+                               "frequency.\n", mmc_hostname(mmc));
+                        return -ENODEV;
+                }
+        }
+        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
+                host->timeout_clk *= 1000;
+
+        if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
+                host->timeout_clk = mmc->f_max / 1000;
+
+        if (!(host->quirks & SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO))
+                mmc->max_discard_to = (1 << 27) / host->timeout_clk;
 
         if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
                 host->flags |= SDHCI_AUTO_CMD12;
@@ -2517,7 +2631,7 @@ int sdhci_add_host(struct sdhci_host *host)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
         if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
-            mmc_card_is_removable(mmc))
+            mmc_card_is_removable(mmc) && !(host->ops->get_cd))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
         /* UHS-I mode(s) supported by the host controller. */
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 745c42fa41e..c00833de19d 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -270,10 +270,15 @@ struct sdhci_ops {
         void (*platform_send_init_74_clocks)(struct sdhci_host *host,
                                              u8 power_mode);
         unsigned int    (*get_ro)(struct sdhci_host *host);
+        unsigned int    (*get_cd)(struct sdhci_host *host);
         void    (*platform_reset_enter)(struct sdhci_host *host, u8 mask);
         void    (*platform_reset_exit)(struct sdhci_host *host, u8 mask);
         int     (*set_uhs_signaling)(struct sdhci_host *host, unsigned int uhs);
-
+        int     (*suspend)(struct sdhci_host *host, pm_message_t state);
+        int     (*resume)(struct sdhci_host *host);
+        int     (*switch_signal_voltage)(struct sdhci_host *host,
+                                unsigned int signal_voltage);
+        int     (*execute_freq_tuning)(struct sdhci_host *sdhci);
 };
 
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 14f8edbaa19..557886bee9c 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -175,6 +175,7 @@ struct sh_mmcif_host {
         enum mmcif_state state;
         spinlock_t lock;
         bool power;
+        bool card_present;
 
         /* DMA support */
         struct dma_chan         *chan_rx;
@@ -877,23 +878,23 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_unlock_irqrestore(&host->lock, flags);
 
         if (ios->power_mode == MMC_POWER_UP) {
-                if (p->set_pwr)
-                        p->set_pwr(host->pd, ios->power_mode);
-                if (!host->power) {
+                if (!host->card_present) {
                         /* See if we also get DMA */
                         sh_mmcif_request_dma(host, host->pd->dev.platform_data);
-                        pm_runtime_get_sync(&host->pd->dev);
-                        host->power = true;
+                        host->card_present = true;
                 }
         } else if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
                 /* clock stop */
                 sh_mmcif_clock_control(host, 0);
                 if (ios->power_mode == MMC_POWER_OFF) {
-                        if (host->power) {
-                                pm_runtime_put(&host->pd->dev);
+                        if (host->card_present) {
                                 sh_mmcif_release_dma(host);
-                                host->power = false;
+                                host->card_present = false;
                         }
+                }
+                if (host->power) {
+                        pm_runtime_put(&host->pd->dev);
+                        host->power = false;
                         if (p->down_pwr)
                                 p->down_pwr(host->pd);
                 }
@@ -901,8 +902,16 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 return;
         }
 
-        if (ios->clock)
+        if (ios->clock) {
+                if (!host->power) {
+                        if (p->set_pwr)
+                                p->set_pwr(host->pd, ios->power_mode);
+                        pm_runtime_get_sync(&host->pd->dev);
+                        host->power = true;
+                        sh_mmcif_sync_reset(host);
+                }
                 sh_mmcif_clock_control(host, ios->clock);
+        }
 
         host->bus_width = ios->bus_width;
         host->state = STATE_IDLE;
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index ce500f03df8..0c4a672f5db 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -26,6 +26,7 @@
 #include <linux/mmc/sh_mobile_sdhi.h>
 #include <linux/mfd/tmio.h>
 #include <linux/sh_dma.h>
+#include <linux/delay.h>
 
 #include "tmio_mmc.h"
 
@@ -55,6 +56,39 @@ static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
                 return -ENOSYS;
 }
 
+static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host)
+{
+        int timeout = 1000;
+
+        while (--timeout && !(sd_ctrl_read16(host, CTL_STATUS2) & (1 << 13)))
+                udelay(1);
+
+        if (!timeout) {
+                dev_warn(host->pdata->dev, "timeout waiting for SD bus idle\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static int sh_mobile_sdhi_write16_hook(struct tmio_mmc_host *host, int addr)
+{
+        switch (addr)
+        {
+        case CTL_SD_CMD:
+        case CTL_STOP_INTERNAL_ACTION:
+        case CTL_XFER_BLK_COUNT:
+        case CTL_SD_CARD_CLK_CTL:
+        case CTL_SD_XFER_LEN:
+        case CTL_SD_MEM_CARD_OPT:
+        case CTL_TRANSACTION_CTL:
+        case CTL_DMA_ENABLE:
+                return sh_mobile_sdhi_wait_idle(host);
+        }
+
+        return 0;
+}
+
 static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
 {
         struct sh_mobile_sdhi *priv;
@@ -89,6 +123,8 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
         if (p) {
                 mmc_data->flags = p->tmio_flags;
+                if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
+                        mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
 
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 8d185de90d2..44a9668c4b7 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -27,7 +27,6 @@
 static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret;
 
         ret = tmio_mmc_host_suspend(&dev->dev);
@@ -42,7 +41,6 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 static int tmio_mmc_resume(struct platform_device *dev)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret = 0;
 
         /* Tell the MFD core we are ready to be enabled */
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index 8260bc2c34e..eeaf64391fb 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -18,8 +18,10 @@
 
 #include <linux/highmem.h>
 #include <linux/mmc/tmio.h>
+#include <linux/mutex.h>
 #include <linux/pagemap.h>
 #include <linux/spinlock.h>
+#include <linux/scatterlist.h>
 
 /* Definitions for values the CTRL_SDIO_STATUS register can take. */
 #define TMIO_SDIO_STAT_IOIRQ    0x0001
@@ -52,6 +54,8 @@ struct tmio_mmc_host {
         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;
@@ -73,8 +77,11 @@ struct tmio_mmc_host {
 
         /* Track lost interrupts */
         struct delayed_work     delayed_reset_work;
-        spinlock_t              lock;
+        struct work_struct      done;
+
+        spinlock_t              lock;           /* protect host private data */
         unsigned long           last_req_ts;
+        struct mutex            ios_lock;       /* protect set_ios() context */
 };
 
 int tmio_mmc_host_probe(struct tmio_mmc_host **host,
@@ -103,6 +110,7 @@ static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg,
 
 #if defined(CONFIG_MMC_SDHI) || defined(CONFIG_MMC_SDHI_MODULE)
 void tmio_mmc_start_dma(struct tmio_mmc_host *host, struct mmc_data *data);
+void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable);
 void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata);
 void tmio_mmc_release_dma(struct tmio_mmc_host *host);
 #else
@@ -111,6 +119,10 @@ static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,
 {
 }
 
+static inline void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
+{
+}
+
 static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
                                  struct tmio_mmc_data *pdata)
 {
@@ -134,4 +146,44 @@ int tmio_mmc_host_resume(struct device *dev);
 int tmio_mmc_host_runtime_suspend(struct device *dev);
 int tmio_mmc_host_runtime_resume(struct device *dev);
 
+static inline u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
+{
+        return readw(host->ctl + (addr << host->bus_shift));
+}
+
+static inline void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
+                u16 *buf, int count)
+{
+        readsw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static inline u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
+{
+        return readw(host->ctl + (addr << host->bus_shift)) |
+               readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
+}
+
+static inline void sd_ctrl_write16(struct tmio_mmc_host *host, int addr, u16 val)
+{
+        /* If there is a hook and it returns non-zero then there
+         * is an error and the write should be skipped
+         */
+        if (host->pdata->write16_hook && host->pdata->write16_hook(host, addr))
+                return;
+        writew(val, host->ctl + (addr << host->bus_shift));
+}
+
+static inline void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
+                u16 *buf, int count)
+{
+        writesw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static inline void sd_ctrl_write32(struct tmio_mmc_host *host, int addr, u32 val)
+{
+        writew(val, host->ctl + (addr << host->bus_shift));
+        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
+}
+
+
 #endif
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
index 25f1ad6cbe0..86f259cdfcb 100644
--- a/drivers/mmc/host/tmio_mmc_dma.c
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/device.h>
+#include <linux/dma-mapping.h>
 #include <linux/dmaengine.h>
 #include <linux/mfd/tmio.h>
 #include <linux/mmc/host.h>
@@ -22,11 +23,14 @@
 
 #define TMIO_MMC_MIN_DMA_LEN 8
 
-static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
+void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
 {
+        if (!host->chan_tx || !host->chan_rx)
+                return;
+
 #if defined(CONFIG_SUPERH) || defined(CONFIG_ARCH_SHMOBILE)
         /* Switch DMA mode on or off - SuperH specific? */
-        writew(enable ? 2 : 0, host->ctl + (0xd8 << host->bus_shift));
+        sd_ctrl_write16(host, CTL_DMA_ENABLE, enable ? 2 : 0);
 #endif
 }
 
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 0b09e8239aa..1f16357e730 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -46,40 +46,6 @@
 
 #include "tmio_mmc.h"
 
-static u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift));
-}
-
-static void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        readsw(host->ctl + (addr << host->bus_shift), buf, count);
-}
-
-static u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift)) |
-               readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
-}
-
-static void sd_ctrl_write16(struct tmio_mmc_host *host, int addr, u16 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-}
-
-static void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        writesw(host->ctl + (addr << host->bus_shift), buf, count);
-}
-
-static void sd_ctrl_write32(struct tmio_mmc_host *host, int addr, u32 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
-}
-
 void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
 {
         u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) & ~(i & TMIO_MASK_IRQ);
@@ -284,10 +250,16 @@ static void tmio_mmc_reset_work(struct work_struct *work)
 /* called with host->lock held, interrupts disabled */
 static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
 {
-        struct mmc_request *mrq = host->mrq;
+        struct mmc_request *mrq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
 
-        if (!mrq)
+        mrq = host->mrq;
+        if (IS_ERR_OR_NULL(mrq)) {
+                spin_unlock_irqrestore(&host->lock, flags);
                 return;
+        }
 
         host->cmd = NULL;
         host->data = NULL;
@@ -296,11 +268,18 @@ static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
         cancel_delayed_work(&host->delayed_reset_work);
 
         host->mrq = NULL;
+        spin_unlock_irqrestore(&host->lock, flags);
 
-        /* FIXME: mmc_request_done() can schedule! */
         mmc_request_done(host->mmc, mrq);
 }
 
+static void tmio_mmc_done_work(struct work_struct *work)
+{
+        struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
+                                                  done);
+        tmio_mmc_finish_request(host);
+}
+
 /* These are the bitmasks the tmio chip requires to implement the MMC response
  * types. Note that R1 and R6 are the same in this scheme. */
 #define APP_CMD        0x0040
@@ -467,7 +446,7 @@ void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
                         BUG();
         }
 
-        tmio_mmc_finish_request(host);
+        schedule_work(&host->done);
 }
 
 static void tmio_mmc_data_irq(struct tmio_mmc_host *host)
@@ -557,7 +536,7 @@ static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
                                 tasklet_schedule(&host->dma_issue);
                 }
         } else {
-                tmio_mmc_finish_request(host);
+                schedule_work(&host->done);
         }
 
 out:
@@ -567,6 +546,7 @@ out:
 irqreturn_t tmio_mmc_irq(int irq, void *devid)
 {
         struct tmio_mmc_host *host = devid;
+        struct mmc_host *mmc = host->mmc;
         struct tmio_mmc_data *pdata = host->pdata;
         unsigned int ireg, irq_mask, status;
         unsigned int sdio_ireg, sdio_irq_mask, sdio_status;
@@ -588,13 +568,13 @@ irqreturn_t tmio_mmc_irq(int irq, void *devid)
                 if (sdio_ireg && !host->sdio_irq_enabled) {
                         pr_warning("tmio_mmc: Spurious SDIO IRQ, disabling! 0x%04x 0x%04x 0x%04x\n",
                                    sdio_status, sdio_irq_mask, sdio_ireg);
-                        tmio_mmc_enable_sdio_irq(host->mmc, 0);
+                        tmio_mmc_enable_sdio_irq(mmc, 0);
                         goto out;
                 }
 
-                if (host->mmc->caps & MMC_CAP_SDIO_IRQ &&
+                if (mmc->caps & MMC_CAP_SDIO_IRQ &&
                         sdio_ireg & TMIO_SDIO_STAT_IOIRQ)
-                        mmc_signal_sdio_irq(host->mmc);
+                        mmc_signal_sdio_irq(mmc);
 
                 if (sdio_ireg)
                         goto out;
@@ -603,58 +583,49 @@ irqreturn_t tmio_mmc_irq(int irq, void *devid)
         pr_debug_status(status);
         pr_debug_status(ireg);
 
-        if (!ireg) {
-                tmio_mmc_disable_mmc_irqs(host, status & ~irq_mask);
-
-                pr_warning("tmio_mmc: Spurious irq, disabling! "
-                        "0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
-                pr_debug_status(status);
-
+        /* Card insert / remove attempts */
+        if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
+                tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
+                        TMIO_STAT_CARD_REMOVE);
+                if ((((ireg & TMIO_STAT_CARD_REMOVE) && mmc->card) ||
+                     ((ireg & TMIO_STAT_CARD_INSERT) && !mmc->card)) &&
+                    !work_pending(&mmc->detect.work))
+                        mmc_detect_change(host->mmc, msecs_to_jiffies(100));
                 goto out;
         }
 
-        while (ireg) {
-                /* Card insert / remove attempts */
-                if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
-                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
-                                TMIO_STAT_CARD_REMOVE);
-                        mmc_detect_change(host->mmc, msecs_to_jiffies(100));
-                }
-
-                /* CRC and other errors */
-/*              if (ireg & TMIO_STAT_ERR_IRQ)
- *                      handled |= tmio_error_irq(host, irq, stat);
+        /* CRC and other errors */
+/*      if (ireg & TMIO_STAT_ERR_IRQ)
+ *              handled |= tmio_error_irq(host, irq, stat);
  */
 
-                /* Command completion */
-                if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
-                        tmio_mmc_ack_mmc_irqs(host,
-                                     TMIO_STAT_CMDRESPEND |
-                                     TMIO_STAT_CMDTIMEOUT);
-                        tmio_mmc_cmd_irq(host, status);
-                }
-
-                /* Data transfer */
-                if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
-                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
-                        tmio_mmc_pio_irq(host);
-                }
-
-                /* Data transfer completion */
-                if (ireg & TMIO_STAT_DATAEND) {
-                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_DATAEND);
-                        tmio_mmc_data_irq(host);
-                }
+        /* Command completion */
+        if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
+                tmio_mmc_ack_mmc_irqs(host,
+                             TMIO_STAT_CMDRESPEND |
+                             TMIO_STAT_CMDTIMEOUT);
+                tmio_mmc_cmd_irq(host, status);
+                goto out;
+        }
 
-                /* Check status - keep going until we've handled it all */
-                status = sd_ctrl_read32(host, CTL_STATUS);
-                irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
-                ireg = status & TMIO_MASK_IRQ & ~irq_mask;
+        /* Data transfer */
+        if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
+                tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
+                tmio_mmc_pio_irq(host);
+                goto out;
+        }
 
-                pr_debug("Status at end of loop: %08x\n", status);
-                pr_debug_status(status);
+        /* Data transfer completion */
+        if (ireg & TMIO_STAT_DATAEND) {
+                tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_DATAEND);
+                tmio_mmc_data_irq(host);
+                goto out;
         }
-        pr_debug("MMC IRQ end\n");
+
+        pr_warning("tmio_mmc: Spurious irq, disabling! "
+                "0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
+        pr_debug_status(status);
+        tmio_mmc_disable_mmc_irqs(host, status & ~irq_mask);
 
 out:
         return IRQ_HANDLED;
@@ -749,6 +720,8 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         struct tmio_mmc_data *pdata = host->pdata;
         unsigned long flags;
 
+        mutex_lock(&host->ios_lock);
+
         spin_lock_irqsave(&host->lock, flags);
         if (host->mrq) {
                 if (IS_ERR(host->mrq)) {
@@ -764,6 +737,8 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                                 host->mrq->cmd->opcode, host->last_req_ts, jiffies);
                 }
                 spin_unlock_irqrestore(&host->lock, flags);
+
+                mutex_unlock(&host->ios_lock);
                 return;
         }
 
@@ -771,33 +746,30 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         spin_unlock_irqrestore(&host->lock, flags);
 
-        if (ios->clock)
-                tmio_mmc_set_clock(host, ios->clock);
-
-        /* Power sequence - OFF -> UP -> ON */
-        if (ios->power_mode == MMC_POWER_UP) {
-                if ((pdata->flags & TMIO_MMC_HAS_COLD_CD) && !pdata->power) {
+        /*
+         * pdata->power == false only if COLD_CD is available, otherwise only
+         * in short time intervals during probing or resuming
+         */
+        if (ios->power_mode == MMC_POWER_ON && ios->clock) {
+                if (!pdata->power) {
                         pm_runtime_get_sync(&host->pdev->dev);
                         pdata->power = true;
                 }
+                tmio_mmc_set_clock(host, ios->clock);
                 /* power up SD bus */
                 if (host->set_pwr)
                         host->set_pwr(host->pdev, 1);
-        } else if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
-                /* power down SD bus */
-                if (ios->power_mode == MMC_POWER_OFF) {
-                        if (host->set_pwr)
-                                host->set_pwr(host->pdev, 0);
-                        if ((pdata->flags & TMIO_MMC_HAS_COLD_CD) &&
-                            pdata->power) {
-                                pdata->power = false;
-                                pm_runtime_put(&host->pdev->dev);
-                        }
-                }
-                tmio_mmc_clk_stop(host);
-        } else {
                 /* start bus clock */
                 tmio_mmc_clk_start(host);
+        } else if (ios->power_mode != MMC_POWER_UP) {
+                if (host->set_pwr)
+                        host->set_pwr(host->pdev, 0);
+                if ((pdata->flags & TMIO_MMC_HAS_COLD_CD) &&
+                    pdata->power) {
+                        pdata->power = false;
+                        pm_runtime_put(&host->pdev->dev);
+                }
+                tmio_mmc_clk_stop(host);
         }
 
         switch (ios->bus_width) {
@@ -817,6 +789,8 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         current->comm, task_pid_nr(current),
                         ios->clock, ios->power_mode);
         host->mrq = NULL;
+
+        mutex_unlock(&host->ios_lock);
 }
 
 static int tmio_mmc_get_ro(struct mmc_host *mmc)
@@ -913,16 +887,20 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
                 tmio_mmc_enable_sdio_irq(mmc, 0);
 
         spin_lock_init(&_host->lock);
+        mutex_init(&_host->ios_lock);
 
         /* Init delayed work for request timeouts */
         INIT_DELAYED_WORK(&_host->delayed_reset_work, tmio_mmc_reset_work);
+        INIT_WORK(&_host->done, tmio_mmc_done_work);
 
         /* See if we also get DMA */
         tmio_mmc_request_dma(_host, pdata);
 
         /* We have to keep the device powered for its card detection to work */
-        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD))
+        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD)) {
+                pdata->power = true;
                 pm_runtime_get_noresume(&pdev->dev);
+        }
 
         mmc_add_host(mmc);
 
@@ -963,6 +941,7 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
                 pm_runtime_get_sync(&pdev->dev);
 
         mmc_remove_host(host->mmc);
+        cancel_work_sync(&host->done);
         cancel_delayed_work_sync(&host->delayed_reset_work);
         tmio_mmc_release_dma(host);
 
@@ -998,11 +977,16 @@ int tmio_mmc_host_resume(struct device *dev)
         /* 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);
 
-        tmio_mmc_reset(mmc_priv(mmc));
-        tmio_mmc_request_dma(host, host->pdata);
+        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;
+        }
 
         return mmc_resume_host(mmc);
 }
@@ -1023,12 +1007,15 @@ int tmio_mmc_host_runtime_resume(struct device *dev)
         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 */
-                tmio_mmc_set_ios(mmc, &mmc->ios);
+                if (!mmc->card)
+                        tmio_mmc_set_ios(mmc, &mmc->ios);
                 mmc_detect_change(mmc, msecs_to_jiffies(100));
         }
+        host->pm_global = false;
 
         return 0;
 }
diff --git a/drivers/mmc/host/vub300.c b/drivers/mmc/host/vub300.c
index d4455ffbefd..2ec978bc32b 100644
--- a/drivers/mmc/host/vub300.c
+++ b/drivers/mmc/host/vub300.c
@@ -259,7 +259,7 @@ static int firmware_rom_wait_states = 0x04;
 static int firmware_rom_wait_states = 0x1C;
 #endif
 
-module_param(firmware_rom_wait_states, bool, 0644);
+module_param(firmware_rom_wait_states, int, 0644);
 MODULE_PARM_DESC(firmware_rom_wait_states,
                  "ROM wait states byte=RRRIIEEE (Reserved Internal External)");
 
@@ -1625,8 +1625,8 @@ static void __vub300_command_response(struct vub300_mmc_host *vub300,
                 cmd->error = respretval;
         } else if (cmd->error) {
                 /*
-                 * the error occured sending the command
-                 * or recieving the response
+                 * the error occurred sending the command
+                 * or receiving the response
                  */
         } else if (vub300->command_out_urb->status) {
                 vub300->usb_transport_fail = vub300->command_out_urb->status;