80 files changed, 15293 insertions, 2603 deletions

diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index 9979f5e9765b..12eef393e216 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -2,9 +2,7 @@
 # Makefile for the kernel mmc device drivers.
 #
 
-ifeq ($(CONFIG_MMC_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
+subdir-ccflags-$(CONFIG_MMC_DEBUG) := -DDEBUG
 
 obj-$(CONFIG_MMC)               += core/
 obj-$(CONFIG_MMC)               += card/
diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
index 3f2a912659af..3b1f783bf924 100644
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -14,6 +14,24 @@ config MMC_BLOCK
           mount the filesystem. Almost everyone wishing MMC support
           should say Y or M here.
 
+config MMC_BLOCK_MINORS
+        int "Number of minors per block device"
+        depends on MMC_BLOCK
+        range 4 256
+        default 8
+        help
+          Number of minors per block device. One is needed for every
+          partition on the disk (plus one for the whole disk).
+
+          Number of total MMC minors available is 256, so your number
+          of supported block devices will be limited to 256 divided
+          by this number.
+
+          Default is 8 to be backwards compatible with previous
+          hardwired device numbering.
+
+          If unsure, say 8 here.
+
 config MMC_BLOCK_BOUNCE
         bool "Use bounce buffer for simple hosts"
         depends on MMC_BLOCK
@@ -40,12 +58,11 @@ config SDIO_UART
 
 config MMC_TEST
         tristate "MMC host test driver"
-        default n
         help
           Development driver that performs a series of reads and writes
           to a memory card in order to expose certain well known bugs
           in host controllers. The tests are executed by writing to the
-          "test" file in sysfs under each card. Note that whatever is
+          "test" file in debugfs under each card. Note that whatever is
           on your card will be overwritten by these tests.
 
           This driver is only of interest to those developing or
diff --git a/drivers/mmc/card/Makefile b/drivers/mmc/card/Makefile
index 0d407514f67d..c73b406a06cd 100644
--- a/drivers/mmc/card/Makefile
+++ b/drivers/mmc/card/Makefile
@@ -2,10 +2,6 @@
 # Makefile for MMC/SD card drivers
 #
 
-ifeq ($(CONFIG_MMC_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
-
 obj-$(CONFIG_MMC_BLOCK)         += mmc_block.o
 mmc_block-objs                  := block.o queue.o
 obj-$(CONFIG_MMC_TEST)          += mmc_test.o
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index d545f79f6000..f85e42224559 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -29,10 +29,13 @@
 #include <linux/kdev_t.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 #include <linux/scatterlist.h>
 #include <linux/string_helpers.h>
+#include <linux/delay.h>
+#include <linux/capability.h>
+#include <linux/compat.h>
 
+#include <linux/mmc/ioctl.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -44,14 +47,35 @@
 #include "queue.h"
 
 MODULE_ALIAS("mmc:block");
+#ifdef MODULE_PARAM_PREFIX
+#undef MODULE_PARAM_PREFIX
+#endif
+#define MODULE_PARAM_PREFIX "mmcblk."
+
+#define INAND_CMD38_ARG_EXT_CSD  113
+#define INAND_CMD38_ARG_ERASE    0x00
+#define INAND_CMD38_ARG_TRIM     0x01
+#define INAND_CMD38_ARG_SECERASE 0x80
+#define INAND_CMD38_ARG_SECTRIM1 0x81
+#define INAND_CMD38_ARG_SECTRIM2 0x88
+
+static DEFINE_MUTEX(block_mutex);
+
+/*
+ * The defaults come from config options but can be overriden by module
+ * or bootarg options.
+ */
+static int perdev_minors = CONFIG_MMC_BLOCK_MINORS;
 
 /*
- * max 8 partitions per card
+ * We've only got one major, so number of mmcblk devices is
+ * limited to 256 / number of minors per device.
  */
-#define MMC_SHIFT       3
-#define MMC_NUM_MINORS  (256 >> MMC_SHIFT)
+static int max_devices;
 
-static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS);
+/* 256 minors, so at most 256 separate devices */
+static DECLARE_BITMAP(dev_use, 256);
+static DECLARE_BITMAP(name_use, 256);
 
 /*
  * There is one mmc_blk_data per slot.
@@ -60,13 +84,31 @@ struct mmc_blk_data {
         spinlock_t      lock;
         struct gendisk  *disk;
         struct mmc_queue queue;
+        struct list_head part;
+
+        unsigned int    flags;
+#define MMC_BLK_CMD23   (1 << 0)        /* Can do SET_BLOCK_COUNT for multiblock */
+#define MMC_BLK_REL_WR  (1 << 1)        /* MMC Reliable write support */
 
         unsigned int    usage;
         unsigned int    read_only;
+        unsigned int    part_type;
+        unsigned int    name_idx;
+
+        /*
+         * Only set in main mmc_blk_data associated
+         * with mmc_card with mmc_set_drvdata, and keeps
+         * track of the current selected device partition.
+         */
+        unsigned int    part_curr;
+        struct device_attribute force_ro;
 };
 
 static DEFINE_MUTEX(open_lock);
 
+module_param(perdev_minors, int, 0444);
+MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device");
+
 static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
 {
         struct mmc_blk_data *md;
@@ -82,17 +124,22 @@ static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
         return md;
 }
 
+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;
+        return devidx;
+}
+
 static void mmc_blk_put(struct mmc_blk_data *md)
 {
         mutex_lock(&open_lock);
         md->usage--;
         if (md->usage == 0) {
-                int devmaj = MAJOR(disk_devt(md->disk));
-                int devidx = MINOR(disk_devt(md->disk)) >> MMC_SHIFT;
-
-                if (!devmaj)
-                        devidx = md->disk->first_minor >> MMC_SHIFT;
-
+                int devidx = mmc_get_devidx(md->disk);
                 blk_cleanup_queue(md->queue.queue);
 
                 __clear_bit(devidx, dev_use);
@@ -103,12 +150,44 @@ static void mmc_blk_put(struct mmc_blk_data *md)
         mutex_unlock(&open_lock);
 }
 
+static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        int ret;
+        struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
+
+        ret = snprintf(buf, PAGE_SIZE, "%d",
+                       get_disk_ro(dev_to_disk(dev)) ^
+                       md->read_only);
+        mmc_blk_put(md);
+        return ret;
+}
+
+static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        int ret;
+        char *end;
+        struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
+        unsigned long set = simple_strtoul(buf, &end, 0);
+        if (end == buf) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        set_disk_ro(dev_to_disk(dev), set || md->read_only);
+        ret = count;
+out:
+        mmc_blk_put(md);
+        return ret;
+}
+
 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
 {
         struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
         int ret = -ENXIO;
 
-        lock_kernel();
+        mutex_lock(&block_mutex);
         if (md) {
                 if (md->usage == 2)
                         check_disk_change(bdev);
@@ -119,7 +198,7 @@ static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
                         ret = -EROFS;
                 }
         }
-        unlock_kernel();
+        mutex_unlock(&block_mutex);
 
         return ret;
 }
@@ -128,9 +207,9 @@ static int mmc_blk_release(struct gendisk *disk, fmode_t mode)
 {
         struct mmc_blk_data *md = disk->private_data;
 
-        lock_kernel();
+        mutex_lock(&block_mutex);
         mmc_blk_put(md);
-        unlock_kernel();
+        mutex_unlock(&block_mutex);
         return 0;
 }
 
@@ -143,35 +222,255 @@ mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
+struct mmc_blk_ioc_data {
+        struct mmc_ioc_cmd ic;
+        unsigned char *buf;
+        u64 buf_bytes;
+};
+
+static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user(
+        struct mmc_ioc_cmd __user *user)
+{
+        struct mmc_blk_ioc_data *idata;
+        int err;
+
+        idata = kzalloc(sizeof(*idata), GFP_KERNEL);
+        if (!idata) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        if (copy_from_user(&idata->ic, user, sizeof(idata->ic))) {
+                err = -EFAULT;
+                goto idata_err;
+        }
+
+        idata->buf_bytes = (u64) idata->ic.blksz * idata->ic.blocks;
+        if (idata->buf_bytes > MMC_IOC_MAX_BYTES) {
+                err = -EOVERFLOW;
+                goto idata_err;
+        }
+
+        idata->buf = kzalloc(idata->buf_bytes, GFP_KERNEL);
+        if (!idata->buf) {
+                err = -ENOMEM;
+                goto idata_err;
+        }
+
+        if (copy_from_user(idata->buf, (void __user *)(unsigned long)
+                                        idata->ic.data_ptr, idata->buf_bytes)) {
+                err = -EFAULT;
+                goto copy_err;
+        }
+
+        return idata;
+
+copy_err:
+        kfree(idata->buf);
+idata_err:
+        kfree(idata);
+out:
+        return ERR_PTR(err);
+}
+
+static int mmc_blk_ioctl_cmd(struct block_device *bdev,
+        struct mmc_ioc_cmd __user *ic_ptr)
+{
+        struct mmc_blk_ioc_data *idata;
+        struct mmc_blk_data *md;
+        struct mmc_card *card;
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
+        struct mmc_request mrq = {0};
+        struct scatterlist sg;
+        int err;
+
+        /*
+         * The caller must have CAP_SYS_RAWIO, and must be calling this on the
+         * whole block device, not on a partition.  This prevents overspray
+         * between sibling partitions.
+         */
+        if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains))
+                return -EPERM;
+
+        idata = mmc_blk_ioctl_copy_from_user(ic_ptr);
+        if (IS_ERR(idata))
+                return PTR_ERR(idata);
+
+        cmd.opcode = idata->ic.opcode;
+        cmd.arg = idata->ic.arg;
+        cmd.flags = idata->ic.flags;
+
+        data.sg = &sg;
+        data.sg_len = 1;
+        data.blksz = idata->ic.blksz;
+        data.blocks = idata->ic.blocks;
+
+        sg_init_one(data.sg, idata->buf, idata->buf_bytes);
+
+        if (idata->ic.write_flag)
+                data.flags = MMC_DATA_WRITE;
+        else
+                data.flags = MMC_DATA_READ;
+
+        mrq.cmd = &cmd;
+        mrq.data = &data;
+
+        md = mmc_blk_get(bdev->bd_disk);
+        if (!md) {
+                err = -EINVAL;
+                goto cmd_done;
+        }
+
+        card = md->queue.card;
+        if (IS_ERR(card)) {
+                err = PTR_ERR(card);
+                goto cmd_done;
+        }
+
+        mmc_claim_host(card->host);
+
+        if (idata->ic.is_acmd) {
+                err = mmc_app_cmd(card->host, card);
+                if (err)
+                        goto cmd_rel_host;
+        }
+
+        /* data.flags must already be set before doing this. */
+        mmc_set_data_timeout(&data, card);
+        /* Allow overriding the timeout_ns for empirical tuning. */
+        if (idata->ic.data_timeout_ns)
+                data.timeout_ns = idata->ic.data_timeout_ns;
+
+        if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) {
+                /*
+                 * Pretend this is a data transfer and rely on the host driver
+                 * to compute timeout.  When all host drivers support
+                 * cmd.cmd_timeout for R1B, this can be changed to:
+                 *
+                 *     mrq.data = NULL;
+                 *     cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
+                 */
+                data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000;
+        }
+
+        mmc_wait_for_req(card->host, &mrq);
+
+        if (cmd.error) {
+                dev_err(mmc_dev(card->host), "%s: cmd error %d\n",
+                                                __func__, cmd.error);
+                err = cmd.error;
+                goto cmd_rel_host;
+        }
+        if (data.error) {
+                dev_err(mmc_dev(card->host), "%s: data error %d\n",
+                                                __func__, data.error);
+                err = data.error;
+                goto cmd_rel_host;
+        }
+
+        /*
+         * According to the SD specs, some commands require a delay after
+         * issuing the command.
+         */
+        if (idata->ic.postsleep_min_us)
+                usleep_range(idata->ic.postsleep_min_us, idata->ic.postsleep_max_us);
+
+        if (copy_to_user(&(ic_ptr->response), cmd.resp, sizeof(cmd.resp))) {
+                err = -EFAULT;
+                goto cmd_rel_host;
+        }
+
+        if (!idata->ic.write_flag) {
+                if (copy_to_user((void __user *)(unsigned long) idata->ic.data_ptr,
+                                                idata->buf, idata->buf_bytes)) {
+                        err = -EFAULT;
+                        goto cmd_rel_host;
+                }
+        }
+
+cmd_rel_host:
+        mmc_release_host(card->host);
+
+cmd_done:
+        mmc_blk_put(md);
+        kfree(idata->buf);
+        kfree(idata);
+        return err;
+}
+
+static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode,
+        unsigned int cmd, unsigned long arg)
+{
+        int ret = -EINVAL;
+        if (cmd == MMC_IOC_CMD)
+                ret = mmc_blk_ioctl_cmd(bdev, (struct mmc_ioc_cmd __user *)arg);
+        return ret;
+}
+
+#ifdef CONFIG_COMPAT
+static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode,
+        unsigned int cmd, unsigned long arg)
+{
+        return mmc_blk_ioctl(bdev, mode, cmd, (unsigned long) compat_ptr(arg));
+}
+#endif
+
 static const struct block_device_operations mmc_bdops = {
         .open                   = mmc_blk_open,
         .release                = mmc_blk_release,
         .getgeo                 = mmc_blk_getgeo,
         .owner                  = THIS_MODULE,
+        .ioctl                  = mmc_blk_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl           = mmc_blk_compat_ioctl,
+#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)
+{
+        int ret;
+        struct mmc_blk_data *main_md = mmc_get_drvdata(card);
+        if (main_md->part_curr == md->part_type)
+                return 0;
+
+        if (mmc_card_mmc(card)) {
+                card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
+                card->ext_csd.part_config |= md->part_type;
+
+                ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_PART_CONFIG, card->ext_csd.part_config,
+                                 card->ext_csd.part_time);
+                if (ret)
+                        return ret;
+}
+
+        main_md->part_curr = md->part_type;
+        return 0;
+}
+
 static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
 {
         int err;
         u32 result;
         __be32 *blocks;
 
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         unsigned int timeout_us;
 
         struct scatterlist sg;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_APP_CMD;
         cmd.arg = card->rca << 16;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
@@ -188,8 +487,6 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         cmd.arg = 0;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 
-        memset(&data, 0, sizeof(struct mmc_data));
-
         data.timeout_ns = card->csd.tacc_ns * 100;
         data.timeout_clks = card->csd.tacc_clks * 100;
 
@@ -208,8 +505,6 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         data.sg = &sg;
         data.sg_len = 1;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
@@ -232,17 +527,16 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
 
 static u32 get_card_status(struct mmc_card *card, struct request *req)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
         cmd.opcode = MMC_SEND_STATUS;
         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);
         if (err)
-                printk(KERN_ERR "%s: error %d sending status comand",
+                printk(KERN_ERR "%s: error %d sending status command",
                        req->rq_disk->disk_name, err);
         return cmd.resp[0];
 }
@@ -254,8 +548,6 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
         unsigned int from, nr, arg;
         int err = 0;
 
-        mmc_claim_host(card->host);
-
         if (!mmc_can_erase(card)) {
                 err = -EOPNOTSUPP;
                 goto out;
@@ -269,14 +561,22 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
         else
                 arg = MMC_ERASE_ARG;
 
+        if (card->quirks & MMC_QUIRK_INAND_CMD38) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 INAND_CMD38_ARG_EXT_CSD,
+                                 arg == MMC_TRIM_ARG ?
+                                 INAND_CMD38_ARG_TRIM :
+                                 INAND_CMD38_ARG_ERASE,
+                                 0);
+                if (err)
+                        goto out;
+        }
         err = mmc_erase(card, from, nr, arg);
 out:
         spin_lock_irq(&md->lock);
         __blk_end_request(req, err, blk_rq_bytes(req));
         spin_unlock_irq(&md->lock);
 
-        mmc_release_host(card->host);
-
         return err ? 0 : 1;
 }
 
@@ -288,8 +588,6 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
         unsigned int from, nr, arg;
         int err = 0;
 
-        mmc_claim_host(card->host);
-
         if (!mmc_can_secure_erase_trim(card)) {
                 err = -EOPNOTSUPP;
                 goto out;
@@ -303,19 +601,74 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
         else
                 arg = MMC_SECURE_ERASE_ARG;
 
+        if (card->quirks & MMC_QUIRK_INAND_CMD38) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 INAND_CMD38_ARG_EXT_CSD,
+                                 arg == MMC_SECURE_TRIM1_ARG ?
+                                 INAND_CMD38_ARG_SECTRIM1 :
+                                 INAND_CMD38_ARG_SECERASE,
+                                 0);
+                if (err)
+                        goto out;
+        }
         err = mmc_erase(card, from, nr, arg);
-        if (!err && arg == MMC_SECURE_TRIM1_ARG)
+        if (!err && arg == MMC_SECURE_TRIM1_ARG) {
+                if (card->quirks & MMC_QUIRK_INAND_CMD38) {
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         INAND_CMD38_ARG_EXT_CSD,
+                                         INAND_CMD38_ARG_SECTRIM2,
+                                         0);
+                        if (err)
+                                goto out;
+                }
                 err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
+        }
 out:
         spin_lock_irq(&md->lock);
         __blk_end_request(req, err, blk_rq_bytes(req));
         spin_unlock_irq(&md->lock);
 
-        mmc_release_host(card->host);
-
         return err ? 0 : 1;
 }
 
+static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req)
+{
+        struct mmc_blk_data *md = mq->data;
+
+        /*
+         * No-op, only service this because we need REQ_FUA for reliable
+         * writes.
+         */
+        spin_lock_irq(&md->lock);
+        __blk_end_request_all(req, 0);
+        spin_unlock_irq(&md->lock);
+
+        return 1;
+}
+
+/*
+ * Reformat current write as a reliable write, supporting
+ * both legacy and the enhanced reliable write MMC cards.
+ * In each transfer we'll handle only as much as a single
+ * reliable write can handle, thus finish the request in
+ * partial completions.
+ */
+static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq,
+                                    struct mmc_card *card,
+                                    struct request *req)
+{
+        if (!(card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN)) {
+                /* Legacy mode imposes restrictions on transfers. */
+                if (!IS_ALIGNED(brq->cmd.arg, card->ext_csd.rel_sectors))
+                        brq->data.blocks = 1;
+
+                if (brq->data.blocks > card->ext_csd.rel_sectors)
+                        brq->data.blocks = card->ext_csd.rel_sectors;
+                else if (brq->data.blocks < card->ext_csd.rel_sectors)
+                        brq->data.blocks = 1;
+        }
+}
+
 static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
 {
         struct mmc_blk_data *md = mq->data;
@@ -323,10 +676,17 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
         struct mmc_blk_request brq;
         int ret = 1, disable_multi = 0;
 
-        mmc_claim_host(card->host);
+        /*
+         * Reliable writes are used to implement Forced Unit Access and
+         * REQ_META accesses, and are supported only on MMCs.
+         */
+        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);
 
         do {
-                struct mmc_command cmd;
+                struct mmc_command cmd = {0};
                 u32 readcmd, writecmd, status = 0;
 
                 memset(&brq, 0, sizeof(struct mmc_blk_request));
@@ -359,12 +719,12 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                 if (disable_multi && brq.data.blocks > 1)
                         brq.data.blocks = 1;
 
-                if (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 (!mmc_host_is_spi(card->host)
-                                        || rq_data_dir(req) == READ)
+                        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;
@@ -373,7 +733,6 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                         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;
@@ -382,6 +741,38 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                         brq.data.flags |= MMC_DATA_WRITE;
                 }
 
+                if (do_rel_wr)
+                        mmc_apply_rel_rw(&brq, card, req);
+
+                /*
+                 * 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.
+                 */
+
+                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;
+                }
+
                 mmc_set_data_timeout(&brq.data, card);
 
                 brq.data.sg = mq->sg;
@@ -417,7 +808,8 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                  * until later as we need to wait for the card to leave
                  * programming mode even when things go wrong.
                  */
-                if (brq.cmd.error || brq.data.error || brq.stop.error) {
+                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 "
@@ -428,6 +820,13 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                         status = get_card_status(card, req);
                 }
 
+                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);
+                }
+
                 if (brq.cmd.error) {
                         printk(KERN_ERR "%s: error %d sending read/write "
                                "command, response %#x, card status %#x\n",
@@ -506,8 +905,6 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                 spin_unlock_irq(&md->lock);
         } while (ret);
 
-        mmc_release_host(card->host);
-
         return 1;
 
  cmd_err:
@@ -534,8 +931,6 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
                 spin_unlock_irq(&md->lock);
         }
 
-        mmc_release_host(card->host);
-
         spin_lock_irq(&md->lock);
         while (ret)
                 ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
@@ -546,14 +941,31 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
 
 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);
+        ret = mmc_blk_part_switch(card, md);
+        if (ret) {
+                ret = 0;
+                goto out;
+        }
+
         if (req->cmd_flags & REQ_DISCARD) {
                 if (req->cmd_flags & REQ_SECURE)
-                        return mmc_blk_issue_secdiscard_rq(mq, req);
+                        ret = mmc_blk_issue_secdiscard_rq(mq, req);
                 else
-                        return mmc_blk_issue_discard_rq(mq, req);
+                        ret = mmc_blk_issue_discard_rq(mq, req);
+        } else if (req->cmd_flags & REQ_FLUSH) {
+                ret = mmc_blk_issue_flush(mq, req);
         } else {
-                return mmc_blk_issue_rw_rq(mq, req);
+                ret = mmc_blk_issue_rw_rq(mq, req);
         }
+
+out:
+        mmc_release_host(card->host);
+        return ret;
 }
 
 static inline int mmc_blk_readonly(struct mmc_card *card)
@@ -562,13 +974,17 @@ static inline int mmc_blk_readonly(struct mmc_card *card)
                !(card->csd.cmdclass & CCC_BLOCK_WRITE);
 }
 
-static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
+static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
+                                              struct device *parent,
+                                              sector_t size,
+                                              bool default_ro,
+                                              const char *subname)
 {
         struct mmc_blk_data *md;
         int devidx, ret;
 
-        devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
-        if (devidx >= MMC_NUM_MINORS)
+        devidx = find_first_zero_bit(dev_use, max_devices);
+        if (devidx >= max_devices)
                 return ERR_PTR(-ENOSPC);
         __set_bit(devidx, dev_use);
 
@@ -578,6 +994,19 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
                 goto out;
         }
 
+        /*
+         * !subname implies we are creating main mmc_blk_data that will be
+         * associated with mmc_card with mmc_set_drvdata. Due to device
+         * partitions, devidx will not coincide with a per-physical card
+         * index anymore so we keep track of a name index.
+         */
+        if (!subname) {
+                md->name_idx = find_first_zero_bit(name_use, max_devices);
+                __set_bit(md->name_idx, name_use);
+        }
+        else
+                md->name_idx = ((struct mmc_blk_data *)
+                                dev_to_disk(parent)->private_data)->name_idx;
 
         /*
          * Set the read-only status based on the supported commands
@@ -585,16 +1014,17 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
          */
         md->read_only = mmc_blk_readonly(card);
 
-        md->disk = alloc_disk(1 << MMC_SHIFT);
+        md->disk = alloc_disk(perdev_minors);
         if (md->disk == NULL) {
                 ret = -ENOMEM;
                 goto err_kfree;
         }
 
         spin_lock_init(&md->lock);
+        INIT_LIST_HEAD(&md->part);
         md->usage = 1;
 
-        ret = mmc_init_queue(&md->queue, card, &md->lock);
+        ret = mmc_init_queue(&md->queue, card, &md->lock, subname);
         if (ret)
                 goto err_putdisk;
 
@@ -602,11 +1032,12 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
         md->queue.data = md;
 
         md->disk->major = MMC_BLOCK_MAJOR;
-        md->disk->first_minor = devidx << MMC_SHIFT;
+        md->disk->first_minor = devidx * perdev_minors;
         md->disk->fops = &mmc_bdops;
         md->disk->private_data = md;
         md->disk->queue = md->queue.queue;
-        md->disk->driverfs_dev = &card->dev;
+        md->disk->driverfs_dev = parent;
+        set_disk_ro(md->disk, md->read_only || default_ro);
 
         /*
          * As discussed on lkml, GENHD_FL_REMOVABLE should:
@@ -620,65 +1051,204 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
          * messages to tell when the card is present.
          */
 
-        sprintf(md->disk->disk_name, "mmcblk%d", devidx);
+        snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
+                 "mmcblk%d%s", md->name_idx, subname ? subname : "");
 
         blk_queue_logical_block_size(md->queue.queue, 512);
+        set_capacity(md->disk, size);
+
+        if (mmc_host_cmd23(card->host)) {
+                if (mmc_card_mmc(card) ||
+                    (mmc_card_sd(card) &&
+                     card->scr.cmds & SD_SCR_CMD23_SUPPORT))
+                        md->flags |= MMC_BLK_CMD23;
+        }
+
+        if (mmc_card_mmc(card) &&
+            md->flags & MMC_BLK_CMD23 &&
+            ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
+             card->ext_csd.rel_sectors)) {
+                md->flags |= MMC_BLK_REL_WR;
+                blk_queue_flush(md->queue.queue, REQ_FLUSH | REQ_FUA);
+        }
+
+        return md;
+
+ err_putdisk:
+        put_disk(md->disk);
+ err_kfree:
+        kfree(md);
+ out:
+        return ERR_PTR(ret);
+}
+
+static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
+{
+        sector_t size;
+        struct mmc_blk_data *md;
 
         if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
                 /*
                  * The EXT_CSD sector count is in number or 512 byte
                  * sectors.
                  */
-                set_capacity(md->disk, card->ext_csd.sectors);
+                size = card->ext_csd.sectors;
         } else {
                 /*
                  * The CSD capacity field is in units of read_blkbits.
                  * set_capacity takes units of 512 bytes.
                  */
-                set_capacity(md->disk,
-                        card->csd.capacity << (card->csd.read_blkbits - 9));
+                size = card->csd.capacity << (card->csd.read_blkbits - 9);
         }
+
+        md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL);
         return md;
+}
 
- err_putdisk:
-        put_disk(md->disk);
- err_kfree:
-        kfree(md);
- out:
-        return ERR_PTR(ret);
+static int mmc_blk_alloc_part(struct mmc_card *card,
+                              struct mmc_blk_data *md,
+                              unsigned int part_type,
+                              sector_t size,
+                              bool default_ro,
+                              const char *subname)
+{
+        char cap_str[10];
+        struct mmc_blk_data *part_md;
+
+        part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
+                                    subname);
+        if (IS_ERR(part_md))
+                return PTR_ERR(part_md);
+        part_md->part_type = part_type;
+        list_add(&part_md->part, &md->part);
+
+        string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2,
+                        cap_str, sizeof(cap_str));
+        printk(KERN_INFO "%s: %s %s partition %u %s\n",
+               part_md->disk->disk_name, mmc_card_id(card),
+               mmc_card_name(card), part_md->part_type, cap_str);
+        return 0;
+}
+
+static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
+{
+        int ret = 0;
+
+        if (!mmc_card_mmc(card))
+                return 0;
+
+        if (card->ext_csd.boot_size) {
+                ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT0,
+                                         card->ext_csd.boot_size >> 9,
+                                         true,
+                                         "boot0");
+                if (ret)
+                        return ret;
+                ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT1,
+                                         card->ext_csd.boot_size >> 9,
+                                         true,
+                                         "boot1");
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
 }
 
 static int
 mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
 {
-        struct mmc_command cmd;
         int err;
 
-        /* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
-        if (mmc_card_blockaddr(card))
-                return 0;
-
         mmc_claim_host(card->host);
-        cmd.opcode = MMC_SET_BLOCKLEN;
-        cmd.arg = 512;
-        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
-        err = mmc_wait_for_cmd(card->host, &cmd, 5);
+        err = mmc_set_blocklen(card, 512);
         mmc_release_host(card->host);
 
         if (err) {
-                printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
-                        md->disk->disk_name, cmd.arg, err);
+                printk(KERN_ERR "%s: unable to set block size to 512: %d\n",
+                        md->disk->disk_name, err);
                 return -EINVAL;
         }
 
         return 0;
 }
 
+static void mmc_blk_remove_req(struct mmc_blk_data *md)
+{
+        if (md) {
+                if (md->disk->flags & GENHD_FL_UP) {
+                        device_remove_file(disk_to_dev(md->disk), &md->force_ro);
+
+                        /* Stop new requests from getting into the queue */
+                        del_gendisk(md->disk);
+                }
+
+                /* Then flush out any already in there */
+                mmc_cleanup_queue(&md->queue);
+                mmc_blk_put(md);
+        }
+}
+
+static void mmc_blk_remove_parts(struct mmc_card *card,
+                                 struct mmc_blk_data *md)
+{
+        struct list_head *pos, *q;
+        struct mmc_blk_data *part_md;
+
+        __clear_bit(md->name_idx, name_use);
+        list_for_each_safe(pos, q, &md->part) {
+                part_md = list_entry(pos, struct mmc_blk_data, part);
+                list_del(pos);
+                mmc_blk_remove_req(part_md);
+        }
+}
+
+static int mmc_add_disk(struct mmc_blk_data *md)
+{
+        int ret;
+
+        add_disk(md->disk);
+        md->force_ro.show = force_ro_show;
+        md->force_ro.store = force_ro_store;
+        sysfs_attr_init(&md->force_ro.attr);
+        md->force_ro.attr.name = "force_ro";
+        md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
+        ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
+        if (ret)
+                del_gendisk(md->disk);
+
+        return ret;
+}
+
+static const struct mmc_fixup blk_fixups[] =
+{
+        MMC_FIXUP("SEM02G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM04G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM08G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM16G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM32G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+
+        /*
+         * Some MMC cards experience performance degradation with CMD23
+         * instead of CMD12-bounded multiblock transfers. For now we'll
+         * black list what's bad...
+         * - Certain Toshiba cards.
+         *
+         * N.B. This doesn't affect SD cards.
+         */
+        MMC_FIXUP("MMC08G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+                  MMC_QUIRK_BLK_NO_CMD23),
+        MMC_FIXUP("MMC16G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+                  MMC_QUIRK_BLK_NO_CMD23),
+        MMC_FIXUP("MMC32G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+                  MMC_QUIRK_BLK_NO_CMD23),
+        END_FIXUP
+};
+
 static int mmc_blk_probe(struct mmc_card *card)
 {
-        struct mmc_blk_data *md;
+        struct mmc_blk_data *md, *part_md;
         int err;
-
         char cap_str[10];
 
         /*
@@ -701,14 +1271,24 @@ static int mmc_blk_probe(struct mmc_card *card)
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
                 cap_str, md->read_only ? "(ro)" : "");
 
+        if (mmc_blk_alloc_parts(card, md))
+                goto out;
+
         mmc_set_drvdata(card, md);
-        add_disk(md->disk);
+        mmc_fixup_device(card, blk_fixups);
+
+        if (mmc_add_disk(md))
+                goto out;
+
+        list_for_each_entry(part_md, &md->part, part) {
+                if (mmc_add_disk(part_md))
+                        goto out;
+        }
         return 0;
 
  out:
-        mmc_cleanup_queue(&md->queue);
-        mmc_blk_put(md);
-
+        mmc_blk_remove_parts(card, md);
+        mmc_blk_remove_req(md);
         return err;
 }
 
@@ -716,36 +1296,46 @@ static void mmc_blk_remove(struct mmc_card *card)
 {
         struct mmc_blk_data *md = mmc_get_drvdata(card);
 
-        if (md) {
-                /* Stop new requests from getting into the queue */
-                del_gendisk(md->disk);
-
-                /* Then flush out any already in there */
-                mmc_cleanup_queue(&md->queue);
-
-                mmc_blk_put(md);
-        }
+        mmc_blk_remove_parts(card, md);
+        mmc_claim_host(card->host);
+        mmc_blk_part_switch(card, md);
+        mmc_release_host(card->host);
+        mmc_blk_remove_req(md);
         mmc_set_drvdata(card, NULL);
 }
 
 #ifdef CONFIG_PM
 static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
 {
+        struct mmc_blk_data *part_md;
         struct mmc_blk_data *md = mmc_get_drvdata(card);
 
         if (md) {
                 mmc_queue_suspend(&md->queue);
+                list_for_each_entry(part_md, &md->part, part) {
+                        mmc_queue_suspend(&part_md->queue);
+                }
         }
         return 0;
 }
 
 static int mmc_blk_resume(struct mmc_card *card)
 {
+        struct mmc_blk_data *part_md;
         struct mmc_blk_data *md = mmc_get_drvdata(card);
 
         if (md) {
                 mmc_blk_set_blksize(md, card);
+
+                /*
+                 * Resume involves the card going into idle state,
+                 * so current partition is always the main one.
+                 */
+                md->part_curr = md->part_type;
                 mmc_queue_resume(&md->queue);
+                list_for_each_entry(part_md, &md->part, part) {
+                        mmc_queue_resume(&part_md->queue);
+                }
         }
         return 0;
 }
@@ -768,6 +1358,11 @@ static int __init mmc_blk_init(void)
 {
         int res;
 
+        if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
+                pr_info("mmcblk: using %d minors per device\n", perdev_minors);
+
+        max_devices = 256 / perdev_minors;
+
         res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
         if (res)
                 goto out;
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 5dd8576b5c18..233cdfae92f4 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -17,6 +17,11 @@
 
 #include <linux/scatterlist.h>
 #include <linux/swap.h>         /* For nr_free_buffer_pages() */
+#include <linux/list.h>
+
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/seq_file.h>
 
 #define RESULT_OK               0
 #define RESULT_FAIL             1
@@ -56,7 +61,9 @@ struct mmc_test_mem {
  * struct mmc_test_area - information for performance tests.
  * @max_sz: test area size (in bytes)
  * @dev_addr: address on card at which to do performance tests
- * @max_segs: maximum segments in scatterlist @sg
+ * @max_tfr: maximum transfer size allowed by driver (in bytes)
+ * @max_segs: maximum segments allowed by driver in scatterlist @sg
+ * @max_seg_sz: maximum segment size allowed by driver
  * @blocks: number of (512 byte) blocks currently mapped by @sg
  * @sg_len: length of currently mapped scatterlist @sg
  * @mem: allocated memory
@@ -65,7 +72,9 @@ struct mmc_test_mem {
 struct mmc_test_area {
         unsigned long max_sz;
         unsigned int dev_addr;
+        unsigned int max_tfr;
         unsigned int max_segs;
+        unsigned int max_seg_sz;
         unsigned int blocks;
         unsigned int sg_len;
         struct mmc_test_mem *mem;
@@ -73,12 +82,59 @@ struct mmc_test_area {
 };
 
 /**
+ * struct mmc_test_transfer_result - transfer results for performance tests.
+ * @link: double-linked list
+ * @count: amount of group of sectors to check
+ * @sectors: amount of sectors to check in one group
+ * @ts: time values of transfer
+ * @rate: calculated transfer rate
+ * @iops: I/O operations per second (times 100)
+ */
+struct mmc_test_transfer_result {
+        struct list_head link;
+        unsigned int count;
+        unsigned int sectors;
+        struct timespec ts;
+        unsigned int rate;
+        unsigned int iops;
+};
+
+/**
+ * struct mmc_test_general_result - results for tests.
+ * @link: double-linked list
+ * @card: card under test
+ * @testcase: number of test case
+ * @result: result of test run
+ * @tr_lst: transfer measurements if any as mmc_test_transfer_result
+ */
+struct mmc_test_general_result {
+        struct list_head link;
+        struct mmc_card *card;
+        int testcase;
+        int result;
+        struct list_head tr_lst;
+};
+
+/**
+ * struct mmc_test_dbgfs_file - debugfs related file.
+ * @link: double-linked list
+ * @card: card under test
+ * @file: file created under debugfs
+ */
+struct mmc_test_dbgfs_file {
+        struct list_head link;
+        struct mmc_card *card;
+        struct dentry *file;
+};
+
+/**
  * struct mmc_test_card - test information.
  * @card: card under test
  * @scratch: transfer buffer
  * @buffer: transfer buffer
  * @highmem: buffer for highmem tests
  * @area: information for performance tests
+ * @gr: pointer to results of current testcase
  */
 struct mmc_test_card {
         struct mmc_card *card;
@@ -88,7 +144,8 @@ struct mmc_test_card {
 #ifdef CONFIG_HIGHMEM
         struct page     *highmem;
 #endif
-        struct mmc_test_area area;
+        struct mmc_test_area            area;
+        struct mmc_test_general_result  *gr;
 };
 
 /*******************************************************************/
@@ -100,17 +157,7 @@ struct mmc_test_card {
  */
 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
 {
-        struct mmc_command cmd;
-        int ret;
-
-        cmd.opcode = MMC_SET_BLOCKLEN;
-        cmd.arg = size;
-        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-        ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
-        if (ret)
-                return ret;
-
-        return 0;
+        return mmc_set_blocklen(test->card, size);
 }
 
 /*
@@ -165,7 +212,7 @@ static int mmc_test_busy(struct mmc_command *cmd)
 static int mmc_test_wait_busy(struct mmc_test_card *test)
 {
         int ret, busy;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         busy = 0;
         do {
@@ -181,9 +228,10 @@ static int mmc_test_wait_busy(struct mmc_test_card *test)
 
                 if (!busy && mmc_test_busy(&cmd)) {
                         busy = 1;
-                        printk(KERN_INFO "%s: Warning: Host did not "
-                                "wait for busy state to end.\n",
-                                mmc_hostname(test->card->host));
+                        if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
+                                printk(KERN_INFO "%s: Warning: Host did not "
+                                        "wait for busy state to end.\n",
+                                        mmc_hostname(test->card->host));
                 }
         } while (mmc_test_busy(&cmd));
 
@@ -198,18 +246,13 @@ static int mmc_test_buffer_transfer(struct mmc_test_card *test,
 {
         int ret;
 
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_command stop;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         struct scatterlist sg;
 
-        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;
@@ -244,28 +287,39 @@ static void mmc_test_free_mem(struct mmc_test_mem *mem)
 }
 
 /*
- * Allocate a lot of memory, preferrably max_sz but at least min_sz.  In case
- * there isn't much memory do not exceed 1/16th total lowmem pages.
+ * Allocate a lot of memory, preferably max_sz but at least min_sz.  In case
+ * there isn't much memory do not exceed 1/16th total lowmem pages.  Also do
+ * not exceed a maximum number of segments and try not to make segments much
+ * bigger than maximum segment size.
  */
 static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
-                                               unsigned long max_sz)
+                                               unsigned long max_sz,
+                                               unsigned int max_segs,
+                                               unsigned int max_seg_sz)
 {
         unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
         unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
+        unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);
         unsigned long page_cnt = 0;
         unsigned long limit = nr_free_buffer_pages() >> 4;
         struct mmc_test_mem *mem;
 
         if (max_page_cnt > limit)
                 max_page_cnt = limit;
-        if (max_page_cnt < min_page_cnt)
-                max_page_cnt = min_page_cnt;
+        if (min_page_cnt > max_page_cnt)
+                min_page_cnt = max_page_cnt;
+
+        if (max_seg_page_cnt > max_page_cnt)
+                max_seg_page_cnt = max_page_cnt;
+
+        if (max_segs > max_page_cnt)
+                max_segs = max_page_cnt;
 
         mem = kzalloc(sizeof(struct mmc_test_mem), GFP_KERNEL);
         if (!mem)
                 return NULL;
 
-        mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_page_cnt,
+        mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_segs,
                            GFP_KERNEL);
         if (!mem->arr)
                 goto out_free;
@@ -276,7 +330,7 @@ static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
                 gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
                                 __GFP_NORETRY;
 
-                order = get_order(max_page_cnt << PAGE_SHIFT);
+                order = get_order(max_seg_page_cnt << PAGE_SHIFT);
                 while (1) {
                         page = alloc_pages(flags, order);
                         if (page || !order)
@@ -295,6 +349,11 @@ static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
                         break;
                 max_page_cnt -= 1UL << order;
                 page_cnt += 1UL << order;
+                if (mem->cnt >= max_segs) {
+                        if (page_cnt < min_page_cnt)
+                                goto out_free;
+                        break;
+                }
         }
 
         return mem;
@@ -310,7 +369,8 @@ out_free:
  */
 static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
                            struct scatterlist *sglist, int repeat,
-                           unsigned int max_segs, unsigned int *sg_len)
+                           unsigned int max_segs, unsigned int max_seg_sz,
+                           unsigned int *sg_len)
 {
         struct scatterlist *sg = NULL;
         unsigned int i;
@@ -322,8 +382,10 @@ static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
                 for (i = 0; i < mem->cnt; i++) {
                         unsigned long len = PAGE_SIZE << mem->arr[i].order;
 
-                        if (sz < len)
+                        if (len > sz)
                                 len = sz;
+                        if (len > max_seg_sz)
+                                len = max_seg_sz;
                         if (sg)
                                 sg = sg_next(sg);
                         else
@@ -355,6 +417,7 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                                        unsigned long sz,
                                        struct scatterlist *sglist,
                                        unsigned int max_segs,
+                                       unsigned int max_seg_sz,
                                        unsigned int *sg_len)
 {
         struct scatterlist *sg = NULL;
@@ -365,7 +428,7 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
         sg_init_table(sglist, max_segs);
 
         *sg_len = 0;
-        while (sz && i) {
+        while (sz) {
                 base = page_address(mem->arr[--i].page);
                 cnt = 1 << mem->arr[i].order;
                 while (sz && cnt) {
@@ -374,7 +437,9 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                                 continue;
                         last_addr = addr;
                         len = PAGE_SIZE;
-                        if (sz < len)
+                        if (len > max_seg_sz)
+                                len = max_seg_sz;
+                        if (len > sz)
                                 len = sz;
                         if (sg)
                                 sg = sg_next(sg);
@@ -386,6 +451,8 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                         sz -= len;
                         *sg_len += 1;
                 }
+                if (i == 0)
+                        i = mem->cnt;
         }
 
         if (sg)
@@ -421,23 +488,52 @@ static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
 }
 
 /*
+ * Save transfer results for future usage
+ */
+static void mmc_test_save_transfer_result(struct mmc_test_card *test,
+        unsigned int count, unsigned int sectors, struct timespec ts,
+        unsigned int rate, unsigned int iops)
+{
+        struct mmc_test_transfer_result *tr;
+
+        if (!test->gr)
+                return;
+
+        tr = kmalloc(sizeof(struct mmc_test_transfer_result), GFP_KERNEL);
+        if (!tr)
+                return;
+
+        tr->count = count;
+        tr->sectors = sectors;
+        tr->ts = ts;
+        tr->rate = rate;
+        tr->iops = iops;
+
+        list_add_tail(&tr->link, &test->gr->tr_lst);
+}
+
+/*
  * Print the transfer rate.
  */
 static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
                                 struct timespec *ts1, struct timespec *ts2)
 {
-        unsigned int rate, sectors = bytes >> 9;
+        unsigned int rate, iops, sectors = bytes >> 9;
         struct timespec ts;
 
         ts = timespec_sub(*ts2, *ts1);
 
         rate = mmc_test_rate(bytes, &ts);
+        iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
 
         printk(KERN_INFO "%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
-                         "seconds (%u kB/s, %u KiB/s)\n",
+                         "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
                          mmc_hostname(test->card->host), sectors, sectors >> 1,
-                         (sectors == 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
-                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024);
+                         (sectors & 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
+                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024,
+                         iops / 100, iops % 100);
+
+        mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
 }
 
 /*
@@ -447,20 +543,24 @@ static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
                                     unsigned int count, struct timespec *ts1,
                                     struct timespec *ts2)
 {
-        unsigned int rate, sectors = bytes >> 9;
+        unsigned int rate, iops, sectors = bytes >> 9;
         uint64_t tot = bytes * count;
         struct timespec ts;
 
         ts = timespec_sub(*ts2, *ts1);
 
         rate = mmc_test_rate(tot, &ts);
+        iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
 
         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)\n",
+                         "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
+                         "%u.%02u IOPS)\n",
                          mmc_hostname(test->card->host), count, sectors, count,
-                         sectors >> 1, (sectors == 1 ? ".5" : ""),
+                         sectors >> 1, (sectors & 1 ? ".5" : ""),
                          (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
-                         rate / 1000, rate / 1024);
+                         rate / 1000, rate / 1024, iops / 100, iops % 100);
+
+        mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
 }
 
 /*
@@ -626,15 +726,10 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
         struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
         unsigned blocks, unsigned blksz, int write)
 {
-        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));
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -656,18 +751,13 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
 static int mmc_test_broken_transfer(struct mmc_test_card *test,
         unsigned blocks, unsigned blksz, int write)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_command stop;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         struct scatterlist sg;
 
-        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;
@@ -1215,16 +1305,22 @@ static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
                              int max_scatter)
 {
         struct mmc_test_area *t = &test->area;
+        int err;
 
         t->blocks = sz >> 9;
 
         if (max_scatter) {
-                return mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
-                                                   t->max_segs, &t->sg_len);
-        } else {
-                return mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
+                err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
+                                                  t->max_segs, t->max_seg_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);
         }
+        if (err)
+                printk(KERN_INFO "%s: Failed to map sg list\n",
+                       mmc_hostname(test->card->host));
+        return err;
 }
 
 /*
@@ -1249,6 +1345,22 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
         struct timespec ts1, ts2;
         int ret;
 
+        /*
+         * In the case of a maximally scattered transfer, the maximum transfer
+         * size is further limited by using PAGE_SIZE segments.
+         */
+        if (max_scatter) {
+                struct mmc_test_area *t = &test->area;
+                unsigned long max_tfr;
+
+                if (t->max_seg_sz >= PAGE_SIZE)
+                        max_tfr = t->max_segs * PAGE_SIZE;
+                else
+                        max_tfr = t->max_segs * t->max_seg_sz;
+                if (sz > max_tfr)
+                        sz = max_tfr;
+        }
+
         ret = mmc_test_area_map(test, sz, max_scatter);
         if (ret)
                 return ret;
@@ -1274,8 +1386,9 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
  */
 static int mmc_test_area_fill(struct mmc_test_card *test)
 {
-        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
-                                1, 0, 0);
+        struct mmc_test_area *t = &test->area;
+
+        return mmc_test_area_io(test, t->max_tfr, t->dev_addr, 1, 0, 0);
 }
 
 /*
@@ -1288,7 +1401,7 @@ static int mmc_test_area_erase(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return 0;
 
-        return mmc_erase(test->card, t->dev_addr, test->area.max_sz >> 9,
+        return mmc_erase(test->card, t->dev_addr, t->max_sz >> 9,
                          MMC_ERASE_ARG);
 }
 
@@ -1306,38 +1419,52 @@ static int mmc_test_area_cleanup(struct mmc_test_card *test)
 }
 
 /*
- * Initialize an area for testing large transfers.  The size of the area is the
- * preferred erase size which is a good size for optimal transfer speed.  Note
- * that is typically 4MiB for modern cards.  The test area is set to the middle
- * of the card because cards may have different charateristics at the front
- * (for FAT file system optimization).  Optionally, the area is erased (if the
- * card supports it) which may improve write performance.  Optionally, the area
- * is filled with data for subsequent read tests.
+ * Initialize an area for testing large transfers.  The test area is set to the
+ * middle of the card because cards may have different charateristics at the
+ * front (for FAT file system optimization).  Optionally, the area is erased
+ * (if the card supports it) which may improve write performance.  Optionally,
+ * the area is filled with data for subsequent read tests.
  */
 static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
 {
         struct mmc_test_area *t = &test->area;
-        unsigned long min_sz = 64 * 1024;
+        unsigned long min_sz = 64 * 1024, sz;
         int ret;
 
         ret = mmc_test_set_blksize(test, 512);
         if (ret)
                 return ret;
 
-        if (test->card->pref_erase > TEST_AREA_MAX_SIZE >> 9)
-                t->max_sz = TEST_AREA_MAX_SIZE;
-        else
-                t->max_sz = (unsigned long)test->card->pref_erase << 9;
+        /* Make the test area size about 4MiB */
+        sz = (unsigned long)test->card->pref_erase << 9;
+        t->max_sz = sz;
+        while (t->max_sz < 4 * 1024 * 1024)
+                t->max_sz += sz;
+        while (t->max_sz > TEST_AREA_MAX_SIZE && t->max_sz > sz)
+                t->max_sz -= sz;
+
+        t->max_segs = test->card->host->max_segs;
+        t->max_seg_sz = test->card->host->max_seg_size;
+
+        t->max_tfr = t->max_sz;
+        if (t->max_tfr >> 9 > test->card->host->max_blk_count)
+                t->max_tfr = test->card->host->max_blk_count << 9;
+        if (t->max_tfr > test->card->host->max_req_size)
+                t->max_tfr = test->card->host->max_req_size;
+        if (t->max_tfr / t->max_seg_sz > t->max_segs)
+                t->max_tfr = t->max_segs * t->max_seg_sz;
+
         /*
-         * Try to allocate enough memory for the whole area.  Less is OK
+         * Try to allocate enough memory for a max. sized transfer.  Less is OK
          * because the same memory can be mapped into the scatterlist more than
-         * once.
+         * once.  Also, take into account the limits imposed on scatterlist
+         * segments by the host driver.
          */
-        t->mem = mmc_test_alloc_mem(min_sz, t->max_sz);
+        t->mem = mmc_test_alloc_mem(min_sz, t->max_tfr, t->max_segs,
+                                    t->max_seg_sz);
         if (!t->mem)
                 return -ENOMEM;
 
-        t->max_segs = DIV_ROUND_UP(t->max_sz, PAGE_SIZE);
         t->sg = kmalloc(sizeof(struct scatterlist) * t->max_segs, GFP_KERNEL);
         if (!t->sg) {
                 ret = -ENOMEM;
@@ -1401,8 +1528,10 @@ static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
 static int mmc_test_best_performance(struct mmc_test_card *test, int write,
                                      int max_scatter)
 {
-        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
-                                write, max_scatter, 1);
+        struct mmc_test_area *t = &test->area;
+
+        return mmc_test_area_io(test, t->max_tfr, t->dev_addr, write,
+                                max_scatter, 1);
 }
 
 /*
@@ -1442,17 +1571,19 @@ static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
  */
 static int mmc_test_profile_read_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         int ret;
 
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
                 if (ret)
                         return ret;
         }
-        dev_addr = test->area.dev_addr;
+        sz = t->max_tfr;
+        dev_addr = t->dev_addr;
         return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
 }
 
@@ -1461,6 +1592,7 @@ static int mmc_test_profile_read_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_write_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         int ret;
@@ -1468,8 +1600,8 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
         ret = mmc_test_area_erase(test);
         if (ret)
                 return ret;
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
                 if (ret)
                         return ret;
@@ -1477,7 +1609,8 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
         ret = mmc_test_area_erase(test);
         if (ret)
                 return ret;
-        dev_addr = test->area.dev_addr;
+        sz = t->max_tfr;
+        dev_addr = t->dev_addr;
         return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
 }
 
@@ -1486,6 +1619,7 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         struct timespec ts1, ts2;
@@ -1497,8 +1631,8 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return RESULT_UNSUP_HOST;
 
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_sz; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 getnstimeofday(&ts1);
                 ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
                 if (ret)
@@ -1506,7 +1640,7 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
                 getnstimeofday(&ts2);
                 mmc_test_print_rate(test, sz, &ts1, &ts2);
         }
-        dev_addr = test->area.dev_addr;
+        dev_addr = t->dev_addr;
         getnstimeofday(&ts1);
         ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
         if (ret)
@@ -1516,29 +1650,66 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
         return 0;
 }
 
+static int mmc_test_seq_read_perf(struct mmc_test_card *test, unsigned long sz)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int dev_addr, i, cnt;
+        struct timespec ts1, ts2;
+        int ret;
+
+        cnt = t->max_sz / sz;
+        dev_addr = t->dev_addr;
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
+                if (ret)
+                        return ret;
+                dev_addr += (sz >> 9);
+        }
+        getnstimeofday(&ts2);
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        return 0;
+}
+
 /*
  * Consecutive read performance by transfer size.
  */
 static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
+        int ret;
+
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                ret = mmc_test_seq_read_perf(test, sz);
+                if (ret)
+                        return ret;
+        }
+        sz = t->max_tfr;
+        return mmc_test_seq_read_perf(test, sz);
+}
+
+static int mmc_test_seq_write_perf(struct mmc_test_card *test, unsigned long sz)
+{
+        struct mmc_test_area *t = &test->area;
         unsigned int dev_addr, i, cnt;
         struct timespec ts1, ts2;
         int ret;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
-                getnstimeofday(&ts1);
-                for (i = 0; i < cnt; i++) {
-                        ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
-                        if (ret)
-                                return ret;
-                        dev_addr += (sz >> 9);
-                }
-                getnstimeofday(&ts2);
-                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        ret = mmc_test_area_erase(test);
+        if (ret)
+                return ret;
+        cnt = t->max_sz / sz;
+        dev_addr = t->dev_addr;
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
+                if (ret)
+                        return ret;
+                dev_addr += (sz >> 9);
         }
+        getnstimeofday(&ts2);
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
         return 0;
 }
 
@@ -1547,28 +1718,17 @@ static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
-        unsigned int dev_addr, i, cnt;
-        struct timespec ts1, ts2;
         int ret;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
-                ret = mmc_test_area_erase(test);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                ret = mmc_test_seq_write_perf(test, sz);
                 if (ret)
                         return ret;
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
-                getnstimeofday(&ts1);
-                for (i = 0; i < cnt; i++) {
-                        ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
-                        if (ret)
-                                return ret;
-                        dev_addr += (sz >> 9);
-                }
-                getnstimeofday(&ts2);
-                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
         }
-        return 0;
+        sz = t->max_tfr;
+        return mmc_test_seq_write_perf(test, sz);
 }
 
 /*
@@ -1576,6 +1736,7 @@ static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr, i, cnt;
         struct timespec ts1, ts2;
@@ -1587,15 +1748,15 @@ static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return RESULT_UNSUP_HOST;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
+        for (sz = 512; sz <= t->max_sz; sz <<= 1) {
                 ret = mmc_test_area_erase(test);
                 if (ret)
                         return ret;
                 ret = mmc_test_area_fill(test);
                 if (ret)
                         return ret;
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
+                cnt = t->max_sz / sz;
+                dev_addr = t->dev_addr;
                 getnstimeofday(&ts1);
                 for (i = 0; i < cnt; i++) {
                         ret = mmc_erase(test->card, dev_addr, sz >> 9,
@@ -1610,6 +1771,189 @@ static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
         return 0;
 }
 
+static unsigned int rnd_next = 1;
+
+static unsigned int mmc_test_rnd_num(unsigned int rnd_cnt)
+{
+        uint64_t r;
+
+        rnd_next = rnd_next * 1103515245 + 12345;
+        r = (rnd_next >> 16) & 0x7fff;
+        return (r * rnd_cnt) >> 15;
+}
+
+static int mmc_test_rnd_perf(struct mmc_test_card *test, int write, int print,
+                             unsigned long sz)
+{
+        unsigned int dev_addr, cnt, rnd_addr, range1, range2, last_ea = 0, ea;
+        unsigned int ssz;
+        struct timespec ts1, ts2, ts;
+        int ret;
+
+        ssz = sz >> 9;
+
+        rnd_addr = mmc_test_capacity(test->card) / 4;
+        range1 = rnd_addr / test->card->pref_erase;
+        range2 = range1 / ssz;
+
+        getnstimeofday(&ts1);
+        for (cnt = 0; cnt < UINT_MAX; cnt++) {
+                getnstimeofday(&ts2);
+                ts = timespec_sub(ts2, ts1);
+                if (ts.tv_sec >= 10)
+                        break;
+                ea = mmc_test_rnd_num(range1);
+                if (ea == last_ea)
+                        ea -= 1;
+                last_ea = ea;
+                dev_addr = rnd_addr + test->card->pref_erase * ea +
+                           ssz * mmc_test_rnd_num(range2);
+                ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0);
+                if (ret)
+                        return ret;
+        }
+        if (print)
+                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        return 0;
+}
+
+static int mmc_test_random_perf(struct mmc_test_card *test, int write)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int next;
+        unsigned long sz;
+        int ret;
+
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                /*
+                 * When writing, try to get more consistent results by running
+                 * the test twice with exactly the same I/O but outputting the
+                 * results only for the 2nd run.
+                 */
+                if (write) {
+                        next = rnd_next;
+                        ret = mmc_test_rnd_perf(test, write, 0, sz);
+                        if (ret)
+                                return ret;
+                        rnd_next = next;
+                }
+                ret = mmc_test_rnd_perf(test, write, 1, sz);
+                if (ret)
+                        return ret;
+        }
+        sz = t->max_tfr;
+        if (write) {
+                next = rnd_next;
+                ret = mmc_test_rnd_perf(test, write, 0, sz);
+                if (ret)
+                        return ret;
+                rnd_next = next;
+        }
+        return mmc_test_rnd_perf(test, write, 1, sz);
+}
+
+/*
+ * Random read performance by transfer size.
+ */
+static int mmc_test_random_read_perf(struct mmc_test_card *test)
+{
+        return mmc_test_random_perf(test, 0);
+}
+
+/*
+ * Random write performance by transfer size.
+ */
+static int mmc_test_random_write_perf(struct mmc_test_card *test)
+{
+        return mmc_test_random_perf(test, 1);
+}
+
+static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
+                             unsigned int tot_sz, int max_scatter)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int dev_addr, i, cnt, sz, ssz;
+        struct timespec ts1, ts2;
+        int ret;
+
+        sz = t->max_tfr;
+
+        /*
+         * In the case of a maximally scattered transfer, the maximum transfer
+         * size is further limited by using PAGE_SIZE segments.
+         */
+        if (max_scatter) {
+                unsigned long max_tfr;
+
+                if (t->max_seg_sz >= PAGE_SIZE)
+                        max_tfr = t->max_segs * PAGE_SIZE;
+                else
+                        max_tfr = t->max_segs * t->max_seg_sz;
+                if (sz > max_tfr)
+                        sz = max_tfr;
+        }
+
+        ssz = sz >> 9;
+        dev_addr = mmc_test_capacity(test->card) / 4;
+        if (tot_sz > dev_addr << 9)
+                tot_sz = dev_addr << 9;
+        cnt = tot_sz / sz;
+        dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
+
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, write,
+                                       max_scatter, 0);
+                if (ret)
+                        return ret;
+                dev_addr += ssz;
+        }
+        getnstimeofday(&ts2);
+
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+
+        return 0;
+}
+
+static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write)
+{
+        int ret, i;
+
+        for (i = 0; i < 10; i++) {
+                ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+        for (i = 0; i < 5; i++) {
+                ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+        for (i = 0; i < 3; i++) {
+                ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
+}
+
+/*
+ * Large sequential read performance.
+ */
+static int mmc_test_large_seq_read_perf(struct mmc_test_card *test)
+{
+        return mmc_test_large_seq_perf(test, 0);
+}
+
+/*
+ * Large sequential write performance.
+ */
+static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
+{
+        return mmc_test_large_seq_perf(test, 1);
+}
+
 static const struct mmc_test_case mmc_test_cases[] = {
         {
                 .name = "Basic write (no data verification)",
@@ -1849,10 +2193,40 @@ static const struct mmc_test_case mmc_test_cases[] = {
                 .cleanup = mmc_test_area_cleanup,
         },
 
+        {
+                .name = "Random read performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_random_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Random write performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_random_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Large sequential read into scattered pages",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_large_seq_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Large sequential write from scattered pages",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_large_seq_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
 };
 
 static DEFINE_MUTEX(mmc_test_lock);
 
+static LIST_HEAD(mmc_test_result);
+
 static void mmc_test_run(struct mmc_test_card *test, int testcase)
 {
         int i, ret;
@@ -1863,6 +2237,8 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
         mmc_claim_host(test->card->host);
 
         for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
+                struct mmc_test_general_result *gr;
+
                 if (testcase && ((i + 1) != testcase))
                         continue;
 
@@ -1881,6 +2257,25 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                         }
                 }
 
+                gr = kzalloc(sizeof(struct mmc_test_general_result),
+                        GFP_KERNEL);
+                if (gr) {
+                        INIT_LIST_HEAD(&gr->tr_lst);
+
+                        /* Assign data what we know already */
+                        gr->card = test->card;
+                        gr->testcase = i;
+
+                        /* Append container to global one */
+                        list_add_tail(&gr->link, &mmc_test_result);
+
+                        /*
+                         * Save the pointer to created container in our private
+                         * structure.
+                         */
+                        test->gr = gr;
+                }
+
                 ret = mmc_test_cases[i].run(test);
                 switch (ret) {
                 case RESULT_OK:
@@ -1906,6 +2301,10 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                                 mmc_hostname(test->card->host), ret);
                 }
 
+                /* Save the result */
+                if (gr)
+                        gr->result = ret;
+
                 if (mmc_test_cases[i].cleanup) {
                         ret = mmc_test_cases[i].cleanup(test);
                         if (ret) {
@@ -1923,30 +2322,95 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                 mmc_hostname(test->card->host));
 }
 
-static ssize_t mmc_test_show(struct device *dev,
-        struct device_attribute *attr, char *buf)
+static void mmc_test_free_result(struct mmc_card *card)
+{
+        struct mmc_test_general_result *gr, *grs;
+
+        mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry_safe(gr, grs, &mmc_test_result, link) {
+                struct mmc_test_transfer_result *tr, *trs;
+
+                if (card && gr->card != card)
+                        continue;
+
+                list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) {
+                        list_del(&tr->link);
+                        kfree(tr);
+                }
+
+                list_del(&gr->link);
+                kfree(gr);
+        }
+
+        mutex_unlock(&mmc_test_lock);
+}
+
+static LIST_HEAD(mmc_test_file_test);
+
+static int mtf_test_show(struct seq_file *sf, void *data)
 {
+        struct mmc_card *card = (struct mmc_card *)sf->private;
+        struct mmc_test_general_result *gr;
+
         mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry(gr, &mmc_test_result, link) {
+                struct mmc_test_transfer_result *tr;
+
+                if (gr->card != card)
+                        continue;
+
+                seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result);
+
+                list_for_each_entry(tr, &gr->tr_lst, link) {
+                        seq_printf(sf, "%u %d %lu.%09lu %u %u.%02u\n",
+                                tr->count, tr->sectors,
+                                (unsigned long)tr->ts.tv_sec,
+                                (unsigned long)tr->ts.tv_nsec,
+                                tr->rate, tr->iops / 100, tr->iops % 100);
+                }
+        }
+
         mutex_unlock(&mmc_test_lock);
 
         return 0;
 }
 
-static ssize_t mmc_test_store(struct device *dev,
-        struct device_attribute *attr, const char *buf, size_t count)
+static int mtf_test_open(struct inode *inode, struct file *file)
 {
-        struct mmc_card *card;
+        return single_open(file, mtf_test_show, inode->i_private);
+}
+
+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;
-        int testcase;
+        char lbuf[12];
+        long testcase;
+
+        if (count >= sizeof(lbuf))
+                return -EINVAL;
 
-        card = container_of(dev, struct mmc_card, dev);
+        if (copy_from_user(lbuf, buf, count))
+                return -EFAULT;
+        lbuf[count] = '\0';
 
-        testcase = simple_strtol(buf, NULL, 10);
+        if (strict_strtol(lbuf, 10, &testcase))
+                return -EINVAL;
 
         test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
         if (!test)
                 return -ENOMEM;
 
+        /*
+         * Remove all test cases associated with given card. Thus we have only
+         * actual data of the last run.
+         */
+        mmc_test_free_result(card);
+
         test->card = card;
 
         test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
@@ -1973,16 +2437,78 @@ static ssize_t mmc_test_store(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(test, S_IWUSR | S_IRUGO, mmc_test_show, mmc_test_store);
+static const struct file_operations mmc_test_fops_test = {
+        .open           = mtf_test_open,
+        .read           = seq_read,
+        .write          = mtf_test_write,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void mmc_test_free_file_test(struct mmc_card *card)
+{
+        struct mmc_test_dbgfs_file *df, *dfs;
+
+        mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) {
+                if (card && df->card != card)
+                        continue;
+                debugfs_remove(df->file);
+                list_del(&df->link);
+                kfree(df);
+        }
+
+        mutex_unlock(&mmc_test_lock);
+}
+
+static int mmc_test_register_file_test(struct mmc_card *card)
+{
+        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);
+
+        if (IS_ERR_OR_NULL(file)) {
+                dev_err(&card->dev,
+                        "Can't create file. Perhaps debugfs is disabled.\n");
+                ret = -ENODEV;
+                goto err;
+        }
+
+        df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
+        if (!df) {
+                debugfs_remove(file);
+                dev_err(&card->dev,
+                        "Can't allocate memory for internal usage.\n");
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        df->card = card;
+        df->file = file;
+
+        list_add(&df->link, &mmc_test_file_test);
+
+err:
+        mutex_unlock(&mmc_test_lock);
+
+        return ret;
+}
 
 static int mmc_test_probe(struct mmc_card *card)
 {
         int ret;
 
-        if ((card->type != MMC_TYPE_MMC) && (card->type != MMC_TYPE_SD))
+        if (!mmc_card_mmc(card) && !mmc_card_sd(card))
                 return -ENODEV;
 
-        ret = device_create_file(&card->dev, &dev_attr_test);
+        ret = mmc_test_register_file_test(card);
         if (ret)
                 return ret;
 
@@ -1993,7 +2519,8 @@ static int mmc_test_probe(struct mmc_card *card)
 
 static void mmc_test_remove(struct mmc_card *card)
 {
-        device_remove_file(&card->dev, &dev_attr_test);
+        mmc_test_free_result(card);
+        mmc_test_free_file_test(card);
 }
 
 static struct mmc_driver mmc_driver = {
@@ -2011,6 +2538,10 @@ static int __init mmc_test_init(void)
 
 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_unregister_driver(&mmc_driver);
 }
 
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index e876678176be..6413afa318d2 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -55,8 +55,7 @@ static int mmc_queue_thread(void *d)
 
                 spin_lock_irq(q->queue_lock);
                 set_current_state(TASK_INTERRUPTIBLE);
-                if (!blk_queue_plugged(q))
-                        req = blk_fetch_request(q);
+                req = blk_fetch_request(q);
                 mq->req = req;
                 spin_unlock_irq(q->queue_lock);
 
@@ -107,10 +106,12 @@ static void mmc_request(struct request_queue *q)
  * @mq: mmc queue
  * @card: mmc card to attach this queue
  * @lock: queue lock
+ * @subname: partition subname
  *
  * Initialise a MMC card request queue.
  */
-int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock)
+int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
+                   spinlock_t *lock, const char *subname)
 {
         struct mmc_host *host = card->host;
         u64 limit = BLK_BOUNCE_HIGH;
@@ -128,26 +129,20 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
         mq->req = NULL;
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
-        blk_queue_ordered(mq->queue, QUEUE_ORDERED_DRAIN);
         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;
-                if (!mmc_can_trim(card) && is_power_of_2(card->erase_size)) {
-                        mq->queue->limits.discard_granularity =
-                                                        card->erase_size << 9;
-                        mq->queue->limits.discard_alignment =
-                                                        card->erase_size << 9;
-                }
+                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);
         }
 
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
-        if (host->max_hw_segs == 1) {
+        if (host->max_segs == 1) {
                 unsigned int bouncesz;
 
                 bouncesz = MMC_QUEUE_BOUNCESZ;
@@ -197,21 +192,23 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
                 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_hw_segs);
+                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_phys_segs, GFP_KERNEL);
+                        host->max_segs, GFP_KERNEL);
                 if (!mq->sg) {
                         ret = -ENOMEM;
                         goto cleanup_queue;
                 }
-                sg_init_table(mq->sg, host->max_phys_segs);
+                sg_init_table(mq->sg, host->max_segs);
         }
 
-        init_MUTEX(&mq->thread_sem);
+        sema_init(&mq->thread_sem, 1);
+
+        mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd/%d%s",
+                host->index, subname ? subname : "");
 
-        mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd");
         if (IS_ERR(mq->thread)) {
                 ret = PTR_ERR(mq->thread);
                 goto free_bounce_sg;
@@ -343,18 +340,14 @@ unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
  */
 void mmc_queue_bounce_pre(struct mmc_queue *mq)
 {
-        unsigned long flags;
-
         if (!mq->bounce_buf)
                 return;
 
         if (rq_data_dir(mq->req) != WRITE)
                 return;
 
-        local_irq_save(flags);
         sg_copy_to_buffer(mq->bounce_sg, mq->bounce_sg_len,
                 mq->bounce_buf, mq->sg[0].length);
-        local_irq_restore(flags);
 }
 
 /*
@@ -363,17 +356,13 @@ void mmc_queue_bounce_pre(struct mmc_queue *mq)
  */
 void mmc_queue_bounce_post(struct mmc_queue *mq)
 {
-        unsigned long flags;
-
         if (!mq->bounce_buf)
                 return;
 
         if (rq_data_dir(mq->req) != READ)
                 return;
 
-        local_irq_save(flags);
         sg_copy_from_buffer(mq->bounce_sg, mq->bounce_sg_len,
                 mq->bounce_buf, mq->sg[0].length);
-        local_irq_restore(flags);
 }
 
diff --git a/drivers/mmc/card/queue.h b/drivers/mmc/card/queue.h
index 64e66e0d4994..6223ef8dc9cd 100644
--- a/drivers/mmc/card/queue.h
+++ b/drivers/mmc/card/queue.h
@@ -19,7 +19,8 @@ struct mmc_queue {
         unsigned int            bounce_sg_len;
 };
 
-extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *);
+extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *,
+                          const char *);
 extern void mmc_cleanup_queue(struct mmc_queue *);
 extern void mmc_queue_suspend(struct mmc_queue *);
 extern void mmc_queue_resume(struct mmc_queue *);
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index a0716967b7c8..c8c9edb3d7cb 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -956,7 +956,7 @@ static int sdio_uart_break_ctl(struct tty_struct *tty, int break_state)
         return 0;
 }
 
-static int sdio_uart_tiocmget(struct tty_struct *tty, struct file *file)
+static int sdio_uart_tiocmget(struct tty_struct *tty)
 {
         struct sdio_uart_port *port = tty->driver_data;
         int result;
@@ -970,7 +970,7 @@ static int sdio_uart_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static int sdio_uart_tiocmset(struct tty_struct *tty, struct file *file,
+static int sdio_uart_tiocmset(struct tty_struct *tty,
                               unsigned int set, unsigned int clear)
 {
         struct sdio_uart_port *port = tty->driver_data;
diff --git a/drivers/mmc/core/Kconfig b/drivers/mmc/core/Kconfig
index bb22ffd76ef8..ef103871517f 100644
--- a/drivers/mmc/core/Kconfig
+++ b/drivers/mmc/core/Kconfig
@@ -16,3 +16,14 @@ config MMC_UNSAFE_RESUME
 
           This option sets a default which can be overridden by the
           module parameter "removable=0" or "removable=1".
+
+config MMC_CLKGATE
+        bool "MMC host clock gating (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        help
+          This will attempt to aggressively gate the clock to the MMC card.
+          This is done to save power due to gating off the logic and bus
+          noise when the MMC card is not in use. Your host driver has to
+          support handling this in order for it to be of any use.
+
+          If unsure, say N.
diff --git a/drivers/mmc/core/Makefile b/drivers/mmc/core/Makefile
index 889e5f898f6f..639501970b41 100644
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -2,14 +2,11 @@
 # Makefile for the kernel mmc core.
 #
 
-ifeq ($(CONFIG_MMC_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
-
 obj-$(CONFIG_MMC)               += mmc_core.o
 mmc_core-y                      := core.o bus.o host.o \
                                    mmc.o mmc_ops.o sd.o sd_ops.o \
                                    sdio.o sdio_ops.o sdio_bus.o \
-                                   sdio_cis.o sdio_io.o sdio_irq.o
+                                   sdio_cis.o sdio_io.o sdio_irq.o \
+                                   quirks.o
 
 mmc_core-$(CONFIG_DEBUG_FS)     += debugfs.o
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 7cd9749dc21d..393d817ed040 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -14,6 +14,7 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -22,13 +23,12 @@
 #include "sdio_cis.h"
 #include "bus.h"
 
-#define dev_to_mmc_card(d)      container_of(d, struct mmc_card, dev)
 #define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
 
 static ssize_t mmc_type_show(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         switch (card->type) {
         case MMC_TYPE_MMC:
@@ -62,7 +62,7 @@ static int mmc_bus_match(struct device *dev, struct device_driver *drv)
 static int
 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         const char *type;
         int retval = 0;
 
@@ -105,7 +105,7 @@ mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 static int mmc_bus_probe(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         return drv->probe(card);
 }
@@ -113,7 +113,7 @@ static int mmc_bus_probe(struct device *dev)
 static int mmc_bus_remove(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         drv->remove(card);
 
@@ -123,7 +123,7 @@ static int mmc_bus_remove(struct device *dev)
 static int mmc_bus_suspend(struct device *dev, pm_message_t state)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         int ret = 0;
 
         if (dev->driver && drv->suspend)
@@ -134,7 +134,7 @@ static int mmc_bus_suspend(struct device *dev, pm_message_t state)
 static int mmc_bus_resume(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         int ret = 0;
 
         if (dev->driver && drv->resume)
@@ -142,6 +142,41 @@ static int mmc_bus_resume(struct device *dev)
         return ret;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static int mmc_runtime_suspend(struct device *dev)
+{
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
+        return mmc_power_save_host(card->host);
+}
+
+static int mmc_runtime_resume(struct device *dev)
+{
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
+        return mmc_power_restore_host(card->host);
+}
+
+static int mmc_runtime_idle(struct device *dev)
+{
+        return pm_runtime_suspend(dev);
+}
+
+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,
+};
+
+#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,
@@ -151,6 +186,7 @@ static struct bus_type mmc_bus_type = {
         .remove         = mmc_bus_remove,
         .suspend        = mmc_bus_suspend,
         .resume         = mmc_bus_resume,
+        .pm             = MMC_PM_OPS_PTR,
 };
 
 int mmc_register_bus(void)
@@ -189,7 +225,7 @@ EXPORT_SYMBOL(mmc_unregister_driver);
 
 static void mmc_release_card(struct device *dev)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         sdio_free_common_cis(card);
 
@@ -238,8 +274,12 @@ int mmc_add_card(struct mmc_card *card)
                 break;
         case MMC_TYPE_SD:
                 type = "SD";
-                if (mmc_card_blockaddr(card))
-                        type = "SDHC";
+                if (mmc_card_blockaddr(card)) {
+                        if (mmc_card_ext_capacity(card))
+                                type = "SDXC";
+                        else
+                                type = "SDHC";
+                }
                 break;
         case MMC_TYPE_SDIO:
                 type = "SDIO";
@@ -248,31 +288,35 @@ int mmc_add_card(struct mmc_card *card)
                 type = "SD-combo";
                 if (mmc_card_blockaddr(card))
                         type = "SDHC-combo";
+                break;
         default:
                 type = "?";
                 break;
         }
 
         if (mmc_host_is_spi(card->host)) {
-                printk(KERN_INFO "%s: new %s%s card on SPI\n",
+                printk(KERN_INFO "%s: new %s%s%s card on SPI\n",
                         mmc_hostname(card->host),
                         mmc_card_highspeed(card) ? "high speed " : "",
+                        mmc_card_ddr_mode(card) ? "DDR " : "",
                         type);
         } else {
-                printk(KERN_INFO "%s: new %s%s card at address %04x\n",
+                printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
                         mmc_hostname(card->host),
-                        mmc_card_highspeed(card) ? "high speed " : "",
+                        mmc_sd_card_uhs(card) ? "ultra high speed " :
+                        (mmc_card_highspeed(card) ? "high speed " : ""),
+                        mmc_card_ddr_mode(card) ? "DDR " : "",
                         type, card->rca);
         }
 
-        ret = device_add(&card->dev);
-        if (ret)
-                return ret;
-
 #ifdef CONFIG_DEBUG_FS
         mmc_add_card_debugfs(card);
 #endif
 
+        ret = device_add(&card->dev);
+        if (ret)
+                return ret;
+
         mmc_card_set_present(card);
 
         return 0;
diff --git a/drivers/mmc/core/bus.h b/drivers/mmc/core/bus.h
index 18178766ab46..00a19710b6b4 100644
--- a/drivers/mmc/core/bus.h
+++ b/drivers/mmc/core/bus.h
@@ -14,7 +14,7 @@
 #define MMC_DEV_ATTR(name, fmt, args...)                                        \
 static ssize_t mmc_##name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
 {                                                                               \
-        struct mmc_card *card = container_of(dev, struct mmc_card, dev);        \
+        struct mmc_card *card = mmc_dev_to_card(dev);                           \
         return sprintf(buf, fmt, args);                                         \
 }                                                                               \
 static DEVICE_ATTR(name, S_IRUGO, mmc_##name##_show, NULL)
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 09eee6df0653..7843efe22359 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -22,6 +22,7 @@
 #include <linux/scatterlist.h>
 #include <linux/log2.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -58,6 +59,7 @@ int mmc_assume_removable;
 #else
 int mmc_assume_removable = 1;
 #endif
+EXPORT_SYMBOL(mmc_assume_removable);
 module_param_named(removable, mmc_assume_removable, bool, 0644);
 MODULE_PARM_DESC(
         removable,
@@ -129,6 +131,8 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 
                 if (mrq->done)
                         mrq->done(mrq);
+
+                mmc_host_clk_gate(host);
         }
 }
 
@@ -163,8 +167,6 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 
         WARN_ON(!host->claimed);
 
-        led_trigger_event(host->led, LED_FULL);
-
         mrq->cmd->error = 0;
         mrq->cmd->mrq = mrq;
         if (mrq->data) {
@@ -189,6 +191,8 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
+        mmc_host_clk_ungate(host);
+        led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
 
@@ -232,12 +236,10 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  */
 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
 {
-        struct mmc_request mrq;
+        struct mmc_request mrq = {0};
 
         WARN_ON(!host->claimed);
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-
         memset(cmd->resp, 0, sizeof(cmd->resp));
         cmd->retries = retries;
 
@@ -294,8 +296,9 @@ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
                 unsigned int timeout_us, limit_us;
 
                 timeout_us = data->timeout_ns / 1000;
-                timeout_us += data->timeout_clks * 1000 /
-                        (card->host->ios.clock / 1000);
+                if (mmc_host_clk_rate(card->host))
+                        timeout_us += data->timeout_clks * 1000 /
+                                (mmc_host_clk_rate(card->host) / 1000);
 
                 if (data->flags & MMC_DATA_WRITE)
                         /*
@@ -522,7 +525,14 @@ int mmc_try_claim_host(struct mmc_host *host)
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 
-static void mmc_do_release_host(struct mmc_host *host)
+/**
+ *      mmc_do_release_host - release a claimed host
+ *      @host: mmc host to release
+ *
+ *      If you successfully claimed a host, this function will
+ *      release it again.
+ */
+void mmc_do_release_host(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -537,6 +547,7 @@ static void mmc_do_release_host(struct mmc_host *host)
                 wake_up(&host->wq);
         }
 }
+EXPORT_SYMBOL(mmc_do_release_host);
 
 void mmc_host_deeper_disable(struct work_struct *work)
 {
@@ -613,6 +624,8 @@ static inline void mmc_set_ios(struct mmc_host *host)
                  ios->power_mode, ios->chip_select, ios->vdd,
                  ios->bus_width, ios->timing);
 
+        if (ios->clock > 0)
+                mmc_set_ungated(host);
         host->ops->set_ios(host, ios);
 }
 
@@ -640,6 +653,61 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+#ifdef CONFIG_MMC_CLKGATE
+/*
+ * This gates the clock by setting it to 0 Hz.
+ */
+void mmc_gate_clock(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_old = host->ios.clock;
+        host->ios.clock = 0;
+        host->clk_gated = true;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mmc_set_ios(host);
+}
+
+/*
+ * This restores the clock from gating by using the cached
+ * clock value.
+ */
+void mmc_ungate_clock(struct mmc_host *host)
+{
+        /*
+         * We should previously have gated the clock, so the clock shall
+         * be 0 here! The clock may however be 0 during initialization,
+         * when some request operations are performed before setting
+         * the frequency. When ungate is requested in that situation
+         * we just ignore the call.
+         */
+        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);
+        }
+}
+
+void mmc_set_ungated(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        /*
+         * We've been given a new frequency while the clock is gated,
+         * so make sure we regard this as ungating it.
+         */
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_gated = false;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+}
+
+#else
+void mmc_set_ungated(struct mmc_host *host)
+{
+}
+#endif
+
 /*
  * Change the bus mode (open drain/push-pull) of a host.
  */
@@ -771,8 +839,9 @@ EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
 
 /**
  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
- * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
+ * @mmc: the host to regulate
  * @supply: regulator to use
+ * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
  *
  * Returns zero on success, else negative errno.
  *
@@ -780,15 +849,12 @@ EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
  * a particular supply voltage.  This would normally be called from the
  * set_ios() method.
  */
-int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
+int mmc_regulator_set_ocr(struct mmc_host *mmc,
+                        struct regulator *supply,
+                        unsigned short vdd_bit)
 {
         int                     result = 0;
         int                     min_uV, max_uV;
-        int                     enabled;
-
-        enabled = regulator_is_enabled(supply);
-        if (enabled < 0)
-                return enabled;
 
         if (vdd_bit) {
                 int             tmp;
@@ -819,17 +885,25 @@ int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
                 else
                         result = 0;
 
-                if (result == 0 && !enabled)
+                if (result == 0 && !mmc->regulator_enabled) {
                         result = regulator_enable(supply);
-        } else if (enabled) {
+                        if (!result)
+                                mmc->regulator_enabled = true;
+                }
+        } else if (mmc->regulator_enabled) {
                 result = regulator_disable(supply);
+                if (result == 0)
+                        mmc->regulator_enabled = false;
         }
 
+        if (result)
+                dev_err(mmc_dev(mmc),
+                        "could not set regulator OCR (%d)\n", result);
         return result;
 }
 EXPORT_SYMBOL(mmc_regulator_set_ocr);
 
-#endif
+#endif /* CONFIG_REGULATOR */
 
 /*
  * Mask off any voltages we don't support and select
@@ -858,6 +932,38 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
         return ocr;
 }
 
+int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11)
+{
+        struct mmc_command cmd = {0};
+        int err = 0;
+
+        BUG_ON(!host);
+
+        /*
+         * Send CMD11 only if the request is to switch the card to
+         * 1.8V signalling.
+         */
+        if ((signal_voltage != MMC_SIGNAL_VOLTAGE_330) && cmd11) {
+                cmd.opcode = SD_SWITCH_VOLTAGE;
+                cmd.arg = 0;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+
+                err = mmc_wait_for_cmd(host, &cmd, 0);
+                if (err)
+                        return err;
+
+                if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
+                        return -EIO;
+        }
+
+        host->ios.signal_voltage = signal_voltage;
+
+        if (host->ops->start_signal_voltage_switch)
+                err = host->ops->start_signal_voltage_switch(host, &host->ios);
+
+        return err;
+}
+
 /*
  * Select timing parameters for host.
  */
@@ -868,6 +974,15 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 }
 
 /*
+ * Select appropriate driver type for host.
+ */
+void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
+{
+        host->ios.drv_type = drv_type;
+        mmc_set_ios(host);
+}
+
+/*
  * Apply power to the MMC stack.  This is a two-stage process.
  * First, we enable power to the card without the clock running.
  * We then wait a bit for the power to stabilise.  Finally,
@@ -907,12 +1022,7 @@ static void mmc_power_up(struct mmc_host *host)
          */
         mmc_delay(10);
 
-        if (host->f_min > 400000) {
-                pr_warning("%s: Minimum clock frequency too high for "
-                                "identification mode\n", mmc_hostname(host));
-                host->ios.clock = host->f_min;
-        } else
-                host->ios.clock = 400000;
+        host->ios.clock = host->f_init;
 
         host->ios.power_mode = MMC_POWER_ON;
         mmc_set_ios(host);
@@ -928,6 +1038,13 @@ static void mmc_power_off(struct mmc_host *host)
 {
         host->ios.clock = 0;
         host->ios.vdd = 0;
+
+        /*
+         * Reset ocr mask to be the highest possible voltage supported for
+         * this mmc host. This value will be used at next power up.
+         */
+        host->ocr = 1 << (fls(host->ocr_avail) - 1);
+
         if (!mmc_host_is_spi(host)) {
                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
                 host->ios.chip_select = MMC_CS_DONTCARE;
@@ -1099,9 +1216,8 @@ void mmc_init_erase(struct mmc_card *card)
         }
 }
 
-static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
-                                      struct mmc_command *cmd,
-                                      unsigned int arg, unsigned int qty)
+static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
+                                          unsigned int arg, unsigned int qty)
 {
         unsigned int erase_timeout;
 
@@ -1129,7 +1245,7 @@ static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
                  */
                 timeout_clks <<= 1;
                 timeout_us += (timeout_clks * 1000) /
-                              (card->host->ios.clock / 1000);
+                              (mmc_host_clk_rate(card->host) / 1000);
 
                 erase_timeout = timeout_us / 1000;
 
@@ -1158,44 +1274,48 @@ static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
         if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
                 erase_timeout = 1000;
 
-        cmd->erase_timeout = erase_timeout;
+        return erase_timeout;
 }
 
-static void mmc_set_sd_erase_timeout(struct mmc_card *card,
-                                     struct mmc_command *cmd, unsigned int arg,
-                                     unsigned int qty)
+static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
+                                         unsigned int arg,
+                                         unsigned int qty)
 {
+        unsigned int erase_timeout;
+
         if (card->ssr.erase_timeout) {
                 /* Erase timeout specified in SD Status Register (SSR) */
-                cmd->erase_timeout = card->ssr.erase_timeout * qty +
-                                     card->ssr.erase_offset;
+                erase_timeout = card->ssr.erase_timeout * qty +
+                                card->ssr.erase_offset;
         } else {
                 /*
                  * Erase timeout not specified in SD Status Register (SSR) so
                  * use 250ms per write block.
                  */
-                cmd->erase_timeout = 250 * qty;
+                erase_timeout = 250 * qty;
         }
 
         /* Must not be less than 1 second */
-        if (cmd->erase_timeout < 1000)
-                cmd->erase_timeout = 1000;
+        if (erase_timeout < 1000)
+                erase_timeout = 1000;
+
+        return erase_timeout;
 }
 
-static void mmc_set_erase_timeout(struct mmc_card *card,
-                                  struct mmc_command *cmd, unsigned int arg,
-                                  unsigned int qty)
+static unsigned int mmc_erase_timeout(struct mmc_card *card,
+                                      unsigned int arg,
+                                      unsigned int qty)
 {
         if (mmc_card_sd(card))
-                mmc_set_sd_erase_timeout(card, cmd, arg, qty);
+                return mmc_sd_erase_timeout(card, arg, qty);
         else
-                mmc_set_mmc_erase_timeout(card, cmd, arg, qty);
+                return mmc_mmc_erase_timeout(card, arg, qty);
 }
 
 static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                         unsigned int to, unsigned int arg)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         unsigned int qty = 0;
         int err;
 
@@ -1229,7 +1349,6 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                 to <<= 9;
         }
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
         if (mmc_card_sd(card))
                 cmd.opcode = SD_ERASE_WR_BLK_START;
         else
@@ -1263,7 +1382,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
         cmd.opcode = MMC_ERASE;
         cmd.arg = arg;
         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-        mmc_set_erase_timeout(card, &cmd, arg, qty);
+        cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
                 printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
@@ -1397,33 +1516,77 @@ int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
 }
 EXPORT_SYMBOL(mmc_erase_group_aligned);
 
+int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
+{
+        struct mmc_command cmd = {0};
+
+        if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card))
+                return 0;
+
+        cmd.opcode = MMC_SET_BLOCKLEN;
+        cmd.arg = blocklen;
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+        return mmc_wait_for_cmd(card->host, &cmd, 5);
+}
+EXPORT_SYMBOL(mmc_set_blocklen);
+
+static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
+{
+        host->f_init = freq;
+
+#ifdef CONFIG_MMC_DEBUG
+        pr_info("%s: %s: trying to init card at %u Hz\n",
+                mmc_hostname(host), __func__, host->f_init);
+#endif
+        mmc_power_up(host);
+
+        /*
+         * sdio_reset sends CMD52 to reset card.  Since we do not know
+         * if the card is being re-initialized, just send it.  CMD52
+         * should be ignored by SD/eMMC cards.
+         */
+        sdio_reset(host);
+        mmc_go_idle(host);
+
+        mmc_send_if_cond(host, host->ocr_avail);
+
+        /* Order's important: probe SDIO, then SD, then MMC */
+        if (!mmc_attach_sdio(host))
+                return 0;
+        if (!mmc_attach_sd(host))
+                return 0;
+        if (!mmc_attach_mmc(host))
+                return 0;
+
+        mmc_power_off(host);
+        return -EIO;
+}
+
 void mmc_rescan(struct work_struct *work)
 {
+        static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
         struct mmc_host *host =
                 container_of(work, struct mmc_host, detect.work);
-        u32 ocr;
-        int err;
-        unsigned long flags;
-
-        spin_lock_irqsave(&host->lock, flags);
+        int i;
 
-        if (host->rescan_disable) {
-                spin_unlock_irqrestore(&host->lock, flags);
+        if (host->rescan_disable)
                 return;
-        }
-
-        spin_unlock_irqrestore(&host->lock, flags);
-
 
         mmc_bus_get(host);
 
-        /* if there is a card registered, check whether it is still present */
-        if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)
+        /*
+         * if there is a _removable_ card registered, check whether it is
+         * still present
+         */
+        if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
+            && !(host->caps & MMC_CAP_NONREMOVABLE))
                 host->bus_ops->detect(host);
 
+        /*
+         * Let mmc_bus_put() free the bus/bus_ops if we've found that
+         * the card is no longer present.
+         */
         mmc_bus_put(host);
-
-
         mmc_bus_get(host);
 
         /* if there still is a card present, stop here */
@@ -1432,8 +1595,6 @@ void mmc_rescan(struct work_struct *work)
                 goto out;
         }
 
-        /* detect a newly inserted card */
-
         /*
          * Only we can add a new handler, so it's safe to
          * release the lock here.
@@ -1444,55 +1605,15 @@ void mmc_rescan(struct work_struct *work)
                 goto out;
 
         mmc_claim_host(host);
-
-        mmc_power_up(host);
-        sdio_reset(host);
-        mmc_go_idle(host);
-
-        mmc_send_if_cond(host, host->ocr_avail);
-
-        /*
-         * First we search for SDIO...
-         */
-        err = mmc_send_io_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_sdio(host, ocr)) {
-                        mmc_claim_host(host);
-                        /* try SDMEM (but not MMC) even if SDIO is broken */
-                        if (mmc_send_app_op_cond(host, 0, &ocr))
-                                goto out_fail;
-
-                        if (mmc_attach_sd(host, ocr))
-                                mmc_power_off(host);
-                }
-                goto out;
-        }
-
-        /*
-         * ...then normal SD...
-         */
-        err = mmc_send_app_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_sd(host, ocr))
-                        mmc_power_off(host);
-                goto out;
-        }
-
-        /*
-         * ...and finally MMC.
-         */
-        err = mmc_send_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_mmc(host, ocr))
-                        mmc_power_off(host);
-                goto out;
+        for (i = 0; i < ARRAY_SIZE(freqs); i++) {
+                if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
+                        break;
+                if (freqs[i] <= host->f_min)
+                        break;
         }
-
-out_fail:
         mmc_release_host(host);
-        mmc_power_off(host);
 
-out:
+ out:
         if (host->caps & MMC_CAP_NEEDS_POLL)
                 mmc_schedule_delayed_work(&host->detect, HZ);
 }
@@ -1514,7 +1635,7 @@ void mmc_stop_host(struct mmc_host *host)
 
         if (host->caps & MMC_CAP_DISABLE)
                 cancel_delayed_work(&host->disable);
-        cancel_delayed_work(&host->detect);
+        cancel_delayed_work_sync(&host->detect);
         mmc_flush_scheduled_work();
 
         /* clear pm flags now and let card drivers set them as needed */
@@ -1538,37 +1659,45 @@ void mmc_stop_host(struct mmc_host *host)
         mmc_power_off(host);
 }
 
-void mmc_power_save_host(struct mmc_host *host)
+int mmc_power_save_host(struct mmc_host *host)
 {
+        int ret = 0;
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
                 mmc_bus_put(host);
-                return;
+                return -EINVAL;
         }
 
         if (host->bus_ops->power_save)
-                host->bus_ops->power_save(host);
+                ret = host->bus_ops->power_save(host);
 
         mmc_bus_put(host);
 
         mmc_power_off(host);
+
+        return ret;
 }
 EXPORT_SYMBOL(mmc_power_save_host);
 
-void mmc_power_restore_host(struct mmc_host *host)
+int mmc_power_restore_host(struct mmc_host *host)
 {
+        int ret;
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
                 mmc_bus_put(host);
-                return;
+                return -EINVAL;
         }
 
         mmc_power_up(host);
-        host->bus_ops->power_restore(host);
+        ret = host->bus_ops->power_restore(host);
 
         mmc_bus_put(host);
+
+        return ret;
 }
 EXPORT_SYMBOL(mmc_power_restore_host);
 
@@ -1647,7 +1776,7 @@ int mmc_suspend_host(struct mmc_host *host)
         }
         mmc_bus_put(host);
 
-        if (!err && !(host->pm_flags & MMC_PM_KEEP_POWER))
+        if (!err && !mmc_card_keep_power(host))
                 mmc_power_off(host);
 
         return err;
@@ -1665,9 +1794,21 @@ int mmc_resume_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-                if (!(host->pm_flags & MMC_PM_KEEP_POWER)) {
+                if (!mmc_card_keep_power(host)) {
                         mmc_power_up(host);
                         mmc_select_voltage(host, host->ocr);
+                        /*
+                         * Tell runtime PM core we just powered up the card,
+                         * since it still believes the card is powered off.
+                         * Note that currently runtime PM is only enabled
+                         * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
+                         */
+                        if (mmc_card_sdio(host->card) &&
+                            (host->caps & MMC_CAP_POWER_OFF_CARD)) {
+                                pm_runtime_disable(&host->card->dev);
+                                pm_runtime_set_active(&host->card->dev);
+                                pm_runtime_enable(&host->card->dev);
+                        }
                 }
                 BUG_ON(!host->bus_ops->resume);
                 err = host->bus_ops->resume(host);
@@ -1678,6 +1819,7 @@ int mmc_resume_host(struct mmc_host *host)
                         err = 0;
                 }
         }
+        host->pm_flags &= ~MMC_PM_KEEP_POWER;
         mmc_bus_put(host);
 
         return err;
@@ -1720,6 +1862,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 
         case PM_POST_SUSPEND:
         case PM_POST_HIBERNATION:
+        case PM_POST_RESTORE:
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 0;
@@ -1736,7 +1879,7 @@ static int __init mmc_init(void)
 {
         int ret;
 
-        workqueue = create_singlethread_workqueue("kmmcd");
+        workqueue = alloc_ordered_workqueue("kmmcd", 0);
         if (!workqueue)
                 return -ENOMEM;
 
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index 9d9eef50e5d1..d9411ed2a39b 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -22,8 +22,8 @@ struct mmc_bus_ops {
         void (*detect)(struct mmc_host *);
         int (*suspend)(struct mmc_host *);
         int (*resume)(struct mmc_host *);
-        void (*power_save)(struct mmc_host *);
-        void (*power_restore)(struct mmc_host *);
+        int (*power_save)(struct mmc_host *);
+        int (*power_restore)(struct mmc_host *);
 };
 
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
@@ -33,10 +33,16 @@ void mmc_init_erase(struct mmc_card *card);
 
 void mmc_set_chip_select(struct mmc_host *host, int mode);
 void mmc_set_clock(struct mmc_host *host, unsigned int hz);
+void mmc_gate_clock(struct mmc_host *host);
+void mmc_ungate_clock(struct mmc_host *host);
+void mmc_set_ungated(struct mmc_host *host);
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width);
 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr);
+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);
 
 static inline void mmc_delay(unsigned int ms)
 {
@@ -52,13 +58,12 @@ void mmc_rescan(struct work_struct *work);
 void mmc_start_host(struct mmc_host *host);
 void mmc_stop_host(struct mmc_host *host);
 
-int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
-int mmc_attach_sd(struct mmc_host *host, u32 ocr);
-int mmc_attach_sdio(struct mmc_host *host, u32 ocr);
+int mmc_attach_mmc(struct mmc_host *host);
+int mmc_attach_sd(struct mmc_host *host);
+int mmc_attach_sdio(struct mmc_host *host);
 
 /* Module parameters */
 extern int use_spi_crc;
-extern int mmc_assume_removable;
 
 /* Debugfs information for hosts and cards */
 void mmc_add_host_debugfs(struct mmc_host *host);
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 53cb380c0987..998797ed67a6 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -134,6 +134,33 @@ static const struct file_operations mmc_ios_fops = {
         .release        = single_release,
 };
 
+static int mmc_clock_opt_get(void *data, u64 *val)
+{
+        struct mmc_host *host = data;
+
+        *val = host->ios.clock;
+
+        return 0;
+}
+
+static int mmc_clock_opt_set(void *data, u64 val)
+{
+        struct mmc_host *host = data;
+
+        /* We need this check due to input value is u64 */
+        if (val > host->f_max)
+                return -EINVAL;
+
+        mmc_claim_host(host);
+        mmc_set_clock(host, (unsigned int) val);
+        mmc_release_host(host);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set,
+        "%llu\n");
+
 void mmc_add_host_debugfs(struct mmc_host *host)
 {
         struct dentry *root;
@@ -150,11 +177,20 @@ void mmc_add_host_debugfs(struct mmc_host *host)
         host->debugfs_root = root;
 
         if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops))
-                goto err_ios;
+                goto err_node;
+
+        if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host,
+                        &mmc_clock_fops))
+                goto err_node;
 
+#ifdef CONFIG_MMC_CLKGATE
+        if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR),
+                                root, &host->clk_delay))
+                goto err_node;
+#endif
         return;
 
-err_ios:
+err_node:
         debugfs_remove_recursive(root);
         host->debugfs_root = NULL;
 err_root:
@@ -245,6 +281,7 @@ static const struct file_operations mmc_dbg_ext_csd_fops = {
         .open           = mmc_ext_csd_open,
         .read           = mmc_ext_csd_read,
         .release        = mmc_ext_csd_release,
+        .llseek         = default_llseek,
 };
 
 void mmc_add_card_debugfs(struct mmc_card *card)
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index d80cfdc8edd2..b29d3e8fd3a2 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2003 Russell King, All Rights Reserved.
  *  Copyright (C) 2007-2008 Pierre Ossman
+ *  Copyright (C) 2010 Linus Walleij
  *
  * 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
@@ -20,6 +21,7 @@
 #include <linux/suspend.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 
 #include "core.h"
 #include "host.h"
@@ -50,6 +52,202 @@ void mmc_unregister_host_class(void)
 static DEFINE_IDR(mmc_host_idr);
 static DEFINE_SPINLOCK(mmc_host_lock);
 
+#ifdef CONFIG_MMC_CLKGATE
+
+/*
+ * Enabling clock gating will make the core call out to the host
+ * once up and once down when it performs a request or card operation
+ * intermingled in any fashion. The driver will see this through
+ * set_ios() operations with ios.clock field set to 0 to gate (disable)
+ * the block clock, and to the old frequency to enable it again.
+ */
+static void mmc_host_clk_gate_delayed(struct mmc_host *host)
+{
+        unsigned long tick_ns;
+        unsigned long freq = host->ios.clock;
+        unsigned long flags;
+
+        if (!freq) {
+                pr_debug("%s: frequency set to 0 in disable function, "
+                         "this means the clock is already disabled.\n",
+                         mmc_hostname(host));
+                return;
+        }
+        /*
+         * New requests may have appeared while we were scheduling,
+         * then there is no reason to delay the check before
+         * clk_disable().
+         */
+        spin_lock_irqsave(&host->clk_lock, flags);
+
+        /*
+         * Delay n bus cycles (at least 8 from MMC spec) before attempting
+         * to disable the MCI block clock. The reference count may have
+         * gone up again after this delay due to rescheduling!
+         */
+        if (!host->clk_requests) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                tick_ns = DIV_ROUND_UP(1000000000, freq);
+                ndelay(host->clk_delay * tick_ns);
+        } else {
+                /* New users appeared while waiting for this work */
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                return;
+        }
+        mutex_lock(&host->clk_gate_mutex);
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (!host->clk_requests) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                /* This will set host->ios.clock to 0 */
+                mmc_gate_clock(host);
+                spin_lock_irqsave(&host->clk_lock, flags);
+                pr_debug("%s: gated MCI clock\n", mmc_hostname(host));
+        }
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mutex_unlock(&host->clk_gate_mutex);
+}
+
+/*
+ * Internal work. Work to disable the clock at some later point.
+ */
+static void mmc_host_clk_gate_work(struct work_struct *work)
+{
+        struct mmc_host *host = container_of(work, struct mmc_host,
+                                              clk_gate_work);
+
+        mmc_host_clk_gate_delayed(host);
+}
+
+/**
+ *      mmc_host_clk_ungate - 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)
+{
+        unsigned long flags;
+
+        mutex_lock(&host->clk_gate_mutex);
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (host->clk_gated) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                mmc_ungate_clock(host);
+                spin_lock_irqsave(&host->clk_lock, flags);
+                pr_debug("%s: ungated MCI clock\n", mmc_hostname(host));
+        }
+        host->clk_requests++;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mutex_unlock(&host->clk_gate_mutex);
+}
+
+/**
+ *      mmc_host_may_gate_card - check if this card may be gated
+ *      @card: card to check.
+ */
+static bool mmc_host_may_gate_card(struct mmc_card *card)
+{
+        /* If there is no card we may gate it */
+        if (!card)
+                return true;
+        /*
+         * Don't gate SDIO cards! These need to be clocked at all times
+         * since they may be independent systems generating interrupts
+         * and other events. The clock requests counter from the core will
+         * go down to zero since the core does not need it, but we will not
+         * gate the clock, because there is somebody out there that may still
+         * be using it.
+         */
+        return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING);
+}
+
+/**
+ *      mmc_host_clk_gate - 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)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_requests--;
+        if (mmc_host_may_gate_card(host->card) &&
+            !host->clk_requests)
+                schedule_work(&host->clk_gate_work);
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+}
+
+/**
+ *      mmc_host_clk_rate - get current clock frequency setting
+ *      @host: host to get the clock frequency for.
+ *
+ *      Returns current clock frequency regardless of gating.
+ */
+unsigned int mmc_host_clk_rate(struct mmc_host *host)
+{
+        unsigned long freq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (host->clk_gated)
+                freq = host->clk_old;
+        else
+                freq = host->ios.clock;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        return freq;
+}
+
+/**
+ *      mmc_host_clk_init - set up clock gating code
+ *      @host: host with potential clock to control
+ */
+static inline void mmc_host_clk_init(struct mmc_host *host)
+{
+        host->clk_requests = 0;
+        /* Hold MCI clock for 8 cycles by default */
+        host->clk_delay = 8;
+        host->clk_gated = false;
+        INIT_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
+        spin_lock_init(&host->clk_lock);
+        mutex_init(&host->clk_gate_mutex);
+}
+
+/**
+ *      mmc_host_clk_exit - shut down clock gating code
+ *      @host: host with potential clock to control
+ */
+static inline void mmc_host_clk_exit(struct mmc_host *host)
+{
+        /*
+         * Wait for any outstanding gate and then make sure we're
+         * ungated before exiting.
+         */
+        if (cancel_work_sync(&host->clk_gate_work))
+                mmc_host_clk_gate_delayed(host);
+        if (host->clk_gated)
+                mmc_host_clk_ungate(host);
+        /* There should be only one user now */
+        WARN_ON(host->clk_requests > 1);
+}
+
+#else
+
+static inline void mmc_host_clk_init(struct mmc_host *host)
+{
+}
+
+static inline void mmc_host_clk_exit(struct mmc_host *host)
+{
+}
+
+#endif
+
 /**
  *      mmc_alloc_host - initialise the per-host structure.
  *      @extra: sizeof private data structure
@@ -82,6 +280,8 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
         host->class_dev.class = &mmc_host_class;
         device_initialize(&host->class_dev);
 
+        mmc_host_clk_init(host);
+
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
@@ -94,8 +294,7 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
          * By default, hosts do not support SGIO or large requests.
          * They have to set these according to their abilities.
          */
-        host->max_hw_segs = 1;
-        host->max_phys_segs = 1;
+        host->max_segs = 1;
         host->max_seg_size = PAGE_CACHE_SIZE;
 
         host->max_req_size = PAGE_CACHE_SIZE;
@@ -126,12 +325,12 @@ int mmc_add_host(struct mmc_host *host)
         WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
                 !host->ops->enable_sdio_irq);
 
-        led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
-
         err = device_add(&host->class_dev);
         if (err)
                 return err;
 
+        led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
+
 #ifdef CONFIG_DEBUG_FS
         mmc_add_host_debugfs(host);
 #endif
@@ -164,6 +363,8 @@ void mmc_remove_host(struct mmc_host *host)
         device_del(&host->class_dev);
 
         led_trigger_unregister_simple(host->led);
+
+        mmc_host_clk_exit(host);
 }
 
 EXPORT_SYMBOL(mmc_remove_host);
@@ -184,4 +385,3 @@ void mmc_free_host(struct mmc_host *host)
 }
 
 EXPORT_SYMBOL(mmc_free_host);
-
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index 8c87e1109a34..de199f911928 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -10,10 +10,31 @@
  */
 #ifndef _MMC_CORE_HOST_H
 #define _MMC_CORE_HOST_H
+#include <linux/mmc/host.h>
 
 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);
+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_gate(struct mmc_host *host)
+{
+}
+
+static inline unsigned int mmc_host_clk_rate(struct mmc_host *host)
+{
+        return host->ios.clock;
+}
+#endif
+
 void mmc_host_deeper_disable(struct work_struct *work);
 
 #endif
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 6909a54c39be..aa7d1d79b8c5 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -20,6 +20,7 @@
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
+#include "sd_ops.h"
 
 static const unsigned int tran_exp[] = {
         10000,          100000,         1000000,        10000000,
@@ -173,14 +174,17 @@ static int mmc_decode_csd(struct mmc_card *card)
 }
 
 /*
- * Read and decode extended CSD.
+ * Read extended CSD.
  */
-static int mmc_read_ext_csd(struct mmc_card *card)
+static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
 {
         int err;
         u8 *ext_csd;
 
         BUG_ON(!card);
+        BUG_ON(!new_ext_csd);
+
+        *new_ext_csd = NULL;
 
         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
                 return 0;
@@ -198,12 +202,15 @@ static int mmc_read_ext_csd(struct mmc_card *card)
 
         err = mmc_send_ext_csd(card, ext_csd);
         if (err) {
+                kfree(ext_csd);
+                *new_ext_csd = NULL;
+
                 /* If the host or the card can't do the switch,
                  * fail more gracefully. */
                 if ((err != -EINVAL)
                  && (err != -ENOSYS)
                  && (err != -EFAULT))
-                        goto out;
+                        return err;
 
                 /*
                  * High capacity cards should have this "magic" size
@@ -221,17 +228,31 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                                 mmc_hostname(card->host));
                         err = 0;
                 }
+        } else
+                *new_ext_csd = ext_csd;
 
-                goto out;
-        }
+        return err;
+}
+
+/*
+ * Decode extended CSD.
+ */
+static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
+{
+        int err = 0;
+
+        BUG_ON(!card);
+
+        if (!ext_csd)
+                return 0;
 
         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
+        card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
         if (card->csd.structure == 3) {
-                int ext_csd_struct = ext_csd[EXT_CSD_STRUCTURE];
-                if (ext_csd_struct > 2) {
+                if (card->ext_csd.raw_ext_csd_structure > 2) {
                         printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
                                 "version %d\n", mmc_hostname(card->host),
-                                        ext_csd_struct);
+                                        card->ext_csd.raw_ext_csd_structure);
                         err = -EINVAL;
                         goto out;
                 }
@@ -245,6 +266,10 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 goto out;
         }
 
+        card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
+        card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
+        card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
+        card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
         if (card->ext_csd.rev >= 2) {
                 card->ext_csd.sectors =
                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
@@ -256,8 +281,23 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
                         mmc_card_set_blockaddr(card);
         }
-
+        card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
         switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
+        case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52;
+                break;
+        case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V;
+                break;
+        case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V;
+                break;
         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
                 card->ext_csd.hs_max_dtr = 52000000;
                 break;
@@ -271,8 +311,17 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         mmc_hostname(card->host));
         }
 
+        card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
+        card->ext_csd.raw_erase_timeout_mult =
+                ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
+        card->ext_csd.raw_hc_erase_grp_size =
+                ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
         if (card->ext_csd.rev >= 3) {
                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
+                card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
+
+                /* EXT_CSD value is in units of 10ms, but we store in ms */
+                card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 
                 /* Sleep / awake timeout in 100ns units */
                 if (sa_shift > 0 && sa_shift <= 0x17)
@@ -284,9 +333,65 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
                 card->ext_csd.hc_erase_size =
                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
+
+                card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
+
+                /*
+                 * There are two boot regions of equal size, defined in
+                 * multiples of 128K.
+                 */
+                card->ext_csd.boot_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
         }
 
+        card->ext_csd.raw_hc_erase_gap_size =
+                ext_csd[EXT_CSD_PARTITION_ATTRIBUTE];
+        card->ext_csd.raw_sec_trim_mult =
+                ext_csd[EXT_CSD_SEC_TRIM_MULT];
+        card->ext_csd.raw_sec_erase_mult =
+                ext_csd[EXT_CSD_SEC_ERASE_MULT];
+        card->ext_csd.raw_sec_feature_support =
+                ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
+        card->ext_csd.raw_trim_mult =
+                ext_csd[EXT_CSD_TRIM_MULT];
         if (card->ext_csd.rev >= 4) {
+                /*
+                 * Enhanced area feature support -- check whether the eMMC
+                 * card has the Enhanced area enabled.  If so, export enhanced
+                 * area offset and size to user by adding sysfs interface.
+                 */
+                if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
+                    (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
+                        u8 hc_erase_grp_sz =
+                                ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
+                        u8 hc_wp_grp_sz =
+                                ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
+
+                        card->ext_csd.enhanced_area_en = 1;
+                        /*
+                         * calculate the enhanced data area offset, in bytes
+                         */
+                        card->ext_csd.enhanced_area_offset =
+                                (ext_csd[139] << 24) + (ext_csd[138] << 16) +
+                                (ext_csd[137] << 8) + ext_csd[136];
+                        if (mmc_card_blockaddr(card))
+                                card->ext_csd.enhanced_area_offset <<= 9;
+                        /*
+                         * calculate the enhanced data area size, in kilobytes
+                         */
+                        card->ext_csd.enhanced_area_size =
+                                (ext_csd[142] << 16) + (ext_csd[141] << 8) +
+                                ext_csd[140];
+                        card->ext_csd.enhanced_area_size *=
+                                (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
+                        card->ext_csd.enhanced_area_size <<= 9;
+                } else {
+                        /*
+                         * If the enhanced area is not enabled, disable these
+                         * device attributes.
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                }
                 card->ext_csd.sec_trim_mult =
                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
                 card->ext_csd.sec_erase_mult =
@@ -297,14 +402,83 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         ext_csd[EXT_CSD_TRIM_MULT];
         }
 
+        if (card->ext_csd.rev >= 5)
+                card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
+
         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
                 card->erased_byte = 0xFF;
         else
                 card->erased_byte = 0x0;
 
 out:
+        return err;
+}
+
+static inline void mmc_free_ext_csd(u8 *ext_csd)
+{
         kfree(ext_csd);
+}
+
+
+static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
+{
+        u8 *bw_ext_csd;
+        int err;
 
+        if (bus_width == MMC_BUS_WIDTH_1)
+                return 0;
+
+        err = mmc_get_ext_csd(card, &bw_ext_csd);
+
+        if (err || bw_ext_csd == NULL) {
+                if (bus_width != MMC_BUS_WIDTH_1)
+                        err = -EINVAL;
+                goto out;
+        }
+
+        if (bus_width == MMC_BUS_WIDTH_1)
+                goto out;
+
+        /* only compare read only fields */
+        err = (!(card->ext_csd.raw_partition_support ==
+                        bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
+                (card->ext_csd.raw_erased_mem_count ==
+                        bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
+                (card->ext_csd.rev ==
+                        bw_ext_csd[EXT_CSD_REV]) &&
+                (card->ext_csd.raw_ext_csd_structure ==
+                        bw_ext_csd[EXT_CSD_STRUCTURE]) &&
+                (card->ext_csd.raw_card_type ==
+                        bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
+                (card->ext_csd.raw_s_a_timeout ==
+                        bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
+                (card->ext_csd.raw_hc_erase_gap_size ==
+                        bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
+                (card->ext_csd.raw_erase_timeout_mult ==
+                        bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
+                (card->ext_csd.raw_hc_erase_grp_size ==
+                        bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
+                (card->ext_csd.raw_sec_trim_mult ==
+                        bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
+                (card->ext_csd.raw_sec_erase_mult ==
+                        bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
+                (card->ext_csd.raw_sec_feature_support ==
+                        bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
+                (card->ext_csd.raw_trim_mult ==
+                        bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
+                (card->ext_csd.raw_sectors[0] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
+                (card->ext_csd.raw_sectors[1] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
+                (card->ext_csd.raw_sectors[2] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
+                (card->ext_csd.raw_sectors[3] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 3]));
+        if (err)
+                err = -EINVAL;
+
+out:
+        mmc_free_ext_csd(bw_ext_csd);
         return err;
 }
 
@@ -321,6 +495,9 @@ MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
+MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
+                card->ext_csd.enhanced_area_offset);
+MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 
 static struct attribute *mmc_std_attrs[] = {
         &dev_attr_cid.attr,
@@ -334,6 +511,8 @@ static struct attribute *mmc_std_attrs[] = {
         &dev_attr_name.attr,
         &dev_attr_oemid.attr,
         &dev_attr_serial.attr,
+        &dev_attr_enhanced_area_offset.attr,
+        &dev_attr_enhanced_area_size.attr,
         NULL,
 };
 
@@ -360,9 +539,11 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         struct mmc_card *oldcard)
 {
         struct mmc_card *card;
-        int err;
+        int err, ddr = 0;
         u32 cid[4];
         unsigned int max_dtr;
+        u32 rocr;
+        u8 *ext_csd = NULL;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -376,7 +557,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         mmc_go_idle(host);
 
         /* The extra bit indicates that we support high capacity */
-        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
+        err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
         if (err)
                 goto err;
 
@@ -461,20 +642,76 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 /*
                  * Fetch and process extended CSD.
                  */
-                err = mmc_read_ext_csd(card);
+
+                err = mmc_get_ext_csd(card, &ext_csd);
+                if (err)
+                        goto free_card;
+                err = mmc_read_ext_csd(card, ext_csd);
                 if (err)
                         goto free_card;
+
+                /* If doing byte addressing, check if required to do sector
+                 * addressing.  Handle the case of <2GB cards needing sector
+                 * addressing.  See section 8.1 JEDEC Standard JED84-A441;
+                 * ocr register has bit 30 set for sector addressing.
+                 */
+                if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
+                        mmc_card_set_blockaddr(card);
+
                 /* Erase size depends on CSD and Extended CSD */
                 mmc_set_erase_size(card);
         }
 
         /*
+         * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
+         * bit.  This bit will be lost every time after a reset or power off.
+         */
+        if (card->ext_csd.enhanced_area_en) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_ERASE_GROUP_DEF, 1, 0);
+
+                if (err && err != -EBADMSG)
+                        goto free_card;
+
+                if (err) {
+                        err = 0;
+                        /*
+                         * Just disable enhanced area off & sz
+                         * will try to enable ERASE_GROUP_DEF
+                         * during next time reinit
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                } else {
+                        card->ext_csd.erase_group_def = 1;
+                        /*
+                         * enable ERASE_GRP_DEF successfully.
+                         * This will affect the erase size, so
+                         * here need to reset erase size
+                         */
+                        mmc_set_erase_size(card);
+                }
+        }
+
+        /*
+         * Ensure eMMC user default partition is enabled
+         */
+        if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
+                card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
+                                 card->ext_csd.part_config,
+                                 card->ext_csd.part_time);
+                if (err && err != -EBADMSG)
+                        goto free_card;
+        }
+
+        /*
          * Activate high speed (if supported)
          */
         if ((card->ext_csd.hs_max_dtr != 0) &&
                 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_HS_TIMING, 1);
+                                 EXT_CSD_HS_TIMING, 1, 0);
                 if (err && err != -EBADMSG)
                         goto free_card;
 
@@ -503,32 +740,102 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         mmc_set_clock(host, max_dtr);
 
         /*
-         * Activate wide bus (if supported).
+         * Indicate DDR mode (if supported).
+         */
+        if (mmc_card_highspeed(card)) {
+                if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
+                        && ((host->caps & (MMC_CAP_1_8V_DDR |
+                             MMC_CAP_UHS_DDR50))
+                                == (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
+                                ddr = MMC_1_8V_DDR_MODE;
+                else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
+                        && ((host->caps & (MMC_CAP_1_2V_DDR |
+                             MMC_CAP_UHS_DDR50))
+                                == (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
+                                ddr = MMC_1_2V_DDR_MODE;
+        }
+
+        /*
+         * Activate wide bus and DDR (if supported).
          */
         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
-                unsigned ext_csd_bit, bus_width;
-
-                if (host->caps & MMC_CAP_8_BIT_DATA) {
-                        ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
-                        bus_width = MMC_BUS_WIDTH_8;
-                } else {
-                        ext_csd_bit = EXT_CSD_BUS_WIDTH_4;
-                        bus_width = MMC_BUS_WIDTH_4;
+                static unsigned ext_csd_bits[][2] = {
+                        { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
+                        { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
+                        { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
+                };
+                static unsigned bus_widths[] = {
+                        MMC_BUS_WIDTH_8,
+                        MMC_BUS_WIDTH_4,
+                        MMC_BUS_WIDTH_1
+                };
+                unsigned idx, bus_width = 0;
+
+                if (host->caps & MMC_CAP_8_BIT_DATA)
+                        idx = 0;
+                else
+                        idx = 1;
+                for (; idx < ARRAY_SIZE(bus_widths); idx++) {
+                        bus_width = bus_widths[idx];
+                        if (bus_width == MMC_BUS_WIDTH_1)
+                                ddr = 0; /* no DDR for 1-bit width */
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         EXT_CSD_BUS_WIDTH,
+                                         ext_csd_bits[idx][0],
+                                         0);
+                        if (!err) {
+                                mmc_set_bus_width(card->host, bus_width);
+
+                                /*
+                                 * If controller can't handle bus width test,
+                                 * compare ext_csd previously read in 1 bit mode
+                                 * against ext_csd at new bus width
+                                 */
+                                if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
+                                        err = mmc_compare_ext_csds(card,
+                                                bus_width);
+                                else
+                                        err = mmc_bus_test(card, bus_width);
+                                if (!err)
+                                        break;
+                        }
                 }
 
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                 EXT_CSD_BUS_WIDTH, ext_csd_bit);
-
-                if (err && err != -EBADMSG)
-                        goto free_card;
-
+                if (!err && ddr) {
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         EXT_CSD_BUS_WIDTH,
+                                         ext_csd_bits[idx][1],
+                                         0);
+                }
                 if (err) {
-                        printk(KERN_WARNING "%s: switch to bus width %d "
-                               "failed\n", mmc_hostname(card->host),
-                               1 << bus_width);
-                        err = 0;
-                } else {
+                        printk(KERN_WARNING "%s: switch to bus width %d ddr %d "
+                                "failed\n", mmc_hostname(card->host),
+                                1 << bus_width, ddr);
+                        goto free_card;
+                } else if (ddr) {
+                        /*
+                         * eMMC cards can support 3.3V to 1.2V i/o (vccq)
+                         * signaling.
+                         *
+                         * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
+                         *
+                         * 1.8V vccq at 3.3V core voltage (vcc) is not required
+                         * in the JEDEC spec for DDR.
+                         *
+                         * Do not force change in vccq since we are obviously
+                         * working and no change to vccq is needed.
+                         *
+                         * WARNING: eMMC rules are NOT the same as SD DDR
+                         */
+                        if (ddr == EXT_CSD_CARD_TYPE_DDR_1_2V) {
+                                err = mmc_set_signal_voltage(host,
+                                        MMC_SIGNAL_VOLTAGE_120, 0);
+                                if (err)
+                                        goto err;
+                        }
+                        mmc_card_set_ddr_mode(card);
+                        mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
                         mmc_set_bus_width(card->host, bus_width);
                 }
         }
@@ -536,12 +843,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (!oldcard)
                 host->card = card;
 
+        mmc_free_ext_csd(ext_csd);
         return 0;
 
 free_card:
         if (!oldcard)
                 mmc_remove_card(card);
 err:
+        mmc_free_ext_csd(ext_csd);
 
         return err;
 }
@@ -623,12 +932,16 @@ static int mmc_resume(struct mmc_host *host)
         return err;
 }
 
-static void mmc_power_restore(struct mmc_host *host)
+static int mmc_power_restore(struct mmc_host *host)
 {
+        int ret;
+
         host->card->state &= ~MMC_STATE_HIGHSPEED;
         mmc_claim_host(host);
-        mmc_init_card(host, host->ocr, host->card);
+        ret = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
+
+        return ret;
 }
 
 static int mmc_sleep(struct mmc_host *host)
@@ -685,7 +998,7 @@ static void mmc_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
+        if (!mmc_card_is_removable(host))
                 bus_ops = &mmc_ops_unsafe;
         else
                 bus_ops = &mmc_ops;
@@ -695,14 +1008,21 @@ static void mmc_attach_bus_ops(struct mmc_host *host)
 /*
  * Starting point for MMC card init.
  */
-int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
+int mmc_attach_mmc(struct mmc_host *host)
 {
         int err;
+        u32 ocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        err = mmc_send_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_attach_bus_ops(host);
+        if (host->ocr_avail_mmc)
+                host->ocr_avail = host->ocr_avail_mmc;
 
         /*
          * We need to get OCR a different way for SPI.
@@ -742,20 +1062,20 @@ int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
                 goto err;
 
         mmc_release_host(host);
-
         err = mmc_add_card(host->card);
+        mmc_claim_host(host);
         if (err)
                 goto remove_card;
 
         return 0;
 
 remove_card:
+        mmc_release_host(host);
         mmc_remove_card(host->card);
-        host->card = NULL;
         mmc_claim_host(host);
+        host->card = NULL;
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 326447c9ede8..845ce7c533b9 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -23,12 +23,10 @@
 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SELECT_CARD;
 
         if (card) {
@@ -60,15 +58,13 @@ int mmc_deselect_cards(struct mmc_host *host)
 
 int mmc_card_sleepawake(struct mmc_host *host, int sleep)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         struct mmc_card *card = host->card;
         int err;
 
         if (sleep)
                 mmc_deselect_cards(host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SLEEP_AWAKE;
         cmd.arg = card->rca << 16;
         if (sleep)
@@ -97,7 +93,7 @@ int mmc_card_sleepawake(struct mmc_host *host, int sleep)
 int mmc_go_idle(struct mmc_host *host)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         /*
          * Non-SPI hosts need to prevent chipselect going active during
@@ -105,7 +101,7 @@ int mmc_go_idle(struct mmc_host *host)
          * that in case of hardware that won't pull up DAT3/nCS otherwise.
          *
          * SPI hosts ignore ios.chip_select; it's managed according to
-         * rules that must accomodate non-MMC slaves which this layer
+         * rules that must accommodate non-MMC slaves which this layer
          * won't even know about.
          */
         if (!mmc_host_is_spi(host)) {
@@ -113,8 +109,6 @@ int mmc_go_idle(struct mmc_host *host)
                 mmc_delay(1);
         }
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_GO_IDLE_STATE;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
@@ -135,13 +129,11 @@ int mmc_go_idle(struct mmc_host *host)
 
 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SEND_OP_COND;
         cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
@@ -178,13 +170,11 @@ int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!cid);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_ALL_SEND_CID;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
@@ -201,13 +191,11 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 int mmc_set_relative_addr(struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SET_RELATIVE_ADDR;
         cmd.arg = card->rca << 16;
         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
@@ -223,13 +211,11 @@ static int
 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!cxd);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = opcode;
         cmd.arg = arg;
         cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
@@ -247,9 +233,9 @@ static int
 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
                 u32 opcode, void *buf, unsigned len)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
         void *data_buf;
 
@@ -260,10 +246,6 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         if (data_buf == NULL)
                 return -ENOMEM;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
@@ -355,11 +337,9 @@ int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
 
 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SPI_READ_OCR;
         cmd.arg = highcap ? (1 << 30) : 0;
         cmd.flags = MMC_RSP_SPI_R3;
@@ -372,11 +352,9 @@ 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)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SPI_CRC_ON_OFF;
         cmd.flags = MMC_RSP_SPI_R1;
         cmd.arg = use_crc;
@@ -387,23 +365,34 @@ int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
         return err;
 }
 
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
+/**
+ *      mmc_switch - modify EXT_CSD register
+ *      @card: the MMC card associated with the data transfer
+ *      @set: cmd set values
+ *      @index: EXT_CSD register index
+ *      @value: value to program into EXT_CSD register
+ *      @timeout_ms: timeout (ms) for operation performed by register write,
+ *                   timeout of zero implies maximum possible timeout
+ *
+ *      Modifies the EXT_CSD register for selected card.
+ */
+int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+               unsigned int timeout_ms)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         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) |
                   (index << 16) |
                   (value << 8) |
                   set;
         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        cmd.cmd_timeout_ms = timeout_ms;
 
         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
         if (err)
@@ -433,17 +422,16 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(mmc_switch);
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SEND_STATUS;
         if (!mmc_host_is_spi(card->host))
                 cmd.arg = card->rca << 16;
@@ -462,3 +450,100 @@ int mmc_send_status(struct mmc_card *card, u32 *status)
         return 0;
 }
 
+static int
+mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
+                  u8 len)
+{
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
+        struct scatterlist sg;
+        u8 *data_buf;
+        u8 *test_buf;
+        int i, err;
+        static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
+        static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
+
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(len, GFP_KERNEL);
+        if (!data_buf)
+                return -ENOMEM;
+
+        if (len == 8)
+                test_buf = testdata_8bit;
+        else if (len == 4)
+                test_buf = testdata_4bit;
+        else {
+                printk(KERN_ERR "%s: Invalid bus_width %d\n",
+                       mmc_hostname(host), len);
+                kfree(data_buf);
+                return -EINVAL;
+        }
+
+        if (opcode == MMC_BUS_TEST_W)
+                memcpy(data_buf, test_buf, len);
+
+        mrq.cmd = &cmd;
+        mrq.data = &data;
+        cmd.opcode = opcode;
+        cmd.arg = 0;
+
+        /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
+         * rely on callers to never use this with "native" calls for reading
+         * CSD or CID.  Native versions of those commands use the R2 type,
+         * not R1 plus a data block.
+         */
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+
+        data.blksz = len;
+        data.blocks = 1;
+        if (opcode == MMC_BUS_TEST_R)
+                data.flags = MMC_DATA_READ;
+        else
+                data.flags = MMC_DATA_WRITE;
+
+        data.sg = &sg;
+        data.sg_len = 1;
+        sg_init_one(&sg, data_buf, len);
+        mmc_wait_for_req(host, &mrq);
+        err = 0;
+        if (opcode == MMC_BUS_TEST_R) {
+                for (i = 0; i < len / 4; i++)
+                        if ((test_buf[i] ^ data_buf[i]) != 0xff) {
+                                err = -EIO;
+                                break;
+                        }
+        }
+        kfree(data_buf);
+
+        if (cmd.error)
+                return cmd.error;
+        if (data.error)
+                return data.error;
+
+        return err;
+}
+
+int mmc_bus_test(struct mmc_card *card, u8 bus_width)
+{
+        int err, width;
+
+        if (bus_width == MMC_BUS_WIDTH_8)
+                width = 8;
+        else if (bus_width == MMC_BUS_WIDTH_4)
+                width = 4;
+        else if (bus_width == MMC_BUS_WIDTH_1)
+                return 0; /* no need for test */
+        else
+                return -EINVAL;
+
+        /*
+         * Ignore errors from BUS_TEST_W.  BUS_TEST_R will fail if there
+         * is a problem.  This improves chances that the test will work.
+         */
+        mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
+        err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
+        return err;
+}
diff --git a/drivers/mmc/core/mmc_ops.h b/drivers/mmc/core/mmc_ops.h
index 653eb8e84178..9276946fa5b7 100644
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -20,12 +20,12 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid);
 int mmc_set_relative_addr(struct mmc_card *card);
 int mmc_send_csd(struct mmc_card *card, u32 *csd);
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value);
 int mmc_send_status(struct mmc_card *card, u32 *status);
 int mmc_send_cid(struct mmc_host *host, u32 *cid);
 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);
 
 #endif
 
diff --git a/drivers/mmc/core/quirks.c b/drivers/mmc/core/quirks.c
new file mode 100644
index 000000000000..3a596217029e
--- /dev/null
+++ b/drivers/mmc/core/quirks.c
@@ -0,0 +1,79 @@
+/*
+ *  This file contains work-arounds for many known SD/MMC
+ *  and SDIO hardware bugs.
+ *
+ *  Copyright (c) 2011 Andrei Warkentin <andreiw@motorola.com>
+ *  Copyright (c) 2011 Pierre Tardy <tardyp@gmail.com>
+ *  Inspired from pci fixup code:
+ *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/mmc/card.h>
+
+#ifndef SDIO_VENDOR_ID_TI
+#define SDIO_VENDOR_ID_TI               0x0097
+#endif
+
+#ifndef SDIO_DEVICE_ID_TI_WL1271
+#define SDIO_DEVICE_ID_TI_WL1271        0x4076
+#endif
+
+/*
+ * This hook just adds a quirk for all sdio devices
+ */
+static void add_quirk_for_sdio_devices(struct mmc_card *card, int data)
+{
+        if (mmc_card_sdio(card))
+                card->quirks |= data;
+}
+
+static const struct mmc_fixup mmc_fixup_methods[] = {
+        /* by default sdio devices are considered CLK_GATING broken */
+        /* good cards will be whitelisted as they are tested */
+        SDIO_FIXUP(SDIO_ANY_ID, SDIO_ANY_ID,
+                   add_quirk_for_sdio_devices,
+                   MMC_QUIRK_BROKEN_CLK_GATING),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   remove_quirk, MMC_QUIRK_BROKEN_CLK_GATING),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   add_quirk, MMC_QUIRK_NONSTD_FUNC_IF),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   add_quirk, MMC_QUIRK_DISABLE_CD),
+
+        END_FIXUP
+};
+
+void mmc_fixup_device(struct mmc_card *card, const struct mmc_fixup *table)
+{
+        const struct mmc_fixup *f;
+        u64 rev = cid_rev_card(card);
+
+        /* Non-core specific workarounds. */
+        if (!table)
+                table = mmc_fixup_methods;
+
+        for (f = table; f->vendor_fixup; f++) {
+                if ((f->manfid == CID_MANFID_ANY ||
+                     f->manfid == card->cid.manfid) &&
+                    (f->oemid == CID_OEMID_ANY ||
+                     f->oemid == card->cid.oemid) &&
+                    (f->name == CID_NAME_ANY ||
+                     !strncmp(f->name, card->cid.prod_name,
+                              sizeof(card->cid.prod_name))) &&
+                    (f->cis_vendor == card->cis.vendor ||
+                     f->cis_vendor == (u16) SDIO_ANY_ID) &&
+                    (f->cis_device == card->cis.device ||
+                     f->cis_device == (u16) SDIO_ANY_ID) &&
+                    rev >= f->rev_start && rev <= f->rev_end) {
+                        dev_dbg(&card->dev, "calling %pF\n", f->vendor_fixup);
+                        f->vendor_fixup(card, f->data);
+                }
+        }
+}
+EXPORT_SYMBOL(mmc_fixup_device);
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 0f5241085557..ff2774128aa9 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -21,6 +21,7 @@
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
+#include "sd.h"
 #include "sd_ops.h"
 
 static const unsigned int tran_exp[] = {
@@ -129,7 +130,7 @@ static int mmc_decode_csd(struct mmc_card *card)
                 break;
         case 1:
                 /*
-                 * This is a block-addressed SDHC card. Most
+                 * This is a block-addressed SDHC or SDXC card. Most
                  * interesting fields are unused and have fixed
                  * values. To avoid getting tripped by buggy cards,
                  * we assume those fixed values ourselves.
@@ -143,6 +144,11 @@ static int mmc_decode_csd(struct mmc_card *card)
                 e = UNSTUFF_BITS(resp, 96, 3);
                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+                csd->c_size       = UNSTUFF_BITS(resp, 48, 22);
+
+                /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
+                if (csd->c_size >= 0xFFFF)
+                        mmc_card_set_ext_capacity(card);
 
                 m = UNSTUFF_BITS(resp, 48, 22);
                 csd->capacity     = (1 + m) << 10;
@@ -188,12 +194,17 @@ static int mmc_decode_scr(struct mmc_card *card)
 
         scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
         scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
+        if (scr->sda_vsn == SCR_SPEC_VER_2)
+                /* Check if Physical Layer Spec v3.0 is supported */
+                scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 
         if (UNSTUFF_BITS(resp, 55, 1))
                 card->erased_byte = 0xFF;
         else
                 card->erased_byte = 0x0;
 
+        if (scr->sda_spec3)
+                scr->cmds = UNSTUFF_BITS(resp, 32, 2);
         return 0;
 }
 
@@ -273,29 +284,74 @@ static int mmc_read_switch(struct mmc_card *card)
         status = kmalloc(64, GFP_KERNEL);
         if (!status) {
                 printk(KERN_ERR "%s: could not allocate a buffer for "
-                        "switch capabilities.\n", mmc_hostname(card->host));
+                        "switch capabilities.\n",
+                        mmc_hostname(card->host));
                 return -ENOMEM;
         }
 
+        /* Find out the supported Bus Speed Modes. */
         err = mmc_sd_switch(card, 0, 0, 1, status);
         if (err) {
-                /* If the host or the card can't do the switch,
-                 * fail more gracefully. */
-                if ((err != -EINVAL)
-                 && (err != -ENOSYS)
-                 && (err != -EFAULT))
+                /*
+                 * If the host or the card can't do the switch,
+                 * fail more gracefully.
+                 */
+                if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
                         goto out;
 
-                printk(KERN_WARNING "%s: problem reading switch "
-                        "capabilities, performance might suffer.\n",
+                printk(KERN_WARNING "%s: problem reading Bus Speed modes.\n",
                         mmc_hostname(card->host));
                 err = 0;
 
                 goto out;
         }
 
-        if (status[13] & 0x02)
-                card->sw_caps.hs_max_dtr = 50000000;
+        if (card->scr.sda_spec3) {
+                card->sw_caps.sd3_bus_mode = status[13];
+
+                /* Find out Driver Strengths supported by the card */
+                err = mmc_sd_switch(card, 0, 2, 1, status);
+                if (err) {
+                        /*
+                         * If the host or the card can't do the switch,
+                         * fail more gracefully.
+                         */
+                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
+                                goto out;
+
+                        printk(KERN_WARNING "%s: problem reading "
+                                "Driver Strength.\n",
+                                mmc_hostname(card->host));
+                        err = 0;
+
+                        goto out;
+                }
+
+                card->sw_caps.sd3_drv_type = status[9];
+
+                /* Find out Current Limits supported by the card */
+                err = mmc_sd_switch(card, 0, 3, 1, status);
+                if (err) {
+                        /*
+                         * If the host or the card can't do the switch,
+                         * fail more gracefully.
+                         */
+                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
+                                goto out;
+
+                        printk(KERN_WARNING "%s: problem reading "
+                                "Current Limit.\n",
+                                mmc_hostname(card->host));
+                        err = 0;
+
+                        goto out;
+                }
+
+                card->sw_caps.sd3_curr_limit = status[7];
+        } else {
+                if (status[13] & 0x02)
+                        card->sw_caps.hs_max_dtr = 50000000;
+        }
 
 out:
         kfree(status);
@@ -351,6 +407,232 @@ out:
         return err;
 }
 
+static int sd_select_driver_type(struct mmc_card *card, u8 *status)
+{
+        int host_drv_type = 0, card_drv_type = 0;
+        int err;
+
+        /*
+         * If the host doesn't support any of the Driver Types A,C or D,
+         * 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;
+        }
+
+        err = mmc_sd_switch(card, 1, 2, card_drv_type, status);
+        if (err)
+                return err;
+
+        if ((status[15] & 0xF) != card_drv_type) {
+                printk(KERN_WARNING "%s: Problem setting driver strength!\n",
+                        mmc_hostname(card->host));
+                return 0;
+        }
+
+        mmc_set_driver_type(card->host, host_drv_type);
+
+        return 0;
+}
+
+static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+{
+        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;
+
+        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;
+        } 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;
+        } 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;
+        } 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;
+        } 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 = bus_speed;
+        err = mmc_sd_switch(card, 1, 0, bus_speed, status);
+        if (err)
+                return err;
+
+        if ((status[16] & 0xF) != bus_speed)
+                printk(KERN_WARNING "%s: Problem setting bus speed mode!\n",
+                        mmc_hostname(card->host));
+        else {
+                mmc_set_timing(card->host, timing);
+                mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
+        }
+
+        return 0;
+}
+
+static int sd_set_current_limit(struct mmc_card *card, u8 *status)
+{
+        int current_limit = 0;
+        int err;
+
+        /*
+         * Current limit switch is only defined for SDR50, SDR104, and DDR50
+         * bus speed modes. For other bus speed modes, we set the default
+         * current limit of 200mA.
+         */
+        if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) ||
+            (card->sd_bus_speed == UHS_SDR104_BUS_SPEED) ||
+            (card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) {
+                if (card->host->caps & MMC_CAP_MAX_CURRENT_800) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
+                                current_limit = SD_SET_CURRENT_LIMIT_800;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_600)
+                                current_limit = SD_SET_CURRENT_LIMIT_600;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
+                                current_limit = SD_SET_CURRENT_LIMIT_600;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                }
+        } else
+                current_limit = SD_SET_CURRENT_LIMIT_200;
+
+        err = mmc_sd_switch(card, 1, 3, current_limit, status);
+        if (err)
+                return err;
+
+        if (((status[15] >> 4) & 0x0F) != current_limit)
+                printk(KERN_WARNING "%s: Problem setting current limit!\n",
+                        mmc_hostname(card->host));
+
+        return 0;
+}
+
+/*
+ * UHS-I specific initialization procedure
+ */
+static int mmc_sd_init_uhs_card(struct mmc_card *card)
+{
+        int err;
+        u8 *status;
+
+        if (!card->scr.sda_spec3)
+                return 0;
+
+        if (!(card->csd.cmdclass & CCC_SWITCH))
+                return 0;
+
+        status = kmalloc(64, GFP_KERNEL);
+        if (!status) {
+                printk(KERN_ERR "%s: could not allocate a buffer for "
+                        "switch capabilities.\n", mmc_hostname(card->host));
+                return -ENOMEM;
+        }
+
+        /* Set 4-bit bus width */
+        if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
+            (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
+                if (err)
+                        goto out;
+
+                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+        }
+
+        /* 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);
+        if (err)
+                goto out;
+
+        /* Set current limit for the card */
+        err = sd_set_current_limit(card, status);
+        if (err)
+                goto out;
+
+        /* SPI mode doesn't define CMD19 */
+        if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
+                err = card->host->ops->execute_tuning(card->host);
+
+out:
+        kfree(status);
+
+        return err;
+}
+
 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
         card->raw_cid[2], card->raw_cid[3]);
 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
@@ -399,7 +681,7 @@ struct device_type sd_type = {
 /*
  * Fetch CID from card.
  */
-int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid)
+int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 {
         int err;
 
@@ -419,12 +701,39 @@ int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid)
          */
         err = mmc_send_if_cond(host, ocr);
         if (!err)
-                ocr |= 1 << 30;
+                ocr |= SD_OCR_CCS;
+
+        /*
+         * If the host supports one of UHS-I modes, request the card
+         * to switch to 1.8V signaling level.
+         */
+        if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))
+                ocr |= SD_OCR_S18R;
+
+        /* If the host can supply more than 150mA, XPC should be set to 1. */
+        if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 |
+            MMC_CAP_SET_XPC_180))
+                ocr |= SD_OCR_XPC;
 
-        err = mmc_send_app_op_cond(host, ocr, NULL);
+try_again:
+        err = mmc_send_app_op_cond(host, ocr, rocr);
         if (err)
                 return err;
 
+        /*
+         * In case CCS and S18A in the response is set, start Signal Voltage
+         * Switch procedure. SPI mode doesn't support CMD11.
+         */
+        if (!mmc_host_is_spi(host) && rocr &&
+           ((*rocr & 0x41000000) == 0x41000000)) {
+                err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true);
+                if (err) {
+                        ocr &= ~SD_OCR_S18R;
+                        goto try_again;
+                }
+        }
+
         if (mmc_host_is_spi(host))
                 err = mmc_send_cid(host, cid);
         else
@@ -552,11 +861,12 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         struct mmc_card *card;
         int err;
         u32 cid[4];
+        u32 rocr = 0;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
-        err = mmc_sd_get_cid(host, ocr, cid);
+        err = mmc_sd_get_cid(host, ocr, cid, &rocr);
         if (err)
                 return err;
 
@@ -609,30 +919,47 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         if (err)
                 goto free_card;
 
-        /*
-         * Attempt to change to high-speed (if supported)
-         */
-        err = mmc_sd_switch_hs(card);
-        if (err > 0)
-                mmc_sd_go_highspeed(card);
-        else if (err)
-                goto free_card;
+        /* Initialization sequence for UHS-I cards */
+        if (rocr & SD_ROCR_S18A) {
+                err = mmc_sd_init_uhs_card(card);
+                if (err)
+                        goto free_card;
 
-        /*
-         * Set bus speed.
-         */
-        mmc_set_clock(host, mmc_sd_get_max_clock(card));
+                /* Card is an ultra-high-speed card */
+                mmc_sd_card_set_uhs(card);
 
-        /*
-         * Switch to wider bus (if supported).
-         */
-        if ((host->caps & MMC_CAP_4_BIT_DATA) &&
-                (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
-                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
-                if (err)
+                /*
+                 * Since initialization is now complete, enable preset
+                 * value registers for UHS-I cards.
+                 */
+                if (host->ops->enable_preset_value)
+                        host->ops->enable_preset_value(host, true);
+        } else {
+                /*
+                 * Attempt to change to high-speed (if supported)
+                 */
+                err = mmc_sd_switch_hs(card);
+                if (err > 0)
+                        mmc_sd_go_highspeed(card);
+                else if (err)
                         goto free_card;
 
-                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+                /*
+                 * Set bus speed.
+                 */
+                mmc_set_clock(host, mmc_sd_get_max_clock(card));
+
+                /*
+                 * Switch to wider bus (if supported).
+                 */
+                if ((host->caps & MMC_CAP_4_BIT_DATA) &&
+                        (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                        err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
+                        if (err)
+                                goto free_card;
+
+                        mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+                }
         }
 
         host->card = card;
@@ -722,12 +1049,16 @@ static int mmc_sd_resume(struct mmc_host *host)
         return err;
 }
 
-static void mmc_sd_power_restore(struct mmc_host *host)
+static int mmc_sd_power_restore(struct mmc_host *host)
 {
+        int ret;
+
         host->card->state &= ~MMC_STATE_HIGHSPEED;
         mmc_claim_host(host);
-        mmc_sd_init_card(host, host->ocr, host->card);
+        ret = mmc_sd_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
+
+        return ret;
 }
 
 static const struct mmc_bus_ops mmc_sd_ops = {
@@ -750,7 +1081,7 @@ static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
+        if (!mmc_card_is_removable(host))
                 bus_ops = &mmc_sd_ops_unsafe;
         else
                 bus_ops = &mmc_sd_ops;
@@ -760,14 +1091,30 @@ static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 /*
  * Starting point for SD card init.
  */
-int mmc_attach_sd(struct mmc_host *host, u32 ocr)
+int mmc_attach_sd(struct mmc_host *host)
 {
         int err;
+        u32 ocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        /* Make sure we are at 3.3V signalling voltage */
+        err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
+        if (err)
+                return err;
+
+        /* Disable preset value enable if already set since last time */
+        if (host->ops->enable_preset_value)
+                host->ops->enable_preset_value(host, false);
+
+        err = mmc_send_app_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_sd_attach_bus_ops(host);
+        if (host->ocr_avail_sd)
+                host->ocr_avail = host->ocr_avail_sd;
 
         /*
          * We need to get OCR a different way for SPI.
@@ -791,7 +1138,8 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
                 ocr &= ~0x7F;
         }
 
-        if (ocr & MMC_VDD_165_195) {
+        if ((ocr & MMC_VDD_165_195) &&
+            !(host->ocr_avail_sd & MMC_VDD_165_195)) {
                 printk(KERN_WARNING "%s: SD card claims to support the "
                        "incompletely defined 'low voltage range'. This "
                        "will be ignored.\n", mmc_hostname(host));
@@ -816,20 +1164,20 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
                 goto err;
 
         mmc_release_host(host);
-
         err = mmc_add_card(host->card);
+        mmc_claim_host(host);
         if (err)
                 goto remove_card;
 
         return 0;
 
 remove_card:
+        mmc_release_host(host);
         mmc_remove_card(host->card);
         host->card = NULL;
         mmc_claim_host(host);
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising SD card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/sd.h b/drivers/mmc/core/sd.h
index 3d8800fa7600..4b34b24f3f76 100644
--- a/drivers/mmc/core/sd.h
+++ b/drivers/mmc/core/sd.h
@@ -5,7 +5,7 @@
 
 extern struct device_type sd_type;
 
-int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid);
+int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr);
 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card);
 void mmc_decode_cid(struct mmc_card *card);
 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 797cdb5887fd..021fed153804 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -9,6 +9,7 @@
  * your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 
@@ -20,10 +21,10 @@
 #include "core.h"
 #include "sd_ops.h"
 
-static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
+int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(card && (card->host != host));
@@ -48,6 +49,7 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(mmc_app_cmd);
 
 /**
  *      mmc_wait_for_app_cmd - start an application command and wait for
@@ -65,7 +67,7 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
         struct mmc_command *cmd, int retries)
 {
-        struct mmc_request mrq;
+        struct mmc_request mrq = {0};
 
         int i, err;
 
@@ -118,13 +120,11 @@ EXPORT_SYMBOL(mmc_wait_for_app_cmd);
 int mmc_app_set_bus_width(struct mmc_card *card, int width)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_APP_SET_BUS_WIDTH;
         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
@@ -148,13 +148,11 @@ int mmc_app_set_bus_width(struct mmc_card *card, int width)
 
 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_APP_OP_COND;
         if (mmc_host_is_spi(host))
                 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
@@ -193,7 +191,7 @@ int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
         static const u8 test_pattern = 0xAA;
         u8 result_pattern;
@@ -225,13 +223,11 @@ int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!rca);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_SEND_RELATIVE_ADDR;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
@@ -248,10 +244,11 @@ int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
 {
         int err;
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
+        void *data_buf;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
@@ -263,9 +260,12 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         if (err)
                 return err;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
+        if (data_buf == NULL)
+                return -ENOMEM;
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -280,12 +280,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, scr, 8);
+        sg_init_one(&sg, data_buf, 8);
 
         mmc_set_data_timeout(&data, card);
 
         mmc_wait_for_req(card->host, &mrq);
 
+        memcpy(scr, data_buf, sizeof(card->raw_scr));
+        kfree(data_buf);
+
         if (cmd.error)
                 return cmd.error;
         if (data.error)
@@ -300,9 +303,9 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         u8 value, u8 *resp)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -313,10 +316,6 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         mode = !!mode;
         value &= 0xF;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
@@ -349,9 +348,9 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
 int mmc_app_sd_status(struct mmc_card *card, void *ssr)
 {
         int err;
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -364,10 +363,6 @@ int mmc_app_sd_status(struct mmc_card *card, void *ssr)
         if (err)
                 return err;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index f332c52968b7..262fff019177 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -10,11 +10,13 @@
  */
 
 #include <linux/err.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
 
 #include "core.h"
 #include "bus.h"
@@ -30,6 +32,11 @@ static int sdio_read_fbr(struct sdio_func *func)
         int ret;
         unsigned char data;
 
+        if (mmc_card_nonstd_func_interface(func->card)) {
+                func->class = SDIO_CLASS_NONE;
+                return 0;
+        }
+
         ret = mmc_io_rw_direct(func->card, 0, 0,
                 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
         if (ret)
@@ -180,7 +187,7 @@ static int sdio_disable_cd(struct mmc_card *card)
         int ret;
         u8 ctrl;
 
-        if (!card->cccr.disable_cd)
+        if (!mmc_card_disable_cd(card))
                 return 0;
 
         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
@@ -362,8 +369,8 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 goto err;
         }
 
-        if (ocr & R4_MEMORY_PRESENT
-            && mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid) == 0) {
+        if ((ocr & R4_MEMORY_PRESENT) &&
+            mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid, NULL) == 0) {
                 card->type = MMC_TYPE_SD_COMBO;
 
                 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
@@ -394,6 +401,14 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 if (err)
                         goto remove;
 
+                /*
+                 * Update oldcard with the new RCA received from the SDIO
+                 * device -- we're doing this so that it's updated in the
+                 * "card" struct when oldcard overwrites that later.
+                 */
+                if (oldcard)
+                        oldcard->rca = card->rca;
+
                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
         }
 
@@ -456,8 +471,8 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                         return -ENOENT;
 
                 card = oldcard;
-                return 0;
         }
+        mmc_fixup_device(card, NULL);
 
         if (card->type == MMC_TYPE_SD_COMBO) {
                 err = mmc_sd_setup_card(host, card, oldcard != NULL);
@@ -546,6 +561,13 @@ static void mmc_sdio_detect(struct mmc_host *host)
         BUG_ON(!host);
         BUG_ON(!host->card);
 
+        /* Make sure card is powered before detecting it */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD) {
+                err = pm_runtime_get_sync(&host->card->dev);
+                if (err < 0)
+                        goto out;
+        }
+
         mmc_claim_host(host);
 
         /*
@@ -555,6 +577,21 @@ static void mmc_sdio_detect(struct mmc_host *host)
 
         mmc_release_host(host);
 
+        /*
+         * Tell PM core it's OK to power off the card now.
+         *
+         * The _sync variant is used in order to ensure that the card
+         * is left powered off in case an error occurred, and the card
+         * is going to be removed.
+         *
+         * Since there is no specific reason to believe a new user
+         * is about to show up at this point, the _sync variant is
+         * desirable anyway.
+         */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_sync(&host->card->dev);
+
+out:
         if (err) {
                 mmc_sdio_remove(host);
 
@@ -594,7 +631,7 @@ static int mmc_sdio_suspend(struct mmc_host *host)
                 }
         }
 
-        if (!err && host->pm_flags & MMC_PM_KEEP_POWER) {
+        if (!err && mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
                 mmc_claim_host(host);
                 sdio_disable_wide(host->card);
                 mmc_release_host(host);
@@ -605,23 +642,27 @@ static int mmc_sdio_suspend(struct mmc_host *host)
 
 static int mmc_sdio_resume(struct mmc_host *host)
 {
-        int i, err;
+        int i, err = 0;
 
         BUG_ON(!host);
         BUG_ON(!host->card);
 
         /* Basic card reinitialization. */
         mmc_claim_host(host);
-        err = mmc_sdio_init_card(host, host->ocr, host->card,
-                                 (host->pm_flags & MMC_PM_KEEP_POWER));
-        if (!err) {
-                /* We may have switched to 1-bit mode during suspend. */
+
+        /* No need to reinitialize powered-resumed nonremovable cards */
+        if (mmc_card_is_removable(host) || !mmc_card_keep_power(host))
+                err = mmc_sdio_init_card(host, host->ocr, host->card,
+                                        mmc_card_keep_power(host));
+        else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
+                /* We may have switched to 1-bit mode during suspend */
                 err = sdio_enable_4bit_bus(host->card);
                 if (err > 0) {
                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
                         err = 0;
                 }
         }
+
         if (!err && host->sdio_irqs)
                 mmc_signal_sdio_irq(host);
         mmc_release_host(host);
@@ -647,27 +688,90 @@ static int mmc_sdio_resume(struct mmc_host *host)
         return err;
 }
 
+static int mmc_sdio_power_restore(struct mmc_host *host)
+{
+        int ret;
+        u32 ocr;
+
+        BUG_ON(!host);
+        BUG_ON(!host->card);
+
+        mmc_claim_host(host);
+
+        /*
+         * Reset the card by performing the same steps that are taken by
+         * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
+         *
+         * sdio_reset() is technically not needed. Having just powered up the
+         * hardware, it should already be in reset state. However, some
+         * platforms (such as SD8686 on OLPC) do not instantly cut power,
+         * meaning that a reset is required when restoring power soon after
+         * powering off. It is harmless in other cases.
+         *
+         * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
+         * is not necessary for non-removable cards. However, it is required
+         * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
+         * harmless in other situations.
+         *
+         * With these steps taken, mmc_select_voltage() is also required to
+         * restore the correct voltage setting of the card.
+         */
+        sdio_reset(host);
+        mmc_go_idle(host);
+        mmc_send_if_cond(host, host->ocr_avail);
+
+        ret = mmc_send_io_op_cond(host, 0, &ocr);
+        if (ret)
+                goto out;
+
+        if (host->ocr_avail_sdio)
+                host->ocr_avail = host->ocr_avail_sdio;
+
+        host->ocr = mmc_select_voltage(host, ocr & ~0x7F);
+        if (!host->ocr) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = mmc_sdio_init_card(host, host->ocr, host->card,
+                                mmc_card_keep_power(host));
+        if (!ret && host->sdio_irqs)
+                mmc_signal_sdio_irq(host);
+
+out:
+        mmc_release_host(host);
+
+        return ret;
+}
+
 static const struct mmc_bus_ops mmc_sdio_ops = {
         .remove = mmc_sdio_remove,
         .detect = mmc_sdio_detect,
         .suspend = mmc_sdio_suspend,
         .resume = mmc_sdio_resume,
+        .power_restore = mmc_sdio_power_restore,
 };
 
 
 /*
  * Starting point for SDIO card init.
  */
-int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
+int mmc_attach_sdio(struct mmc_host *host)
 {
-        int err;
-        int i, funcs;
+        int err, i, funcs;
+        u32 ocr;
         struct mmc_card *card;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        err = mmc_send_io_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_attach_bus(host, &mmc_sdio_ops);
+        if (host->ocr_avail_sdio)
+                host->ocr_avail = host->ocr_avail_sdio;
 
         /*
          * Sanity check the voltages that the card claims to
@@ -699,6 +803,23 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
         card = host->card;
 
         /*
+         * Enable runtime PM only if supported by host+card+board
+         */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD) {
+                /*
+                 * Let runtime PM core know our card is active
+                 */
+                err = pm_runtime_set_active(&card->dev);
+                if (err)
+                        goto remove;
+
+                /*
+                 * Enable runtime PM for this card
+                 */
+                pm_runtime_enable(&card->dev);
+        }
+
+        /*
          * The number of functions on the card is encoded inside
          * the ocr.
          */
@@ -712,13 +833,18 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                 err = sdio_init_func(host->card, i + 1);
                 if (err)
                         goto remove;
-        }
 
-        mmc_release_host(host);
+                /*
+                 * Enable Runtime PM for this func (if supported)
+                 */
+                if (host->caps & MMC_CAP_POWER_OFF_CARD)
+                        pm_runtime_enable(&card->sdio_func[i]->dev);
+        }
 
         /*
          * First add the card to the driver model...
          */
+        mmc_release_host(host);
         err = mmc_add_card(host->card);
         if (err)
                 goto remove_added;
@@ -732,6 +858,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                         goto remove_added;
         }
 
+        mmc_claim_host(host);
         return 0;
 
 
@@ -741,11 +868,12 @@ remove_added:
         mmc_claim_host(host);
 remove:
         /* And with lock if it hasn't been added. */
+        mmc_release_host(host);
         if (host->card)
                 mmc_sdio_remove(host);
+        mmc_claim_host(host);
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising SDIO card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 4a890dcb95ab..d2565df8a7fb 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -14,8 +14,10 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
 #include <linux/mmc/sdio_func.h>
 
 #include "sdio_cis.h"
@@ -125,21 +127,51 @@ static int sdio_bus_probe(struct device *dev)
         if (!id)
                 return -ENODEV;
 
+        /* Unbound SDIO functions are always suspended.
+         * During probe, the function is set active and the usage count
+         * is incremented.  If the driver supports runtime PM,
+         * it should call pm_runtime_put_noidle() in its probe routine and
+         * pm_runtime_get_noresume() in its remove routine.
+         */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
+                ret = pm_runtime_get_sync(dev);
+                if (ret < 0)
+                        goto out;
+        }
+
         /* Set the default block size so the driver is sure it's something
          * sensible. */
         sdio_claim_host(func);
         ret = sdio_set_block_size(func, 0);
         sdio_release_host(func);
         if (ret)
-                return ret;
+                goto disable_runtimepm;
+
+        ret = drv->probe(func, id);
+        if (ret)
+                goto disable_runtimepm;
+
+        return 0;
 
-        return drv->probe(func, id);
+disable_runtimepm:
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_noidle(dev);
+out:
+        return ret;
 }
 
 static int sdio_bus_remove(struct device *dev)
 {
         struct sdio_driver *drv = to_sdio_driver(dev->driver);
         struct sdio_func *func = dev_to_sdio_func(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;
+        }
 
         drv->remove(func);
 
@@ -151,9 +183,36 @@ static int sdio_bus_remove(struct device *dev)
                 sdio_release_host(func);
         }
 
-        return 0;
+        /* First, undo the increment made directly above */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_noidle(dev);
+
+        /* Then undo the runtime PM settings in sdio_bus_probe() */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_sync(dev);
+
+out:
+        return ret;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static const struct dev_pm_ops sdio_bus_pm_ops = {
+        SET_RUNTIME_PM_OPS(
+                pm_generic_runtime_suspend,
+                pm_generic_runtime_resume,
+                pm_generic_runtime_idle
+        )
+};
+
+#define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
+
+#else /* !CONFIG_PM_RUNTIME */
+
+#define SDIO_PM_OPS_PTR NULL
+
+#endif /* !CONFIG_PM_RUNTIME */
+
 static struct bus_type sdio_bus_type = {
         .name           = "sdio",
         .dev_attrs      = sdio_dev_attrs,
@@ -161,6 +220,7 @@ static struct bus_type sdio_bus_type = {
         .uevent         = sdio_bus_uevent,
         .probe          = sdio_bus_probe,
         .remove         = sdio_bus_remove,
+        .pm             = SDIO_PM_OPS_PTR,
 };
 
 int sdio_register_bus(void)
diff --git a/drivers/mmc/core/sdio_irq.c b/drivers/mmc/core/sdio_irq.c
index bb192f90e8e9..03ead028d2ce 100644
--- a/drivers/mmc/core/sdio_irq.c
+++ b/drivers/mmc/core/sdio_irq.c
@@ -31,6 +31,17 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
 {
         int i, ret, count;
         unsigned char pending;
+        struct sdio_func *func;
+
+        /*
+         * Optimization, if there is only 1 function interrupt registered
+         * call irq handler directly
+         */
+        func = card->sdio_single_irq;
+        if (func) {
+                func->irq_handler(func);
+                return 1;
+        }
 
         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending);
         if (ret) {
@@ -42,10 +53,10 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
         count = 0;
         for (i = 1; i <= 7; i++) {
                 if (pending & (1 << i)) {
-                        struct sdio_func *func = card->sdio_func[i - 1];
+                        func = card->sdio_func[i - 1];
                         if (!func) {
                                 printk(KERN_WARNING "%s: pending IRQ for "
-                                        "non-existant function\n",
+                                        "non-existent function\n",
                                         mmc_card_id(card));
                                 ret = -EINVAL;
                         } else if (func->irq_handler) {
@@ -186,6 +197,24 @@ static int sdio_card_irq_put(struct mmc_card *card)
         return 0;
 }
 
+/* If there is only 1 function registered set sdio_single_irq */
+static void sdio_single_irq_set(struct mmc_card *card)
+{
+        struct sdio_func *func;
+        int i;
+
+        card->sdio_single_irq = NULL;
+        if ((card->host->caps & MMC_CAP_SDIO_IRQ) &&
+            card->host->sdio_irqs == 1)
+                for (i = 0; i < card->sdio_funcs; i++) {
+                       func = card->sdio_func[i];
+                       if (func && func->irq_handler) {
+                               card->sdio_single_irq = func;
+                               break;
+                       }
+               }
+}
+
 /**
  *      sdio_claim_irq - claim the IRQ for a SDIO function
  *      @func: SDIO function
@@ -227,6 +256,7 @@ int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
         ret = sdio_card_irq_get(func->card);
         if (ret)
                 func->irq_handler = NULL;
+        sdio_single_irq_set(func->card);
 
         return ret;
 }
@@ -251,6 +281,7 @@ int sdio_release_irq(struct sdio_func *func)
         if (func->irq_handler) {
                 func->irq_handler = NULL;
                 sdio_card_irq_put(func->card);
+                sdio_single_irq_set(func->card);
         }
 
         ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index dea36d9c22e6..f087d876c573 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -21,13 +21,11 @@
 
 int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_IO_SEND_OP_COND;
         cmd.arg = ocr;
         cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
@@ -70,7 +68,7 @@ int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
         unsigned addr, u8 in, u8 *out)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
         BUG_ON(!host);
@@ -80,8 +78,6 @@ static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
         if (addr & ~0x1FFFF)
                 return -EINVAL;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_IO_RW_DIRECT;
         cmd.arg = write ? 0x80000000 : 0x00000000;
         cmd.arg |= fn << 28;
@@ -125,9 +121,9 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -140,10 +136,6 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         if (addr & ~0x1FFFF)
                 return -EINVAL;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 68d12794cfd9..56dbf3f6ad08 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -83,7 +83,7 @@ config MMC_RICOH_MMC
 
 config MMC_SDHCI_OF
         tristate "SDHCI support on OpenFirmware platforms"
-        depends on MMC_SDHCI && PPC_OF
+        depends on MMC_SDHCI && OF
         help
           This selects the OF support for Secure Digital Host Controller
           Interfaces.
@@ -93,6 +93,7 @@ config MMC_SDHCI_OF
 config MMC_SDHCI_OF_ESDHC
         bool "SDHCI OF support for the Freescale eSDHC controller"
         depends on MMC_SDHCI_OF
+        depends on PPC_OF
         select MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
         help
           This selects the Freescale eSDHC controller support.
@@ -102,6 +103,7 @@ config MMC_SDHCI_OF_ESDHC
 config MMC_SDHCI_OF_HLWD
         bool "SDHCI OF support for the Nintendo Wii SDHCI controllers"
         depends on MMC_SDHCI_OF
+        depends on PPC_OF
         select MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER
         help
           This selects the Secure Digital Host Controller Interface (SDHCI)
@@ -130,6 +132,37 @@ config MMC_SDHCI_CNS3XXX
 
           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)
+        select MMC_SDHCI_IO_ACCESSORS
+        help
+          This selects the Freescale eSDHC controller support on the platform
+          bus, found on platforms like mx35/51.
+
+          If unsure, say N.
+
+config MMC_SDHCI_DOVE
+        bool "SDHCI support on Marvell's Dove SoC"
+        depends on ARCH_DOVE
+        depends on MMC_SDHCI_PLTFM
+        select MMC_SDHCI_IO_ACCESSORS
+        help
+          This selects the Secure Digital Host Controller Interface in
+          Marvell's Dove SoC.
+
+          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
+        select MMC_SDHCI_IO_ACCESSORS
+        help
+          This selects the Tegra SD/MMC controller. If you have a Tegra
+          platform with SD or MMC devices, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_SDHCI_S3C
         tristate "SDHCI support on Samsung S3C SoC"
         depends on MMC_SDHCI && PLAT_SAMSUNG
@@ -145,6 +178,18 @@ 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
+        select MMC_SDHCI
+        select MMC_SDHCI_IO_ACCESSORS
+        help
+          This selects the Marvell(R) PXA168/PXA910/MMP2 SD Host Controller.
+          If you have a PXA168/PXA910/MMP2 platform with SD Host Controller
+          and a card slot, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_SDHCI_SPEAR
         tristate "SDHCI support on ST SPEAr platform"
         depends on MMC_SDHCI && PLAT_SPEAR
@@ -180,7 +225,7 @@ config MMC_OMAP
 
 config MMC_OMAP_HS
         tristate "TI OMAP High Speed Multimedia Card Interface support"
-        depends on ARCH_OMAP2430 || ARCH_OMAP3 || ARCH_OMAP4
+        depends on SOC_OMAP2430 || ARCH_OMAP3 || ARCH_OMAP4
         help
           This selects the TI OMAP High Speed Multimedia card Interface.
           If you have an OMAP2430 or OMAP3 board or OMAP4 board with a
@@ -237,7 +282,7 @@ endchoice
 
 config MMC_ATMELMCI_DMA
         bool "Atmel MCI DMA support (EXPERIMENTAL)"
-        depends on MMC_ATMELMCI && AVR32 && DMA_ENGINE && EXPERIMENTAL
+        depends on MMC_ATMELMCI && (AVR32 || ARCH_AT91SAM9G45) && DMA_ENGINE && EXPERIMENTAL
         help
           Say Y here to have the Atmel MCI driver use a DMA engine to
           do data transfers and thus increase the throughput and
@@ -266,7 +311,7 @@ config MMC_MSM
 
 config MMC_MXC
         tristate "Freescale i.MX2/3 Multimedia Card Interface support"
-        depends on ARCH_MXC
+        depends on MACH_MX21 || MACH_MX27 || ARCH_MX31
         help
           This selects the Freescale i.MX2/3 Multimedia card Interface.
           If you have a i.MX platform with a Multimedia Card slot,
@@ -274,6 +319,15 @@ config MMC_MXC
 
           If unsure, say N.
 
+config MMC_MXS
+        tristate "Freescale MXS Multimedia Card Interface support"
+        depends on ARCH_MXS && MXS_DMA
+        help
+          This selects the Freescale SSP MMC controller found on MXS based
+          platforms like mx23/28.
+
+          If unsure, say N.
+
 config MMC_TIFM_SD
         tristate "TI Flash Media MMC/SD Interface support  (EXPERIMENTAL)"
         depends on EXPERIMENTAL && PCI
@@ -385,16 +439,29 @@ config MMC_SDRICOH_CS
           To compile this driver as a module, choose M here: the
           module will be called sdricoh_cs.
 
+config MMC_TMIO_CORE
+        tristate
+
 config MMC_TMIO
         tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"
-        depends on MFD_TMIO || MFD_ASIC3 || MFD_SH_MOBILE_SDHI
+        depends on MFD_TMIO || MFD_ASIC3
+        select MMC_TMIO_CORE
         help
           This provides support for the SD/MMC cell found in TC6393XB,
           T7L66XB and also HTC ASIC3
 
+config MMC_SDHI
+        tristate "SH-Mobile SDHI SD/SDIO controller support"
+        depends on SUPERH || ARCH_SHMOBILE
+        select MMC_TMIO_CORE
+        help
+          This provides support for the SDHI SD/SDIO controller found in
+          SuperH and ARM SH-Mobile SoCs
+
 config MMC_CB710
         tristate "ENE CB710 MMC/SD Interface support"
         depends on PCI
+        select MISC_DEVICES
         select CB710_CORE
         help
           This option enables support for MMC/SD part of ENE CB710/720 Flash
@@ -435,11 +502,27 @@ config SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
         help
           If you say yes here SD-Cards may work on the EZkit.
 
+config MMC_DW
+        tristate "Synopsys DesignWare Memory Card Interface"
+        depends on ARM
+        help
+          This selects support for the Synopsys DesignWare Mobile Storage IP
+          block, this provides host support for SD and MMC interfaces, in both
+          PIO and external DMA modes.
+
+config MMC_DW_IDMAC
+        bool "Internal DMAC interface"
+        depends on MMC_DW
+        help
+          This selects support for the internal DMAC block within the Synopsys
+          Designware Mobile Storage IP block. This disables the external DMA
+          interface.
+
 config MMC_SH_MMCIF
         tristate "SuperH Internal MMCIF support"
         depends on MMC_BLOCK && (SUPERH || ARCH_SHMOBILE)
         help
-          This selects the MMC Host Interface controler (MMCIF).
+          This selects the MMC Host Interface controller (MMCIF).
 
           This driver supports MMCIF in sh7724/sh7757/sh7372.
 
@@ -451,3 +534,48 @@ config MMC_JZ4740
           SoCs.
           If you have a board based on such a SoC and with a SD/MMC slot,
           say Y or M here.
+
+config MMC_VUB300
+        tristate "VUB300 USB to SDIO/SD/MMC Host Controller support"
+        depends on USB
+        help
+          This selects support for Elan Digital Systems' VUB300 chip.
+
+          The VUB300 is a USB-SDIO Host Controller Interface chip
+          that enables the host computer to use SDIO/SD/MMC cards
+          via a USB 2.0 or USB 1.1 host.
+
+          The VUB300 chip will be found in both physically separate
+          USB to SDIO/SD/MMC adapters and embedded on some motherboards.
+
+          The VUB300 chip supports SD and MMC memory cards in addition
+          to single and multifunction SDIO cards.
+
+          Some SDIO cards will need a firmware file to be loaded and
+          sent to VUB300 chip in order to achieve better data throughput.
+          Download these "Offload Pseudocode" from Elan Digital Systems'
+          web-site http://www.elandigitalsystems.com/support/downloads.php
+          and put them in /lib/firmware. Note that without these additional
+          firmware files the VUB300 chip will still function, but not at
+          the best obtainable data rate.
+
+          To compile this mmc host controller driver as a module,
+          choose M here: the module will be called vub300.
+
+          If you have a computer with an embedded VUB300 chip
+          or if you intend connecting a USB adapter based on a
+          VUB300 chip say Y or M here.
+
+config MMC_USHC
+        tristate "USB SD Host Controller (USHC) support"
+        depends on USB
+        help
+          This selects support for USB SD Host Controllers based on
+          the Cypress Astoria chip with firmware compliant with CSR's
+          USB SD Host Controller specification (CS-118793-SP).
+
+          CSR boards with this device include: USB<>SDIO (M1985v2),
+          and Ultrasira.
+
+          Note: These controllers only support SDIO cards and do not
+          support MMC or SD memory cards.
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 840bcb52d82f..58a5cf73d6e9 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -2,16 +2,14 @@
 # Makefile for MMC/SD host controller drivers
 #
 
-ifeq ($(CONFIG_MMC_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
-
 obj-$(CONFIG_MMC_ARMMMCI)       += mmci.o
 obj-$(CONFIG_MMC_PXA)           += pxamci.o
 obj-$(CONFIG_MMC_IMX)           += imxmmc.o
 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_S3C)     += sdhci-s3c.o
 obj-$(CONFIG_MMC_SDHCI_SPEAR)   += sdhci-spear.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
@@ -31,15 +29,27 @@ endif
 obj-$(CONFIG_MMC_S3C)           += s3cmci.o
 obj-$(CONFIG_MMC_SDRICOH_CS)    += sdricoh_cs.o
 obj-$(CONFIG_MMC_TMIO)          += tmio_mmc.o
-obj-$(CONFIG_MMC_CB710) += cb710-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
+obj-$(CONFIG_MMC_SDHI)          += sh_mobile_sdhi.o
+obj-$(CONFIG_MMC_CB710)         += cb710-mmc.o
 obj-$(CONFIG_MMC_VIA_SDMMC)     += via-sdmmc.o
 obj-$(CONFIG_SDH_BFIN)          += bfin_sdh.o
+obj-$(CONFIG_MMC_DW)            += dw_mmc.o
 obj-$(CONFIG_MMC_SH_MMCIF)      += sh_mmcif.o
 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
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 87226cd202a5..d3e6a962f423 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -69,6 +69,7 @@
 #include <linux/highmem.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/sdio.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -493,10 +494,14 @@ static void at91_mci_send_command(struct at91mci_host *host, struct mmc_command
                 else if (data->flags & MMC_DATA_WRITE)
                         cmdr |= AT91_MCI_TRCMD_START;
 
-                if (data->flags & MMC_DATA_STREAM)
-                        cmdr |= AT91_MCI_TRTYP_STREAM;
-                if (data->blocks > 1)
-                        cmdr |= AT91_MCI_TRTYP_MULTIPLE;
+                if (cmd->opcode == SD_IO_RW_EXTENDED) {
+                        cmdr |= AT91_MCI_TRTYP_SDIO_BLOCK;
+                } else {
+                        if (data->flags & MMC_DATA_STREAM)
+                                cmdr |= AT91_MCI_TRTYP_STREAM;
+                        if (data->blocks > 1)
+                                cmdr |= AT91_MCI_TRTYP_MULTIPLE;
+                }
         }
         else {
                 block_length = 0;
@@ -928,7 +933,7 @@ static int __init at91_mci_probe(struct platform_device *pdev)
         if (!res)
                 return -ENXIO;
 
-        if (!request_mem_region(res->start, res->end - res->start + 1, DRIVER_NAME))
+        if (!request_mem_region(res->start, resource_size(res), DRIVER_NAME))
                 return -EBUSY;
 
         mmc = mmc_alloc_host(sizeof(struct at91mci_host), &pdev->dev);
@@ -947,8 +952,7 @@ static int __init at91_mci_probe(struct platform_device *pdev)
         mmc->max_blk_size  = MCI_MAXBLKSIZE;
         mmc->max_blk_count = MCI_BLKATONCE;
         mmc->max_req_size  = MCI_BUFSIZE;
-        mmc->max_phys_segs = MCI_BLKATONCE;
-        mmc->max_hw_segs   = MCI_BLKATONCE;
+        mmc->max_segs      = MCI_BLKATONCE;
         mmc->max_seg_size  = MCI_BUFSIZE;
 
         host = mmc_priv(mmc);
@@ -1017,7 +1021,7 @@ static int __init at91_mci_probe(struct platform_device *pdev)
         /*
          * Map I/O region
          */
-        host->baseaddr = ioremap(res->start, res->end - res->start + 1);
+        host->baseaddr = ioremap(res->start, resource_size(res));
         if (!host->baseaddr) {
                 ret = -ENOMEM;
                 goto fail1;
@@ -1093,7 +1097,7 @@ fail4b:
 fail5:
         mmc_free_host(mmc);
 fail6:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
         dev_err(&pdev->dev, "probe failed, err %d\n", ret);
         return ret;
 }
@@ -1138,7 +1142,7 @@ static int __exit at91_mci_remove(struct platform_device *pdev)
 
         iounmap(host->baseaddr);
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
 
         mmc_free_host(mmc);
         platform_set_drvdata(pdev, NULL);
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 95ef864ad8f9..aa8039f473c4 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -26,6 +26,7 @@
 #include <linux/stat.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/sdio.h>
 
 #include <mach/atmel-mci.h>
 #include <linux/atmel-mci.h>
@@ -126,7 +127,7 @@ struct atmel_mci_dma {
  * EVENT_DATA_COMPLETE is set in @pending_events, all data-related
  * interrupts must be disabled and @data_status updated with a
  * snapshot of SR. Similarly, before EVENT_CMD_COMPLETE is set, the
- * CMDRDY interupt must be disabled and @cmd_status updated with a
+ * CMDRDY interrupt must be disabled and @cmd_status updated with a
  * snapshot of SR, and before EVENT_XFER_COMPLETE can be set, the
  * bytes_xfered field of @data must be written. This is ensured by
  * using barriers.
@@ -532,12 +533,17 @@ static u32 atmci_prepare_command(struct mmc_host *mmc,
         data = cmd->data;
         if (data) {
                 cmdr |= MCI_CMDR_START_XFER;
-                if (data->flags & MMC_DATA_STREAM)
-                        cmdr |= MCI_CMDR_STREAM;
-                else if (data->blocks > 1)
-                        cmdr |= MCI_CMDR_MULTI_BLOCK;
-                else
-                        cmdr |= MCI_CMDR_BLOCK;
+
+                if (cmd->opcode == SD_IO_RW_EXTENDED) {
+                        cmdr |= MCI_CMDR_SDIO_BLOCK;
+                } else {
+                        if (data->flags & MMC_DATA_STREAM)
+                                cmdr |= MCI_CMDR_STREAM;
+                        else if (data->blocks > 1)
+                                cmdr |= MCI_CMDR_MULTI_BLOCK;
+                        else
+                                cmdr |= MCI_CMDR_BLOCK;
+                }
 
                 if (data->flags & MMC_DATA_READ)
                         cmdr |= MCI_CMDR_TRDIR_READ;
@@ -572,7 +578,8 @@ static void atmci_dma_cleanup(struct atmel_mci *host)
         struct mmc_data                 *data = host->data;
 
         if (data)
-                dma_unmap_sg(&host->pdev->dev, data->sg, data->sg_len,
+                dma_unmap_sg(host->dma.chan->device->dev,
+                             data->sg, data->sg_len,
                              ((data->flags & MMC_DATA_WRITE)
                               ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
 }
@@ -582,7 +589,7 @@ static void atmci_stop_dma(struct atmel_mci *host)
         struct dma_chan *chan = host->data_chan;
 
         if (chan) {
-          chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
+                dmaengine_terminate_all(chan);
                 atmci_dma_cleanup(host);
         } else {
                 /* Data transfer was stopped by the interrupt handler */
@@ -678,11 +685,11 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
         else
                 direction = DMA_TO_DEVICE;
 
-        sglen = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len, direction);
-        if (sglen != data->sg_len)
-                goto unmap_exit;
+        sglen = dma_map_sg(chan->device->dev, data->sg,
+                           data->sg_len, direction);
+
         desc = chan->device->device_prep_slave_sg(chan,
-                        data->sg, data->sg_len, direction,
+                        data->sg, sglen, direction,
                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc)
                 goto unmap_exit;
@@ -693,7 +700,7 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
 
         return 0;
 unmap_exit:
-        dma_unmap_sg(&host->pdev->dev, data->sg, sglen, direction);
+        dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, direction);
         return -ENOMEM;
 }
 
@@ -703,8 +710,8 @@ static void atmci_submit_data(struct atmel_mci *host)
         struct dma_async_tx_descriptor  *desc = host->dma.data_desc;
 
         if (chan) {
-                desc->tx_submit(desc);
-                chan->device->device_issue_pending(chan);
+                dmaengine_submit(desc);
+                dma_async_issue_pending(chan);
         }
 }
 
@@ -1075,7 +1082,7 @@ static void atmci_request_end(struct atmel_mci *host, struct mmc_request *mrq)
         /*
          * Update the MMC clock rate if necessary. This may be
          * necessary if set_ios() is called when a different slot is
-         * busy transfering data.
+         * busy transferring data.
          */
         if (host->need_clock_update) {
                 mci_writel(host, MR, host->mode_reg);
@@ -1618,8 +1625,7 @@ static int __init atmci_init_slot(struct atmel_mci *host,
         if (slot_data->bus_width >= 4)
                 mmc->caps |= MMC_CAP_4_BIT_DATA;
 
-        mmc->max_hw_segs = 64;
-        mmc->max_phys_segs = 64;
+        mmc->max_segs = 64;
         mmc->max_req_size = 32768 * 512;
         mmc->max_blk_size = 32768;
         mmc->max_blk_count = 512;
@@ -1777,7 +1783,7 @@ static int __init atmci_probe(struct platform_device *pdev)
         }
 
         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_ioremap;
 
@@ -1893,5 +1899,5 @@ late_initcall(atmci_init); /* try to load after dma driver when built-in */
 module_exit(atmci_exit);
 
 MODULE_DESCRIPTION("Atmel Multimedia Card Interface driver");
-MODULE_AUTHOR("Haavard Skinnemoen <haavard.skinnemoen@atmel.com>");
+MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index c8da5d30a861..ef72e874ca36 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -192,7 +192,7 @@ static inline void SEND_STOP(struct au1xmmc_host *host)
         au_writel(config2 | SD_CONFIG2_DF, HOST_CONFIG2(host));
         au_sync();
 
-        /* Send the stop commmand */
+        /* Send the stop command */
         au_writel(STOP_CMD, HOST_CMD(host));
 }
 
@@ -964,7 +964,7 @@ static int __devinit au1xmmc_probe(struct platform_device *pdev)
                 goto out1;
         }
 
-        host->ioarea = request_mem_region(r->start, r->end - r->start + 1,
+        host->ioarea = request_mem_region(r->start, resource_size(r),
                                            pdev->name);
         if (!host->ioarea) {
                 dev_err(&pdev->dev, "mmio already in use\n");
@@ -998,7 +998,7 @@ static int __devinit au1xmmc_probe(struct platform_device *pdev)
         mmc->f_max = 24000000;
 
         mmc->max_seg_size = AU1XMMC_DESCRIPTOR_SIZE;
-        mmc->max_phys_segs = AU1XMMC_DESCRIPTOR_COUNT;
+        mmc->max_segs = AU1XMMC_DESCRIPTOR_COUNT;
 
         mmc->max_blk_size = 2048;
         mmc->max_blk_count = 512;
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index 4b0e677d7295..0371bf502249 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -462,14 +462,14 @@ static int __devinit sdh_probe(struct platform_device *pdev)
                 goto out;
         }
 
-        mmc = mmc_alloc_host(sizeof(*mmc), &pdev->dev);
+        mmc = mmc_alloc_host(sizeof(struct sdh_host), &pdev->dev);
         if (!mmc) {
                 ret = -ENOMEM;
                 goto out;
         }
 
         mmc->ops = &sdh_ops;
-        mmc->max_phys_segs = 32;
+        mmc->max_segs = 32;
         mmc->max_seg_size = 1 << 16;
         mmc->max_blk_size = 1 << 11;
         mmc->max_blk_count = 1 << 11;
diff --git a/drivers/mmc/host/cb710-mmc.c b/drivers/mmc/host/cb710-mmc.c
index ca3bdc831900..ce2a47b71dd6 100644
--- a/drivers/mmc/host/cb710-mmc.c
+++ b/drivers/mmc/host/cb710-mmc.c
@@ -25,7 +25,7 @@ static const u8 cb710_src_freq_mhz[16] = {
         50, 55, 60, 65, 70, 75, 80, 85
 };
 
-static void cb710_mmc_set_clock(struct mmc_host *mmc, int hz)
+static void cb710_mmc_select_clock_divider(struct mmc_host *mmc, int hz)
 {
         struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
         struct pci_dev *pdev = cb710_slot_to_chip(slot)->pdev;
@@ -33,8 +33,11 @@ static void cb710_mmc_set_clock(struct mmc_host *mmc, int hz)
         u32 divider_idx;
         int src_hz;
 
-        /* this is magic, unverifiable for me, unless I get
-         * MMC card with cables connected to bus signals */
+        /* on CB710 in HP nx9500:
+         *   src_freq_idx == 0
+         *   indexes 1-7 work as written in the table
+         *   indexes 0,8-15 give no clock output
+         */
         pci_read_config_dword(pdev, 0x48, &src_freq_idx);
         src_freq_idx = (src_freq_idx >> 16) & 0xF;
         src_hz = cb710_src_freq_mhz[src_freq_idx] * 1000000;
@@ -46,13 +49,15 @@ static void cb710_mmc_set_clock(struct mmc_host *mmc, int hz)
 
         if (src_freq_idx)
                 divider_idx |= 0x8;
+        else if (divider_idx == 0)
+                divider_idx = 1;
 
         cb710_pci_update_config_reg(pdev, 0x40, ~0xF0000000, divider_idx << 28);
 
         dev_dbg(cb710_slot_dev(slot),
-                "clock set to %d Hz, wanted %d Hz; flag = %d\n",
+                "clock set to %d Hz, wanted %d Hz; src_freq_idx = %d, divider_idx = %d|%d\n",
                 src_hz >> cb710_clock_divider_log2[divider_idx & 7],
-                hz, (divider_idx & 8) != 0);
+                hz, src_freq_idx, divider_idx & 7, divider_idx & 8);
 }
 
 static void __cb710_mmc_enable_irq(struct cb710_slot *slot,
@@ -95,16 +100,8 @@ static void cb710_mmc_reset_events(struct cb710_slot *slot)
         cb710_write_port_8(slot, CB710_MMC_STATUS2_PORT, 0xFF);
 }
 
-static int cb710_mmc_is_card_inserted(struct cb710_slot *slot)
-{
-        return cb710_read_port_8(slot, CB710_MMC_STATUS3_PORT)
-                & CB710_MMC_S3_CARD_DETECTED;
-}
-
 static void cb710_mmc_enable_4bit_data(struct cb710_slot *slot, int enable)
 {
-        dev_dbg(cb710_slot_dev(slot), "configuring %d-data-line%s mode\n",
-                enable ? 4 : 1, enable ? "s" : "");
         if (enable)
                 cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT,
                         CB710_MMC_C1_4BIT_DATA_BUS, 0);
@@ -208,7 +205,7 @@ static int cb710_wait_while_busy(struct cb710_slot *slot, uint8_t mask)
                         "WAIT12: waited %d loops, mask %02X, entry val %08X, exit val %08X\n",
                         limit, mask, e, x);
 #endif
-        return 0;
+        return err;
 }
 
 static void cb710_mmc_set_transfer_size(struct cb710_slot *slot,
@@ -494,13 +491,8 @@ static void cb710_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
         reader->mrq = mrq;
         cb710_mmc_enable_irq(slot, CB710_MMC_IE_TEST_MASK, 0);
 
-        if (cb710_mmc_is_card_inserted(slot)) {
-                if (!cb710_mmc_command(mmc, mrq->cmd) && mrq->stop)
-                        cb710_mmc_command(mmc, mrq->stop);
-                mdelay(1);
-        } else {
-                mrq->cmd->error = -ENOMEDIUM;
-        }
+        if (!cb710_mmc_command(mmc, mrq->cmd) && mrq->stop)
+                cb710_mmc_command(mmc, mrq->stop);
 
         tasklet_schedule(&reader->finish_req_tasklet);
 }
@@ -512,7 +504,7 @@ static int cb710_mmc_powerup(struct cb710_slot *slot)
 #endif
         int err;
 
-        /* a lot of magic; see comment in cb710_mmc_set_clock() */
+        /* a lot of magic for now */
         dev_dbg(cb710_slot_dev(slot), "bus powerup\n");
         cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
         err = cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
@@ -572,13 +564,7 @@ static void cb710_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         struct cb710_mmc_reader *reader = mmc_priv(mmc);
         int err;
 
-        cb710_mmc_set_clock(mmc, ios->clock);
-
-        if (!cb710_mmc_is_card_inserted(slot)) {
-                dev_dbg(cb710_slot_dev(slot),
-                        "no card inserted - ignoring bus powerup request\n");
-                ios->power_mode = MMC_POWER_OFF;
-        }
+        cb710_mmc_select_clock_divider(mmc, ios->clock);
 
         if (ios->power_mode != reader->last_power_mode)
         switch (ios->power_mode) {
@@ -619,6 +605,14 @@ static int cb710_mmc_get_ro(struct mmc_host *mmc)
                 & CB710_MMC_S3_WRITE_PROTECTED;
 }
 
+static int cb710_mmc_get_cd(struct mmc_host *mmc)
+{
+        struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
+
+        return cb710_read_port_8(slot, CB710_MMC_STATUS3_PORT)
+                & CB710_MMC_S3_CARD_DETECTED;
+}
+
 static int cb710_mmc_irq_handler(struct cb710_slot *slot)
 {
         struct mmc_host *mmc = cb710_slot_to_mmc(slot);
@@ -664,7 +658,8 @@ static void cb710_mmc_finish_request_tasklet(unsigned long data)
 static const struct mmc_host_ops cb710_mmc_host = {
         .request = cb710_mmc_request,
         .set_ios = cb710_mmc_set_ios,
-        .get_ro = cb710_mmc_get_ro
+        .get_ro = cb710_mmc_get_ro,
+        .get_cd = cb710_mmc_get_cd,
 };
 
 #ifdef CONFIG_PM
@@ -746,6 +741,7 @@ static int __devinit cb710_mmc_init(struct platform_device *pdev)
 err_free_mmc:
         dev_dbg(cb710_slot_dev(slot), "mmc_add_host() failed: %d\n", err);
 
+        cb710_set_irq_handler(slot, NULL);
         mmc_free_host(mmc);
         return err;
 }
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index 33d9f1b00862..0076c7448fe6 100644
--- a/drivers/mmc/host/davinci_mmc.c
+++ b/drivers/mmc/host/davinci_mmc.c
@@ -66,8 +66,8 @@
 #define DAVINCI_MMCBLNC      0x60
 #define DAVINCI_SDIOCTL      0x64
 #define DAVINCI_SDIOST0      0x68
-#define DAVINCI_SDIOEN       0x6C
-#define DAVINCI_SDIOST       0x70
+#define DAVINCI_SDIOIEN      0x6C
+#define DAVINCI_SDIOIST      0x70
 #define DAVINCI_MMCFIFOCTL   0x74 /* FIFO Control Register             */
 
 /* DAVINCI_MMCCTL definitions */
@@ -131,6 +131,14 @@
 #define MMCFIFOCTL_ACCWD_2    (2 << 3) /* access width of 2 bytes    */
 #define MMCFIFOCTL_ACCWD_1    (3 << 3) /* access width of 1 byte     */
 
+/* DAVINCI_SDIOST0 definitions */
+#define SDIOST0_DAT1_HI       BIT(0)
+
+/* DAVINCI_SDIOIEN definitions */
+#define SDIOIEN_IOINTEN       BIT(0)
+
+/* DAVINCI_SDIOIST definitions */
+#define SDIOIST_IOINT         BIT(0)
 
 /* MMCSD Init clock in Hz in opendrain mode */
 #define MMCSD_INIT_CLOCK                200000
@@ -138,7 +146,7 @@
 /*
  * One scatterlist dma "segment" is at most MAX_CCNT rw_threshold units,
  * and we handle up to MAX_NR_SG segments.  MMC_BLOCK_BOUNCE kicks in only
- * for drivers with max_hw_segs == 1, making the segments bigger (64KB)
+ * for drivers with max_segs == 1, making the segments bigger (64KB)
  * than the page or two that's otherwise typical. nr_sg (passed from
  * platform data) == 16 gives at least the same throughput boost, using
  * EDMA transfer linkage instead of spending CPU time copying pages.
@@ -164,7 +172,7 @@ struct mmc_davinci_host {
         unsigned int mmc_input_clk;
         void __iomem *base;
         struct resource *mem_res;
-        int irq;
+        int mmc_irq, sdio_irq;
         unsigned char bus_mode;
 
 #define DAVINCI_MMC_DATADIR_NONE        0
@@ -184,6 +192,7 @@ struct mmc_davinci_host {
         u32 rxdma, txdma;
         bool use_dma;
         bool do_dma;
+        bool sdio_int;
 
         /* Scatterlist DMA uses one or more parameter RAM entries:
          * the main one (associated with rxdma or txdma) plus zero or
@@ -480,7 +489,7 @@ static void mmc_davinci_send_dma_request(struct mmc_davinci_host *host,
         struct scatterlist      *sg;
         unsigned                sg_len;
         unsigned                bytes_left = host->bytes_left;
-        const unsigned          shift = ffs(rw_threshold) - 1;;
+        const unsigned          shift = ffs(rw_threshold) - 1;
 
         if (host->data_dir == DAVINCI_MMC_DATADIR_WRITE) {
                 template = &host->tx_template;
@@ -866,6 +875,19 @@ mmc_davinci_xfer_done(struct mmc_davinci_host *host, struct mmc_data *data)
 {
         host->data = NULL;
 
+        if (host->mmc->caps & MMC_CAP_SDIO_IRQ) {
+                /*
+                 * SDIO Interrupt Detection work-around as suggested by
+                 * Davinci Errata (TMS320DM355 Silicon Revision 1.1 Errata
+                 * 2.1.6): Signal SDIO interrupt only if it is enabled by core
+                 */
+                if (host->sdio_int && !(readl(host->base + DAVINCI_SDIOST0) &
+                                        SDIOST0_DAT1_HI)) {
+                        writel(SDIOIST_IOINT, host->base + DAVINCI_SDIOIST);
+                        mmc_signal_sdio_irq(host->mmc);
+                }
+        }
+
         if (host->do_dma) {
                 davinci_abort_dma(host);
 
@@ -932,6 +954,21 @@ davinci_abort_data(struct mmc_davinci_host *host, struct mmc_data *data)
         mmc_davinci_reset_ctrl(host, 0);
 }
 
+static irqreturn_t mmc_davinci_sdio_irq(int irq, void *dev_id)
+{
+        struct mmc_davinci_host *host = dev_id;
+        unsigned int status;
+
+        status = readl(host->base + DAVINCI_SDIOIST);
+        if (status & SDIOIST_IOINT) {
+                dev_dbg(mmc_dev(host->mmc),
+                        "SDIO interrupt status %x\n", status);
+                writel(status | SDIOIST_IOINT, host->base + DAVINCI_SDIOIST);
+                mmc_signal_sdio_irq(host->mmc);
+        }
+        return IRQ_HANDLED;
+}
+
 static irqreturn_t mmc_davinci_irq(int irq, void *dev_id)
 {
         struct mmc_davinci_host *host = (struct mmc_davinci_host *)dev_id;
@@ -1076,11 +1113,32 @@ static int mmc_davinci_get_ro(struct mmc_host *mmc)
         return config->get_ro(pdev->id);
 }
 
+static void mmc_davinci_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct mmc_davinci_host *host = mmc_priv(mmc);
+
+        if (enable) {
+                if (!(readl(host->base + DAVINCI_SDIOST0) & SDIOST0_DAT1_HI)) {
+                        writel(SDIOIST_IOINT, host->base + DAVINCI_SDIOIST);
+                        mmc_signal_sdio_irq(host->mmc);
+                } else {
+                        host->sdio_int = true;
+                        writel(readl(host->base + DAVINCI_SDIOIEN) |
+                               SDIOIEN_IOINTEN, host->base + DAVINCI_SDIOIEN);
+                }
+        } else {
+                host->sdio_int = false;
+                writel(readl(host->base + DAVINCI_SDIOIEN) & ~SDIOIEN_IOINTEN,
+                       host->base + DAVINCI_SDIOIEN);
+        }
+}
+
 static struct mmc_host_ops mmc_davinci_ops = {
         .request        = mmc_davinci_request,
         .set_ios        = mmc_davinci_set_ios,
         .get_cd         = mmc_davinci_get_cd,
         .get_ro         = mmc_davinci_get_ro,
+        .enable_sdio_irq = mmc_davinci_enable_sdio_irq,
 };
 
 /*----------------------------------------------------------------------*/
@@ -1209,7 +1267,8 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
                 host->nr_sg = MAX_NR_SG;
 
         host->use_dma = use_dma;
-        host->irq = irq;
+        host->mmc_irq = irq;
+        host->sdio_irq = platform_get_irq(pdev, 1);
 
         if (host->use_dma && davinci_acquire_dma_channels(host) != 0)
                 host->use_dma = 0;
@@ -1239,8 +1298,7 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
          * Each hw_seg uses one EDMA parameter RAM slot, always one
          * channel and then usually some linked slots.
          */
-        mmc->max_hw_segs        = 1 + host->n_link;
-        mmc->max_phys_segs      = mmc->max_hw_segs;
+        mmc->max_segs           = 1 + host->n_link;
 
         /* EDMA limit per hw segment (one or two MBytes) */
         mmc->max_seg_size       = MAX_CCNT * rw_threshold;
@@ -1250,8 +1308,7 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
         mmc->max_blk_count      = 65535; /* NBLK is 16 bits */
         mmc->max_req_size       = mmc->max_blk_size * mmc->max_blk_count;
 
-        dev_dbg(mmc_dev(host->mmc), "max_phys_segs=%d\n", mmc->max_phys_segs);
-        dev_dbg(mmc_dev(host->mmc), "max_hw_segs=%d\n", mmc->max_hw_segs);
+        dev_dbg(mmc_dev(host->mmc), "max_segs=%d\n", mmc->max_segs);
         dev_dbg(mmc_dev(host->mmc), "max_blk_size=%d\n", mmc->max_blk_size);
         dev_dbg(mmc_dev(host->mmc), "max_req_size=%d\n", mmc->max_req_size);
         dev_dbg(mmc_dev(host->mmc), "max_seg_size=%d\n", mmc->max_seg_size);
@@ -1272,6 +1329,13 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
         if (ret)
                 goto out;
 
+        if (host->sdio_irq >= 0) {
+                ret = request_irq(host->sdio_irq, mmc_davinci_sdio_irq, 0,
+                                  mmc_hostname(mmc), host);
+                if (!ret)
+                        mmc->caps |= MMC_CAP_SDIO_IRQ;
+        }
+
         rename_region(mem, mmc_hostname(mmc));
 
         dev_info(mmc_dev(host->mmc), "Using %s, %d-bit mode\n",
@@ -1315,7 +1379,9 @@ static int __exit davinci_mmcsd_remove(struct platform_device *pdev)
                 mmc_davinci_cpufreq_deregister(host);
 
                 mmc_remove_host(host->mmc);
-                free_irq(host->irq, host);
+                free_irq(host->mmc_irq, host);
+                if (host->mmc->caps & MMC_CAP_SDIO_IRQ)
+                        free_irq(host->sdio_irq, host);
 
                 davinci_release_dma_channels(host);
 
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
new file mode 100644
index 000000000000..66dcddb9c205
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc.c
@@ -0,0 +1,1859 @@
+/*
+ * Synopsys DesignWare Multimedia Card Interface driver
+ *  (Based on NXP driver for lpc 31xx)
+ *
+ * Copyright (C) 2009 NXP Semiconductors
+ * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/blkdev.h>
+#include <linux/clk.h>
+#include <linux/debugfs.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/scatterlist.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/stat.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/dw_mmc.h>
+#include <linux/bitops.h>
+#include <linux/regulator/consumer.h>
+
+#include "dw_mmc.h"
+
+/* Common flag combinations */
+#define DW_MCI_DATA_ERROR_FLAGS (SDMMC_INT_DTO | SDMMC_INT_DCRC | \
+                                 SDMMC_INT_HTO | SDMMC_INT_SBE  | \
+                                 SDMMC_INT_EBE)
+#define DW_MCI_CMD_ERROR_FLAGS  (SDMMC_INT_RTO | SDMMC_INT_RCRC | \
+                                 SDMMC_INT_RESP_ERR)
+#define DW_MCI_ERROR_FLAGS      (DW_MCI_DATA_ERROR_FLAGS | \
+                                 DW_MCI_CMD_ERROR_FLAGS  | SDMMC_INT_HLE)
+#define DW_MCI_SEND_STATUS      1
+#define DW_MCI_RECV_STATUS      2
+#define DW_MCI_DMA_THRESHOLD    16
+
+#ifdef CONFIG_MMC_DW_IDMAC
+struct idmac_desc {
+        u32             des0;   /* Control Descriptor */
+#define IDMAC_DES0_DIC  BIT(1)
+#define IDMAC_DES0_LD   BIT(2)
+#define IDMAC_DES0_FD   BIT(3)
+#define IDMAC_DES0_CH   BIT(4)
+#define IDMAC_DES0_ER   BIT(5)
+#define IDMAC_DES0_CES  BIT(30)
+#define IDMAC_DES0_OWN  BIT(31)
+
+        u32             des1;   /* Buffer sizes */
+#define IDMAC_SET_BUFFER1_SIZE(d, s) \
+        ((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff))
+
+        u32             des2;   /* buffer 1 physical address */
+
+        u32             des3;   /* buffer 2 physical address */
+};
+#endif /* CONFIG_MMC_DW_IDMAC */
+
+/**
+ * struct dw_mci_slot - MMC slot state
+ * @mmc: The mmc_host representing this slot.
+ * @host: The MMC controller this slot is using.
+ * @ctype: Card type for this slot.
+ * @mrq: mmc_request currently being processed or waiting to be
+ *      processed, or NULL when the slot is idle.
+ * @queue_node: List node for placing this node in the @queue list of
+ *      &struct dw_mci.
+ * @clock: Clock rate configured by set_ios(). Protected by host->lock.
+ * @flags: Random state bits associated with the slot.
+ * @id: Number of this slot.
+ * @last_detect_state: Most recently observed card detect state.
+ */
+struct dw_mci_slot {
+        struct mmc_host         *mmc;
+        struct dw_mci           *host;
+
+        u32                     ctype;
+
+        struct mmc_request      *mrq;
+        struct list_head        queue_node;
+
+        unsigned int            clock;
+        unsigned long           flags;
+#define DW_MMC_CARD_PRESENT     0
+#define DW_MMC_CARD_NEED_INIT   1
+        int                     id;
+        int                     last_detect_state;
+};
+
+#if defined(CONFIG_DEBUG_FS)
+static int dw_mci_req_show(struct seq_file *s, void *v)
+{
+        struct dw_mci_slot *slot = s->private;
+        struct mmc_request *mrq;
+        struct mmc_command *cmd;
+        struct mmc_command *stop;
+        struct mmc_data *data;
+
+        /* Make sure we get a consistent snapshot */
+        spin_lock_bh(&slot->host->lock);
+        mrq = slot->mrq;
+
+        if (mrq) {
+                cmd = mrq->cmd;
+                data = mrq->data;
+                stop = mrq->stop;
+
+                if (cmd)
+                        seq_printf(s,
+                                   "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
+                                   cmd->opcode, cmd->arg, cmd->flags,
+                                   cmd->resp[0], cmd->resp[1], cmd->resp[2],
+                                   cmd->resp[2], cmd->error);
+                if (data)
+                        seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
+                                   data->bytes_xfered, data->blocks,
+                                   data->blksz, data->flags, data->error);
+                if (stop)
+                        seq_printf(s,
+                                   "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
+                                   stop->opcode, stop->arg, stop->flags,
+                                   stop->resp[0], stop->resp[1], stop->resp[2],
+                                   stop->resp[2], stop->error);
+        }
+
+        spin_unlock_bh(&slot->host->lock);
+
+        return 0;
+}
+
+static int dw_mci_req_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dw_mci_req_show, inode->i_private);
+}
+
+static const struct file_operations dw_mci_req_fops = {
+        .owner          = THIS_MODULE,
+        .open           = dw_mci_req_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int dw_mci_regs_show(struct seq_file *s, void *v)
+{
+        seq_printf(s, "STATUS:\t0x%08x\n", SDMMC_STATUS);
+        seq_printf(s, "RINTSTS:\t0x%08x\n", SDMMC_RINTSTS);
+        seq_printf(s, "CMD:\t0x%08x\n", SDMMC_CMD);
+        seq_printf(s, "CTRL:\t0x%08x\n", SDMMC_CTRL);
+        seq_printf(s, "INTMASK:\t0x%08x\n", SDMMC_INTMASK);
+        seq_printf(s, "CLKENA:\t0x%08x\n", SDMMC_CLKENA);
+
+        return 0;
+}
+
+static int dw_mci_regs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dw_mci_regs_show, inode->i_private);
+}
+
+static const struct file_operations dw_mci_regs_fops = {
+        .owner          = THIS_MODULE,
+        .open           = dw_mci_regs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void dw_mci_init_debugfs(struct dw_mci_slot *slot)
+{
+        struct mmc_host *mmc = slot->mmc;
+        struct dw_mci *host = slot->host;
+        struct dentry *root;
+        struct dentry *node;
+
+        root = mmc->debugfs_root;
+        if (!root)
+                return;
+
+        node = debugfs_create_file("regs", S_IRUSR, root, host,
+                                   &dw_mci_regs_fops);
+        if (!node)
+                goto err;
+
+        node = debugfs_create_file("req", S_IRUSR, root, slot,
+                                   &dw_mci_req_fops);
+        if (!node)
+                goto err;
+
+        node = debugfs_create_u32("state", S_IRUSR, root, (u32 *)&host->state);
+        if (!node)
+                goto err;
+
+        node = debugfs_create_x32("pending_events", S_IRUSR, root,
+                                  (u32 *)&host->pending_events);
+        if (!node)
+                goto err;
+
+        node = debugfs_create_x32("completed_events", S_IRUSR, root,
+                                  (u32 *)&host->completed_events);
+        if (!node)
+                goto err;
+
+        return;
+
+err:
+        dev_err(&mmc->class_dev, "failed to initialize debugfs for slot\n");
+}
+#endif /* defined(CONFIG_DEBUG_FS) */
+
+static void dw_mci_set_timeout(struct dw_mci *host)
+{
+        /* timeout (maximum) */
+        mci_writel(host, TMOUT, 0xffffffff);
+}
+
+static u32 dw_mci_prepare_command(struct mmc_host *mmc, struct mmc_command *cmd)
+{
+        struct mmc_data *data;
+        u32 cmdr;
+        cmd->error = -EINPROGRESS;
+
+        cmdr = cmd->opcode;
+
+        if (cmdr == MMC_STOP_TRANSMISSION)
+                cmdr |= SDMMC_CMD_STOP;
+        else
+                cmdr |= SDMMC_CMD_PRV_DAT_WAIT;
+
+        if (cmd->flags & MMC_RSP_PRESENT) {
+                /* We expect a response, so set this bit */
+                cmdr |= SDMMC_CMD_RESP_EXP;
+                if (cmd->flags & MMC_RSP_136)
+                        cmdr |= SDMMC_CMD_RESP_LONG;
+        }
+
+        if (cmd->flags & MMC_RSP_CRC)
+                cmdr |= SDMMC_CMD_RESP_CRC;
+
+        data = cmd->data;
+        if (data) {
+                cmdr |= SDMMC_CMD_DAT_EXP;
+                if (data->flags & MMC_DATA_STREAM)
+                        cmdr |= SDMMC_CMD_STRM_MODE;
+                if (data->flags & MMC_DATA_WRITE)
+                        cmdr |= SDMMC_CMD_DAT_WR;
+        }
+
+        return cmdr;
+}
+
+static void dw_mci_start_command(struct dw_mci *host,
+                                 struct mmc_command *cmd, u32 cmd_flags)
+{
+        host->cmd = cmd;
+        dev_vdbg(&host->pdev->dev,
+                 "start command: ARGR=0x%08x CMDR=0x%08x\n",
+                 cmd->arg, cmd_flags);
+
+        mci_writel(host, CMDARG, cmd->arg);
+        wmb();
+
+        mci_writel(host, CMD, cmd_flags | SDMMC_CMD_START);
+}
+
+static void send_stop_cmd(struct dw_mci *host, struct mmc_data *data)
+{
+        dw_mci_start_command(host, data->stop, host->stop_cmdr);
+}
+
+/* DMA interface functions */
+static void dw_mci_stop_dma(struct dw_mci *host)
+{
+        if (host->use_dma) {
+                host->dma_ops->stop(host);
+                host->dma_ops->cleanup(host);
+        } else {
+                /* Data transfer was stopped by the interrupt handler */
+                set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
+        }
+}
+
+#ifdef CONFIG_MMC_DW_IDMAC
+static void dw_mci_dma_cleanup(struct dw_mci *host)
+{
+        struct mmc_data *data = host->data;
+
+        if (data)
+                dma_unmap_sg(&host->pdev->dev, data->sg, data->sg_len,
+                             ((data->flags & MMC_DATA_WRITE)
+                              ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
+}
+
+static void dw_mci_idmac_stop_dma(struct dw_mci *host)
+{
+        u32 temp;
+
+        /* Disable and reset the IDMAC interface */
+        temp = mci_readl(host, CTRL);
+        temp &= ~SDMMC_CTRL_USE_IDMAC;
+        temp |= SDMMC_CTRL_DMA_RESET;
+        mci_writel(host, CTRL, temp);
+
+        /* Stop the IDMAC running */
+        temp = mci_readl(host, BMOD);
+        temp &= ~(SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB);
+        mci_writel(host, BMOD, temp);
+}
+
+static void dw_mci_idmac_complete_dma(struct dw_mci *host)
+{
+        struct mmc_data *data = host->data;
+
+        dev_vdbg(&host->pdev->dev, "DMA complete\n");
+
+        host->dma_ops->cleanup(host);
+
+        /*
+         * If the card was removed, data will be NULL. No point in trying to
+         * send the stop command or waiting for NBUSY in this case.
+         */
+        if (data) {
+                set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
+                tasklet_schedule(&host->tasklet);
+        }
+}
+
+static void dw_mci_translate_sglist(struct dw_mci *host, struct mmc_data *data,
+                                    unsigned int sg_len)
+{
+        int i;
+        struct idmac_desc *desc = host->sg_cpu;
+
+        for (i = 0; i < sg_len; i++, desc++) {
+                unsigned int length = sg_dma_len(&data->sg[i]);
+                u32 mem_addr = sg_dma_address(&data->sg[i]);
+
+                /* Set the OWN bit and disable interrupts for this descriptor */
+                desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC | IDMAC_DES0_CH;
+
+                /* Buffer length */
+                IDMAC_SET_BUFFER1_SIZE(desc, length);
+
+                /* Physical address to DMA to/from */
+                desc->des2 = mem_addr;
+        }
+
+        /* Set first descriptor */
+        desc = host->sg_cpu;
+        desc->des0 |= IDMAC_DES0_FD;
+
+        /* Set last descriptor */
+        desc = host->sg_cpu + (i - 1) * sizeof(struct idmac_desc);
+        desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
+        desc->des0 |= IDMAC_DES0_LD;
+
+        wmb();
+}
+
+static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
+{
+        u32 temp;
+
+        dw_mci_translate_sglist(host, host->data, sg_len);
+
+        /* Select IDMAC interface */
+        temp = mci_readl(host, CTRL);
+        temp |= SDMMC_CTRL_USE_IDMAC;
+        mci_writel(host, CTRL, temp);
+
+        wmb();
+
+        /* Enable the IDMAC */
+        temp = mci_readl(host, BMOD);
+        temp |= SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB;
+        mci_writel(host, BMOD, temp);
+
+        /* Start it running */
+        mci_writel(host, PLDMND, 1);
+}
+
+static int dw_mci_idmac_init(struct dw_mci *host)
+{
+        struct idmac_desc *p;
+        int i;
+
+        /* Number of descriptors in the ring buffer */
+        host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
+
+        /* Forward link the descriptor list */
+        for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
+                p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
+
+        /* Set the last descriptor as the end-of-ring descriptor */
+        p->des3 = host->sg_dma;
+        p->des0 = IDMAC_DES0_ER;
+
+        /* Mask out interrupts - get Tx & Rx complete only */
+        mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
+                   SDMMC_IDMAC_INT_TI);
+
+        /* Set the descriptor base address */
+        mci_writel(host, DBADDR, host->sg_dma);
+        return 0;
+}
+
+static struct dw_mci_dma_ops dw_mci_idmac_ops = {
+        .init = dw_mci_idmac_init,
+        .start = dw_mci_idmac_start_dma,
+        .stop = dw_mci_idmac_stop_dma,
+        .complete = dw_mci_idmac_complete_dma,
+        .cleanup = dw_mci_dma_cleanup,
+};
+#endif /* CONFIG_MMC_DW_IDMAC */
+
+static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
+{
+        struct scatterlist *sg;
+        unsigned int i, direction, sg_len;
+        u32 temp;
+
+        /* If we don't have a channel, we can't do DMA */
+        if (!host->use_dma)
+                return -ENODEV;
+
+        /*
+         * We don't do DMA on "complex" transfers, i.e. with
+         * non-word-aligned buffers or lengths. Also, we don't bother
+         * with all the DMA setup overhead for short transfers.
+         */
+        if (data->blocks * data->blksz < DW_MCI_DMA_THRESHOLD)
+                return -EINVAL;
+        if (data->blksz & 3)
+                return -EINVAL;
+
+        for_each_sg(data->sg, sg, data->sg_len, i) {
+                if (sg->offset & 3 || sg->length & 3)
+                        return -EINVAL;
+        }
+
+        if (data->flags & MMC_DATA_READ)
+                direction = DMA_FROM_DEVICE;
+        else
+                direction = DMA_TO_DEVICE;
+
+        sg_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len,
+                            direction);
+
+        dev_vdbg(&host->pdev->dev,
+                 "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
+                 (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
+                 sg_len);
+
+        /* Enable the DMA interface */
+        temp = mci_readl(host, CTRL);
+        temp |= SDMMC_CTRL_DMA_ENABLE;
+        mci_writel(host, CTRL, temp);
+
+        /* Disable RX/TX IRQs, let DMA handle it */
+        temp = mci_readl(host, INTMASK);
+        temp  &= ~(SDMMC_INT_RXDR | SDMMC_INT_TXDR);
+        mci_writel(host, INTMASK, temp);
+
+        host->dma_ops->start(host, sg_len);
+
+        return 0;
+}
+
+static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data)
+{
+        u32 temp;
+
+        data->error = -EINPROGRESS;
+
+        WARN_ON(host->data);
+        host->sg = NULL;
+        host->data = data;
+
+        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;
+
+                temp = mci_readl(host, INTMASK);
+                temp |= SDMMC_INT_TXDR | SDMMC_INT_RXDR;
+                mci_writel(host, INTMASK, temp);
+
+                temp = mci_readl(host, CTRL);
+                temp &= ~SDMMC_CTRL_DMA_ENABLE;
+                mci_writel(host, CTRL, temp);
+        }
+}
+
+static void mci_send_cmd(struct dw_mci_slot *slot, u32 cmd, u32 arg)
+{
+        struct dw_mci *host = slot->host;
+        unsigned long timeout = jiffies + msecs_to_jiffies(500);
+        unsigned int cmd_status = 0;
+
+        mci_writel(host, CMDARG, arg);
+        wmb();
+        mci_writel(host, CMD, SDMMC_CMD_START | cmd);
+
+        while (time_before(jiffies, timeout)) {
+                cmd_status = mci_readl(host, CMD);
+                if (!(cmd_status & SDMMC_CMD_START))
+                        return;
+        }
+        dev_err(&slot->mmc->class_dev,
+                "Timeout sending command (cmd %#x arg %#x status %#x)\n",
+                cmd, arg, cmd_status);
+}
+
+static void dw_mci_setup_bus(struct dw_mci_slot *slot)
+{
+        struct dw_mci *host = slot->host;
+        u32 div;
+
+        if (slot->clock != host->current_speed) {
+                if (host->bus_hz % slot->clock)
+                        /*
+                         * move the + 1 after the divide to prevent
+                         * over-clocking the card.
+                         */
+                        div = ((host->bus_hz / slot->clock) >> 1) + 1;
+                else
+                        div = (host->bus_hz  / slot->clock) >> 1;
+
+                dev_info(&slot->mmc->class_dev,
+                         "Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ"
+                         " div = %d)\n", slot->id, host->bus_hz, slot->clock,
+                         div ? ((host->bus_hz / div) >> 1) : host->bus_hz, div);
+
+                /* disable clock */
+                mci_writel(host, CLKENA, 0);
+                mci_writel(host, CLKSRC, 0);
+
+                /* inform CIU */
+                mci_send_cmd(slot,
+                             SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+
+                /* set clock to desired speed */
+                mci_writel(host, CLKDIV, div);
+
+                /* inform CIU */
+                mci_send_cmd(slot,
+                             SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+
+                /* enable clock */
+                mci_writel(host, CLKENA, SDMMC_CLKEN_ENABLE |
+                           SDMMC_CLKEN_LOW_PWR);
+
+                /* inform CIU */
+                mci_send_cmd(slot,
+                             SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+
+                host->current_speed = slot->clock;
+        }
+
+        /* Set the current slot bus width */
+        mci_writel(host, CTYPE, slot->ctype);
+}
+
+static void dw_mci_start_request(struct dw_mci *host,
+                                 struct dw_mci_slot *slot)
+{
+        struct mmc_request *mrq;
+        struct mmc_command *cmd;
+        struct mmc_data *data;
+        u32 cmdflags;
+
+        mrq = slot->mrq;
+        if (host->pdata->select_slot)
+                host->pdata->select_slot(slot->id);
+
+        /* Slot specific timing and width adjustment */
+        dw_mci_setup_bus(slot);
+
+        host->cur_slot = slot;
+        host->mrq = mrq;
+
+        host->pending_events = 0;
+        host->completed_events = 0;
+        host->data_status = 0;
+
+        data = mrq->data;
+        if (data) {
+                dw_mci_set_timeout(host);
+                mci_writel(host, BYTCNT, data->blksz*data->blocks);
+                mci_writel(host, BLKSIZ, data->blksz);
+        }
+
+        cmd = mrq->cmd;
+        cmdflags = dw_mci_prepare_command(slot->mmc, cmd);
+
+        /* this is the first command, send the initialization clock */
+        if (test_and_clear_bit(DW_MMC_CARD_NEED_INIT, &slot->flags))
+                cmdflags |= SDMMC_CMD_INIT;
+
+        if (data) {
+                dw_mci_submit_data(host, data);
+                wmb();
+        }
+
+        dw_mci_start_command(host, cmd, cmdflags);
+
+        if (mrq->stop)
+                host->stop_cmdr = dw_mci_prepare_command(slot->mmc, mrq->stop);
+}
+
+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) {
+                host->state = STATE_SENDING_CMD;
+                dw_mci_start_request(host, 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)
+{
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        struct dw_mci *host = slot->host;
+
+        WARN_ON(slot->mrq);
+
+        if (!test_bit(DW_MMC_CARD_PRESENT, &slot->flags)) {
+                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);
+}
+
+static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        u32 regs;
+
+        /* set default 1 bit mode */
+        slot->ctype = SDMMC_CTYPE_1BIT;
+
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_1:
+                slot->ctype = SDMMC_CTYPE_1BIT;
+                break;
+        case MMC_BUS_WIDTH_4:
+                slot->ctype = SDMMC_CTYPE_4BIT;
+                break;
+        case MMC_BUS_WIDTH_8:
+                slot->ctype = SDMMC_CTYPE_8BIT;
+                break;
+        }
+
+        /* DDR mode set */
+        if (ios->ddr) {
+                regs = mci_readl(slot->host, UHS_REG);
+                regs |= (0x1 << slot->id) << 16;
+                mci_writel(slot->host, UHS_REG, regs);
+        }
+
+        if (ios->clock) {
+                /*
+                 * Use mirror of ios->clock to prevent race with mmc
+                 * core ios update when finding the minimum.
+                 */
+                slot->clock = ios->clock;
+        }
+
+        switch (ios->power_mode) {
+        case MMC_POWER_UP:
+                set_bit(DW_MMC_CARD_NEED_INIT, &slot->flags);
+                break;
+        default:
+                break;
+        }
+}
+
+static int dw_mci_get_ro(struct mmc_host *mmc)
+{
+        int read_only;
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        struct dw_mci_board *brd = slot->host->pdata;
+
+        /* Use platform get_ro function, else try on board write protect */
+        if (brd->get_ro)
+                read_only = brd->get_ro(slot->id);
+        else
+                read_only =
+                        mci_readl(slot->host, WRTPRT) & (1 << slot->id) ? 1 : 0;
+
+        dev_dbg(&mmc->class_dev, "card is %s\n",
+                read_only ? "read-only" : "read-write");
+
+        return read_only;
+}
+
+static int dw_mci_get_cd(struct mmc_host *mmc)
+{
+        int present;
+        struct dw_mci_slot *slot = mmc_priv(mmc);
+        struct dw_mci_board *brd = slot->host->pdata;
+
+        /* Use platform get_cd function, else try onboard card detect */
+        if (brd->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION)
+                present = 1;
+        else if (brd->get_cd)
+                present = !brd->get_cd(slot->id);
+        else
+                present = (mci_readl(slot->host, CDETECT) & (1 << slot->id))
+                        == 0 ? 1 : 0;
+
+        if (present)
+                dev_dbg(&mmc->class_dev, "card is present\n");
+        else
+                dev_dbg(&mmc->class_dev, "card is not present\n");
+
+        return present;
+}
+
+static const struct mmc_host_ops dw_mci_ops = {
+        .request        = dw_mci_request,
+        .set_ios        = dw_mci_set_ios,
+        .get_ro         = dw_mci_get_ro,
+        .get_cd         = dw_mci_get_cd,
+};
+
+static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
+        __releases(&host->lock)
+        __acquires(&host->lock)
+{
+        struct dw_mci_slot *slot;
+        struct mmc_host *prev_mmc = host->cur_slot->mmc;
+
+        WARN_ON(host->cmd || host->data);
+
+        host->cur_slot->mrq = NULL;
+        host->mrq = NULL;
+        if (!list_empty(&host->queue)) {
+                slot = list_entry(host->queue.next,
+                                  struct dw_mci_slot, queue_node);
+                list_del(&slot->queue_node);
+                dev_vdbg(&host->pdev->dev, "list not empty: %s is next\n",
+                         mmc_hostname(slot->mmc));
+                host->state = STATE_SENDING_CMD;
+                dw_mci_start_request(host, slot);
+        } else {
+                dev_vdbg(&host->pdev->dev, "list empty\n");
+                host->state = STATE_IDLE;
+        }
+
+        spin_unlock(&host->lock);
+        mmc_request_done(prev_mmc, mrq);
+        spin_lock(&host->lock);
+}
+
+static void dw_mci_command_complete(struct dw_mci *host, struct mmc_command *cmd)
+{
+        u32 status = host->cmd_status;
+
+        host->cmd_status = 0;
+
+        /* Read the response from the card (up to 16 bytes) */
+        if (cmd->flags & MMC_RSP_PRESENT) {
+                if (cmd->flags & MMC_RSP_136) {
+                        cmd->resp[3] = mci_readl(host, RESP0);
+                        cmd->resp[2] = mci_readl(host, RESP1);
+                        cmd->resp[1] = mci_readl(host, RESP2);
+                        cmd->resp[0] = mci_readl(host, RESP3);
+                } else {
+                        cmd->resp[0] = mci_readl(host, RESP0);
+                        cmd->resp[1] = 0;
+                        cmd->resp[2] = 0;
+                        cmd->resp[3] = 0;
+                }
+        }
+
+        if (status & SDMMC_INT_RTO)
+                cmd->error = -ETIMEDOUT;
+        else if ((cmd->flags & MMC_RSP_CRC) && (status & SDMMC_INT_RCRC))
+                cmd->error = -EILSEQ;
+        else if (status & SDMMC_INT_RESP_ERR)
+                cmd->error = -EIO;
+        else
+                cmd->error = 0;
+
+        if (cmd->error) {
+                /* newer ip versions need a delay between retries */
+                if (host->quirks & DW_MCI_QUIRK_RETRY_DELAY)
+                        mdelay(20);
+
+                if (cmd->data) {
+                        host->data = NULL;
+                        dw_mci_stop_dma(host);
+                }
+        }
+}
+
+static void dw_mci_tasklet_func(unsigned long priv)
+{
+        struct dw_mci *host = (struct dw_mci *)priv;
+        struct mmc_data *data;
+        struct mmc_command *cmd;
+        enum dw_mci_state state;
+        enum dw_mci_state prev_state;
+        u32 status;
+
+        spin_lock(&host->lock);
+
+        state = host->state;
+        data = host->data;
+
+        do {
+                prev_state = state;
+
+                switch (state) {
+                case STATE_IDLE:
+                        break;
+
+                case STATE_SENDING_CMD:
+                        if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
+                                                &host->pending_events))
+                                break;
+
+                        cmd = host->cmd;
+                        host->cmd = NULL;
+                        set_bit(EVENT_CMD_COMPLETE, &host->completed_events);
+                        dw_mci_command_complete(host, host->mrq->cmd);
+                        if (!host->mrq->data || cmd->error) {
+                                dw_mci_request_end(host, host->mrq);
+                                goto unlock;
+                        }
+
+                        prev_state = state = STATE_SENDING_DATA;
+                        /* fall through */
+
+                case STATE_SENDING_DATA:
+                        if (test_and_clear_bit(EVENT_DATA_ERROR,
+                                               &host->pending_events)) {
+                                dw_mci_stop_dma(host);
+                                if (data->stop)
+                                        send_stop_cmd(host, data);
+                                state = STATE_DATA_ERROR;
+                                break;
+                        }
+
+                        if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
+                                                &host->pending_events))
+                                break;
+
+                        set_bit(EVENT_XFER_COMPLETE, &host->completed_events);
+                        prev_state = state = STATE_DATA_BUSY;
+                        /* fall through */
+
+                case STATE_DATA_BUSY:
+                        if (!test_and_clear_bit(EVENT_DATA_COMPLETE,
+                                                &host->pending_events))
+                                break;
+
+                        host->data = NULL;
+                        set_bit(EVENT_DATA_COMPLETE, &host->completed_events);
+                        status = host->data_status;
+
+                        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 {
+                                        dev_err(&host->pdev->dev,
+                                                "data FIFO error "
+                                                "(status=%08x)\n",
+                                                status);
+                                        data->error = -EIO;
+                                }
+                        } else {
+                                data->bytes_xfered = data->blocks * data->blksz;
+                                data->error = 0;
+                        }
+
+                        if (!data->stop) {
+                                dw_mci_request_end(host, host->mrq);
+                                goto unlock;
+                        }
+
+                        prev_state = state = STATE_SENDING_STOP;
+                        if (!data->error)
+                                send_stop_cmd(host, data);
+                        /* fall through */
+
+                case STATE_SENDING_STOP:
+                        if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
+                                                &host->pending_events))
+                                break;
+
+                        host->cmd = NULL;
+                        dw_mci_command_complete(host, host->mrq->stop);
+                        dw_mci_request_end(host, host->mrq);
+                        goto unlock;
+
+                case STATE_DATA_ERROR:
+                        if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
+                                                &host->pending_events))
+                                break;
+
+                        state = STATE_DATA_BUSY;
+                        break;
+                }
+        } while (state != prev_state);
+
+        host->state = state;
+unlock:
+        spin_unlock(&host->lock);
+
+}
+
+static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
+{
+        u16 *pdata = (u16 *)buf;
+
+        WARN_ON(cnt % 2 != 0);
+
+        cnt = cnt >> 1;
+        while (cnt > 0) {
+                mci_writew(host, DATA, *pdata++);
+                cnt--;
+        }
+}
+
+static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
+{
+        u16 *pdata = (u16 *)buf;
+
+        WARN_ON(cnt % 2 != 0);
+
+        cnt = cnt >> 1;
+        while (cnt > 0) {
+                *pdata++ = mci_readw(host, DATA);
+                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--;
+        }
+}
+
+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--;
+        }
+}
+
+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--;
+        }
+}
+
+static void dw_mci_pull_data64(struct dw_mci *host, void *buf, int cnt)
+{
+        u64 *pdata = (u64 *)buf;
+
+        WARN_ON(cnt % 8 != 0);
+
+        cnt = cnt >> 3;
+        while (cnt > 0) {
+                *pdata++ = mci_readq(host, DATA);
+                cnt--;
+        }
+}
+
+static void dw_mci_read_data_pio(struct dw_mci *host)
+{
+        struct scatterlist *sg = host->sg;
+        void *buf = sg_virt(sg);
+        unsigned int offset = host->pio_offset;
+        struct mmc_data *data = host->data;
+        int shift = host->data_shift;
+        u32 status;
+        unsigned int nbytes = 0, len;
+
+        do {
+                len = SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift;
+                if (offset + len <= sg->length) {
+                        host->pull_data(host, (void *)(buf + offset), len);
+
+                        offset += len;
+                        nbytes += len;
+
+                        if (offset == sg->length) {
+                                flush_dcache_page(sg_page(sg));
+                                host->sg = sg = sg_next(sg);
+                                if (!sg)
+                                        goto done;
+
+                                offset = 0;
+                                buf = sg_virt(sg);
+                        }
+                } else {
+                        unsigned int remaining = sg->length - offset;
+                        host->pull_data(host, (void *)(buf + offset),
+                                        remaining);
+                        nbytes += remaining;
+
+                        flush_dcache_page(sg_page(sg));
+                        host->sg = sg = sg_next(sg);
+                        if (!sg)
+                                goto done;
+
+                        offset = len - remaining;
+                        buf = sg_virt(sg);
+                        host->pull_data(host, buf, offset);
+                        nbytes += offset;
+                }
+
+                status = mci_readl(host, MINTSTS);
+                mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
+                if (status & DW_MCI_DATA_ERROR_FLAGS) {
+                        host->data_status = status;
+                        data->bytes_xfered += nbytes;
+                        smp_wmb();
+
+                        set_bit(EVENT_DATA_ERROR, &host->pending_events);
+
+                        tasklet_schedule(&host->tasklet);
+                        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;
+
+done:
+        data->bytes_xfered += nbytes;
+        smp_wmb();
+        set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
+}
+
+static void dw_mci_write_data_pio(struct dw_mci *host)
+{
+        struct scatterlist *sg = host->sg;
+        void *buf = sg_virt(sg);
+        unsigned int offset = host->pio_offset;
+        struct mmc_data *data = host->data;
+        int shift = host->data_shift;
+        u32 status;
+        unsigned int nbytes = 0, len;
+
+        do {
+                len = SDMMC_FIFO_SZ -
+                        (SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
+                if (offset + len <= sg->length) {
+                        host->push_data(host, (void *)(buf + offset), len);
+
+                        offset += len;
+                        nbytes += len;
+                        if (offset == sg->length) {
+                                host->sg = sg = sg_next(sg);
+                                if (!sg)
+                                        goto done;
+
+                                offset = 0;
+                                buf = sg_virt(sg);
+                        }
+                } else {
+                        unsigned int remaining = sg->length - offset;
+
+                        host->push_data(host, (void *)(buf + offset),
+                                        remaining);
+                        nbytes += remaining;
+
+                        host->sg = sg = sg_next(sg);
+                        if (!sg)
+                                goto done;
+
+                        offset = len - remaining;
+                        buf = sg_virt(sg);
+                        host->push_data(host, (void *)buf, offset);
+                        nbytes += offset;
+                }
+
+                status = mci_readl(host, MINTSTS);
+                mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
+                if (status & DW_MCI_DATA_ERROR_FLAGS) {
+                        host->data_status = status;
+                        data->bytes_xfered += nbytes;
+
+                        smp_wmb();
+
+                        set_bit(EVENT_DATA_ERROR, &host->pending_events);
+
+                        tasklet_schedule(&host->tasklet);
+                        return;
+                }
+        } while (status & SDMMC_INT_TXDR); /* if TXDR write again */
+
+        host->pio_offset = offset;
+        data->bytes_xfered += nbytes;
+
+        return;
+
+done:
+        data->bytes_xfered += nbytes;
+        smp_wmb();
+        set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
+}
+
+static void dw_mci_cmd_interrupt(struct dw_mci *host, u32 status)
+{
+        if (!host->cmd_status)
+                host->cmd_status = status;
+
+        smp_wmb();
+
+        set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
+        tasklet_schedule(&host->tasklet);
+}
+
+static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
+{
+        struct dw_mci *host = dev_id;
+        u32 status, pending;
+        unsigned int pass_count = 0;
+
+        do {
+                status = mci_readl(host, RINTSTS);
+                pending = mci_readl(host, MINTSTS); /* read-only mask reg */
+
+                /*
+                 * DTO fix - version 2.10a and below, and only if internal DMA
+                 * is configured.
+                 */
+                if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO) {
+                        if (!pending &&
+                            ((mci_readl(host, STATUS) >> 17) & 0x1fff))
+                                pending |= SDMMC_INT_DATA_OVER;
+                }
+
+                if (!pending)
+                        break;
+
+                if (pending & DW_MCI_CMD_ERROR_FLAGS) {
+                        mci_writel(host, RINTSTS, DW_MCI_CMD_ERROR_FLAGS);
+                        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) {
+                        /* if there is an error report DATA_ERROR */
+                        mci_writel(host, RINTSTS, DW_MCI_DATA_ERROR_FLAGS);
+                        host->data_status = status;
+                        smp_wmb();
+                        set_bit(EVENT_DATA_ERROR, &host->pending_events);
+                        tasklet_schedule(&host->tasklet);
+                }
+
+                if (pending & SDMMC_INT_DATA_OVER) {
+                        mci_writel(host, RINTSTS, SDMMC_INT_DATA_OVER);
+                        if (!host->data_status)
+                                host->data_status = status;
+                        smp_wmb();
+                        if (host->dir_status == DW_MCI_RECV_STATUS) {
+                                if (host->sg != NULL)
+                                        dw_mci_read_data_pio(host);
+                        }
+                        set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
+                        tasklet_schedule(&host->tasklet);
+                }
+
+                if (pending & SDMMC_INT_RXDR) {
+                        mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
+                        if (host->sg)
+                                dw_mci_read_data_pio(host);
+                }
+
+                if (pending & SDMMC_INT_TXDR) {
+                        mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
+                        if (host->sg)
+                                dw_mci_write_data_pio(host);
+                }
+
+                if (pending & SDMMC_INT_CMD_DONE) {
+                        mci_writel(host, RINTSTS, SDMMC_INT_CMD_DONE);
+                        dw_mci_cmd_interrupt(host, status);
+                }
+
+                if (pending & SDMMC_INT_CD) {
+                        mci_writel(host, RINTSTS, SDMMC_INT_CD);
+                        tasklet_schedule(&host->card_tasklet);
+                }
+
+        } while (pass_count++ < 5);
+
+#ifdef CONFIG_MMC_DW_IDMAC
+        /* Handle DMA interrupts */
+        pending = mci_readl(host, IDSTS);
+        if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
+                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI);
+                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
+                set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
+                host->dma_ops->complete(host);
+        }
+#endif
+
+        return IRQ_HANDLED;
+}
+
+static void dw_mci_tasklet_card(unsigned long data)
+{
+        struct dw_mci *host = (struct dw_mci *)data;
+        int i;
+
+        for (i = 0; i < host->num_slots; i++) {
+                struct dw_mci_slot *slot = host->slot[i];
+                struct mmc_host *mmc = slot->mmc;
+                struct mmc_request *mrq;
+                int present;
+                u32 ctrl;
+
+                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");
+
+                        /* 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);
+
+                                set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
+                        }
+
+                        /* Clean up queue if present */
+                        mrq = slot->mrq;
+                        if (mrq) {
+                                if (mrq == host->mrq) {
+                                        host->data = NULL;
+                                        host->cmd = NULL;
+
+                                        switch (host->state) {
+                                        case STATE_IDLE:
+                                                break;
+                                        case STATE_SENDING_CMD:
+                                                mrq->cmd->error = -ENOMEDIUM;
+                                                if (!mrq->data)
+                                                        break;
+                                                /* fall through */
+                                        case STATE_SENDING_DATA:
+                                                mrq->data->error = -ENOMEDIUM;
+                                                dw_mci_stop_dma(host);
+                                                break;
+                                        case STATE_DATA_BUSY:
+                                        case STATE_DATA_ERROR:
+                                                if (mrq->data->error == -EINPROGRESS)
+                                                        mrq->data->error = -ENOMEDIUM;
+                                                if (!mrq->stop)
+                                                        break;
+                                                /* fall through */
+                                        case STATE_SENDING_STOP:
+                                                mrq->stop->error = -ENOMEDIUM;
+                                                break;
+                                        }
+
+                                        dw_mci_request_end(host, mrq);
+                                } else {
+                                        list_del(&slot->queue_node);
+                                        mrq->cmd->error = -ENOMEDIUM;
+                                        if (mrq->data)
+                                                mrq->data->error = -ENOMEDIUM;
+                                        if (mrq->stop)
+                                                mrq->stop->error = -ENOMEDIUM;
+
+                                        spin_unlock(&host->lock);
+                                        mmc_request_done(slot->mmc, mrq);
+                                        spin_lock(&host->lock);
+                                }
+                        }
+
+                        /* Power down slot */
+                        if (present == 0) {
+                                if (host->pdata->setpower)
+                                        host->pdata->setpower(slot->id, 0);
+                                clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
+
+                                /*
+                                 * Clear down the FIFO - 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);
+
+#ifdef CONFIG_MMC_DW_IDMAC
+                                ctrl = mci_readl(host, BMOD);
+                                ctrl |= 0x01; /* Software reset of DMA */
+                                mci_writel(host, BMOD, ctrl);
+#endif
+
+                        }
+
+                        spin_unlock(&host->lock);
+                        present = dw_mci_get_cd(mmc);
+                }
+
+                mmc_detect_change(slot->mmc,
+                        msecs_to_jiffies(host->pdata->detect_delay_ms));
+        }
+}
+
+static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
+{
+        struct mmc_host *mmc;
+        struct dw_mci_slot *slot;
+
+        mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->pdev->dev);
+        if (!mmc)
+                return -ENOMEM;
+
+        slot = mmc_priv(mmc);
+        slot->id = id;
+        slot->mmc = mmc;
+        slot->host = host;
+
+        mmc->ops = &dw_mci_ops;
+        mmc->f_min = DIV_ROUND_UP(host->bus_hz, 510);
+        mmc->f_max = host->bus_hz;
+
+        if (host->pdata->get_ocr)
+                mmc->ocr_avail = host->pdata->get_ocr(id);
+        else
+                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+
+        /*
+         * Start with slot power disabled, it will be enabled when a card
+         * is detected.
+         */
+        if (host->pdata->setpower)
+                host->pdata->setpower(id, 0);
+
+        if (host->pdata->caps)
+                mmc->caps = host->pdata->caps;
+        else
+                mmc->caps = 0;
+
+        if (host->pdata->get_bus_wd)
+                if (host->pdata->get_bus_wd(slot->id) >= 4)
+                        mmc->caps |= MMC_CAP_4_BIT_DATA;
+
+        if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+
+#ifdef CONFIG_MMC_DW_IDMAC
+        mmc->max_segs = host->ring_size;
+        mmc->max_blk_size = 65536;
+        mmc->max_blk_count = host->ring_size;
+        mmc->max_seg_size = 0x1000;
+        mmc->max_req_size = mmc->max_seg_size * mmc->max_blk_count;
+#else
+        if (host->pdata->blk_settings) {
+                mmc->max_segs = host->pdata->blk_settings->max_segs;
+                mmc->max_blk_size = host->pdata->blk_settings->max_blk_size;
+                mmc->max_blk_count = host->pdata->blk_settings->max_blk_count;
+                mmc->max_req_size = host->pdata->blk_settings->max_req_size;
+                mmc->max_seg_size = host->pdata->blk_settings->max_seg_size;
+        } else {
+                /* Useful defaults if platform data is unset. */
+                mmc->max_segs = 64;
+                mmc->max_blk_size = 65536; /* BLKSIZ is 16 bits */
+                mmc->max_blk_count = 512;
+                mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+                mmc->max_seg_size = mmc->max_req_size;
+        }
+#endif /* CONFIG_MMC_DW_IDMAC */
+
+        host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
+        if (IS_ERR(host->vmmc)) {
+                printk(KERN_INFO "%s: no vmmc regulator found\n", mmc_hostname(mmc));
+                host->vmmc = NULL;
+        } else
+                regulator_enable(host->vmmc);
+
+        if (dw_mci_get_cd(mmc))
+                set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
+        else
+                clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
+
+        host->slot[id] = slot;
+        mmc_add_host(mmc);
+
+#if defined(CONFIG_DEBUG_FS)
+        dw_mci_init_debugfs(slot);
+#endif
+
+        /* Card initially undetected */
+        slot->last_detect_state = 0;
+
+        /*
+         * Card may have been plugged in prior to boot so we
+         * need to run the detect tasklet
+         */
+        tasklet_schedule(&host->card_tasklet);
+
+        return 0;
+}
+
+static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
+{
+        /* Shutdown detect IRQ */
+        if (slot->host->pdata->exit)
+                slot->host->pdata->exit(id);
+
+        /* Debugfs stuff is cleaned up by mmc core */
+        mmc_remove_host(slot->mmc);
+        slot->host->slot[id] = NULL;
+        mmc_free_host(slot->mmc);
+}
+
+static void dw_mci_init_dma(struct dw_mci *host)
+{
+        /* Alloc memory for sg translation */
+        host->sg_cpu = dma_alloc_coherent(&host->pdev->dev, PAGE_SIZE,
+                                          &host->sg_dma, GFP_KERNEL);
+        if (!host->sg_cpu) {
+                dev_err(&host->pdev->dev, "%s: could not alloc DMA memory\n",
+                        __func__);
+                goto no_dma;
+        }
+
+        /* Determine which DMA interface to use */
+#ifdef CONFIG_MMC_DW_IDMAC
+        host->dma_ops = &dw_mci_idmac_ops;
+        dev_info(&host->pdev->dev, "Using internal DMA controller.\n");
+#endif
+
+        if (!host->dma_ops)
+                goto no_dma;
+
+        if (host->dma_ops->init) {
+                if (host->dma_ops->init(host)) {
+                        dev_err(&host->pdev->dev, "%s: Unable to initialize "
+                                "DMA Controller.\n", __func__);
+                        goto no_dma;
+                }
+        } else {
+                dev_err(&host->pdev->dev, "DMA initialization not found.\n");
+                goto no_dma;
+        }
+
+        host->use_dma = 1;
+        return;
+
+no_dma:
+        dev_info(&host->pdev->dev, "Using PIO mode.\n");
+        host->use_dma = 0;
+        return;
+}
+
+static bool mci_wait_reset(struct device *dev, struct dw_mci *host)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(500);
+        unsigned int ctrl;
+
+        mci_writel(host, CTRL, (SDMMC_CTRL_RESET | SDMMC_CTRL_FIFO_RESET |
+                                SDMMC_CTRL_DMA_RESET));
+
+        /* wait till resets clear */
+        do {
+                ctrl = mci_readl(host, CTRL);
+                if (!(ctrl & (SDMMC_CTRL_RESET | SDMMC_CTRL_FIFO_RESET |
+                              SDMMC_CTRL_DMA_RESET)))
+                        return true;
+        } while (time_before(jiffies, timeout));
+
+        dev_err(dev, "Timeout resetting block (ctrl %#x)\n", ctrl);
+
+        return false;
+}
+
+static int dw_mci_probe(struct platform_device *pdev)
+{
+        struct dw_mci *host;
+        struct resource *regs;
+        struct dw_mci_board *pdata;
+        int irq, ret, i, width;
+        u32 fifo_size;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs)
+                return -ENXIO;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
+        if (!host)
+                return -ENOMEM;
+
+        host->pdev = pdev;
+        host->pdata = pdata = pdev->dev.platform_data;
+        if (!pdata || !pdata->init) {
+                dev_err(&pdev->dev,
+                        "Platform data must supply init function\n");
+                ret = -ENODEV;
+                goto err_freehost;
+        }
+
+        if (!pdata->select_slot && pdata->num_slots > 1) {
+                dev_err(&pdev->dev,
+                        "Platform data must supply select_slot function\n");
+                ret = -ENODEV;
+                goto err_freehost;
+        }
+
+        if (!pdata->bus_hz) {
+                dev_err(&pdev->dev,
+                        "Platform data must supply bus speed\n");
+                ret = -ENODEV;
+                goto err_freehost;
+        }
+
+        host->bus_hz = pdata->bus_hz;
+        host->quirks = pdata->quirks;
+
+        spin_lock_init(&host->lock);
+        INIT_LIST_HEAD(&host->queue);
+
+        ret = -ENOMEM;
+        host->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        if (!host->regs)
+                goto err_freehost;
+
+        host->dma_ops = pdata->dma_ops;
+        dw_mci_init_dma(host);
+
+        /*
+         * Get the host data width - this assumes that HCON has been set with
+         * the correct values.
+         */
+        i = (mci_readl(host, HCON) >> 7) & 0x7;
+        if (!i) {
+                host->push_data = dw_mci_push_data16;
+                host->pull_data = dw_mci_pull_data16;
+                width = 16;
+                host->data_shift = 1;
+        } else if (i == 2) {
+                host->push_data = dw_mci_push_data64;
+                host->pull_data = dw_mci_pull_data64;
+                width = 64;
+                host->data_shift = 3;
+        } else {
+                /* Check for a reserved value, and warn if it is */
+                WARN((i != 1),
+                     "HCON reports a reserved host data width!\n"
+                     "Defaulting to 32-bit access.\n");
+                host->push_data = dw_mci_push_data32;
+                host->pull_data = dw_mci_pull_data32;
+                width = 32;
+                host->data_shift = 2;
+        }
+
+        /* Reset all blocks */
+        if (!mci_wait_reset(&pdev->dev, host)) {
+                ret = -ENODEV;
+                goto err_dmaunmap;
+        }
+
+        /* Clear the interrupts for the host controller */
+        mci_writel(host, RINTSTS, 0xFFFFFFFF);
+        mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
+
+        /* Put in max timeout */
+        mci_writel(host, TMOUT, 0xFFFFFFFF);
+
+        /*
+         * 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;
+        host->fifoth_val = ((0x2 << 28) | ((fifo_size/2 - 1) << 16) |
+                        ((fifo_size/2) << 0));
+        mci_writel(host, FIFOTH, host->fifoth_val);
+
+        /* disable clock to CIU */
+        mci_writel(host, CLKENA, 0);
+        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);
+
+        ret = request_irq(irq, dw_mci_interrupt, 0, "dw-mci", host);
+        if (ret)
+                goto err_dmaunmap;
+
+        platform_set_drvdata(pdev, host);
+
+        if (host->pdata->num_slots)
+                host->num_slots = host->pdata->num_slots;
+        else
+                host->num_slots = ((mci_readl(host, HCON) >> 1) & 0x1F) + 1;
+
+        /* We need at least one slot to succeed */
+        for (i = 0; i < host->num_slots; i++) {
+                ret = dw_mci_init_slot(host, i);
+                if (ret) {
+                        ret = -ENODEV;
+                        goto err_init_slot;
+                }
+        }
+
+        /*
+         * Enable interrupts for command done, data over, data empty, card det,
+         * receive ready and error such as transmit, receive timeout, crc error
+         */
+        mci_writel(host, RINTSTS, 0xFFFFFFFF);
+        mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
+                   SDMMC_INT_TXDR | SDMMC_INT_RXDR |
+                   DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
+        mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
+
+        dev_info(&pdev->dev, "DW MMC controller at irq %d, "
+                 "%d bit host data width\n", irq, width);
+        if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
+                dev_info(&pdev->dev, "Internal DMAC interrupt fix enabled.\n");
+
+        return 0;
+
+err_init_slot:
+        /* De-init any initialized slots */
+        while (i > 0) {
+                if (host->slot[i])
+                        dw_mci_cleanup_slot(host->slot[i], i);
+                i--;
+        }
+        free_irq(irq, host);
+
+err_dmaunmap:
+        if (host->use_dma && host->dma_ops->exit)
+                host->dma_ops->exit(host);
+        dma_free_coherent(&host->pdev->dev, PAGE_SIZE,
+                          host->sg_cpu, host->sg_dma);
+        iounmap(host->regs);
+
+        if (host->vmmc) {
+                regulator_disable(host->vmmc);
+                regulator_put(host->vmmc);
+        }
+
+
+err_freehost:
+        kfree(host);
+        return ret;
+}
+
+static int __exit dw_mci_remove(struct platform_device *pdev)
+{
+        struct dw_mci *host = platform_get_drvdata(pdev);
+        int i;
+
+        mci_writel(host, RINTSTS, 0xFFFFFFFF);
+        mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
+
+        platform_set_drvdata(pdev, NULL);
+
+        for (i = 0; i < host->num_slots; i++) {
+                dev_dbg(&pdev->dev, "remove slot %d\n", i);
+                if (host->slot[i])
+                        dw_mci_cleanup_slot(host->slot[i], i);
+        }
+
+        /* disable clock to CIU */
+        mci_writel(host, CLKENA, 0);
+        mci_writel(host, CLKSRC, 0);
+
+        free_irq(platform_get_irq(pdev, 0), host);
+        dma_free_coherent(&pdev->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
+
+        if (host->use_dma && host->dma_ops->exit)
+                host->dma_ops->exit(host);
+
+        if (host->vmmc) {
+                regulator_disable(host->vmmc);
+                regulator_put(host->vmmc);
+        }
+
+        iounmap(host->regs);
+
+        kfree(host);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+/*
+ * TODO: we should probably disable the clock to the card in the suspend path.
+ */
+static int dw_mci_suspend(struct platform_device *pdev, pm_message_t mesg)
+{
+        int i, ret;
+        struct dw_mci *host = platform_get_drvdata(pdev);
+
+        for (i = 0; i < host->num_slots; i++) {
+                struct dw_mci_slot *slot = host->slot[i];
+                if (!slot)
+                        continue;
+                ret = mmc_suspend_host(slot->mmc);
+                if (ret < 0) {
+                        while (--i >= 0) {
+                                slot = host->slot[i];
+                                if (slot)
+                                        mmc_resume_host(host->slot[i]->mmc);
+                        }
+                        return ret;
+                }
+        }
+
+        if (host->vmmc)
+                regulator_disable(host->vmmc);
+
+        return 0;
+}
+
+static int dw_mci_resume(struct platform_device *pdev)
+{
+        int i, ret;
+        struct dw_mci *host = platform_get_drvdata(pdev);
+
+        if (host->vmmc)
+                regulator_enable(host->vmmc);
+
+        if (host->dma_ops->init)
+                host->dma_ops->init(host);
+
+        if (!mci_wait_reset(&pdev->dev, host)) {
+                ret = -ENODEV;
+                return ret;
+        }
+
+        /* Restore the old value at FIFOTH register */
+        mci_writel(host, FIFOTH, host->fifoth_val);
+
+        mci_writel(host, RINTSTS, 0xFFFFFFFF);
+        mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
+                   SDMMC_INT_TXDR | SDMMC_INT_RXDR |
+                   DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
+        mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE);
+
+        for (i = 0; i < host->num_slots; i++) {
+                struct dw_mci_slot *slot = host->slot[i];
+                if (!slot)
+                        continue;
+                ret = mmc_resume_host(host->slot[i]->mmc);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+#else
+#define dw_mci_suspend  NULL
+#define dw_mci_resume   NULL
+#endif /* CONFIG_PM */
+
+static struct platform_driver dw_mci_driver = {
+        .remove         = __exit_p(dw_mci_remove),
+        .suspend        = dw_mci_suspend,
+        .resume         = dw_mci_resume,
+        .driver         = {
+                .name           = "dw_mmc",
+        },
+};
+
+static int __init dw_mci_init(void)
+{
+        return platform_driver_probe(&dw_mci_driver, dw_mci_probe);
+}
+
+static void __exit dw_mci_exit(void)
+{
+        platform_driver_unregister(&dw_mci_driver);
+}
+
+module_init(dw_mci_init);
+module_exit(dw_mci_exit);
+
+MODULE_DESCRIPTION("DW Multimedia Card Interface driver");
+MODULE_AUTHOR("NXP Semiconductor VietNam");
+MODULE_AUTHOR("Imagination Technologies Ltd");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
new file mode 100644
index 000000000000..23c662af5616
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc.h
@@ -0,0 +1,168 @@
+/*
+ * Synopsys DesignWare Multimedia Card Interface driver
+ *  (Based on NXP driver for lpc 31xx)
+ *
+ * Copyright (C) 2009 NXP Semiconductors
+ * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _DW_MMC_H_
+#define _DW_MMC_H_
+
+#define SDMMC_CTRL              0x000
+#define SDMMC_PWREN             0x004
+#define SDMMC_CLKDIV            0x008
+#define SDMMC_CLKSRC            0x00c
+#define SDMMC_CLKENA            0x010
+#define SDMMC_TMOUT             0x014
+#define SDMMC_CTYPE             0x018
+#define SDMMC_BLKSIZ            0x01c
+#define SDMMC_BYTCNT            0x020
+#define SDMMC_INTMASK           0x024
+#define SDMMC_CMDARG            0x028
+#define SDMMC_CMD               0x02c
+#define SDMMC_RESP0             0x030
+#define SDMMC_RESP1             0x034
+#define SDMMC_RESP2             0x038
+#define SDMMC_RESP3             0x03c
+#define SDMMC_MINTSTS           0x040
+#define SDMMC_RINTSTS           0x044
+#define SDMMC_STATUS            0x048
+#define SDMMC_FIFOTH            0x04c
+#define SDMMC_CDETECT           0x050
+#define SDMMC_WRTPRT            0x054
+#define SDMMC_GPIO              0x058
+#define SDMMC_TCBCNT            0x05c
+#define SDMMC_TBBCNT            0x060
+#define SDMMC_DEBNCE            0x064
+#define SDMMC_USRID             0x068
+#define SDMMC_VERID             0x06c
+#define SDMMC_HCON              0x070
+#define SDMMC_UHS_REG           0x074
+#define SDMMC_BMOD              0x080
+#define SDMMC_PLDMND            0x084
+#define SDMMC_DBADDR            0x088
+#define SDMMC_IDSTS             0x08c
+#define SDMMC_IDINTEN           0x090
+#define SDMMC_DSCADDR           0x094
+#define SDMMC_BUFADDR           0x098
+#define SDMMC_DATA              0x100
+
+/* shift bit field */
+#define _SBF(f, v)              ((v) << (f))
+
+/* Control register defines */
+#define SDMMC_CTRL_USE_IDMAC            BIT(25)
+#define SDMMC_CTRL_CEATA_INT_EN         BIT(11)
+#define SDMMC_CTRL_SEND_AS_CCSD         BIT(10)
+#define SDMMC_CTRL_SEND_CCSD            BIT(9)
+#define SDMMC_CTRL_ABRT_READ_DATA       BIT(8)
+#define SDMMC_CTRL_SEND_IRQ_RESP        BIT(7)
+#define SDMMC_CTRL_READ_WAIT            BIT(6)
+#define SDMMC_CTRL_DMA_ENABLE           BIT(5)
+#define SDMMC_CTRL_INT_ENABLE           BIT(4)
+#define SDMMC_CTRL_DMA_RESET            BIT(2)
+#define SDMMC_CTRL_FIFO_RESET           BIT(1)
+#define SDMMC_CTRL_RESET                BIT(0)
+/* Clock Enable register defines */
+#define SDMMC_CLKEN_LOW_PWR             BIT(16)
+#define SDMMC_CLKEN_ENABLE              BIT(0)
+/* time-out register defines */
+#define SDMMC_TMOUT_DATA(n)             _SBF(8, (n))
+#define SDMMC_TMOUT_DATA_MSK            0xFFFFFF00
+#define SDMMC_TMOUT_RESP(n)             ((n) & 0xFF)
+#define SDMMC_TMOUT_RESP_MSK            0xFF
+/* card-type register defines */
+#define SDMMC_CTYPE_8BIT                BIT(16)
+#define SDMMC_CTYPE_4BIT                BIT(0)
+#define SDMMC_CTYPE_1BIT                0
+/* Interrupt status & mask register defines */
+#define SDMMC_INT_SDIO                  BIT(16)
+#define SDMMC_INT_EBE                   BIT(15)
+#define SDMMC_INT_ACD                   BIT(14)
+#define SDMMC_INT_SBE                   BIT(13)
+#define SDMMC_INT_HLE                   BIT(12)
+#define SDMMC_INT_FRUN                  BIT(11)
+#define SDMMC_INT_HTO                   BIT(10)
+#define SDMMC_INT_DTO                   BIT(9)
+#define SDMMC_INT_RTO                   BIT(8)
+#define SDMMC_INT_DCRC                  BIT(7)
+#define SDMMC_INT_RCRC                  BIT(6)
+#define SDMMC_INT_RXDR                  BIT(5)
+#define SDMMC_INT_TXDR                  BIT(4)
+#define SDMMC_INT_DATA_OVER             BIT(3)
+#define SDMMC_INT_CMD_DONE              BIT(2)
+#define SDMMC_INT_RESP_ERR              BIT(1)
+#define SDMMC_INT_CD                    BIT(0)
+#define SDMMC_INT_ERROR                 0xbfc2
+/* Command register defines */
+#define SDMMC_CMD_START                 BIT(31)
+#define SDMMC_CMD_CCS_EXP               BIT(23)
+#define SDMMC_CMD_CEATA_RD              BIT(22)
+#define SDMMC_CMD_UPD_CLK               BIT(21)
+#define SDMMC_CMD_INIT                  BIT(15)
+#define SDMMC_CMD_STOP                  BIT(14)
+#define SDMMC_CMD_PRV_DAT_WAIT          BIT(13)
+#define SDMMC_CMD_SEND_STOP             BIT(12)
+#define SDMMC_CMD_STRM_MODE             BIT(11)
+#define SDMMC_CMD_DAT_WR                BIT(10)
+#define SDMMC_CMD_DAT_EXP               BIT(9)
+#define SDMMC_CMD_RESP_CRC              BIT(8)
+#define SDMMC_CMD_RESP_LONG             BIT(7)
+#define SDMMC_CMD_RESP_EXP              BIT(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)
+#define SDMMC_IDMAC_INT_CES             BIT(5)
+#define SDMMC_IDMAC_INT_DU              BIT(4)
+#define SDMMC_IDMAC_INT_FBE             BIT(2)
+#define SDMMC_IDMAC_INT_RI              BIT(1)
+#define SDMMC_IDMAC_INT_TI              BIT(0)
+/* Internal DMAC bus mode bits */
+#define SDMMC_IDMAC_ENABLE              BIT(7)
+#define SDMMC_IDMAC_FB                  BIT(1)
+#define SDMMC_IDMAC_SWRESET             BIT(0)
+
+/* Register access macros */
+#define mci_readl(dev, reg)                     \
+        __raw_readl(dev->regs + SDMMC_##reg)
+#define mci_writel(dev, reg, value)                     \
+        __raw_writel((value), dev->regs + SDMMC_##reg)
+
+/* 16-bit FIFO access macros */
+#define mci_readw(dev, reg)                     \
+        __raw_readw(dev->regs + SDMMC_##reg)
+#define mci_writew(dev, reg, value)                     \
+        __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)
+#define mci_writeq(dev, reg, value)                     \
+        __raw_writeq((value), dev->regs + SDMMC_##reg)
+#else
+/*
+ * Dummy readq implementation for architectures that don't define it.
+ *
+ * We would assume that none of these architectures would configure
+ * the IP block with a 64bit FIFO width, so this code will never be
+ * executed on those machines. Defining these macros here keeps the
+ * rest of the code free from ifdefs.
+ */
+#define mci_readq(dev, reg)                     \
+        (*(volatile u64 __force *)(dev->regs + SDMMC_##reg))
+#define mci_writeq(dev, reg, value)                     \
+        (*(volatile u64 __force *)(dev->regs + SDMMC_##reg) = value)
+#endif
+
+#endif /* _DW_MMC_H_ */
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index 5a950b16d9e6..881f7ba545ae 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -966,8 +966,7 @@ static int __init imxmci_probe(struct platform_device *pdev)
         mmc->caps = MMC_CAP_4_BIT_DATA;
 
         /* MMC core transfer sizes tunable parameters */
-        mmc->max_hw_segs = 64;
-        mmc->max_phys_segs = 64;
+        mmc->max_segs = 64;
         mmc->max_seg_size = 64*512;     /* default PAGE_CACHE_SIZE */
         mmc->max_req_size = 64*512;     /* default PAGE_CACHE_SIZE */
         mmc->max_blk_size = 2048;
diff --git a/drivers/mmc/host/jz4740_mmc.c b/drivers/mmc/host/jz4740_mmc.c
index ad4f9870e3ca..74218ad677e4 100644
--- a/drivers/mmc/host/jz4740_mmc.c
+++ b/drivers/mmc/host/jz4740_mmc.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/mmc/host.h>
+#include <linux/err.h>
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
@@ -827,8 +828,8 @@ static int __devinit jz4740_mmc_probe(struct platform_device* pdev)
         }
 
         host->clk = clk_get(&pdev->dev, "mmc");
-        if (!host->clk) {
-                ret = -ENOENT;
+        if (IS_ERR(host->clk)) {
+                ret = PTR_ERR(host->clk);
                 dev_err(&pdev->dev, "Failed to get mmc clock\n");
                 goto err_free_host;
         }
@@ -876,8 +877,7 @@ static int __devinit jz4740_mmc_probe(struct platform_device* pdev)
         mmc->max_blk_count = (1 << 15) - 1;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
 
-        mmc->max_phys_segs = 128;
-        mmc->max_hw_segs = 128;
+        mmc->max_segs = 128;
         mmc->max_seg_size = mmc->max_req_size;
 
         host->mmc = mmc;
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 62a35822003e..7c1e16aaf17f 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -99,7 +99,7 @@
 #define r1b_timeout             (HZ * 3)
 
 /* One of the critical speed parameters is the amount of data which may
- * be transfered in one command. If this value is too low, the SD card
+ * be transferred in one command. If this value is too low, the SD card
  * controller has to do multiple partial block writes (argggh!). With
  * today (2008) SD cards there is little speed gain if we transfer more
  * than 64 KBytes at a time. So use this value until there is any indication
@@ -1055,6 +1055,8 @@ static void mmc_spi_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
         struct mmc_spi_host     *host = mmc_priv(mmc);
         int                     status = -EINVAL;
+        int                     crc_retry = 5;
+        struct mmc_command      stop;
 
 #ifdef DEBUG
         /* MMC core and layered drivers *MUST* issue SPI-aware commands */
@@ -1087,10 +1089,29 @@ static void mmc_spi_request(struct mmc_host *mmc, struct mmc_request *mrq)
         /* request exclusive bus access */
         spi_bus_lock(host->spi->master);
 
+crc_recover:
         /* issue command; then optionally data and stop */
         status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
         if (status == 0 && mrq->data) {
                 mmc_spi_data_do(host, mrq->cmd, mrq->data, mrq->data->blksz);
+
+                /*
+                 * The SPI bus is not always reliable for large data transfers.
+                 * If an occasional crc error is reported by the SD device with
+                 * data read/write over SPI, it may be recovered by repeating
+                 * the last SD command again. The retry count is set to 5 to
+                 * ensure the driver passes stress tests.
+                 */
+                if (mrq->data->error == -EILSEQ && crc_retry) {
+                        stop.opcode = MMC_STOP_TRANSMISSION;
+                        stop.arg = 0;
+                        stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+                        status = mmc_spi_command_send(host, mrq, &stop, 0);
+                        crc_retry--;
+                        mrq->data->error = 0;
+                        goto crc_recover;
+                }
+
                 if (mrq->stop)
                         status = mmc_spi_command_send(host, mrq, mrq->stop, 0);
                 else
@@ -1345,8 +1366,7 @@ static int mmc_spi_probe(struct spi_device *spi)
 
         mmc->ops = &mmc_spi_ops;
         mmc->max_blk_size = MMC_SPI_BLOCKSIZE;
-        mmc->max_hw_segs = MMC_SPI_BLOCKSATONCE;
-        mmc->max_phys_segs = MMC_SPI_BLOCKSATONCE;
+        mmc->max_segs = MMC_SPI_BLOCKSATONCE;
         mmc->max_req_size = MMC_SPI_BLOCKSATONCE * MMC_SPI_BLOCKSIZE;
         mmc->max_blk_count = MMC_SPI_BLOCKSATONCE;
 
@@ -1496,21 +1516,17 @@ static int __devexit mmc_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-#if defined(CONFIG_OF)
 static struct of_device_id mmc_spi_of_match_table[] __devinitdata = {
         { .compatible = "mmc-spi-slot", },
         {},
 };
-#endif
 
 static struct spi_driver mmc_spi_driver = {
         .driver = {
                 .name =         "mmc_spi",
                 .bus =          &spi_bus_type,
                 .owner =        THIS_MODULE,
-#if defined(CONFIG_OF)
                 .of_match_table = mmc_spi_of_match_table,
-#endif
         },
         .probe =        mmc_spi_probe,
         .remove =       __devexit_p(mmc_spi_remove),
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 840b301b5671..fe140724a02e 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -2,7 +2,7 @@
  *  linux/drivers/mmc/host/mmci.c - ARM PrimeCell MMCI PL180/1 driver
  *
  *  Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved.
- *  Copyright (C) 2010 ST-Ericsson AB.
+ *  Copyright (C) 2010 ST-Ericsson SA
  *
  * 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
@@ -14,17 +14,21 @@
 #include <linux/ioport.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
+#include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/highmem.h>
 #include <linux/log2.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 #include <linux/amba/bus.h>
 #include <linux/clk.h>
 #include <linux/scatterlist.h>
 #include <linux/gpio.h>
-#include <linux/amba/mmci.h>
 #include <linux/regulator/consumer.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/amba/mmci.h>
 
 #include <asm/div64.h>
 #include <asm/io.h>
@@ -41,27 +45,66 @@ static unsigned int fmax = 515633;
  * @clkreg: default value for MCICLOCK register
  * @clkreg_enable: enable value for MMCICLOCK register
  * @datalength_bits: number of bits in the MMCIDATALENGTH register
+ * @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY
+ *            is asserted (likewise for RX)
+ * @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
+ *                is asserted (likewise for RX)
+ * @sdio: variant supports SDIO
+ * @st_clkdiv: true if using a ST-specific clock divider algorithm
+ * @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
  */
 struct variant_data {
         unsigned int            clkreg;
         unsigned int            clkreg_enable;
         unsigned int            datalength_bits;
+        unsigned int            fifosize;
+        unsigned int            fifohalfsize;
+        bool                    sdio;
+        bool                    st_clkdiv;
+        bool                    blksz_datactrl16;
 };
 
 static struct variant_data variant_arm = {
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
+        .datalength_bits        = 16,
+};
+
+static struct variant_data variant_arm_extended_fifo = {
+        .fifosize               = 128 * 4,
+        .fifohalfsize           = 64 * 4,
         .datalength_bits        = 16,
 };
 
 static struct variant_data variant_u300 = {
-        .clkreg_enable          = 1 << 13, /* HWFCEN */
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
+        .clkreg_enable          = MCI_ST_U300_HWFCEN,
         .datalength_bits        = 16,
+        .sdio                   = true,
 };
 
 static struct variant_data variant_ux500 = {
+        .fifosize               = 30 * 4,
+        .fifohalfsize           = 8 * 4,
         .clkreg                 = MCI_CLK_ENABLE,
-        .clkreg_enable          = 1 << 14, /* HWFCEN */
+        .clkreg_enable          = MCI_ST_UX500_HWFCEN,
         .datalength_bits        = 24,
+        .sdio                   = true,
+        .st_clkdiv              = true,
 };
+
+static struct variant_data variant_ux500v2 = {
+        .fifosize               = 30 * 4,
+        .fifohalfsize           = 8 * 4,
+        .clkreg                 = MCI_CLK_ENABLE,
+        .clkreg_enable          = MCI_ST_UX500_HWFCEN,
+        .datalength_bits        = 24,
+        .sdio                   = true,
+        .st_clkdiv              = true,
+        .blksz_datactrl16       = true,
+};
+
 /*
  * This must be called with host->lock held
  */
@@ -73,8 +116,25 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
         if (desired) {
                 if (desired >= host->mclk) {
                         clk = MCI_CLK_BYPASS;
+                        if (variant->st_clkdiv)
+                                clk |= MCI_ST_UX500_NEG_EDGE;
                         host->cclk = host->mclk;
+                } else if (variant->st_clkdiv) {
+                        /*
+                         * DB8500 TRM says f = mclk / (clkdiv + 2)
+                         * => clkdiv = (mclk / f) - 2
+                         * Round the divider up so we don't exceed the max
+                         * frequency
+                         */
+                        clk = DIV_ROUND_UP(host->mclk, desired) - 2;
+                        if (clk >= 256)
+                                clk = 255;
+                        host->cclk = host->mclk / (clk + 2);
                 } else {
+                        /*
+                         * PL180 TRM says f = mclk / (2 * (clkdiv + 1))
+                         * => clkdiv = mclk / (2 * f) - 1
+                         */
                         clk = host->mclk / (2 * desired) - 1;
                         if (clk >= 256)
                                 clk = 255;
@@ -105,9 +165,6 @@ mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
         host->mrq = NULL;
         host->cmd = NULL;
 
-        if (mrq->data)
-                mrq->data->bytes_xfered = host->data_xfered;
-
         /*
          * Need to drop the host lock here; mmc_request_done may call
          * back into the driver...
@@ -117,10 +174,26 @@ mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
         spin_lock(&host->lock);
 }
 
+static void mmci_set_mask1(struct mmci_host *host, unsigned int mask)
+{
+        void __iomem *base = host->base;
+
+        if (host->singleirq) {
+                unsigned int mask0 = readl(base + MMCIMASK0);
+
+                mask0 &= ~MCI_IRQ1MASK;
+                mask0 |= mask;
+
+                writel(mask0, base + MMCIMASK0);
+        }
+
+        writel(mask, base + MMCIMASK1);
+}
+
 static void mmci_stop_data(struct mmci_host *host)
 {
         writel(0, host->base + MMCIDATACTRL);
-        writel(0, host->base + MMCIMASK1);
+        mmci_set_mask1(host, 0);
         host->data = NULL;
 }
 
@@ -136,8 +209,251 @@ static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data)
         sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
 }
 
+/*
+ * All the DMA operation mode stuff goes inside this ifdef.
+ * This assumes that you have a generic DMA device interface,
+ * no custom DMA interfaces are supported.
+ */
+#ifdef CONFIG_DMA_ENGINE
+static void __devinit mmci_dma_setup(struct mmci_host *host)
+{
+        struct mmci_platform_data *plat = host->plat;
+        const char *rxname, *txname;
+        dma_cap_mask_t mask;
+
+        if (!plat || !plat->dma_filter) {
+                dev_info(mmc_dev(host->mmc), "no DMA platform data\n");
+                return;
+        }
+
+        /* Try to acquire a generic DMA engine slave channel */
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        /*
+         * If only an RX channel is specified, the driver will
+         * attempt to use it bidirectionally, however if it is
+         * is specified but cannot be located, DMA will be disabled.
+         */
+        if (plat->dma_rx_param) {
+                host->dma_rx_channel = dma_request_channel(mask,
+                                                           plat->dma_filter,
+                                                           plat->dma_rx_param);
+                /* E.g if no DMA hardware is present */
+                if (!host->dma_rx_channel)
+                        dev_err(mmc_dev(host->mmc), "no RX DMA channel\n");
+        }
+
+        if (plat->dma_tx_param) {
+                host->dma_tx_channel = dma_request_channel(mask,
+                                                           plat->dma_filter,
+                                                           plat->dma_tx_param);
+                if (!host->dma_tx_channel)
+                        dev_warn(mmc_dev(host->mmc), "no TX DMA channel\n");
+        } else {
+                host->dma_tx_channel = host->dma_rx_channel;
+        }
+
+        if (host->dma_rx_channel)
+                rxname = dma_chan_name(host->dma_rx_channel);
+        else
+                rxname = "none";
+
+        if (host->dma_tx_channel)
+                txname = dma_chan_name(host->dma_tx_channel);
+        else
+                txname = "none";
+
+        dev_info(mmc_dev(host->mmc), "DMA channels RX %s, TX %s\n",
+                 rxname, txname);
+
+        /*
+         * Limit the maximum segment size in any SG entry according to
+         * the parameters of the DMA engine device.
+         */
+        if (host->dma_tx_channel) {
+                struct device *dev = host->dma_tx_channel->device->dev;
+                unsigned int max_seg_size = dma_get_max_seg_size(dev);
+
+                if (max_seg_size < host->mmc->max_seg_size)
+                        host->mmc->max_seg_size = max_seg_size;
+        }
+        if (host->dma_rx_channel) {
+                struct device *dev = host->dma_rx_channel->device->dev;
+                unsigned int max_seg_size = dma_get_max_seg_size(dev);
+
+                if (max_seg_size < host->mmc->max_seg_size)
+                        host->mmc->max_seg_size = max_seg_size;
+        }
+}
+
+/*
+ * This is used in __devinit or __devexit so inline it
+ * so it can be discarded.
+ */
+static inline void mmci_dma_release(struct mmci_host *host)
+{
+        struct mmci_platform_data *plat = host->plat;
+
+        if (host->dma_rx_channel)
+                dma_release_channel(host->dma_rx_channel);
+        if (host->dma_tx_channel && plat->dma_tx_param)
+                dma_release_channel(host->dma_tx_channel);
+        host->dma_rx_channel = host->dma_tx_channel = NULL;
+}
+
+static void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)
+{
+        struct dma_chan *chan = host->dma_current;
+        enum dma_data_direction dir;
+        u32 status;
+        int i;
+
+        /* Wait up to 1ms for the DMA to complete */
+        for (i = 0; ; i++) {
+                status = readl(host->base + MMCISTATUS);
+                if (!(status & MCI_RXDATAAVLBLMASK) || i >= 100)
+                        break;
+                udelay(10);
+        }
+
+        /*
+         * Check to see whether we still have some data left in the FIFO -
+         * this catches DMA controllers which are unable to monitor the
+         * DMALBREQ and DMALSREQ signals while allowing us to DMA to non-
+         * contiguous buffers.  On TX, we'll get a FIFO underrun error.
+         */
+        if (status & MCI_RXDATAAVLBLMASK) {
+                dmaengine_terminate_all(chan);
+                if (!data->error)
+                        data->error = -EIO;
+        }
+
+        if (data->flags & MMC_DATA_WRITE) {
+                dir = DMA_TO_DEVICE;
+        } else {
+                dir = DMA_FROM_DEVICE;
+        }
+
+        dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, dir);
+
+        /*
+         * Use of DMA with scatter-gather is impossible.
+         * Give up with DMA and switch back to PIO mode.
+         */
+        if (status & MCI_RXDATAAVLBLMASK) {
+                dev_err(mmc_dev(host->mmc), "buggy DMA detected. Taking evasive action.\n");
+                mmci_dma_release(host);
+        }
+}
+
+static void mmci_dma_data_error(struct mmci_host *host)
+{
+        dev_err(mmc_dev(host->mmc), "error during DMA transfer!\n");
+        dmaengine_terminate_all(host->dma_current);
+}
+
+static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
+{
+        struct variant_data *variant = host->variant;
+        struct dma_slave_config conf = {
+                .src_addr = host->phybase + MMCIFIFO,
+                .dst_addr = host->phybase + MMCIFIFO,
+                .src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
+                .dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
+                .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;
+
+        if (data->flags & MMC_DATA_READ) {
+                conf.direction = DMA_FROM_DEVICE;
+                chan = host->dma_rx_channel;
+        } else {
+                conf.direction = DMA_TO_DEVICE;
+                chan = host->dma_tx_channel;
+        }
+
+        /* If there's no DMA channel, fall back to PIO */
+        if (!chan)
+                return -EINVAL;
+
+        /* If less than or equal to the fifo size, don't bother with DMA */
+        if (host->size <= variant->fifosize)
+                return -EINVAL;
+
+        device = chan->device;
+        nr_sg = dma_map_sg(device->dev, data->sg, data->sg_len, conf.direction);
+        if (nr_sg == 0)
+                return -EINVAL;
+
+        dmaengine_slave_config(chan, &conf);
+        desc = device->device_prep_slave_sg(chan, data->sg, nr_sg,
+                                            conf.direction, DMA_CTRL_ACK);
+        if (!desc)
+                goto unmap_exit;
+
+        /* Okay, go for it. */
+        host->dma_current = chan;
+
+        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);
+
+        datactrl |= MCI_DPSM_DMAENABLE;
+
+        /* Trigger the DMA transfer */
+        writel(datactrl, host->base + MMCIDATACTRL);
+
+        /*
+         * Let the MMCI say when the data is ended and it's time
+         * to fire next DMA request. When that happens, MMCI will
+         * call mmci_data_end()
+         */
+        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;
+}
+#else
+/* Blank functions if the DMA engine is not available */
+static inline void mmci_dma_setup(struct mmci_host *host)
+{
+}
+
+static inline void mmci_dma_release(struct mmci_host *host)
+{
+}
+
+static inline void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)
+{
+}
+
+static inline void mmci_dma_data_error(struct mmci_host *host)
+{
+}
+
+static inline int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
+{
+        return -ENOSYS;
+}
+#endif
+
 static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 {
+        struct variant_data *variant = host->variant;
         unsigned int datactrl, timeout, irqmask;
         unsigned long long clks;
         void __iomem *base;
@@ -148,9 +464,7 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 
         host->data = data;
         host->size = data->blksz * data->blocks;
-        host->data_xfered = 0;
-
-        mmci_init_sg(host, data);
+        data->bytes_xfered = 0;
 
         clks = (unsigned long long)data->timeout_ns * host->cclk;
         do_div(clks, 1000000000UL);
@@ -164,16 +478,33 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         blksz_bits = ffs(data->blksz) - 1;
         BUG_ON(1 << blksz_bits != data->blksz);
 
-        datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
-        if (data->flags & MMC_DATA_READ) {
+        if (variant->blksz_datactrl16)
+                datactrl = MCI_DPSM_ENABLE | (data->blksz << 16);
+        else
+                datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
+
+        if (data->flags & MMC_DATA_READ)
                 datactrl |= MCI_DPSM_DIRECTION;
+
+        /*
+         * Attempt to use DMA operation mode, if this
+         * should fail, fall back to PIO mode
+         */
+        if (!mmci_dma_start_data(host, datactrl))
+                return;
+
+        /* IRQ mode, map the SG list for CPU reading/writing */
+        mmci_init_sg(host, data);
+
+        if (data->flags & MMC_DATA_READ) {
                 irqmask = MCI_RXFIFOHALFFULLMASK;
 
                 /*
-                 * If we have less than a FIFOSIZE of bytes to transfer,
-                 * trigger a PIO interrupt as soon as any data is available.
+                 * If we have less than the fifo 'half-full' threshold to
+                 * transfer, trigger a PIO interrupt as soon as any data
+                 * is available.
                  */
-                if (host->size < MCI_FIFOSIZE)
+                if (host->size < variant->fifohalfsize)
                         irqmask |= MCI_RXDATAAVLBLMASK;
         } else {
                 /*
@@ -183,9 +514,14 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                 irqmask = MCI_TXFIFOHALFEMPTYMASK;
         }
 
+        /* The ST Micro variants has a special bit to enable SDIO */
+        if (variant->sdio && host->mmc->card)
+                if (mmc_card_sdio(host->mmc->card))
+                        datactrl |= MCI_ST_DPSM_SDIOEN;
+
         writel(datactrl, base + MMCIDATACTRL);
         writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
-        writel(irqmask, base + MMCIMASK1);
+        mmci_set_mask1(host, irqmask);
 }
 
 static void
@@ -220,49 +556,58 @@ static void
 mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
               unsigned int status)
 {
-        if (status & MCI_DATABLOCKEND) {
-                host->data_xfered += data->blksz;
-#ifdef CONFIG_ARCH_U300
+        /* First check for errors */
+        if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
+                u32 remain, success;
+
+                /* Terminate the DMA transfer */
+                if (dma_inprogress(host))
+                        mmci_dma_data_error(host);
+
                 /*
-                 * On the U300 some signal or other is
-                 * badly routed so that a data write does
-                 * not properly terminate with a MCI_DATAEND
-                 * status flag. This quirk will make writes
-                 * work again.
+                 * Calculate how far we are into the transfer.  Note that
+                 * the data counter gives the number of bytes transferred
+                 * on the MMC bus, not on the host side.  On reads, this
+                 * can be as much as a FIFO-worth of data ahead.  This
+                 * matters for FIFO overruns only.
                  */
-                if (data->flags & MMC_DATA_WRITE)
-                        status |= MCI_DATAEND;
-#endif
-        }
-        if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
-                dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ (status %08x)\n", status);
-                if (status & MCI_DATACRCFAIL)
+                remain = readl(host->base + MMCIDATACNT);
+                success = data->blksz * data->blocks - remain;
+
+                dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ, status 0x%08x at 0x%08x\n",
+                        status, success);
+                if (status & MCI_DATACRCFAIL) {
+                        /* Last block was not successful */
+                        success -= 1;
                         data->error = -EILSEQ;
-                else if (status & MCI_DATATIMEOUT)
+                } else if (status & MCI_DATATIMEOUT) {
                         data->error = -ETIMEDOUT;
-                else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN))
+                } else if (status & MCI_STARTBITERR) {
+                        data->error = -ECOMM;
+                } else if (status & MCI_TXUNDERRUN) {
+                        data->error = -EIO;
+                } else if (status & MCI_RXOVERRUN) {
+                        if (success > host->variant->fifosize)
+                                success -= host->variant->fifosize;
+                        else
+                                success = 0;
                         data->error = -EIO;
-                status |= MCI_DATAEND;
-
-                /*
-                 * We hit an error condition.  Ensure that any data
-                 * partially written to a page is properly coherent.
-                 */
-                if (data->flags & MMC_DATA_READ) {
-                        struct sg_mapping_iter *sg_miter = &host->sg_miter;
-                        unsigned long flags;
-
-                        local_irq_save(flags);
-                        if (sg_miter_next(sg_miter)) {
-                                flush_dcache_page(sg_miter->page);
-                                sg_miter_stop(sg_miter);
-                        }
-                        local_irq_restore(flags);
                 }
+                data->bytes_xfered = round_down(success, data->blksz);
         }
-        if (status & MCI_DATAEND) {
+
+        if (status & MCI_DATABLOCKEND)
+                dev_err(mmc_dev(host->mmc), "stray MCI_DATABLOCKEND interrupt\n");
+
+        if (status & MCI_DATAEND || data->error) {
+                if (dma_inprogress(host))
+                        mmci_dma_unmap(host, data);
                 mmci_stop_data(host);
 
+                if (!data->error)
+                        /* The error clause is handled above, success! */
+                        data->bytes_xfered = data->blksz * data->blocks;
+
                 if (!data->stop) {
                         mmci_request_end(host, data->mrq);
                 } else {
@@ -279,15 +624,15 @@ mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
 
         host->cmd = NULL;
 
-        cmd->resp[0] = readl(base + MMCIRESPONSE0);
-        cmd->resp[1] = readl(base + MMCIRESPONSE1);
-        cmd->resp[2] = readl(base + MMCIRESPONSE2);
-        cmd->resp[3] = readl(base + MMCIRESPONSE3);
-
         if (status & MCI_CMDTIMEOUT) {
                 cmd->error = -ETIMEDOUT;
         } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) {
                 cmd->error = -EILSEQ;
+        } else {
+                cmd->resp[0] = readl(base + MMCIRESPONSE0);
+                cmd->resp[1] = readl(base + MMCIRESPONSE1);
+                cmd->resp[2] = readl(base + MMCIRESPONSE2);
+                cmd->resp[3] = readl(base + MMCIRESPONSE3);
         }
 
         if (!cmd->data || cmd->error) {
@@ -332,16 +677,43 @@ static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int rema
 
 static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int remain, u32 status)
 {
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         char *ptr = buffer;
 
         do {
                 unsigned int count, maxcnt;
 
-                maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE : MCI_FIFOHALFSIZE;
+                maxcnt = status & MCI_TXFIFOEMPTY ?
+                         variant->fifosize : variant->fifohalfsize;
                 count = min(remain, maxcnt);
 
-                writesl(base + MMCIFIFO, ptr, count >> 2);
+                /*
+                 * The ST Micro variant for SDIO transfer sizes
+                 * less then 8 bytes should have clock H/W flow
+                 * control disabled.
+                 */
+                if (variant->sdio &&
+                    mmc_card_sdio(host->mmc->card)) {
+                        if (count < 8)
+                                writel(readl(host->base + MMCICLOCK) &
+                                        ~variant->clkreg_enable,
+                                        host->base + MMCICLOCK);
+                        else
+                                writel(readl(host->base + MMCICLOCK) |
+                                        variant->clkreg_enable,
+                                        host->base + MMCICLOCK);
+                }
+
+                /*
+                 * SDIO especially may want to send something that is
+                 * not divisible by 4 (as opposed to card sectors
+                 * etc), and the FIFO only accept full 32-bit writes.
+                 * So compensate by adding +3 on the count, a single
+                 * byte become a 32bit write, 7 bytes will be two
+                 * 32bit writes etc.
+                 */
+                writesl(base + MMCIFIFO, ptr, (count + 3) >> 2);
 
                 ptr += count;
                 remain -= count;
@@ -362,6 +734,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
 {
         struct mmci_host *host = dev_id;
         struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         unsigned long flags;
         u32 status;
@@ -406,9 +779,6 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
                 if (remain)
                         break;
 
-                if (status & MCI_RXACTIVE)
-                        flush_dcache_page(sg_miter->page);
-
                 status = readl(base + MMCISTATUS);
         } while (1);
 
@@ -417,11 +787,11 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
         local_irq_restore(flags);
 
         /*
-         * If we're nearing the end of the read, switch to
-         * "any data available" mode.
+         * If we have less than the fifo 'half-full' threshold to transfer,
+         * trigger a PIO interrupt as soon as any data is available.
          */
-        if (status & MCI_RXACTIVE && host->size < MCI_FIFOSIZE)
-                writel(MCI_RXDATAAVLBLMASK, base + MMCIMASK1);
+        if (status & MCI_RXACTIVE && host->size < variant->fifohalfsize)
+                mmci_set_mask1(host, MCI_RXDATAAVLBLMASK);
 
         /*
          * If we run out of data, disable the data IRQs; this
@@ -430,7 +800,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
          * stops us racing with our data end IRQ.
          */
         if (host->size == 0) {
-                writel(0, base + MMCIMASK1);
+                mmci_set_mask1(host, 0);
                 writel(readl(base + MMCIMASK0) | MCI_DATAENDMASK, base + MMCIMASK0);
         }
 
@@ -453,6 +823,14 @@ static irqreturn_t mmci_irq(int irq, void *dev_id)
                 struct mmc_data *data;
 
                 status = readl(host->base + MMCISTATUS);
+
+                if (host->singleirq) {
+                        if (status & readl(host->base + MMCIMASK1))
+                                mmci_pio_irq(irq, dev_id);
+
+                        status &= ~MCI_IRQ1MASK;
+                }
+
                 status &= readl(host->base + MMCIMASK0);
                 writel(status, host->base + MMCICLEAR);
 
@@ -507,19 +885,27 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         struct mmci_host *host = mmc_priv(mmc);
         u32 pwr = 0;
         unsigned long flags;
+        int ret;
 
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
-                if(host->vcc &&
-                   regulator_is_enabled(host->vcc))
-                        regulator_disable(host->vcc);
+                if (host->vcc)
+                        ret = mmc_regulator_set_ocr(mmc, host->vcc, 0);
                 break;
         case MMC_POWER_UP:
-#ifdef CONFIG_REGULATOR
-                if (host->vcc)
-                        /* This implicitly enables the regulator */
-                        mmc_regulator_set_ocr(host->vcc, ios->vdd);
-#endif
+                if (host->vcc) {
+                        ret = mmc_regulator_set_ocr(mmc, host->vcc, ios->vdd);
+                        if (ret) {
+                                dev_err(mmc_dev(mmc), "unable to set OCR\n");
+                                /*
+                                 * The .set_ios() function in the mmc_host_ops
+                                 * struct return void, and failing to set the
+                                 * power should be rare so we print an error
+                                 * and return here.
+                                 */
+                                return;
+                        }
+                }
                 if (host->plat->vdd_handler)
                         pwr |= host->plat->vdd_handler(mmc_dev(mmc), ios->vdd,
                                                        ios->power_mode);
@@ -564,18 +950,23 @@ static int mmci_get_ro(struct mmc_host *mmc)
         if (host->gpio_wp == -ENOSYS)
                 return -ENOSYS;
 
-        return gpio_get_value(host->gpio_wp);
+        return gpio_get_value_cansleep(host->gpio_wp);
 }
 
 static int mmci_get_cd(struct mmc_host *mmc)
 {
         struct mmci_host *host = mmc_priv(mmc);
+        struct mmci_platform_data *plat = host->plat;
         unsigned int status;
 
-        if (host->gpio_cd == -ENOSYS)
-                status = host->plat->status(mmc_dev(host->mmc));
-        else
-                status = !gpio_get_value(host->gpio_cd);
+        if (host->gpio_cd == -ENOSYS) {
+                if (!plat->status)
+                        return 1; /* Assume always present */
+
+                status = plat->status(mmc_dev(host->mmc));
+        } else
+                status = !!gpio_get_value_cansleep(host->gpio_cd)
+                        ^ plat->cd_invert;
 
         /*
          * Use positive logic throughout - status is zero for no card,
@@ -584,6 +975,15 @@ static int mmci_get_cd(struct mmc_host *mmc)
         return status;
 }
 
+static irqreturn_t mmci_cd_irq(int irq, void *dev_id)
+{
+        struct mmci_host *host = dev_id;
+
+        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
+
+        return IRQ_HANDLED;
+}
+
 static const struct mmc_host_ops mmci_ops = {
         .request        = mmci_request,
         .set_ios        = mmci_set_ios,
@@ -591,7 +991,8 @@ static const struct mmc_host_ops mmci_ops = {
         .get_cd         = mmci_get_cd,
 };
 
-static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
+static int __devinit mmci_probe(struct amba_device *dev,
+        const struct amba_id *id)
 {
         struct mmci_platform_data *plat = dev->dev.platform_data;
         struct variant_data *variant = id->data;
@@ -620,6 +1021,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
 
         host->gpio_wp = -ENOSYS;
         host->gpio_cd = -ENOSYS;
+        host->gpio_cd_irq = -1;
 
         host->hw_designer = amba_manf(dev);
         host->hw_revision = amba_rev(dev);
@@ -653,6 +1055,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                 dev_dbg(mmc_dev(mmc), "eventual mclk rate: %u Hz\n",
                         host->mclk);
         }
+        host->phybase = dev->res.start;
         host->base = ioremap(dev->res.start, resource_size(&dev->res));
         if (!host->base) {
                 ret = -ENOMEM;
@@ -699,13 +1102,11 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->vcc == NULL)
                 mmc->ocr_avail = plat->ocr_mask;
         mmc->caps = plat->capabilities;
-        mmc->caps |= MMC_CAP_NEEDS_POLL;
 
         /*
          * We can do SGIO
          */
-        mmc->max_hw_segs = 16;
-        mmc->max_phys_segs = NR_SG;
+        mmc->max_segs = NR_SG;
 
         /*
          * Since only a certain number of bits are valid in the data length
@@ -744,6 +1145,20 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         host->gpio_cd = plat->gpio_cd;
                 else if (ret != -ENOSYS)
                         goto err_gpio_cd;
+
+                /*
+                 * A gpio pin that will detect cards when inserted and removed
+                 * will most likely want to trigger on the edges if it is
+                 * 0 when ejected and 1 when inserted (or mutatis mutandis
+                 * for the inverted case) so we request triggers on both
+                 * edges.
+                 */
+                ret = request_any_context_irq(gpio_to_irq(plat->gpio_cd),
+                                mmci_cd_irq,
+                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                DRIVER_NAME " (cd)", host);
+                if (ret >= 0)
+                        host->gpio_cd_irq = gpio_to_irq(plat->gpio_cd);
         }
         if (gpio_is_valid(plat->gpio_wp)) {
                 ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
@@ -755,23 +1170,35 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         goto err_gpio_wp;
         }
 
+        if ((host->plat->status || host->gpio_cd != -ENOSYS)
+            && host->gpio_cd_irq < 0)
+                mmc->caps |= MMC_CAP_NEEDS_POLL;
+
         ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host);
         if (ret)
                 goto unmap;
 
-        ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED, DRIVER_NAME " (pio)", host);
-        if (ret)
-                goto irq0_free;
+        if (dev->irq[1] == NO_IRQ)
+                host->singleirq = true;
+        else {
+                ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED,
+                                  DRIVER_NAME " (pio)", host);
+                if (ret)
+                        goto irq0_free;
+        }
 
         writel(MCI_IRQENABLE, host->base + MMCIMASK0);
 
         amba_set_drvdata(dev, mmc);
 
-        mmc_add_host(mmc);
+        dev_info(&dev->dev, "%s: PL%03x manf %x rev%u at 0x%08llx irq %d,%d (pio)\n",
+                 mmc_hostname(mmc), amba_part(dev), amba_manf(dev),
+                 amba_rev(dev), (unsigned long long)dev->res.start,
+                 dev->irq[0], dev->irq[1]);
 
-        dev_info(&dev->dev, "%s: MMCI rev %x cfg %02x at 0x%016llx irq %d,%d\n",
-                mmc_hostname(mmc), amba_rev(dev), amba_config(dev),
-                (unsigned long long)dev->res.start, dev->irq[0], dev->irq[1]);
+        mmci_dma_setup(host);
+
+        mmc_add_host(mmc);
 
         return 0;
 
@@ -781,6 +1208,8 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->gpio_wp != -ENOSYS)
                 gpio_free(host->gpio_wp);
  err_gpio_wp:
+        if (host->gpio_cd_irq >= 0)
+                free_irq(host->gpio_cd_irq, host);
         if (host->gpio_cd != -ENOSYS)
                 gpio_free(host->gpio_cd);
  err_gpio_cd:
@@ -814,11 +1243,15 @@ static int __devexit mmci_remove(struct amba_device *dev)
                 writel(0, host->base + MMCICOMMAND);
                 writel(0, host->base + MMCIDATACTRL);
 
+                mmci_dma_release(host);
                 free_irq(dev->irq[0], host);
-                free_irq(dev->irq[1], host);
+                if (!host->singleirq)
+                        free_irq(dev->irq[1], host);
 
                 if (host->gpio_wp != -ENOSYS)
                         gpio_free(host->gpio_wp);
+                if (host->gpio_cd_irq >= 0)
+                        free_irq(host->gpio_cd_irq, host);
                 if (host->gpio_cd != -ENOSYS)
                         gpio_free(host->gpio_cd);
 
@@ -826,8 +1259,8 @@ static int __devexit mmci_remove(struct amba_device *dev)
                 clk_disable(host->clk);
                 clk_put(host->clk);
 
-                if (regulator_is_enabled(host->vcc))
-                        regulator_disable(host->vcc);
+                if (host->vcc)
+                        mmc_regulator_set_ocr(mmc, host->vcc, 0);
                 regulator_put(host->vcc);
 
                 mmc_free_host(mmc);
@@ -878,10 +1311,15 @@ static int mmci_resume(struct amba_device *dev)
 static struct amba_id mmci_ids[] = {
         {
                 .id     = 0x00041180,
-                .mask   = 0x000fffff,
+                .mask   = 0xff0fffff,
                 .data   = &variant_arm,
         },
         {
+                .id     = 0x01041180,
+                .mask   = 0xff0fffff,
+                .data   = &variant_arm_extended_fifo,
+        },
+        {
                 .id     = 0x00041181,
                 .mask   = 0x000fffff,
                 .data   = &variant_arm,
@@ -899,9 +1337,14 @@ static struct amba_id mmci_ids[] = {
         },
         {
                 .id     = 0x00480180,
-                .mask   = 0x00ffffff,
+                .mask   = 0xf0ffffff,
                 .data   = &variant_ux500,
         },
+        {
+                .id     = 0x10480180,
+                .mask   = 0xf0ffffff,
+                .data   = &variant_ux500v2,
+        },
         { 0, 0 },
 };
 
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 68970cfb81e1..2164e8c6476c 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -11,23 +11,33 @@
 #define MCI_PWR_OFF             0x00
 #define MCI_PWR_UP              0x02
 #define MCI_PWR_ON              0x03
-#define MCI_DATA2DIREN          (1 << 2)
-#define MCI_CMDDIREN            (1 << 3)
-#define MCI_DATA0DIREN          (1 << 4)
-#define MCI_DATA31DIREN         (1 << 5)
 #define MCI_OD                  (1 << 6)
 #define MCI_ROD                 (1 << 7)
-/* The ST Micro version does not have ROD */
-#define MCI_FBCLKEN             (1 << 7)
-#define MCI_DATA74DIREN         (1 << 8)
+/*
+ * The ST Micro version does not have ROD and reuse the voltage registers
+ * for direction settings
+ */
+#define MCI_ST_DATA2DIREN       (1 << 2)
+#define MCI_ST_CMDDIREN         (1 << 3)
+#define MCI_ST_DATA0DIREN       (1 << 4)
+#define MCI_ST_DATA31DIREN      (1 << 5)
+#define MCI_ST_FBCLKEN          (1 << 7)
+#define MCI_ST_DATA74DIREN      (1 << 8)
 
 #define MMCICLOCK               0x004
 #define MCI_CLK_ENABLE          (1 << 8)
 #define MCI_CLK_PWRSAVE         (1 << 9)
 #define MCI_CLK_BYPASS          (1 << 10)
 #define MCI_4BIT_BUS            (1 << 11)
-/* 8bit wide buses supported in ST Micro versions */
+/*
+ * 8bit wide buses, hardware flow contronl, negative edges and clock inversion
+ * supported in ST Micro U300 and Ux500 versions
+ */
 #define MCI_ST_8BIT_BUS         (1 << 12)
+#define MCI_ST_U300_HWFCEN      (1 << 13)
+#define MCI_ST_UX500_NEG_EDGE   (1 << 13)
+#define MCI_ST_UX500_HWFCEN     (1 << 14)
+#define MCI_ST_UX500_CLK_INV    (1 << 15)
 
 #define MMCIARGUMENT            0x008
 #define MMCICOMMAND             0x00c
@@ -54,10 +64,16 @@
 #define MCI_DPSM_MODE           (1 << 2)
 #define MCI_DPSM_DMAENABLE      (1 << 3)
 #define MCI_DPSM_BLOCKSIZE      (1 << 4)
-#define MCI_DPSM_RWSTART        (1 << 8)
-#define MCI_DPSM_RWSTOP         (1 << 9)
-#define MCI_DPSM_RWMOD          (1 << 10)
-#define MCI_DPSM_SDIOEN         (1 << 11)
+/* Control register extensions in the ST Micro U300 and Ux500 versions */
+#define MCI_ST_DPSM_RWSTART     (1 << 8)
+#define MCI_ST_DPSM_RWSTOP      (1 << 9)
+#define MCI_ST_DPSM_RWMOD       (1 << 10)
+#define MCI_ST_DPSM_SDIOEN      (1 << 11)
+/* Control register extensions in the ST Micro Ux500 versions */
+#define MCI_ST_DPSM_DMAREQCTL   (1 << 12)
+#define MCI_ST_DPSM_DBOOTMODEEN (1 << 13)
+#define MCI_ST_DPSM_BUSYMODE    (1 << 14)
+#define MCI_ST_DPSM_DDRMODE     (1 << 15)
 
 #define MMCIDATACNT             0x030
 #define MMCISTATUS              0x034
@@ -70,6 +86,7 @@
 #define MCI_CMDRESPEND          (1 << 6)
 #define MCI_CMDSENT             (1 << 7)
 #define MCI_DATAEND             (1 << 8)
+#define MCI_STARTBITERR         (1 << 9)
 #define MCI_DATABLOCKEND        (1 << 10)
 #define MCI_CMDACTIVE           (1 << 11)
 #define MCI_TXACTIVE            (1 << 12)
@@ -82,8 +99,9 @@
 #define MCI_RXFIFOEMPTY         (1 << 19)
 #define MCI_TXDATAAVLBL         (1 << 20)
 #define MCI_RXDATAAVLBL         (1 << 21)
-#define MCI_SDIOIT              (1 << 22)
-#define MCI_CEATAEND            (1 << 23)
+/* Extended status bits for the ST Micro variants */
+#define MCI_ST_SDIOIT           (1 << 22)
+#define MCI_ST_CEATAEND         (1 << 23)
 
 #define MMCICLEAR               0x038
 #define MCI_CMDCRCFAILCLR       (1 << 0)
@@ -95,9 +113,11 @@
 #define MCI_CMDRESPENDCLR       (1 << 6)
 #define MCI_CMDSENTCLR          (1 << 7)
 #define MCI_DATAENDCLR          (1 << 8)
+#define MCI_STARTBITERRCLR      (1 << 9)
 #define MCI_DATABLOCKENDCLR     (1 << 10)
-#define MCI_SDIOITC             (1 << 22)
-#define MCI_CEATAENDC           (1 << 23)
+/* Extended status bits for the ST Micro variants */
+#define MCI_ST_SDIOITC          (1 << 22)
+#define MCI_ST_CEATAENDC        (1 << 23)
 
 #define MMCIMASK0               0x03c
 #define MCI_CMDCRCFAILMASK      (1 << 0)
@@ -109,6 +129,7 @@
 #define MCI_CMDRESPENDMASK      (1 << 6)
 #define MCI_CMDSENTMASK         (1 << 7)
 #define MCI_DATAENDMASK         (1 << 8)
+#define MCI_STARTBITERRMASK     (1 << 9)
 #define MCI_DATABLOCKENDMASK    (1 << 10)
 #define MCI_CMDACTIVEMASK       (1 << 11)
 #define MCI_TXACTIVEMASK        (1 << 12)
@@ -121,8 +142,9 @@
 #define MCI_RXFIFOEMPTYMASK     (1 << 19)
 #define MCI_TXDATAAVLBLMASK     (1 << 20)
 #define MCI_RXDATAAVLBLMASK     (1 << 21)
-#define MCI_SDIOITMASK          (1 << 22)
-#define MCI_CEATAENDMASK        (1 << 23)
+/* Extended status bits for the ST Micro variants */
+#define MCI_ST_SDIOITMASK       (1 << 22)
+#define MCI_ST_CEATAENDMASK     (1 << 23)
 
 #define MMCIMASK1               0x040
 #define MMCIFIFOCNT             0x048
@@ -131,21 +153,21 @@
 #define MCI_IRQENABLE   \
         (MCI_CMDCRCFAILMASK|MCI_DATACRCFAILMASK|MCI_CMDTIMEOUTMASK|     \
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
-        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATABLOCKENDMASK)
+        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_STARTBITERRMASK)
 
-/*
- * The size of the FIFO in bytes.
- */
-#define MCI_FIFOSIZE    (16*4)
-        
-#define MCI_FIFOHALFSIZE (MCI_FIFOSIZE / 2)
+/* These interrupts are directed to IRQ1 when two IRQ lines are available */
+#define MCI_IRQ1MASK \
+        (MCI_RXFIFOHALFFULLMASK | MCI_RXDATAAVLBLMASK | \
+         MCI_TXFIFOHALFEMPTYMASK)
 
 #define NR_SG           16
 
 struct clk;
 struct variant_data;
+struct dma_chan;
 
 struct mmci_host {
+        phys_addr_t             phybase;
         void __iomem            *base;
         struct mmc_request      *mrq;
         struct mmc_command      *cmd;
@@ -154,8 +176,8 @@ struct mmci_host {
         struct clk              *clk;
         int                     gpio_cd;
         int                     gpio_wp;
-
-        unsigned int            data_xfered;
+        int                     gpio_cd_irq;
+        bool                    singleirq;
 
         spinlock_t              lock;
 
@@ -175,5 +197,16 @@ struct mmci_host {
         struct sg_mapping_iter  sg_miter;
         unsigned int            size;
         struct regulator        *vcc;
+
+#ifdef CONFIG_DMA_ENGINE
+        /* DMA stuff */
+        struct dma_chan         *dma_current;
+        struct dma_chan         *dma_rx_channel;
+        struct dma_chan         *dma_tx_channel;
+
+#define dma_inprogress(host)    ((host)->dma_current)
+#else
+#define dma_inprogress(host)    (0)
+#endif
 };
 
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index ff7752348b11..a4c865a5286b 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -36,6 +36,7 @@
 #include <linux/io.h>
 #include <linux/memory.h>
 #include <linux/gfp.h>
+#include <linux/gpio.h>
 
 #include <asm/cacheflush.h>
 #include <asm/div64.h>
@@ -44,6 +45,7 @@
 #include <mach/mmc.h>
 #include <mach/msm_iomap.h>
 #include <mach/dma.h>
+#include <mach/clk.h>
 
 #include "msm_sdcc.h"
 
@@ -126,6 +128,40 @@ static void
 msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd,
                       u32 c);
 
+static void msmsdcc_reset_and_restore(struct msmsdcc_host *host)
+{
+        u32     mci_clk = 0;
+        u32     mci_mask0 = 0;
+        int     ret = 0;
+
+        /* Save the controller state */
+        mci_clk = readl(host->base + MMCICLOCK);
+        mci_mask0 = readl(host->base + MMCIMASK0);
+
+        /* Reset the controller */
+        ret = clk_reset(host->clk, CLK_RESET_ASSERT);
+        if (ret)
+                pr_err("%s: Clock assert failed at %u Hz with err %d\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+
+        ret = clk_reset(host->clk, CLK_RESET_DEASSERT);
+        if (ret)
+                pr_err("%s: Clock deassert failed at %u Hz with err %d\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+
+        pr_info("%s: Controller has been re-initialiazed\n",
+                        mmc_hostname(host->mmc));
+
+        /* Restore the contoller state */
+        writel(host->pwr, host->base + MMCIPOWER);
+        writel(mci_clk, host->base + MMCICLOCK);
+        writel(mci_mask0, host->base + MMCIMASK0);
+        ret = clk_set_rate(host->clk, host->clk_rate);
+        if (ret)
+                pr_err("%s: Failed to set clk rate %u Hz (%d)\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+}
+
 static void
 msmsdcc_request_end(struct msmsdcc_host *host, struct mmc_request *mrq)
 {
@@ -155,7 +191,7 @@ static void
 msmsdcc_stop_data(struct msmsdcc_host *host)
 {
         host->curr.data = NULL;
-        host->curr.got_dataend = host->curr.got_datablkend = 0;
+        host->curr.got_dataend = 0;
 }
 
 uint32_t msmsdcc_fifo_addr(struct msmsdcc_host *host)
@@ -189,61 +225,52 @@ msmsdcc_dma_exec_func(struct msm_dmov_cmd *cmd)
 }
 
 static void
-msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd,
-                          unsigned int result,
-                          struct msm_dmov_errdata *err)
+msmsdcc_dma_complete_tlet(unsigned long data)
 {
-        struct msmsdcc_dma_data *dma_data =
-                container_of(cmd, struct msmsdcc_dma_data, hdr);
-        struct msmsdcc_host     *host = dma_data->host;
+        struct msmsdcc_host *host = (struct msmsdcc_host *)data;
         unsigned long           flags;
         struct mmc_request      *mrq;
+        struct msm_dmov_errdata err;
 
         spin_lock_irqsave(&host->lock, flags);
         host->dma.active = 0;
 
+        err = host->dma.err;
         mrq = host->curr.mrq;
         BUG_ON(!mrq);
         WARN_ON(!mrq->data);
 
-        if (!(result & DMOV_RSLT_VALID)) {
+        if (!(host->dma.result & DMOV_RSLT_VALID)) {
                 pr_err("msmsdcc: Invalid DataMover result\n");
                 goto out;
         }
 
-        if (result & DMOV_RSLT_DONE) {
+        if (host->dma.result & DMOV_RSLT_DONE) {
                 host->curr.data_xfered = host->curr.xfer_size;
         } else {
                 /* Error or flush  */
-                if (result & DMOV_RSLT_ERROR)
+                if (host->dma.result & DMOV_RSLT_ERROR)
                         pr_err("%s: DMA error (0x%.8x)\n",
-                               mmc_hostname(host->mmc), result);
-                if (result & DMOV_RSLT_FLUSH)
+                               mmc_hostname(host->mmc), host->dma.result);
+                if (host->dma.result & DMOV_RSLT_FLUSH)
                         pr_err("%s: DMA channel flushed (0x%.8x)\n",
-                               mmc_hostname(host->mmc), result);
-                if (err)
-                        pr_err("Flush data: %.8x %.8x %.8x %.8x %.8x %.8x\n",
-                               err->flush[0], err->flush[1], err->flush[2],
-                               err->flush[3], err->flush[4], err->flush[5]);
+                               mmc_hostname(host->mmc), host->dma.result);
+
+                pr_err("Flush data: %.8x %.8x %.8x %.8x %.8x %.8x\n",
+                       err.flush[0], err.flush[1], err.flush[2],
+                       err.flush[3], err.flush[4], err.flush[5]);
+
+                msmsdcc_reset_and_restore(host);
                 if (!mrq->data->error)
                         mrq->data->error = -EIO;
         }
         dma_unmap_sg(mmc_dev(host->mmc), host->dma.sg, host->dma.num_ents,
                      host->dma.dir);
 
-        if (host->curr.user_pages) {
-                struct scatterlist *sg = host->dma.sg;
-                int i;
-
-                for (i = 0; i < host->dma.num_ents; i++)
-                        flush_dcache_page(sg_page(sg++));
-        }
-
         host->dma.sg = NULL;
         host->dma.busy = 0;
 
-        if ((host->curr.got_dataend && host->curr.got_datablkend)
-             || mrq->data->error) {
+        if (host->curr.got_dataend || mrq->data->error) {
 
                 /*
                  * If we've already gotten our DATAEND / DATABLKEND
@@ -273,6 +300,22 @@ out:
         return;
 }
 
+static void
+msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd,
+                          unsigned int result,
+                          struct msm_dmov_errdata *err)
+{
+        struct msmsdcc_dma_data *dma_data =
+                container_of(cmd, struct msmsdcc_dma_data, hdr);
+        struct msmsdcc_host *host = dma_data->host;
+
+        dma_data->result = result;
+        if (err)
+                memcpy(&dma_data->err, err, sizeof(struct msm_dmov_errdata));
+
+        tasklet_schedule(&host->dma_tlet);
+}
+
 static int validate_dma(struct msmsdcc_host *host, struct mmc_data *data)
 {
         if (host->dma.channel == -1)
@@ -333,14 +376,30 @@ static int msmsdcc_config_dma(struct msmsdcc_host *host, struct mmc_data *data)
         host->curr.user_pages = 0;
 
         box = &nc->cmd[0];
-        for (i = 0; i < host->dma.num_ents; i++) {
-                box->cmd = CMD_MODE_BOX;
 
-        /* Initialize sg dma address */
-        sg->dma_address = page_to_dma(mmc_dev(host->mmc), sg_page(sg))
-                                + sg->offset;
+        /* location of command block must be 64 bit aligned */
+        BUG_ON(host->dma.cmd_busaddr & 0x07);
 
-        if (i == (host->dma.num_ents - 1))
+        nc->cmdptr = (host->dma.cmd_busaddr >> 3) | CMD_PTR_LP;
+        host->dma.hdr.cmdptr = DMOV_CMD_PTR_LIST |
+                               DMOV_CMD_ADDR(host->dma.cmdptr_busaddr);
+        host->dma.hdr.complete_func = msmsdcc_dma_complete_func;
+
+        n = dma_map_sg(mmc_dev(host->mmc), host->dma.sg,
+                        host->dma.num_ents, host->dma.dir);
+        if (n == 0) {
+                printk(KERN_ERR "%s: Unable to map in all sg elements\n",
+                        mmc_hostname(host->mmc));
+                host->dma.sg = NULL;
+                host->dma.num_ents = 0;
+                return -ENOMEM;
+        }
+
+        for_each_sg(host->dma.sg, sg, n, i) {
+
+                box->cmd = CMD_MODE_BOX;
+
+                if (i == n - 1)
                         box->cmd |= CMD_LC;
                 rows = (sg_dma_len(sg) % MCI_FIFOSIZE) ?
                         (sg_dma_len(sg) / MCI_FIFOSIZE) + 1 :
@@ -368,27 +427,6 @@ static int msmsdcc_config_dma(struct msmsdcc_host *host, struct mmc_data *data)
                         box->cmd |= CMD_DST_CRCI(crci);
                 }
                 box++;
-                sg++;
-        }
-
-        /* location of command block must be 64 bit aligned */
-        BUG_ON(host->dma.cmd_busaddr & 0x07);
-
-        nc->cmdptr = (host->dma.cmd_busaddr >> 3) | CMD_PTR_LP;
-        host->dma.hdr.cmdptr = DMOV_CMD_PTR_LIST |
-                               DMOV_CMD_ADDR(host->dma.cmdptr_busaddr);
-        host->dma.hdr.complete_func = msmsdcc_dma_complete_func;
-
-        n = dma_map_sg(mmc_dev(host->mmc), host->dma.sg,
-                        host->dma.num_ents, host->dma.dir);
-/* dsb inside dma_map_sg will write nc out to mem as well */
-
-        if (n != host->dma.num_ents) {
-                printk(KERN_ERR "%s: Unable to map in all sg elements\n",
-                        mmc_hostname(host->mmc));
-                host->dma.sg = NULL;
-                host->dma.num_ents = 0;
-                return -ENOMEM;
         }
 
         return 0;
@@ -424,6 +462,11 @@ msmsdcc_start_command_deferred(struct msmsdcc_host *host,
               (cmd->opcode == 53))
                 *c |= MCI_CSPM_DATCMD;
 
+        if (host->prog_scan && (cmd->opcode == 12)) {
+                *c |= MCI_CPSM_PROGENA;
+                host->prog_enable = true;
+        }
+
         if (cmd == cmd->mrq->stop)
                 *c |= MCI_CSPM_MCIABORT;
 
@@ -450,7 +493,6 @@ msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data,
         host->curr.xfer_remain = host->curr.xfer_size;
         host->curr.data_xfered = 0;
         host->curr.got_dataend = 0;
-        host->curr.got_datablkend = 0;
 
         memset(&host->pio, 0, sizeof(host->pio));
 
@@ -494,6 +536,8 @@ msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data,
                         host->cmd_c = c;
                 }
                 msm_dmov_enqueue_cmd(host->dma.channel, &host->dma.hdr);
+                if (data->flags & MMC_DATA_WRITE)
+                        host->prog_scan = true;
         } else {
                 msmsdcc_writel(host, timeout, MMCIDATATIMER);
 
@@ -555,6 +599,9 @@ msmsdcc_pio_read(struct msmsdcc_host *host, char *buffer, unsigned int remain)
         uint32_t        *ptr = (uint32_t *) buffer;
         int             count = 0;
 
+        if (remain % 4)
+                remain = ((remain >> 2) + 1) << 2;
+
         while (msmsdcc_readl(host, MMCISTATUS) & MCI_RXDATAAVLBL) {
                 *ptr = msmsdcc_readl(host, MMCIFIFO + (count % MCI_FIFOSIZE));
                 ptr++;
@@ -575,13 +622,14 @@ msmsdcc_pio_write(struct msmsdcc_host *host, char *buffer,
         char *ptr = buffer;
 
         do {
-                unsigned int count, maxcnt;
+                unsigned int count, maxcnt, sz;
 
                 maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE :
                                                     MCI_FIFOHALFSIZE;
                 count = min(remain, maxcnt);
 
-                writesl(base + MMCIFIFO, ptr, count >> 2);
+                sz = count % 4 ? (count >> 2) + 1 : (count >> 2);
+                writesl(base + MMCIFIFO, ptr, sz);
                 ptr += count;
                 remain -= count;
 
@@ -702,10 +750,26 @@ static void msmsdcc_do_cmdirq(struct msmsdcc_host *host, uint32_t status)
                         msm_dmov_stop_cmd(host->dma.channel,
                                           &host->dma.hdr, 0);
                 else if (host->curr.data) { /* Non DMA */
+                        msmsdcc_reset_and_restore(host);
                         msmsdcc_stop_data(host);
                         msmsdcc_request_end(host, cmd->mrq);
-                } else /* host->data == NULL */
-                        msmsdcc_request_end(host, cmd->mrq);
+                } else { /* host->data == NULL */
+                        if (!cmd->error && host->prog_enable) {
+                                if (status & MCI_PROGDONE) {
+                                        host->prog_scan = false;
+                                        host->prog_enable = false;
+                                        msmsdcc_request_end(host, cmd->mrq);
+                                } else {
+                                        host->curr.cmd = cmd;
+                                }
+                        } else {
+                                if (host->prog_enable) {
+                                        host->prog_scan = false;
+                                        host->prog_enable = false;
+                                }
+                                msmsdcc_request_end(host, cmd->mrq);
+                        }
+                }
         } else if (cmd->data)
                 if (!(cmd->data->flags & MMC_DATA_READ))
                         msmsdcc_start_data(host, cmd->data,
@@ -719,7 +783,7 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
         struct mmc_data *data = host->curr.data;
 
         if (status & (MCI_CMDSENT | MCI_CMDRESPEND | MCI_CMDCRCFAIL |
-                      MCI_CMDTIMEOUT) && host->curr.cmd) {
+                        MCI_CMDTIMEOUT | MCI_PROGDONE) && host->curr.cmd) {
                 msmsdcc_do_cmdirq(host, status);
         }
 
@@ -735,6 +799,7 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
                         msm_dmov_stop_cmd(host->dma.channel,
                                           &host->dma.hdr, 0);
                 else {
+                        msmsdcc_reset_and_restore(host);
                         if (host->curr.data)
                                 msmsdcc_stop_data(host);
                         if (!data->stop)
@@ -748,14 +813,10 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
         if (!host->curr.got_dataend && (status & MCI_DATAEND))
                 host->curr.got_dataend = 1;
 
-        if (!host->curr.got_datablkend && (status & MCI_DATABLOCKEND))
-                host->curr.got_datablkend = 1;
-
         /*
          * If DMA is still in progress, we complete via the completion handler
          */
-        if (host->curr.got_dataend && host->curr.got_datablkend &&
-            !host->dma.busy) {
+        if (host->curr.got_dataend && !host->dma.busy) {
                 /*
                  * There appears to be an issue in the controller where
                  * if you request a small block transfer (< fifo size),
@@ -792,8 +853,7 @@ msmsdcc_irq(int irq, void *dev_id)
 
         do {
                 status = msmsdcc_readl(host, MMCISTATUS);
-                status &= (msmsdcc_readl(host, MMCIMASK0) |
-                                              MCI_DATABLOCKENDMASK);
+                status &= msmsdcc_readl(host, MMCIMASK0);
                 msmsdcc_writel(host, status, MMCICLEAR);
 
                 if (status & MCI_SDIOINTR)
@@ -874,6 +934,38 @@ msmsdcc_request(struct mmc_host *mmc, struct mmc_request *mrq)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static void msmsdcc_setup_gpio(struct msmsdcc_host *host, bool enable)
+{
+        struct msm_mmc_gpio_data *curr;
+        int i, rc = 0;
+
+        if (!host->plat->gpio_data && host->gpio_config_status == enable)
+                return;
+
+        curr = host->plat->gpio_data;
+        for (i = 0; i < curr->size; i++) {
+                if (enable) {
+                        rc = gpio_request(curr->gpio[i].no,
+                                                curr->gpio[i].name);
+                        if (rc) {
+                                pr_err("%s: gpio_request(%d, %s) failed %d\n",
+                                        mmc_hostname(host->mmc),
+                                        curr->gpio[i].no,
+                                        curr->gpio[i].name, rc);
+                                goto free_gpios;
+                        }
+                } else {
+                        gpio_free(curr->gpio[i].no);
+                }
+        }
+        host->gpio_config_status = enable;
+        return;
+
+free_gpios:
+        for (; i >= 0; i--)
+                gpio_free(curr->gpio[i].no);
+}
+
 static void
 msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
@@ -886,6 +978,8 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         msmsdcc_enable_clocks(host);
 
+        spin_unlock_irqrestore(&host->lock, flags);
+
         if (ios->clock) {
                 if (ios->clock != host->clk_rate) {
                         rc = clk_set_rate(host->clk, ios->clock);
@@ -912,9 +1006,11 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
+                msmsdcc_setup_gpio(host, false);
                 break;
         case MMC_POWER_UP:
                 pwr |= MCI_PWR_UP;
+                msmsdcc_setup_gpio(host, true);
                 break;
         case MMC_POWER_ON:
                 pwr |= MCI_PWR_ON;
@@ -931,9 +1027,10 @@ msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 msmsdcc_writel(host, pwr, MMCIPOWER);
         }
 #if BUSCLK_PWRSAVE
+        spin_lock_irqsave(&host->lock, flags);
         msmsdcc_disable_clocks(host, 1);
-#endif
         spin_unlock_irqrestore(&host->lock, flags);
+#endif
 }
 
 static void msmsdcc_enable_sdio_irq(struct mmc_host *mmc, int enable)
@@ -1118,6 +1215,9 @@ msmsdcc_probe(struct platform_device *pdev)
         host->dmares = dmares;
         spin_lock_init(&host->lock);
 
+        tasklet_init(&host->dma_tlet, msmsdcc_dma_complete_tlet,
+                        (unsigned long)host);
+
         /*
          * Setup DMA
          */
@@ -1164,8 +1264,7 @@ msmsdcc_probe(struct platform_device *pdev)
                 mmc->caps |= MMC_CAP_SDIO_IRQ;
         mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;
 
-        mmc->max_phys_segs = NR_SG;
-        mmc->max_hw_segs = NR_SG;
+        mmc->max_segs = NR_SG;
         mmc->max_blk_size = 4096;       /* MCI_DATA_CTL BLOCKSIZE up to 4096 */
         mmc->max_blk_count = 65536;
 
@@ -1257,9 +1356,6 @@ msmsdcc_probe(struct platform_device *pdev)
         if (host->timer.function)
                 pr_info("%s: Polling status mode enabled\n", mmc_hostname(mmc));
 
-#if BUSCLK_PWRSAVE
-        msmsdcc_disable_clocks(host, 1);
-#endif
         return 0;
  cmd_irq_free:
         free_irq(cmd_irqres->start, host);
diff --git a/drivers/mmc/host/msm_sdcc.h b/drivers/mmc/host/msm_sdcc.h
index ff2b0f74f6f4..42d7bbc977c5 100644
--- a/drivers/mmc/host/msm_sdcc.h
+++ b/drivers/mmc/host/msm_sdcc.h
@@ -138,7 +138,7 @@
 #define MCI_IRQENABLE   \
         (MCI_CMDCRCFAILMASK|MCI_DATACRCFAILMASK|MCI_CMDTIMEOUTMASK|     \
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
-        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATAENDMASK)
+        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATAENDMASK|MCI_PROGDONEMASK)
 
 /*
  * The size of the FIFO in bytes.
@@ -172,6 +172,8 @@ struct msmsdcc_dma_data {
         struct msmsdcc_host             *host;
         int                             busy; /* Set if DM is busy */
         int                             active;
+        unsigned int                    result;
+        struct msm_dmov_errdata         err;
 };
 
 struct msmsdcc_pio_data {
@@ -188,7 +190,6 @@ struct msmsdcc_curr_req {
         unsigned int            xfer_remain;    /* Bytes remaining to send */
         unsigned int            data_xfered;    /* Bytes acked by BLKEND irq */
         int                     got_dataend;
-        int                     got_datablkend;
         int                     user_pages;
 };
 
@@ -235,13 +236,17 @@ struct msmsdcc_host {
         int                     cmdpoll;
         struct msmsdcc_stats    stats;
 
+        struct tasklet_struct   dma_tlet;
         /* Command parameters */
         unsigned int            cmd_timeout;
         unsigned int            cmd_pio_irqmask;
         unsigned int            cmd_datactrl;
         struct mmc_command      *cmd_cmd;
         u32                     cmd_c;
+        bool                    gpio_config_status;
 
+        bool prog_scan;
+        bool prog_enable;
 };
 
 #endif
diff --git a/drivers/mmc/host/mvsdio.c b/drivers/mmc/host/mvsdio.c
index 366eefa77c5a..a5bf60e01af4 100644
--- a/drivers/mmc/host/mvsdio.c
+++ b/drivers/mmc/host/mvsdio.c
@@ -742,8 +742,7 @@ static int __init mvsd_probe(struct platform_device *pdev)
         mmc->max_blk_size = 2048;
         mmc->max_blk_count = 65535;
 
-        mmc->max_hw_segs = 1;
-        mmc->max_phys_segs = 1;
+        mmc->max_segs = 1;
         mmc->max_seg_size = mmc->max_blk_size * mmc->max_blk_count;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
 
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 350f78e86245..cc20e0259325 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -31,16 +31,15 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/dmaengine.h>
 
 #include <asm/dma.h>
 #include <asm/irq.h>
 #include <asm/sizes.h>
 #include <mach/mmc.h>
 
-#ifdef CONFIG_ARCH_MX2
-#include <mach/dma-mx1-mx2.h>
-#define HAS_DMA
-#endif
+#include <mach/dma.h>
 
 #define DRIVER_NAME "mxc-mmc"
 
@@ -117,7 +116,8 @@ struct mxcmci_host {
         void __iomem            *base;
         int                     irq;
         int                     detect_irq;
-        int                     dma;
+        struct dma_chan         *dma;
+        struct dma_async_tx_descriptor *desc;
         int                     do_dma;
         int                     default_irq_mask;
         int                     use_sdio;
@@ -128,7 +128,6 @@ struct mxcmci_host {
         struct mmc_command      *cmd;
         struct mmc_data         *data;
 
-        unsigned int            dma_nents;
         unsigned int            datasize;
         unsigned int            dma_dir;
 
@@ -141,10 +140,54 @@ struct mxcmci_host {
 
         struct work_struct      datawork;
         spinlock_t              lock;
+
+        struct regulator        *vcc;
+
+        int                     burstlen;
+        int                     dmareq;
+        struct dma_slave_config dma_slave_config;
+        struct imx_dma_data     dma_data;
 };
 
 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios);
 
+static inline void mxcmci_init_ocr(struct mxcmci_host *host)
+{
+        host->vcc = regulator_get(mmc_dev(host->mmc), "vmmc");
+
+        if (IS_ERR(host->vcc)) {
+                host->vcc = NULL;
+        } else {
+                host->mmc->ocr_avail = mmc_regulator_get_ocrmask(host->vcc);
+                if (host->pdata && host->pdata->ocr_avail)
+                        dev_warn(mmc_dev(host->mmc),
+                                "pdata->ocr_avail will not be used\n");
+        }
+
+        if (host->vcc == NULL) {
+                /* fall-back to platform data */
+                if (host->pdata && host->pdata->ocr_avail)
+                        host->mmc->ocr_avail = host->pdata->ocr_avail;
+                else
+                        host->mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        }
+}
+
+static inline void mxcmci_set_power(struct mxcmci_host *host,
+                                    unsigned char power_mode,
+                                    unsigned int vdd)
+{
+        if (host->vcc) {
+                if (power_mode == MMC_POWER_UP)
+                        mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
+                else if (power_mode == MMC_POWER_OFF)
+                        mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
+        }
+
+        if (host->pdata && host->pdata->setpower)
+                host->pdata->setpower(mmc_dev(host->mmc), vdd);
+}
+
 static inline int mxcmci_use_dma(struct mxcmci_host *host)
 {
         return host->do_dma;
@@ -166,17 +209,16 @@ static void mxcmci_softreset(struct mxcmci_host *host)
 
         writew(0xff, host->base + MMC_REG_RES_TO);
 }
+static int mxcmci_setup_dma(struct mmc_host *mmc);
 
 static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
 {
         unsigned int nob = data->blocks;
         unsigned int blksz = data->blksz;
         unsigned int datasize = nob * blksz;
-#ifdef HAS_DMA
         struct scatterlist *sg;
-        int i;
-        int ret;
-#endif
+        int i, nents;
+
         if (data->flags & MMC_DATA_STREAM)
                 nob = 0xffff;
 
@@ -187,7 +229,9 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
         writew(blksz, host->base + MMC_REG_BLK_LEN);
         host->datasize = datasize;
 
-#ifdef HAS_DMA
+        if (!mxcmci_use_dma(host))
+                return 0;
+
         for_each_sg(data->sg, sg, data->sg_len, i) {
                 if (sg->offset & 3 || sg->length & 3) {
                         host->do_dma = 0;
@@ -195,34 +239,30 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
                 }
         }
 
-        if (data->flags & MMC_DATA_READ) {
+        if (data->flags & MMC_DATA_READ)
                 host->dma_dir = DMA_FROM_DEVICE;
-                host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg,
-                                             data->sg_len,  host->dma_dir);
-
-                ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents,
-                                datasize,
-                                host->res->start + MMC_REG_BUFFER_ACCESS,
-                                DMA_MODE_READ);
-        } else {
+        else
                 host->dma_dir = DMA_TO_DEVICE;
-                host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg,
-                                             data->sg_len,  host->dma_dir);
 
-                ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents,
-                                datasize,
-                                host->res->start + MMC_REG_BUFFER_ACCESS,
-                                DMA_MODE_WRITE);
-        }
+        nents = dma_map_sg(host->dma->device->dev, data->sg,
+                                     data->sg_len,  host->dma_dir);
+        if (nents != data->sg_len)
+                return -EINVAL;
+
+        host->desc = host->dma->device->device_prep_slave_sg(host->dma,
+                data->sg, data->sg_len, host->dma_dir,
+                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 
-        if (ret) {
-                dev_err(mmc_dev(host->mmc), "failed to setup DMA : %d\n", ret);
-                return ret;
+        if (!host->desc) {
+                dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len,
+                                host->dma_dir);
+                host->do_dma = 0;
+                return 0; /* Fall back to PIO */
         }
         wmb();
 
-        imx_dma_enable(host->dma);
-#endif /* HAS_DMA */
+        dmaengine_submit(host->desc);
+
         return 0;
 }
 
@@ -297,13 +337,11 @@ static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat)
         struct mmc_data *data = host->data;
         int data_error;
 
-#ifdef HAS_DMA
         if (mxcmci_use_dma(host)) {
-                imx_dma_disable(host->dma);
-                dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_nents,
+                dmaengine_terminate_all(host->dma);
+                dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len,
                                 host->dma_dir);
         }
-#endif
 
         if (stat & STATUS_ERR_MASK) {
                 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",
@@ -505,7 +543,6 @@ static void mxcmci_datawork(struct work_struct *work)
         }
 }
 
-#ifdef HAS_DMA
 static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat)
 {
         struct mmc_data *data = host->data;
@@ -528,7 +565,6 @@ static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat)
                 mxcmci_finish_request(host, host->req);
         }
 }
-#endif /* HAS_DMA */
 
 static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat)
 {
@@ -566,12 +602,10 @@ static irqreturn_t mxcmci_irq(int irq, void *devid)
         sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio;
         spin_unlock_irqrestore(&host->lock, flags);
 
-#ifdef HAS_DMA
         if (mxcmci_use_dma(host) &&
             (stat & (STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE)))
                 writel(STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE,
                         host->base + MMC_REG_STATUS);
-#endif
 
         if (sdio_irq) {
                 writel(STATUS_SDIO_INT_ACTIVE, host->base + MMC_REG_STATUS);
@@ -581,14 +615,14 @@ static irqreturn_t mxcmci_irq(int irq, void *devid)
         if (stat & STATUS_END_CMD_RESP)
                 mxcmci_cmd_done(host, stat);
 
-#ifdef HAS_DMA
         if (mxcmci_use_dma(host) &&
                   (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE)))
                 mxcmci_data_done(host, stat);
-#endif
+
         if (host->default_irq_mask &&
                   (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL)))
                 mmc_detect_change(host->mmc, msecs_to_jiffies(200));
+
         return IRQ_HANDLED;
 }
 
@@ -602,9 +636,10 @@ static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req)
 
         host->req = req;
         host->cmdat &= ~CMD_DAT_CONT_INIT;
-#ifdef HAS_DMA
-        host->do_dma = 1;
-#endif
+
+        if (host->dma)
+                host->do_dma = 1;
+
         if (req->data) {
                 error = mxcmci_setup_data(host, req->data);
                 if (error) {
@@ -620,6 +655,7 @@ static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req)
         }
 
         error = mxcmci_start_cmd(host, req->cmd, cmdat);
+
 out:
         if (error)
                 mxcmci_finish_request(host, req);
@@ -658,31 +694,55 @@ static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios)
                         prescaler, divider, clk_in, clk_ios);
 }
 
+static int mxcmci_setup_dma(struct mmc_host *mmc)
+{
+        struct mxcmci_host *host = mmc_priv(mmc);
+        struct dma_slave_config *config = &host->dma_slave_config;
+
+        config->dst_addr = host->res->start + MMC_REG_BUFFER_ACCESS;
+        config->src_addr = host->res->start + MMC_REG_BUFFER_ACCESS;
+        config->dst_addr_width = 4;
+        config->src_addr_width = 4;
+        config->dst_maxburst = host->burstlen;
+        config->src_maxburst = host->burstlen;
+
+        return dmaengine_slave_config(host->dma, config);
+}
+
 static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct mxcmci_host *host = mmc_priv(mmc);
-#ifdef HAS_DMA
-        unsigned int blen;
+        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)
          */
         if (ios->bus_width == MMC_BUS_WIDTH_4)
-                blen = 0;
+                burstlen = 64;
         else
-                blen = 16;
+                burstlen = 16;
+
+        if (mxcmci_use_dma(host) && burstlen != host->burstlen) {
+                host->burstlen = burstlen;
+                ret = mxcmci_setup_dma(mmc);
+                if (ret) {
+                        dev_err(mmc_dev(host->mmc),
+                                "failed to config DMA channel. Falling back to PIO\n");
+                        dma_release_channel(host->dma);
+                        host->do_dma = 0;
+                }
+        }
 
-        imx_dma_config_burstlen(host->dma, blen);
-#endif
         if (ios->bus_width == MMC_BUS_WIDTH_4)
                 host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4;
         else
                 host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4;
 
         if (host->power_mode != ios->power_mode) {
-                if (host->pdata && host->pdata->setpower)
-                        host->pdata->setpower(mmc_dev(mmc), ios->vdd);
+                mxcmci_set_power(host, ios->power_mode, ios->vdd);
                 host->power_mode = ios->power_mode;
+
                 if (ios->power_mode == MMC_POWER_ON)
                         host->cmdat |= CMD_DAT_CONT_INIT;
         }
@@ -754,6 +814,18 @@ static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card)
                 host->caps |= MMC_CAP_4_BIT_DATA;
 }
 
+static bool filter(struct dma_chan *chan, void *param)
+{
+        struct mxcmci_host *host = param;
+
+        if (!imx_dma_is_general_purpose(chan))
+                return false;
+
+        chan->private = &host->dma_data;
+
+        return true;
+}
+
 static const struct mmc_host_ops mxcmci_ops = {
         .request                = mxcmci_request,
         .set_ios                = mxcmci_set_ios,
@@ -768,6 +840,7 @@ static int mxcmci_probe(struct platform_device *pdev)
         struct mxcmci_host *host = NULL;
         struct resource *iores, *r;
         int ret = 0, irq;
+        dma_cap_mask_t mask;
 
         printk(KERN_INFO "i.MX SDHC driver\n");
 
@@ -790,8 +863,7 @@ static int mxcmci_probe(struct platform_device *pdev)
         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
 
         /* MMC core transfer sizes tunable parameters */
-        mmc->max_hw_segs = 64;
-        mmc->max_phys_segs = 64;
+        mmc->max_segs = 64;
         mmc->max_blk_size = 2048;
         mmc->max_blk_count = 65535;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
@@ -808,10 +880,7 @@ static int mxcmci_probe(struct platform_device *pdev)
         host->pdata = pdev->dev.platform_data;
         spin_lock_init(&host->lock);
 
-        if (host->pdata && host->pdata->ocr_avail)
-                mmc->ocr_avail = host->pdata->ocr_avail;
-        else
-                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        mxcmci_init_ocr(host);
 
         if (host->pdata && host->pdata->dat3_card_detect)
                 host->default_irq_mask =
@@ -847,29 +916,23 @@ static int mxcmci_probe(struct platform_device *pdev)
 
         writel(host->default_irq_mask, host->base + MMC_REG_INT_CNTR);
 
-#ifdef HAS_DMA
-        host->dma = imx_dma_request_by_prio(DRIVER_NAME, DMA_PRIO_LOW);
-        if (host->dma < 0) {
-                dev_err(mmc_dev(host->mmc), "imx_dma_request_by_prio failed\n");
-                ret = -EBUSY;
-                goto out_clk_put;
-        }
-
         r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
-        if (!r) {
-                ret = -EINVAL;
-                goto out_free_dma;
+        if (r) {
+                host->dmareq = r->start;
+                host->dma_data.peripheral_type = IMX_DMATYPE_SDHC;
+                host->dma_data.priority = DMA_PRIO_LOW;
+                host->dma_data.dma_request = host->dmareq;
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+                host->dma = dma_request_channel(mask, filter, host);
+                if (host->dma)
+                        mmc->max_seg_size = dma_get_max_seg_size(
+                                        host->dma->device->dev);
         }
 
-        ret = imx_dma_config_channel(host->dma,
-                                     IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_FIFO,
-                                     IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-                                     r->start, 0);
-        if (ret) {
-                dev_err(mmc_dev(host->mmc), "failed to config DMA channel\n");
-                goto out_free_dma;
-        }
-#endif
+        if (!host->dma)
+                dev_info(mmc_dev(host->mmc), "dma not available. Using PIO\n");
+
         INIT_WORK(&host->datawork, mxcmci_datawork);
 
         ret = request_irq(host->irq, mxcmci_irq, 0, DRIVER_NAME, host);
@@ -892,9 +955,8 @@ static int mxcmci_probe(struct platform_device *pdev)
 out_free_irq:
         free_irq(host->irq, host);
 out_free_dma:
-#ifdef HAS_DMA
-        imx_dma_free(host->dma);
-#endif
+        if (host->dma)
+                dma_release_channel(host->dma);
 out_clk_put:
         clk_disable(host->clk);
         clk_put(host->clk);
@@ -916,19 +978,22 @@ static int mxcmci_remove(struct platform_device *pdev)
 
         mmc_remove_host(mmc);
 
+        if (host->vcc)
+                regulator_put(host->vcc);
+
         if (host->pdata && host->pdata->exit)
                 host->pdata->exit(&pdev->dev, mmc);
 
         free_irq(host->irq, host);
         iounmap(host->base);
-#ifdef HAS_DMA
-        imx_dma_free(host->dma);
-#endif
+
+        if (host->dma)
+                dma_release_channel(host->dma);
+
         clk_disable(host->clk);
         clk_put(host->clk);
 
         release_mem_region(host->res->start, resource_size(host->res));
-        release_resource(host->res);
 
         mmc_free_host(mmc);
 
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
new file mode 100644
index 000000000000..99d39a6a1032
--- /dev/null
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -0,0 +1,874 @@
+/*
+ * Portions copyright (C) 2003 Russell King, PXA MMCI Driver
+ * Portions copyright (C) 2004-2005 Pierre Ossman, W83L51xD SD/MMC driver
+ *
+ * Copyright 2008 Embedded Alley Solutions, Inc.
+ * Copyright 2009-2011 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/highmem.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/completion.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sdio.h>
+#include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+
+#include <mach/mxs.h>
+#include <mach/common.h>
+#include <mach/dma.h>
+#include <mach/mmc.h>
+
+#define DRIVER_NAME     "mxs-mmc"
+
+/* card detect polling timeout */
+#define MXS_MMC_DETECT_TIMEOUT                  (HZ/2)
+
+#define SSP_VERSION_LATEST      4
+#define ssp_is_old()            (host->version < SSP_VERSION_LATEST)
+
+/* SSP registers */
+#define HW_SSP_CTRL0                            0x000
+#define  BM_SSP_CTRL0_RUN                       (1 << 29)
+#define  BM_SSP_CTRL0_SDIO_IRQ_CHECK            (1 << 28)
+#define  BM_SSP_CTRL0_IGNORE_CRC                (1 << 26)
+#define  BM_SSP_CTRL0_READ                      (1 << 25)
+#define  BM_SSP_CTRL0_DATA_XFER                 (1 << 24)
+#define  BP_SSP_CTRL0_BUS_WIDTH                 (22)
+#define  BM_SSP_CTRL0_BUS_WIDTH                 (0x3 << 22)
+#define  BM_SSP_CTRL0_WAIT_FOR_IRQ              (1 << 21)
+#define  BM_SSP_CTRL0_LONG_RESP                 (1 << 19)
+#define  BM_SSP_CTRL0_GET_RESP                  (1 << 17)
+#define  BM_SSP_CTRL0_ENABLE                    (1 << 16)
+#define  BP_SSP_CTRL0_XFER_COUNT                (0)
+#define  BM_SSP_CTRL0_XFER_COUNT                (0xffff)
+#define HW_SSP_CMD0                             0x010
+#define  BM_SSP_CMD0_DBL_DATA_RATE_EN           (1 << 25)
+#define  BM_SSP_CMD0_SLOW_CLKING_EN             (1 << 22)
+#define  BM_SSP_CMD0_CONT_CLKING_EN             (1 << 21)
+#define  BM_SSP_CMD0_APPEND_8CYC                (1 << 20)
+#define  BP_SSP_CMD0_BLOCK_SIZE                 (16)
+#define  BM_SSP_CMD0_BLOCK_SIZE                 (0xf << 16)
+#define  BP_SSP_CMD0_BLOCK_COUNT                (8)
+#define  BM_SSP_CMD0_BLOCK_COUNT                (0xff << 8)
+#define  BP_SSP_CMD0_CMD                        (0)
+#define  BM_SSP_CMD0_CMD                        (0xff)
+#define HW_SSP_CMD1                             0x020
+#define HW_SSP_XFER_SIZE                        0x030
+#define HW_SSP_BLOCK_SIZE                       0x040
+#define  BP_SSP_BLOCK_SIZE_BLOCK_COUNT          (4)
+#define  BM_SSP_BLOCK_SIZE_BLOCK_COUNT          (0xffffff << 4)
+#define  BP_SSP_BLOCK_SIZE_BLOCK_SIZE           (0)
+#define  BM_SSP_BLOCK_SIZE_BLOCK_SIZE           (0xf)
+#define HW_SSP_TIMING                           (ssp_is_old() ? 0x050 : 0x070)
+#define  BP_SSP_TIMING_TIMEOUT                  (16)
+#define  BM_SSP_TIMING_TIMEOUT                  (0xffff << 16)
+#define  BP_SSP_TIMING_CLOCK_DIVIDE             (8)
+#define  BM_SSP_TIMING_CLOCK_DIVIDE             (0xff << 8)
+#define  BP_SSP_TIMING_CLOCK_RATE               (0)
+#define  BM_SSP_TIMING_CLOCK_RATE               (0xff)
+#define HW_SSP_CTRL1                            (ssp_is_old() ? 0x060 : 0x080)
+#define  BM_SSP_CTRL1_SDIO_IRQ                  (1 << 31)
+#define  BM_SSP_CTRL1_SDIO_IRQ_EN               (1 << 30)
+#define  BM_SSP_CTRL1_RESP_ERR_IRQ              (1 << 29)
+#define  BM_SSP_CTRL1_RESP_ERR_IRQ_EN           (1 << 28)
+#define  BM_SSP_CTRL1_RESP_TIMEOUT_IRQ          (1 << 27)
+#define  BM_SSP_CTRL1_RESP_TIMEOUT_IRQ_EN       (1 << 26)
+#define  BM_SSP_CTRL1_DATA_TIMEOUT_IRQ          (1 << 25)
+#define  BM_SSP_CTRL1_DATA_TIMEOUT_IRQ_EN       (1 << 24)
+#define  BM_SSP_CTRL1_DATA_CRC_IRQ              (1 << 23)
+#define  BM_SSP_CTRL1_DATA_CRC_IRQ_EN           (1 << 22)
+#define  BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ         (1 << 21)
+#define  BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ_EN      (1 << 20)
+#define  BM_SSP_CTRL1_RECV_TIMEOUT_IRQ          (1 << 17)
+#define  BM_SSP_CTRL1_RECV_TIMEOUT_IRQ_EN       (1 << 16)
+#define  BM_SSP_CTRL1_FIFO_OVERRUN_IRQ          (1 << 15)
+#define  BM_SSP_CTRL1_FIFO_OVERRUN_IRQ_EN       (1 << 14)
+#define  BM_SSP_CTRL1_DMA_ENABLE                (1 << 13)
+#define  BM_SSP_CTRL1_POLARITY                  (1 << 9)
+#define  BP_SSP_CTRL1_WORD_LENGTH               (4)
+#define  BM_SSP_CTRL1_WORD_LENGTH               (0xf << 4)
+#define  BP_SSP_CTRL1_SSP_MODE                  (0)
+#define  BM_SSP_CTRL1_SSP_MODE                  (0xf)
+#define HW_SSP_SDRESP0                          (ssp_is_old() ? 0x080 : 0x0a0)
+#define HW_SSP_SDRESP1                          (ssp_is_old() ? 0x090 : 0x0b0)
+#define HW_SSP_SDRESP2                          (ssp_is_old() ? 0x0a0 : 0x0c0)
+#define HW_SSP_SDRESP3                          (ssp_is_old() ? 0x0b0 : 0x0d0)
+#define HW_SSP_STATUS                           (ssp_is_old() ? 0x0c0 : 0x100)
+#define  BM_SSP_STATUS_CARD_DETECT              (1 << 28)
+#define  BM_SSP_STATUS_SDIO_IRQ                 (1 << 17)
+#define HW_SSP_VERSION                          (cpu_is_mx23() ? 0x110 : 0x130)
+#define  BP_SSP_VERSION_MAJOR                   (24)
+
+#define BF_SSP(value, field)    (((value) << BP_SSP_##field) & BM_SSP_##field)
+
+#define MXS_MMC_IRQ_BITS        (BM_SSP_CTRL1_SDIO_IRQ          | \
+                                 BM_SSP_CTRL1_RESP_ERR_IRQ      | \
+                                 BM_SSP_CTRL1_RESP_TIMEOUT_IRQ  | \
+                                 BM_SSP_CTRL1_DATA_TIMEOUT_IRQ  | \
+                                 BM_SSP_CTRL1_DATA_CRC_IRQ      | \
+                                 BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ | \
+                                 BM_SSP_CTRL1_RECV_TIMEOUT_IRQ  | \
+                                 BM_SSP_CTRL1_FIFO_OVERRUN_IRQ)
+
+#define SSP_PIO_NUM     3
+
+struct mxs_mmc_host {
+        struct mmc_host                 *mmc;
+        struct mmc_request              *mrq;
+        struct mmc_command              *cmd;
+        struct mmc_data                 *data;
+
+        void __iomem                    *base;
+        int                             irq;
+        struct resource                 *res;
+        struct resource                 *dma_res;
+        struct clk                      *clk;
+        unsigned int                    clk_rate;
+
+        struct dma_chan                 *dmach;
+        struct mxs_dma_data             dma_data;
+        unsigned int                    dma_dir;
+        u32                             ssp_pio_words[SSP_PIO_NUM];
+
+        unsigned int                    version;
+        unsigned char                   bus_width;
+        spinlock_t                      lock;
+        int                             sdio_irq_en;
+};
+
+static int mxs_mmc_get_ro(struct mmc_host *mmc)
+{
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+        struct mxs_mmc_platform_data *pdata =
+                mmc_dev(host->mmc)->platform_data;
+
+        if (!pdata)
+                return -EFAULT;
+
+        if (!gpio_is_valid(pdata->wp_gpio))
+                return -EINVAL;
+
+        return gpio_get_value(pdata->wp_gpio);
+}
+
+static int mxs_mmc_get_cd(struct mmc_host *mmc)
+{
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+
+        return !(readl(host->base + HW_SSP_STATUS) &
+                 BM_SSP_STATUS_CARD_DETECT);
+}
+
+static void mxs_mmc_reset(struct mxs_mmc_host *host)
+{
+        u32 ctrl0, ctrl1;
+
+        mxs_reset_block(host->base);
+
+        ctrl0 = BM_SSP_CTRL0_IGNORE_CRC;
+        ctrl1 = BF_SSP(0x3, CTRL1_SSP_MODE) |
+                BF_SSP(0x7, CTRL1_WORD_LENGTH) |
+                BM_SSP_CTRL1_DMA_ENABLE |
+                BM_SSP_CTRL1_POLARITY |
+                BM_SSP_CTRL1_RECV_TIMEOUT_IRQ_EN |
+                BM_SSP_CTRL1_DATA_CRC_IRQ_EN |
+                BM_SSP_CTRL1_DATA_TIMEOUT_IRQ_EN |
+                BM_SSP_CTRL1_RESP_TIMEOUT_IRQ_EN |
+                BM_SSP_CTRL1_RESP_ERR_IRQ_EN;
+
+        writel(BF_SSP(0xffff, TIMING_TIMEOUT) |
+               BF_SSP(2, TIMING_CLOCK_DIVIDE) |
+               BF_SSP(0, TIMING_CLOCK_RATE),
+               host->base + HW_SSP_TIMING);
+
+        if (host->sdio_irq_en) {
+                ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
+                ctrl1 |= BM_SSP_CTRL1_SDIO_IRQ_EN;
+        }
+
+        writel(ctrl0, host->base + HW_SSP_CTRL0);
+        writel(ctrl1, host->base + HW_SSP_CTRL1);
+}
+
+static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
+                              struct mmc_command *cmd);
+
+static void mxs_mmc_request_done(struct mxs_mmc_host *host)
+{
+        struct mmc_command *cmd = host->cmd;
+        struct mmc_data *data = host->data;
+        struct mmc_request *mrq = host->mrq;
+
+        if (mmc_resp_type(cmd) & MMC_RSP_PRESENT) {
+                if (mmc_resp_type(cmd) & MMC_RSP_136) {
+                        cmd->resp[3] = readl(host->base + HW_SSP_SDRESP0);
+                        cmd->resp[2] = readl(host->base + HW_SSP_SDRESP1);
+                        cmd->resp[1] = readl(host->base + HW_SSP_SDRESP2);
+                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP3);
+                } else {
+                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP0);
+                }
+        }
+
+        if (data) {
+                dma_unmap_sg(mmc_dev(host->mmc), data->sg,
+                             data->sg_len, host->dma_dir);
+                /*
+                 * If there was an error on any block, we mark all
+                 * data blocks as being in error.
+                 */
+                if (!data->error)
+                        data->bytes_xfered = data->blocks * data->blksz;
+                else
+                        data->bytes_xfered = 0;
+
+                host->data = NULL;
+                if (mrq->stop) {
+                        mxs_mmc_start_cmd(host, mrq->stop);
+                        return;
+                }
+        }
+
+        host->mrq = NULL;
+        mmc_request_done(host->mmc, mrq);
+}
+
+static void mxs_mmc_dma_irq_callback(void *param)
+{
+        struct mxs_mmc_host *host = param;
+
+        mxs_mmc_request_done(host);
+}
+
+static irqreturn_t mxs_mmc_irq_handler(int irq, void *dev_id)
+{
+        struct mxs_mmc_host *host = dev_id;
+        struct mmc_command *cmd = host->cmd;
+        struct mmc_data *data = host->data;
+        u32 stat;
+
+        spin_lock(&host->lock);
+
+        stat = readl(host->base + HW_SSP_CTRL1);
+        writel(stat & MXS_MMC_IRQ_BITS,
+               host->base + HW_SSP_CTRL1 + MXS_CLR_ADDR);
+
+        if ((stat & BM_SSP_CTRL1_SDIO_IRQ) && (stat & BM_SSP_CTRL1_SDIO_IRQ_EN))
+                mmc_signal_sdio_irq(host->mmc);
+
+        spin_unlock(&host->lock);
+
+        if (stat & BM_SSP_CTRL1_RESP_TIMEOUT_IRQ)
+                cmd->error = -ETIMEDOUT;
+        else if (stat & BM_SSP_CTRL1_RESP_ERR_IRQ)
+                cmd->error = -EIO;
+
+        if (data) {
+                if (stat & (BM_SSP_CTRL1_DATA_TIMEOUT_IRQ |
+                            BM_SSP_CTRL1_RECV_TIMEOUT_IRQ))
+                        data->error = -ETIMEDOUT;
+                else if (stat & BM_SSP_CTRL1_DATA_CRC_IRQ)
+                        data->error = -EILSEQ;
+                else if (stat & (BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ |
+                                 BM_SSP_CTRL1_FIFO_OVERRUN_IRQ))
+                        data->error = -EIO;
+        }
+
+        return IRQ_HANDLED;
+}
+
+static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
+        struct mxs_mmc_host *host, unsigned int append)
+{
+        struct dma_async_tx_descriptor *desc;
+        struct mmc_data *data = host->data;
+        struct scatterlist * sgl;
+        unsigned int sg_len;
+
+        if (data) {
+                /* data */
+                dma_map_sg(mmc_dev(host->mmc), data->sg,
+                           data->sg_len, host->dma_dir);
+                sgl = data->sg;
+                sg_len = data->sg_len;
+        } else {
+                /* pio */
+                sgl = (struct scatterlist *) host->ssp_pio_words;
+                sg_len = SSP_PIO_NUM;
+        }
+
+        desc = host->dmach->device->device_prep_slave_sg(host->dmach,
+                                sgl, sg_len, host->dma_dir, append);
+        if (desc) {
+                desc->callback = mxs_mmc_dma_irq_callback;
+                desc->callback_param = host;
+        } else {
+                if (data)
+                        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
+                                     data->sg_len, host->dma_dir);
+        }
+
+        return desc;
+}
+
+static void mxs_mmc_bc(struct mxs_mmc_host *host)
+{
+        struct mmc_command *cmd = host->cmd;
+        struct dma_async_tx_descriptor *desc;
+        u32 ctrl0, cmd0, cmd1;
+
+        ctrl0 = BM_SSP_CTRL0_ENABLE | BM_SSP_CTRL0_IGNORE_CRC;
+        cmd0 = BF_SSP(cmd->opcode, CMD0_CMD) | BM_SSP_CMD0_APPEND_8CYC;
+        cmd1 = cmd->arg;
+
+        if (host->sdio_irq_en) {
+                ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
+                cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
+        }
+
+        host->ssp_pio_words[0] = ctrl0;
+        host->ssp_pio_words[1] = cmd0;
+        host->ssp_pio_words[2] = cmd1;
+        host->dma_dir = DMA_NONE;
+        desc = mxs_mmc_prep_dma(host, 0);
+        if (!desc)
+                goto out;
+
+        dmaengine_submit(desc);
+        return;
+
+out:
+        dev_warn(mmc_dev(host->mmc),
+                 "%s: failed to prep dma\n", __func__);
+}
+
+static void mxs_mmc_ac(struct mxs_mmc_host *host)
+{
+        struct mmc_command *cmd = host->cmd;
+        struct dma_async_tx_descriptor *desc;
+        u32 ignore_crc, get_resp, long_resp;
+        u32 ctrl0, cmd0, cmd1;
+
+        ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
+                        0 : BM_SSP_CTRL0_IGNORE_CRC;
+        get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
+                        BM_SSP_CTRL0_GET_RESP : 0;
+        long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
+                        BM_SSP_CTRL0_LONG_RESP : 0;
+
+        ctrl0 = BM_SSP_CTRL0_ENABLE | ignore_crc | get_resp | long_resp;
+        cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
+        cmd1 = cmd->arg;
+
+        if (host->sdio_irq_en) {
+                ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
+                cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
+        }
+
+        host->ssp_pio_words[0] = ctrl0;
+        host->ssp_pio_words[1] = cmd0;
+        host->ssp_pio_words[2] = cmd1;
+        host->dma_dir = DMA_NONE;
+        desc = mxs_mmc_prep_dma(host, 0);
+        if (!desc)
+                goto out;
+
+        dmaengine_submit(desc);
+        return;
+
+out:
+        dev_warn(mmc_dev(host->mmc),
+                 "%s: failed to prep dma\n", __func__);
+}
+
+static unsigned short mxs_ns_to_ssp_ticks(unsigned clock_rate, unsigned ns)
+{
+        const unsigned int ssp_timeout_mul = 4096;
+        /*
+         * Calculate ticks in ms since ns are large numbers
+         * and might overflow
+         */
+        const unsigned int clock_per_ms = clock_rate / 1000;
+        const unsigned int ms = ns / 1000;
+        const unsigned int ticks = ms * clock_per_ms;
+        const unsigned int ssp_ticks = ticks / ssp_timeout_mul;
+
+        WARN_ON(ssp_ticks == 0);
+        return ssp_ticks;
+}
+
+static void mxs_mmc_adtc(struct mxs_mmc_host *host)
+{
+        struct mmc_command *cmd = host->cmd;
+        struct mmc_data *data = cmd->data;
+        struct dma_async_tx_descriptor *desc;
+        struct scatterlist *sgl = data->sg, *sg;
+        unsigned int sg_len = data->sg_len;
+        int i;
+
+        unsigned short dma_data_dir, timeout;
+        unsigned int data_size = 0, log2_blksz;
+        unsigned int blocks = data->blocks;
+
+        u32 ignore_crc, get_resp, long_resp, read;
+        u32 ctrl0, cmd0, cmd1, val;
+
+        ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
+                        0 : BM_SSP_CTRL0_IGNORE_CRC;
+        get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
+                        BM_SSP_CTRL0_GET_RESP : 0;
+        long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
+                        BM_SSP_CTRL0_LONG_RESP : 0;
+
+        if (data->flags & MMC_DATA_WRITE) {
+                dma_data_dir = DMA_TO_DEVICE;
+                read = 0;
+        } else {
+                dma_data_dir = DMA_FROM_DEVICE;
+                read = BM_SSP_CTRL0_READ;
+        }
+
+        ctrl0 = BF_SSP(host->bus_width, CTRL0_BUS_WIDTH) |
+                ignore_crc | get_resp | long_resp |
+                BM_SSP_CTRL0_DATA_XFER | read |
+                BM_SSP_CTRL0_WAIT_FOR_IRQ |
+                BM_SSP_CTRL0_ENABLE;
+
+        cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
+
+        /* get logarithm to base 2 of block size for setting register */
+        log2_blksz = ilog2(data->blksz);
+
+        /*
+         * take special care of the case that data size from data->sg
+         * is not equal to blocks x blksz
+         */
+        for_each_sg(sgl, sg, sg_len, i)
+                data_size += sg->length;
+
+        if (data_size != data->blocks * data->blksz)
+                blocks = 1;
+
+        /* xfer count, block size and count need to be set differently */
+        if (ssp_is_old()) {
+                ctrl0 |= BF_SSP(data_size, CTRL0_XFER_COUNT);
+                cmd0 |= BF_SSP(log2_blksz, CMD0_BLOCK_SIZE) |
+                        BF_SSP(blocks - 1, CMD0_BLOCK_COUNT);
+        } else {
+                writel(data_size, host->base + HW_SSP_XFER_SIZE);
+                writel(BF_SSP(log2_blksz, BLOCK_SIZE_BLOCK_SIZE) |
+                       BF_SSP(blocks - 1, BLOCK_SIZE_BLOCK_COUNT),
+                       host->base + HW_SSP_BLOCK_SIZE);
+        }
+
+        if ((cmd->opcode == MMC_STOP_TRANSMISSION) ||
+            (cmd->opcode == SD_IO_RW_EXTENDED))
+                cmd0 |= BM_SSP_CMD0_APPEND_8CYC;
+
+        cmd1 = cmd->arg;
+
+        if (host->sdio_irq_en) {
+                ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
+                cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
+        }
+
+        /* set the timeout count */
+        timeout = mxs_ns_to_ssp_ticks(host->clk_rate, data->timeout_ns);
+        val = readl(host->base + HW_SSP_TIMING);
+        val &= ~(BM_SSP_TIMING_TIMEOUT);
+        val |= BF_SSP(timeout, TIMING_TIMEOUT);
+        writel(val, host->base + HW_SSP_TIMING);
+
+        /* pio */
+        host->ssp_pio_words[0] = ctrl0;
+        host->ssp_pio_words[1] = cmd0;
+        host->ssp_pio_words[2] = cmd1;
+        host->dma_dir = DMA_NONE;
+        desc = mxs_mmc_prep_dma(host, 0);
+        if (!desc)
+                goto out;
+
+        /* append data sg */
+        WARN_ON(host->data != NULL);
+        host->data = data;
+        host->dma_dir = dma_data_dir;
+        desc = mxs_mmc_prep_dma(host, 1);
+        if (!desc)
+                goto out;
+
+        dmaengine_submit(desc);
+        return;
+out:
+        dev_warn(mmc_dev(host->mmc),
+                 "%s: failed to prep dma\n", __func__);
+}
+
+static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
+                              struct mmc_command *cmd)
+{
+        host->cmd = cmd;
+
+        switch (mmc_cmd_type(cmd)) {
+        case MMC_CMD_BC:
+                mxs_mmc_bc(host);
+                break;
+        case MMC_CMD_BCR:
+                mxs_mmc_ac(host);
+                break;
+        case MMC_CMD_AC:
+                mxs_mmc_ac(host);
+                break;
+        case MMC_CMD_ADTC:
+                mxs_mmc_adtc(host);
+                break;
+        default:
+                dev_warn(mmc_dev(host->mmc),
+                         "%s: unknown MMC command\n", __func__);
+                break;
+        }
+}
+
+static void mxs_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+
+        WARN_ON(host->mrq != NULL);
+        host->mrq = mrq;
+        mxs_mmc_start_cmd(host, mrq->cmd);
+}
+
+static void mxs_mmc_set_clk_rate(struct mxs_mmc_host *host, unsigned int rate)
+{
+        unsigned int ssp_rate, bit_rate;
+        u32 div1, div2;
+        u32 val;
+
+        ssp_rate = clk_get_rate(host->clk);
+
+        for (div1 = 2; div1 < 254; div1 += 2) {
+                div2 = ssp_rate / rate / div1;
+                if (div2 < 0x100)
+                        break;
+        }
+
+        if (div1 >= 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;
+
+        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);
+        writel(val, host->base + HW_SSP_TIMING);
+
+        host->clk_rate = bit_rate;
+
+        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);
+}
+
+static void mxs_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+
+        if (ios->bus_width == MMC_BUS_WIDTH_8)
+                host->bus_width = 2;
+        else if (ios->bus_width == MMC_BUS_WIDTH_4)
+                host->bus_width = 1;
+        else
+                host->bus_width = 0;
+
+        if (ios->clock)
+                mxs_mmc_set_clk_rate(host, ios->clock);
+}
+
+static void mxs_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        host->sdio_irq_en = enable;
+
+        if (enable) {
+                writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
+                       host->base + HW_SSP_CTRL0 + MXS_SET_ADDR);
+                writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
+                       host->base + HW_SSP_CTRL1 + MXS_SET_ADDR);
+
+                if (readl(host->base + HW_SSP_STATUS) & BM_SSP_STATUS_SDIO_IRQ)
+                        mmc_signal_sdio_irq(host->mmc);
+
+        } else {
+                writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
+                       host->base + HW_SSP_CTRL0 + MXS_CLR_ADDR);
+                writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
+                       host->base + HW_SSP_CTRL1 + MXS_CLR_ADDR);
+        }
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static const struct mmc_host_ops mxs_mmc_ops = {
+        .request = mxs_mmc_request,
+        .get_ro = mxs_mmc_get_ro,
+        .get_cd = mxs_mmc_get_cd,
+        .set_ios = mxs_mmc_set_ios,
+        .enable_sdio_irq = mxs_mmc_enable_sdio_irq,
+};
+
+static bool mxs_mmc_dma_filter(struct dma_chan *chan, void *param)
+{
+        struct mxs_mmc_host *host = param;
+
+        if (!mxs_dma_is_apbh(chan))
+                return false;
+
+        if (chan->chan_id != host->dma_res->start)
+                return false;
+
+        chan->private = &host->dma_data;
+
+        return true;
+}
+
+static int mxs_mmc_probe(struct platform_device *pdev)
+{
+        struct mxs_mmc_host *host;
+        struct mmc_host *mmc;
+        struct resource *iores, *dmares, *r;
+        struct mxs_mmc_platform_data *pdata;
+        int ret = 0, irq_err, irq_dma;
+        dma_cap_mask_t mask;
+
+        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        irq_err = platform_get_irq(pdev, 0);
+        irq_dma = platform_get_irq(pdev, 1);
+        if (!iores || !dmares || irq_err < 0 || irq_dma < 0)
+                return -EINVAL;
+
+        r = request_mem_region(iores->start, resource_size(iores), pdev->name);
+        if (!r)
+                return -EBUSY;
+
+        mmc = mmc_alloc_host(sizeof(struct mxs_mmc_host), &pdev->dev);
+        if (!mmc) {
+                ret = -ENOMEM;
+                goto out_release_mem;
+        }
+
+        host = mmc_priv(mmc);
+        host->base = ioremap(r->start, resource_size(r));
+        if (!host->base) {
+                ret = -ENOMEM;
+                goto out_mmc_free;
+        }
+
+        /* only major verion does matter */
+        host->version = readl(host->base + HW_SSP_VERSION) >>
+                        BP_SSP_VERSION_MAJOR;
+
+        host->mmc = mmc;
+        host->res = r;
+        host->dma_res = dmares;
+        host->irq = irq_err;
+        host->sdio_irq_en = 0;
+
+        host->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(host->clk)) {
+                ret = PTR_ERR(host->clk);
+                goto out_iounmap;
+        }
+        clk_enable(host->clk);
+
+        mxs_mmc_reset(host);
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        host->dma_data.chan_irq = irq_dma;
+        host->dmach = dma_request_channel(mask, mxs_mmc_dma_filter, host);
+        if (!host->dmach) {
+                dev_err(mmc_dev(host->mmc),
+                        "%s: failed to request dma\n", __func__);
+                goto out_clk_put;
+        }
+
+        /* set mmc core parameters */
+        mmc->ops = &mxs_mmc_ops;
+        mmc->caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
+                    MMC_CAP_SDIO_IRQ | MMC_CAP_NEEDS_POLL;
+
+        pdata = mmc_dev(host->mmc)->platform_data;
+        if (pdata) {
+                if (pdata->flags & SLOTF_8_BIT_CAPABLE)
+                        mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
+                if (pdata->flags & SLOTF_4_BIT_CAPABLE)
+                        mmc->caps |= MMC_CAP_4_BIT_DATA;
+        }
+
+        mmc->f_min = 400000;
+        mmc->f_max = 288000000;
+        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+
+        mmc->max_segs = 52;
+        mmc->max_blk_size = 1 << 0xf;
+        mmc->max_blk_count = (ssp_is_old()) ? 0xff : 0xffffff;
+        mmc->max_req_size = (ssp_is_old()) ? 0xffff : 0xffffffff;
+        mmc->max_seg_size = dma_get_max_seg_size(host->dmach->device->dev);
+
+        platform_set_drvdata(pdev, mmc);
+
+        ret = request_irq(host->irq, mxs_mmc_irq_handler, 0, DRIVER_NAME, host);
+        if (ret)
+                goto out_free_dma;
+
+        spin_lock_init(&host->lock);
+
+        ret = mmc_add_host(mmc);
+        if (ret)
+                goto out_free_irq;
+
+        dev_info(mmc_dev(host->mmc), "initialized\n");
+
+        return 0;
+
+out_free_irq:
+        free_irq(host->irq, host);
+out_free_dma:
+        if (host->dmach)
+                dma_release_channel(host->dmach);
+out_clk_put:
+        clk_disable(host->clk);
+        clk_put(host->clk);
+out_iounmap:
+        iounmap(host->base);
+out_mmc_free:
+        mmc_free_host(mmc);
+out_release_mem:
+        release_mem_region(iores->start, resource_size(iores));
+        return ret;
+}
+
+static int mxs_mmc_remove(struct platform_device *pdev)
+{
+        struct mmc_host *mmc = platform_get_drvdata(pdev);
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+        struct resource *res = host->res;
+
+        mmc_remove_host(mmc);
+
+        free_irq(host->irq, host);
+
+        platform_set_drvdata(pdev, NULL);
+
+        if (host->dmach)
+                dma_release_channel(host->dmach);
+
+        clk_disable(host->clk);
+        clk_put(host->clk);
+
+        iounmap(host->base);
+
+        mmc_free_host(mmc);
+
+        release_mem_region(res->start, resource_size(res));
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int mxs_mmc_suspend(struct device *dev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(dev);
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+        int ret = 0;
+
+        ret = mmc_suspend_host(mmc);
+
+        clk_disable(host->clk);
+
+        return ret;
+}
+
+static int mxs_mmc_resume(struct device *dev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(dev);
+        struct mxs_mmc_host *host = mmc_priv(mmc);
+        int ret = 0;
+
+        clk_enable(host->clk);
+
+        ret = mmc_resume_host(mmc);
+
+        return ret;
+}
+
+static const struct dev_pm_ops mxs_mmc_pm_ops = {
+        .suspend        = mxs_mmc_suspend,
+        .resume         = mxs_mmc_resume,
+};
+#endif
+
+static struct platform_driver mxs_mmc_driver = {
+        .probe          = mxs_mmc_probe,
+        .remove         = mxs_mmc_remove,
+        .driver         = {
+                .name   = DRIVER_NAME,
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &mxs_mmc_pm_ops,
+#endif
+        },
+};
+
+static int __init mxs_mmc_init(void)
+{
+        return platform_driver_register(&mxs_mmc_driver);
+}
+
+static void __exit mxs_mmc_exit(void)
+{
+        platform_driver_unregister(&mxs_mmc_driver);
+}
+
+module_init(mxs_mmc_init);
+module_exit(mxs_mmc_exit);
+
+MODULE_DESCRIPTION("FREESCALE MXS MMC peripheral");
+MODULE_AUTHOR("Freescale Semiconductor");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index 1247e5de9faa..ab66f2454dc4 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -15,14 +15,21 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/slab.h>
+#include <linux/irq.h>
 #include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
+#include <linux/of_irq.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/mmc_spi.h>
 #include <linux/mmc/core.h>
 #include <linux/mmc/host.h>
 
+/* For archs that don't support NO_IRQ (such as mips), provide a dummy value */
+#ifndef NO_IRQ
+#define NO_IRQ 0
+#endif
+
 MODULE_LICENSE("GPL");
 
 enum {
@@ -34,6 +41,7 @@ enum {
 struct of_mmc_spi {
         int gpios[NUM_GPIOS];
         bool alow_gpios[NUM_GPIOS];
+        int detect_irq;
         struct mmc_spi_platform_data pdata;
 };
 
@@ -61,6 +69,22 @@ static int of_mmc_spi_get_ro(struct device *dev)
         return of_mmc_spi_read_gpio(dev, WP_GPIO);
 }
 
+static int of_mmc_spi_init(struct device *dev,
+                           irqreturn_t (*irqhandler)(int, void *), void *mmc)
+{
+        struct of_mmc_spi *oms = to_of_mmc_spi(dev);
+
+        return request_threaded_irq(oms->detect_irq, NULL, irqhandler, 0,
+                                    dev_name(dev), mmc);
+}
+
+static void of_mmc_spi_exit(struct device *dev, void *mmc)
+{
+        struct of_mmc_spi *oms = to_of_mmc_spi(dev);
+
+        free_irq(oms->detect_irq, mmc);
+}
+
 struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
 {
         struct device *dev = &spi->dev;
@@ -121,8 +145,13 @@ struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
         if (gpio_is_valid(oms->gpios[WP_GPIO]))
                 oms->pdata.get_ro = of_mmc_spi_get_ro;
 
-        /* We don't support interrupts yet, let's poll. */
-        oms->pdata.caps |= MMC_CAP_NEEDS_POLL;
+        oms->detect_irq = irq_of_parse_and_map(np, 0);
+        if (oms->detect_irq != NO_IRQ) {
+                oms->pdata.init = of_mmc_spi_init;
+                oms->pdata.exit = of_mmc_spi_exit;
+        } else {
+                oms->pdata.caps |= MMC_CAP_NEEDS_POLL;
+        }
 
         dev->platform_data = &oms->pdata;
         return dev->platform_data;
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index d98ddcfac5e5..a6c329040140 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -173,6 +173,8 @@ struct mmc_omap_host {
         struct omap_mmc_platform_data *pdata;
 };
 
+static struct workqueue_struct *mmc_omap_wq;
+
 static void mmc_omap_fclk_offdelay(struct mmc_omap_slot *slot)
 {
         unsigned long tick_ns;
@@ -289,7 +291,7 @@ static void mmc_omap_release_slot(struct mmc_omap_slot *slot, int clk_enabled)
                 host->next_slot = new_slot;
                 host->mmc = new_slot->mmc;
                 spin_unlock_irqrestore(&host->slot_lock, flags);
-                schedule_work(&host->slot_release_work);
+                queue_work(mmc_omap_wq, &host->slot_release_work);
                 return;
         }
 
@@ -457,7 +459,7 @@ mmc_omap_xfer_done(struct mmc_omap_host *host, struct mmc_data *data)
         }
 
         host->stop_data = data;
-        schedule_work(&host->send_stop_work);
+        queue_work(mmc_omap_wq, &host->send_stop_work);
 }
 
 static void
@@ -637,7 +639,7 @@ mmc_omap_cmd_timer(unsigned long data)
                 OMAP_MMC_WRITE(host, IE, 0);
                 disable_irq(host->irq);
                 host->abort = 1;
-                schedule_work(&host->cmd_abort_work);
+                queue_work(mmc_omap_wq, &host->cmd_abort_work);
         }
         spin_unlock_irqrestore(&host->slot_lock, flags);
 }
@@ -826,11 +828,11 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                 host->abort = 1;
                 OMAP_MMC_WRITE(host, IE, 0);
                 disable_irq_nosync(host->irq);
-                schedule_work(&host->cmd_abort_work);
+                queue_work(mmc_omap_wq, &host->cmd_abort_work);
                 return IRQ_HANDLED;
         }
 
-        if (end_command)
+        if (end_command && host->cmd)
                 mmc_omap_cmd_done(host, host->cmd);
         if (host->data != NULL) {
                 if (transfer_error)
@@ -1335,8 +1337,7 @@ static int __init mmc_omap_new_slot(struct mmc_omap_host *host, int id)
          * NOTE max_seg_size assumption that small blocks aren't
          * normally used (except e.g. for reading SD registers).
          */
-        mmc->max_phys_segs = 32;
-        mmc->max_hw_segs = 32;
+        mmc->max_segs = 32;
         mmc->max_blk_size = 2048;       /* BLEN is 11 bits (+1) */
         mmc->max_blk_count = 2048;      /* NBLK is 11 bits (+1) */
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
@@ -1388,7 +1389,7 @@ static void mmc_omap_remove_slot(struct mmc_omap_slot *slot)
 
         tasklet_kill(&slot->cover_tasklet);
         del_timer_sync(&slot->cover_timer);
-        flush_scheduled_work();
+        flush_workqueue(mmc_omap_wq);
 
         mmc_remove_host(mmc);
         mmc_free_host(mmc);
@@ -1416,7 +1417,7 @@ static int __init mmc_omap_probe(struct platform_device *pdev)
         if (res == NULL || irq < 0)
                 return -ENXIO;
 
-        res = request_mem_region(res->start, res->end - res->start + 1,
+        res = request_mem_region(res->start, resource_size(res),
                                  pdev->name);
         if (res == NULL)
                 return -EBUSY;
@@ -1456,7 +1457,7 @@ static int __init mmc_omap_probe(struct platform_device *pdev)
 
         host->irq = irq;
         host->phys_base = host->mem_res->start;
-        host->virt_base = ioremap(res->start, res->end - res->start + 1);
+        host->virt_base = ioremap(res->start, resource_size(res));
         if (!host->virt_base)
                 goto err_ioremap;
 
@@ -1513,7 +1514,7 @@ err_free_mmc_host:
 err_ioremap:
         kfree(host);
 err_free_mem_region:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
         return ret;
 }
 
@@ -1609,12 +1610,22 @@ static struct platform_driver mmc_omap_driver = {
 
 static int __init mmc_omap_init(void)
 {
-        return platform_driver_probe(&mmc_omap_driver, mmc_omap_probe);
+        int ret;
+
+        mmc_omap_wq = alloc_workqueue("mmc_omap", 0, 0);
+        if (!mmc_omap_wq)
+                return -ENOMEM;
+
+        ret = platform_driver_probe(&mmc_omap_driver, mmc_omap_probe);
+        if (ret)
+                destroy_workqueue(mmc_omap_wq);
+        return ret;
 }
 
 static void __exit mmc_omap_exit(void)
 {
         platform_driver_unregister(&mmc_omap_driver);
+        destroy_workqueue(mmc_omap_wq);
 }
 
 module_init(mmc_omap_init);
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 4526d2791f29..dedf3dab8a3b 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -118,7 +118,7 @@
 
 #define MMC_TIMEOUT_MS          20
 #define OMAP_MMC_MASTER_CLOCK   96000000
-#define DRIVER_NAME             "mmci-omap-hs"
+#define DRIVER_NAME             "omap_hsmmc"
 
 /* Timeouts for entering power saving states on inactivity, msec */
 #define OMAP_MMC_DISABLED_TIMEOUT       100
@@ -250,9 +250,9 @@ static int omap_hsmmc_1_set_power(struct device *dev, int slot, int power_on,
                 mmc_slot(host).before_set_reg(dev, slot, power_on, vdd);
 
         if (power_on)
-                ret = mmc_regulator_set_ocr(host->vcc, vdd);
+                ret = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
         else
-                ret = mmc_regulator_set_ocr(host->vcc, 0);
+                ret = mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
 
         if (mmc_slot(host).after_set_reg)
                 mmc_slot(host).after_set_reg(dev, slot, power_on, vdd);
@@ -260,7 +260,7 @@ static int omap_hsmmc_1_set_power(struct device *dev, int slot, int power_on,
         return ret;
 }
 
-static int omap_hsmmc_23_set_power(struct device *dev, int slot, int power_on,
+static int omap_hsmmc_235_set_power(struct device *dev, int slot, int power_on,
                                    int vdd)
 {
         struct omap_hsmmc_host *host =
@@ -291,18 +291,23 @@ static int omap_hsmmc_23_set_power(struct device *dev, int slot, int power_on,
          * chips/cards need an interface voltage rail too.
          */
         if (power_on) {
-                ret = mmc_regulator_set_ocr(host->vcc, vdd);
+                ret = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
                 /* Enable interface voltage rail, if needed */
                 if (ret == 0 && host->vcc_aux) {
                         ret = regulator_enable(host->vcc_aux);
                         if (ret < 0)
-                                ret = mmc_regulator_set_ocr(host->vcc, 0);
+                                ret = mmc_regulator_set_ocr(host->mmc,
+                                                        host->vcc, 0);
                 }
         } else {
+                /* Shut down the rail */
                 if (host->vcc_aux)
                         ret = regulator_disable(host->vcc_aux);
-                if (ret == 0)
-                        ret = mmc_regulator_set_ocr(host->vcc, 0);
+                if (!ret) {
+                        /* Then proceed to shut down the local regulator */
+                        ret = mmc_regulator_set_ocr(host->mmc,
+                                                host->vcc, 0);
+                }
         }
 
         if (mmc_slot(host).after_set_reg)
@@ -311,6 +316,12 @@ static int omap_hsmmc_23_set_power(struct device *dev, int slot, int power_on,
         return ret;
 }
 
+static int omap_hsmmc_4_set_power(struct device *dev, int slot, int power_on,
+                                        int vdd)
+{
+        return 0;
+}
+
 static int omap_hsmmc_1_set_sleep(struct device *dev, int slot, int sleep,
                                   int vdd, int cardsleep)
 {
@@ -321,7 +332,7 @@ static int omap_hsmmc_1_set_sleep(struct device *dev, int slot, int sleep,
         return regulator_set_mode(host->vcc, mode);
 }
 
-static int omap_hsmmc_23_set_sleep(struct device *dev, int slot, int sleep,
+static int omap_hsmmc_235_set_sleep(struct device *dev, int slot, int sleep,
                                    int vdd, int cardsleep)
 {
         struct omap_hsmmc_host *host =
@@ -343,9 +354,9 @@ static int omap_hsmmc_23_set_sleep(struct device *dev, int slot, int sleep,
         if (cardsleep) {
                 /* VCC can be turned off if card is asleep */
                 if (sleep)
-                        err = mmc_regulator_set_ocr(host->vcc, 0);
+                        err = mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
                 else
-                        err = mmc_regulator_set_ocr(host->vcc, vdd);
+                        err = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
         } else
                 err = regulator_set_mode(host->vcc, mode);
         if (err)
@@ -360,10 +371,17 @@ static int omap_hsmmc_23_set_sleep(struct device *dev, int slot, int sleep,
                 return regulator_enable(host->vcc_aux);
 }
 
+static int omap_hsmmc_4_set_sleep(struct device *dev, int slot, int sleep,
+                                        int vdd, int cardsleep)
+{
+        return 0;
+}
+
 static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
 {
         struct regulator *reg;
         int ret = 0;
+        int ocr_value = 0;
 
         switch (host->id) {
         case OMAP_MMC1_DEVID:
@@ -373,10 +391,14 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
                 break;
         case OMAP_MMC2_DEVID:
         case OMAP_MMC3_DEVID:
+        case OMAP_MMC5_DEVID:
                 /* Off-chip level shifting, or none */
-                mmc_slot(host).set_power = omap_hsmmc_23_set_power;
-                mmc_slot(host).set_sleep = omap_hsmmc_23_set_sleep;
+                mmc_slot(host).set_power = omap_hsmmc_235_set_power;
+                mmc_slot(host).set_sleep = omap_hsmmc_235_set_sleep;
                 break;
+        case OMAP_MMC4_DEVID:
+                mmc_slot(host).set_power = omap_hsmmc_4_set_power;
+                mmc_slot(host).set_sleep = omap_hsmmc_4_set_sleep;
         default:
                 pr_err("MMC%d configuration not supported!\n", host->id);
                 return -EINVAL;
@@ -396,12 +418,25 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
                 }
         } else {
                 host->vcc = reg;
-                mmc_slot(host).ocr_mask = mmc_regulator_get_ocrmask(reg);
+                ocr_value = mmc_regulator_get_ocrmask(reg);
+                if (!mmc_slot(host).ocr_mask) {
+                        mmc_slot(host).ocr_mask = ocr_value;
+                } else {
+                        if (!(mmc_slot(host).ocr_mask & ocr_value)) {
+                                pr_err("MMC%d ocrmask %x is not supported\n",
+                                        host->id, mmc_slot(host).ocr_mask);
+                                mmc_slot(host).ocr_mask = 0;
+                                return -EINVAL;
+                        }
+                }
 
                 /* Allow an aux regulator */
                 reg = regulator_get(host->dev, "vmmc_aux");
                 host->vcc_aux = IS_ERR(reg) ? NULL : reg;
 
+                /* For eMMC do not power off when not in sleep state */
+                if (mmc_slot(host).no_regulator_off_init)
+                        return 0;
                 /*
                 * UGLY HACK:  workaround regulator framework bugs.
                 * When the bootloader leaves a supply active, it's
@@ -466,8 +501,6 @@ static int omap_hsmmc_gpio_init(struct omap_mmc_platform_data *pdata)
         int ret;
 
         if (gpio_is_valid(pdata->slots[0].switch_pin)) {
-                pdata->suspend = omap_hsmmc_suspend_cdirq;
-                pdata->resume = omap_hsmmc_resume_cdirq;
                 if (pdata->slots[0].cover)
                         pdata->slots[0].get_cover_state =
                                         omap_hsmmc_get_cover_state;
@@ -928,7 +961,8 @@ static void omap_hsmmc_dma_cleanup(struct omap_hsmmc_host *host, int errno)
         spin_unlock(&host->irq_lock);
 
         if (host->use_dma && dma_ch != -1) {
-                dma_unmap_sg(mmc_dev(host->mmc), host->data->sg, host->dma_len,
+                dma_unmap_sg(mmc_dev(host->mmc), host->data->sg,
+                        host->data->sg_len,
                         omap_hsmmc_get_dma_dir(host, host->data));
                 omap_free_dma(dma_ch);
         }
@@ -982,6 +1016,17 @@ static inline void omap_hsmmc_reset_controller_fsm(struct omap_hsmmc_host *host,
         OMAP_HSMMC_WRITE(host->base, SYSCTL,
                          OMAP_HSMMC_READ(host->base, SYSCTL) | bit);
 
+        /*
+         * OMAP4 ES2 and greater has an updated reset logic.
+         * Monitor a 0->1 transition first
+         */
+        if (mmc_slot(host).features & HSMMC_HAS_UPDATED_RESET) {
+                while ((!(OMAP_HSMMC_READ(host->base, SYSCTL) & bit))
+                                        && (i++ < limit))
+                        cpu_relax();
+        }
+        i = 0;
+
         while ((OMAP_HSMMC_READ(host->base, SYSCTL) & bit) &&
                 (i++ < limit))
                 cpu_relax();
@@ -1301,7 +1346,7 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
                 return;
         }
 
-        dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_len,
+        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;
@@ -1529,7 +1574,7 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 break;
         }
 
-        if (host->id == OMAP_MMC1_DEVID) {
+        if (host->pdata->controller_flags & OMAP_HSMMC_SUPPORTS_DUAL_VOLT) {
                 /* Only MMC1 can interface at 3V without some flavor
                  * of external transceiver; but they all handle 1.8V.
                  */
@@ -1621,7 +1666,7 @@ static void omap_hsmmc_conf_bus_power(struct omap_hsmmc_host *host)
         u32 hctl, capa, value;
 
         /* Only MMC1 supports 3.0V */
-        if (host->id == OMAP_MMC1_DEVID) {
+        if (host->pdata->controller_flags & OMAP_HSMMC_SUPPORTS_DUAL_VOLT) {
                 hctl = SDVS30;
                 capa = VS30 | VS18;
         } else {
@@ -2003,8 +2048,9 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         if (res == NULL || irq < 0)
                 return -ENXIO;
 
-        res = request_mem_region(res->start, res->end - res->start + 1,
-                                                        pdev->name);
+        res->start += pdata->reg_offset;
+        res->end += pdata->reg_offset;
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
         if (res == NULL)
                 return -EBUSY;
 
@@ -2073,14 +2119,14 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         /* we start off in DISABLED state */
         host->dpm_state = DISABLED;
 
-        if (mmc_host_enable(host->mmc) != 0) {
+        if (clk_enable(host->iclk) != 0) {
                 clk_put(host->iclk);
                 clk_put(host->fclk);
                 goto err1;
         }
 
-        if (clk_enable(host->iclk) != 0) {
-                mmc_host_disable(host->mmc);
+        if (mmc_host_enable(host->mmc) != 0) {
+                clk_disable(host->iclk);
                 clk_put(host->iclk);
                 clk_put(host->fclk);
                 goto err1;
@@ -2105,8 +2151,7 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
 
         /* Since we do only SG emulation, we can have as many segs
          * as we want. */
-        mmc->max_phys_segs = 1024;
-        mmc->max_hw_segs = 1024;
+        mmc->max_segs = 1024;
 
         mmc->max_blk_size = 512;       /* Block Length at max can be 1024 */
         mmc->max_blk_count = 0xFFFF;    /* No. of Blocks is 16 bits */
@@ -2116,23 +2161,9 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED |
                      MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_ERASE;
 
-        switch (mmc_slot(host).wires) {
-        case 8:
-                mmc->caps |= MMC_CAP_8_BIT_DATA;
-                /* Fall through */
-        case 4:
+        mmc->caps |= mmc_slot(host).caps;
+        if (mmc->caps & MMC_CAP_8_BIT_DATA)
                 mmc->caps |= MMC_CAP_4_BIT_DATA;
-                break;
-        case 1:
-                /* Nothing to crib here */
-        case 0:
-                /* Assuming nothing was given by board, Core use's 1-Bit */
-                break;
-        default:
-                /* Completely unexpected.. Core goes with 1-Bit Width */
-                dev_crit(mmc_dev(host->mmc), "Invalid width %d\n used!"
-                        "using 1 instead\n", mmc_slot(host).wires);
-        }
 
         if (mmc_slot(host).nonremovable)
                 mmc->caps |= MMC_CAP_NONREMOVABLE;
@@ -2203,6 +2234,8 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
                                 "Unable to grab MMC CD IRQ\n");
                         goto err_irq_cd;
                 }
+                pdata->suspend = omap_hsmmc_suspend_cdirq;
+                pdata->resume = omap_hsmmc_resume_cdirq;
         }
 
         omap_hsmmc_disable_irq(host);
@@ -2256,7 +2289,7 @@ err1:
 err_alloc:
         omap_hsmmc_gpio_free(pdata);
 err:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
         return ret;
 }
 
@@ -2275,7 +2308,7 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
                 free_irq(host->irq, host);
                 if (mmc_slot(host).card_detect_irq)
                         free_irq(mmc_slot(host).card_detect_irq, host);
-                flush_scheduled_work();
+                flush_work_sync(&host->mmc_carddetect_work);
 
                 mmc_host_disable(host->mmc);
                 clk_disable(host->iclk);
@@ -2293,7 +2326,7 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res)
-                release_mem_region(res->start, res->end - res->start + 1);
+                release_mem_region(res->start, resource_size(res));
         platform_set_drvdata(pdev, NULL);
 
         return 0;
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index 0a4e43f37140..7257738fd7da 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -99,14 +99,25 @@ static inline void pxamci_init_ocr(struct pxamci_host *host)
         }
 }
 
-static inline void pxamci_set_power(struct pxamci_host *host, unsigned int vdd)
+static inline int pxamci_set_power(struct pxamci_host *host,
+                                    unsigned char power_mode,
+                                    unsigned int vdd)
 {
         int on;
 
-#ifdef CONFIG_REGULATOR
-        if (host->vcc)
-                mmc_regulator_set_ocr(host->vcc, vdd);
-#endif
+        if (host->vcc) {
+                int ret;
+
+                if (power_mode == MMC_POWER_UP) {
+                        ret = mmc_regulator_set_ocr(host->mmc, host->vcc, vdd);
+                        if (ret)
+                                return ret;
+                } else if (power_mode == MMC_POWER_OFF) {
+                        ret = mmc_regulator_set_ocr(host->mmc, host->vcc, 0);
+                        if (ret)
+                                return ret;
+                }
+        }
         if (!host->vcc && host->pdata &&
             gpio_is_valid(host->pdata->gpio_power)) {
                 on = ((1 << vdd) & host->pdata->ocr_mask);
@@ -115,6 +126,8 @@ static inline void pxamci_set_power(struct pxamci_host *host, unsigned int vdd)
         }
         if (!host->vcc && host->pdata && host->pdata->setpower)
                 host->pdata->setpower(mmc_dev(host->mmc), vdd);
+
+        return 0;
 }
 
 static void pxamci_stop_clock(struct pxamci_host *host)
@@ -490,9 +503,21 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         }
 
         if (host->power_mode != ios->power_mode) {
+                int ret;
+
                 host->power_mode = ios->power_mode;
 
-                pxamci_set_power(host, ios->vdd);
+                ret = pxamci_set_power(host, ios->power_mode, ios->vdd);
+                if (ret) {
+                        dev_err(mmc_dev(mmc), "unable to set power\n");
+                        /*
+                         * The .set_ios() function in the mmc_host_ops
+                         * struct return void, and failing to set the
+                         * power should be rare so we print an error and
+                         * return here.
+                         */
+                        return;
+                }
 
                 if (ios->power_mode == MMC_POWER_ON)
                         host->cmdat |= CMDAT_INIT;
@@ -503,8 +528,8 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         else
                 host->cmdat &= ~CMDAT_SD_4DAT;
 
-        pr_debug("PXAMCI: clkrt = %x cmdat = %x\n",
-                 host->clkrt, host->cmdat);
+        dev_dbg(mmc_dev(mmc), "PXAMCI: clkrt = %x cmdat = %x\n",
+                host->clkrt, host->cmdat);
 }
 
 static void pxamci_enable_sdio_irq(struct mmc_host *host, int enable)
@@ -576,7 +601,7 @@ static int pxamci_probe(struct platform_device *pdev)
          * We can do SG-DMA, but we don't because we never know how much
          * data we successfully wrote to the card.
          */
-        mmc->max_phys_segs = NR_SG;
+        mmc->max_segs = NR_SG;
 
         /*
          * Our hardware DMA can handle a maximum of one page per SG entry.
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 976330de379e..a04f87d7ee3d 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -874,7 +874,7 @@ static void finalize_request(struct s3cmci_host *host)
         if (!mrq->data)
                 goto request_done;
 
-        /* Calulate the amout of bytes transfer if there was no error */
+        /* Calculate the amout of bytes transfer if there was no error */
         if (mrq->data->error == 0) {
                 mrq->data->bytes_xfered =
                         (mrq->data->blocks * mrq->data->blksz);
@@ -882,7 +882,7 @@ static void finalize_request(struct s3cmci_host *host)
                 mrq->data->bytes_xfered = 0;
         }
 
-        /* If we had an error while transfering data we flush the
+        /* If we had an error while transferring data we flush the
          * DMA channel and the fifo to clear out any garbage. */
         if (mrq->data->error != 0) {
                 if (s3cmci_host_usedma(host))
@@ -980,7 +980,7 @@ static int s3cmci_setup_data(struct s3cmci_host *host, struct mmc_data *data)
 
         if ((data->blksz & 3) != 0) {
                 /* We cannot deal with unaligned blocks with more than
-                 * one block being transfered. */
+                 * one block being transferred. */
 
                 if (data->blocks > 1) {
                         pr_warning("%s: can't do non-word sized block transfers (blksz %d)\n", __func__, data->blksz);
@@ -1736,8 +1736,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
         mmc->max_req_size       = 4095 * 512;
         mmc->max_seg_size       = mmc->max_req_size;
 
-        mmc->max_phys_segs      = 128;
-        mmc->max_hw_segs        = 128;
+        mmc->max_segs           = 128;
 
         dbg(host, dbg_debug,
             "probe: mode:%s mapped mci_base:%p irq:%u irq_cd:%u dma:%u.\n",
diff --git a/drivers/mmc/host/sdhci-cns3xxx.c b/drivers/mmc/host/sdhci-cns3xxx.c
index b7050b380d5f..9ebd1d7759dc 100644
--- a/drivers/mmc/host/sdhci-cns3xxx.c
+++ b/drivers/mmc/host/sdhci-cns3xxx.c
@@ -15,7 +15,7 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/mmc/host.h>
-#include <linux/sdhci-pltfm.h>
+#include <linux/mmc/sdhci-pltfm.h>
 #include <mach/cns3xxx.h>
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
new file mode 100644
index 000000000000..2aeef4ffed8c
--- /dev/null
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -0,0 +1,70 @@
+/*
+ * sdhci-dove.c Support for SDHCI on Marvell's Dove SoC
+ *
+ * Author: Saeed Bishara <saeed@marvell.com>
+ *         Mike Rapoport <mike@compulab.co.il>
+ * Based on sdhci-cns3xxx.c
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#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)
+{
+        u16 ret;
+
+        switch (reg) {
+        case SDHCI_HOST_VERSION:
+        case SDHCI_SLOT_INT_STATUS:
+                /* those registers don't exist */
+                return 0;
+        default:
+                ret = readw(host->ioaddr + reg);
+        }
+        return ret;
+}
+
+static u32 sdhci_dove_readl(struct sdhci_host *host, int reg)
+{
+        u32 ret;
+
+        switch (reg) {
+        case SDHCI_CAPABILITIES:
+                ret = readl(host->ioaddr + reg);
+                /* Mask the support for 3.0V */
+                ret &= ~SDHCI_CAN_VDD_300;
+                break;
+        default:
+                ret = readl(host->ioaddr + reg);
+        }
+        return ret;
+}
+
+static struct sdhci_ops sdhci_dove_ops = {
+        .read_w = sdhci_dove_readw,
+        .read_l = sdhci_dove_readl,
+};
+
+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,
+};
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
new file mode 100644
index 000000000000..a19967d0bfc4
--- /dev/null
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -0,0 +1,331 @@
+/*
+ * Freescale eSDHC i.MX controller driver for the platform bus.
+ *
+ * derived from the OF-version.
+ *
+ * Copyright (c) 2010 Pengutronix e.K.
+ *   Author: Wolfram Sang <w.sang@pengutronix.de>
+ *
+ * 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.
+ */
+
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/gpio.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 <mach/esdhc.h>
+#include "sdhci.h"
+#include "sdhci-pltfm.h"
+#include "sdhci-esdhc.h"
+
+/* 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
+ * open ended multi-blk IO. Otherwise the TC INT wouldn't
+ * be generated.
+ * In exact block transfer, the controller doesn't complete the
+ * operations automatically as required at the end of the
+ * transfer and remains on hold if the abort command is not sent.
+ * As a result, the TC flag is not asserted and SW  received timeout
+ * exeception. Bit1 of Vendor Spec registor is used to fix it.
+ */
+#define ESDHC_FLAG_MULTIBLK_NO_INT      (1 << 1)
+
+struct pltfm_imx_data {
+        int flags;
+        u32 scratchpad;
+};
+
+static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, int reg)
+{
+        void __iomem *base = host->ioaddr + (reg & ~0x3);
+        u32 shift = (reg & 0x3) * 8;
+
+        writel(((readl(base) & ~(mask << shift)) | (val << shift)), base);
+}
+
+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;
+
+        /* fake CARD_PRESENT flag on mx25/35 */
+        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))
+                        /* no card, if a valid gpio says so... */
+                        val &= SDHCI_CARD_PRESENT;
+                else
+                        /* ... in all other cases assume card is present */
+                        val |= SDHCI_CARD_PRESENT;
+        }
+
+        return val;
+}
+
+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);
+
+        if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
+                                && (reg == SDHCI_INT_STATUS)
+                                && (val & SDHCI_INT_DATA_END))) {
+                        u32 v;
+                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v &= ~SDHCI_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+        }
+
+        writel(val, host->ioaddr + reg);
+}
+
+static u16 esdhc_readw_le(struct sdhci_host *host, int reg)
+{
+        if (unlikely(reg == SDHCI_HOST_VERSION))
+                reg ^= 2;
+
+        return readw(host->ioaddr + reg);
+}
+
+static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+
+        switch (reg) {
+        case SDHCI_TRANSFER_MODE:
+                /*
+                 * Postpone this write, we must do it together with a
+                 * command write that is down below.
+                 */
+                if ((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
+                                && (host->cmd->opcode == SD_IO_RW_EXTENDED)
+                                && (host->cmd->data->blocks > 1)
+                                && (host->cmd->data->flags & MMC_DATA_READ)) {
+                        u32 v;
+                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v |= SDHCI_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+                }
+                imx_data->scratchpad = val;
+                return;
+        case SDHCI_COMMAND:
+                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION)
+                        && (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
+                        val |= SDHCI_CMD_ABORTCMD;
+                writel(val << 16 | imx_data->scratchpad,
+                        host->ioaddr + SDHCI_TRANSFER_MODE);
+                return;
+        case SDHCI_BLOCK_SIZE:
+                val &= ~SDHCI_MAKE_BLKSZ(0x7, 0);
+                break;
+        }
+        esdhc_clrset_le(host, 0xffff, val, reg);
+}
+
+static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
+{
+        u32 new_val;
+
+        switch (reg) {
+        case SDHCI_POWER_CONTROL:
+                /*
+                 * FSL put some DMA bits here
+                 * If your board has a regulator, code should be here
+                 */
+                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);
+                /* ensure the endianess */
+                new_val |= ESDHC_HOST_CONTROL_LE;
+                /* DMA mode bits are shifted */
+                new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
+
+                esdhc_clrset_le(host, 0xffff, new_val, reg);
+                return;
+        }
+        esdhc_clrset_le(host, 0xff, val, reg);
+}
+
+static unsigned int esdhc_pltfm_get_max_clock(struct sdhci_host *host)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+
+        return clk_get_rate(pltfm_host->clk);
+}
+
+static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+
+        return clk_get_rate(pltfm_host->clk) / 256 / 16;
+}
+
+static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
+{
+        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+
+        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+                return gpio_get_value(boarddata->wp_gpio);
+        else
+                return -ENOSYS;
+}
+
+static struct sdhci_ops sdhci_esdhc_ops = {
+        .read_l = esdhc_readl_le,
+        .read_w = esdhc_readw_le,
+        .write_l = esdhc_writel_le,
+        .write_w = esdhc_writew_le,
+        .write_b = esdhc_writeb_le,
+        .set_clock = esdhc_set_clock,
+        .get_max_clock = esdhc_pltfm_get_max_clock,
+        .get_min_clock = esdhc_pltfm_get_min_clock,
+};
+
+static irqreturn_t cd_irq(int irq, void *data)
+{
+        struct sdhci_host *sdhost = (struct sdhci_host *)data;
+
+        tasklet_schedule(&sdhost->card_tasklet);
+        return IRQ_HANDLED;
+};
+
+static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pdata)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+        struct clk *clk;
+        int err;
+        struct pltfm_imx_data *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);
+        }
+        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())
+                host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
+
+        if (cpu_is_mx25() || cpu_is_mx35()) {
+                /* 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()))
+                imx_data->flags |= ESDHC_FLAG_MULTIBLK_NO_INT;
+
+        if (boarddata) {
+                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;
+                }
+
+                err = gpio_request_one(boarddata->cd_gpio, GPIOF_IN, "ESDHC_CD");
+                if (err) {
+                        dev_warn(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");
+                        goto no_card_detect_irq;
+                }
+
+                imx_data->flags |= ESDHC_FLAG_GPIO_FOR_CD_WP;
+                /* Now we have a working card_detect again */
+                host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+        }
+
+        return 0;
+
+ no_card_detect_irq:
+        gpio_free(boarddata->cd_gpio);
+ no_card_detect_pin:
+        boarddata->cd_gpio = err;
+ not_supported:
+        kfree(imx_data);
+        return 0;
+}
+
+static void esdhc_pltfm_exit(struct sdhci_host *host)
+{
+        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;
+
+        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+                gpio_free(boarddata->wp_gpio);
+
+        if (boarddata && gpio_is_valid(boarddata->cd_gpio)) {
+                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);
+}
+
+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,
+};
diff --git a/drivers/mmc/host/sdhci-esdhc.h b/drivers/mmc/host/sdhci-esdhc.h
new file mode 100644
index 000000000000..c3b08f111942
--- /dev/null
+++ b/drivers/mmc/host/sdhci-esdhc.h
@@ -0,0 +1,81 @@
+/*
+ * Freescale eSDHC controller driver generics for OF and pltfm.
+ *
+ * Copyright (c) 2007 Freescale Semiconductor, Inc.
+ * Copyright (c) 2009 MontaVista Software, Inc.
+ * Copyright (c) 2010 Pengutronix e.K.
+ *   Author: Wolfram Sang <w.sang@pengutronix.de>
+ *
+ * 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.
+ */
+
+#ifndef _DRIVERS_MMC_SDHCI_ESDHC_H
+#define _DRIVERS_MMC_SDHCI_ESDHC_H
+
+/*
+ * Ops and quirks for the Freescale eSDHC controller.
+ */
+
+#define ESDHC_DEFAULT_QUIRKS    (SDHCI_QUIRK_FORCE_BLK_SZ_2048 | \
+                                SDHCI_QUIRK_NO_BUSY_IRQ | \
+                                SDHCI_QUIRK_NONSTANDARD_CLOCK | \
+                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | \
+                                SDHCI_QUIRK_PIO_NEEDS_DELAY | \
+                                SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
+
+#define ESDHC_SYSTEM_CONTROL    0x2c
+#define ESDHC_CLOCK_MASK        0x0000fff0
+#define ESDHC_PREDIV_SHIFT      8
+#define ESDHC_DIVIDER_SHIFT     4
+#define ESDHC_CLOCK_PEREN       0x00000004
+#define ESDHC_CLOCK_HCKEN       0x00000002
+#define ESDHC_CLOCK_IPGEN       0x00000001
+
+/* pltfm-specific */
+#define ESDHC_HOST_CONTROL_LE   0x20
+
+/* OF-specific */
+#define ESDHC_DMA_SYSCTL        0x40c
+#define ESDHC_DMA_SNOOP         0x00000040
+
+#define ESDHC_HOST_CONTROL_RES  0x05
+
+static inline void esdhc_set_clock(struct sdhci_host *host, unsigned int clock)
+{
+        int pre_div = 2;
+        int div = 1;
+        u32 temp;
+
+        temp = sdhci_readl(host, ESDHC_SYSTEM_CONTROL);
+        temp &= ~(ESDHC_CLOCK_IPGEN | ESDHC_CLOCK_HCKEN | ESDHC_CLOCK_PEREN
+                | ESDHC_CLOCK_MASK);
+        sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL);
+
+        if (clock == 0)
+                goto out;
+
+        while (host->max_clk / pre_div / 16 > clock && pre_div < 256)
+                pre_div *= 2;
+
+        while (host->max_clk / pre_div / div > clock && div < 16)
+                div++;
+
+        dev_dbg(mmc_dev(host->mmc), "desired SD clock: %d, actual: %d\n",
+                clock, host->max_clk / pre_div / div);
+
+        pre_div >>= 1;
+        div--;
+
+        temp = sdhci_readl(host, ESDHC_SYSTEM_CONTROL);
+        temp |= (ESDHC_CLOCK_IPGEN | ESDHC_CLOCK_HCKEN | ESDHC_CLOCK_PEREN
+                | (div << ESDHC_DIVIDER_SHIFT)
+                | (pre_div << ESDHC_PREDIV_SHIFT));
+        sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL);
+        mdelay(100);
+out:
+        host->clock = clock;
+}
+
+#endif /* _DRIVERS_MMC_SDHCI_ESDHC_H */
diff --git a/drivers/mmc/host/sdhci-of-core.c b/drivers/mmc/host/sdhci-of-core.c
index c51b71174c1d..60e4186a4345 100644
--- a/drivers/mmc/host/sdhci-of-core.c
+++ b/drivers/mmc/host/sdhci-of-core.c
@@ -13,6 +13,7 @@
  * your option) any later version.
  */
 
+#include <linux/err.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/io.h>
@@ -20,8 +21,12 @@
 #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"
 
@@ -112,20 +117,30 @@ static bool __devinit sdhci_of_wp_inverted(struct device_node *np)
                 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 int __devinit sdhci_of_probe(struct platform_device *ofdev,
-                                 const struct of_device_id *match)
+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 = match->data;
+        struct sdhci_of_data *sdhci_of_data;
         struct sdhci_host *host;
         struct sdhci_of_host *of_host;
-        const u32 *clk;
+        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;
 
@@ -166,7 +181,7 @@ static int __devinit sdhci_of_probe(struct platform_device *ofdev,
 
         clk = of_get_property(np, "clock-frequency", &size);
         if (clk && size == sizeof(*clk) && *clk)
-                of_host->clock = *clk;
+                of_host->clock = be32_to_cpup(clk);
 
         ret = sdhci_add_host(host);
         if (ret)
@@ -208,7 +223,7 @@ static const struct of_device_id sdhci_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, sdhci_of_match);
 
-static struct of_platform_driver sdhci_of_driver = {
+static struct platform_driver sdhci_of_driver = {
         .driver = {
                 .name = "sdhci-of",
                 .owner = THIS_MODULE,
@@ -222,13 +237,13 @@ static struct of_platform_driver sdhci_of_driver = {
 
 static int __init sdhci_of_init(void)
 {
-        return of_register_platform_driver(&sdhci_of_driver);
+        return platform_driver_register(&sdhci_of_driver);
 }
 module_init(sdhci_of_init);
 
 static void __exit sdhci_of_exit(void)
 {
-        of_unregister_platform_driver(&sdhci_of_driver);
+        platform_driver_unregister(&sdhci_of_driver);
 }
 module_exit(sdhci_of_exit);
 
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index c8623de13af3..ba40d6d035c7 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -18,23 +18,7 @@
 #include <linux/mmc/host.h>
 #include "sdhci-of.h"
 #include "sdhci.h"
-
-/*
- * Ops and quirks for the Freescale eSDHC controller.
- */
-
-#define ESDHC_DMA_SYSCTL        0x40c
-#define ESDHC_DMA_SNOOP         0x00000040
-
-#define ESDHC_SYSTEM_CONTROL    0x2c
-#define ESDHC_CLOCK_MASK        0x0000fff0
-#define ESDHC_PREDIV_SHIFT      8
-#define ESDHC_DIVIDER_SHIFT     4
-#define ESDHC_CLOCK_PEREN       0x00000004
-#define ESDHC_CLOCK_HCKEN       0x00000002
-#define ESDHC_CLOCK_IPGEN       0x00000001
-
-#define ESDHC_HOST_CONTROL_RES  0x05
+#include "sdhci-esdhc.h"
 
 static u16 esdhc_readw(struct sdhci_host *host, int reg)
 {
@@ -68,51 +52,20 @@ static void esdhc_writeb(struct sdhci_host *host, u8 val, int reg)
         sdhci_be32bs_writeb(host, val, reg);
 }
 
-static void esdhc_set_clock(struct sdhci_host *host, unsigned int clock)
-{
-        int pre_div = 2;
-        int div = 1;
-
-        clrbits32(host->ioaddr + ESDHC_SYSTEM_CONTROL, ESDHC_CLOCK_IPGEN |
-                  ESDHC_CLOCK_HCKEN | ESDHC_CLOCK_PEREN | ESDHC_CLOCK_MASK);
-
-        if (clock == 0)
-                goto out;
-
-        while (host->max_clk / pre_div / 16 > clock && pre_div < 256)
-                pre_div *= 2;
-
-        while (host->max_clk / pre_div / div > clock && div < 16)
-                div++;
-
-        dev_dbg(mmc_dev(host->mmc), "desired SD clock: %d, actual: %d\n",
-                clock, host->max_clk / pre_div / div);
-
-        pre_div >>= 1;
-        div--;
-
-        setbits32(host->ioaddr + ESDHC_SYSTEM_CONTROL, ESDHC_CLOCK_IPGEN |
-                  ESDHC_CLOCK_HCKEN | ESDHC_CLOCK_PEREN |
-                  div << ESDHC_DIVIDER_SHIFT | pre_div << ESDHC_PREDIV_SHIFT);
-        mdelay(100);
-out:
-        host->clock = clock;
-}
-
-static int esdhc_enable_dma(struct sdhci_host *host)
+static int esdhc_of_enable_dma(struct sdhci_host *host)
 {
         setbits32(host->ioaddr + ESDHC_DMA_SYSCTL, ESDHC_DMA_SNOOP);
         return 0;
 }
 
-static unsigned int esdhc_get_max_clock(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);
 
         return of_host->clock;
 }
 
-static unsigned int esdhc_get_min_clock(struct sdhci_host *host)
+static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host)
 {
         struct sdhci_of_host *of_host = sdhci_priv(host);
 
@@ -120,14 +73,9 @@ static unsigned int esdhc_get_min_clock(struct sdhci_host *host)
 }
 
 struct sdhci_of_data sdhci_esdhc = {
-        .quirks = SDHCI_QUIRK_FORCE_BLK_SZ_2048 |
-                  SDHCI_QUIRK_BROKEN_CARD_DETECTION |
-                  SDHCI_QUIRK_NO_BUSY_IRQ |
-                  SDHCI_QUIRK_NONSTANDARD_CLOCK |
-                  SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
-                  SDHCI_QUIRK_PIO_NEEDS_DELAY |
-                  SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET |
-                  SDHCI_QUIRK_NO_CARD_NO_RESET,
+        /* 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,
@@ -136,8 +84,8 @@ struct sdhci_of_data sdhci_esdhc = {
                 .write_w = esdhc_writew,
                 .write_b = esdhc_writeb,
                 .set_clock = esdhc_set_clock,
-                .enable_dma = esdhc_enable_dma,
-                .get_max_clock = esdhc_get_max_clock,
-                .get_min_clock = esdhc_get_min_clock,
+                .enable_dma = esdhc_of_enable_dma,
+                .get_max_clock = esdhc_of_get_max_clock,
+                .get_min_clock = esdhc_of_get_min_clock,
         },
 };
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index e8aa99deae9a..936bbca19c0a 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -18,11 +18,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 #include <linux/device.h>
-
 #include <linux/mmc/host.h>
-
-#include <asm/scatterlist.h>
-#include <asm/io.h>
+#include <linux/scatterlist.h>
+#include <linux/io.h>
 
 #include "sdhci.h"
 
@@ -46,14 +44,14 @@ struct sdhci_pci_slot;
 struct sdhci_pci_fixes {
         unsigned int            quirks;
 
-        int                     (*probe)(struct sdhci_pci_chip*);
+        int                     (*probe) (struct sdhci_pci_chip *);
 
-        int                     (*probe_slot)(struct sdhci_pci_slot*);
-        void                    (*remove_slot)(struct sdhci_pci_slot*, int);
+        int                     (*probe_slot) (struct sdhci_pci_slot *);
+        void                    (*remove_slot) (struct sdhci_pci_slot *, int);
 
-        int                     (*suspend)(struct sdhci_pci_chip*,
+        int                     (*suspend) (struct sdhci_pci_chip *,
                                         pm_message_t);
-        int                     (*resume)(struct sdhci_pci_chip*);
+        int                     (*resume) (struct sdhci_pci_chip *);
 };
 
 struct sdhci_pci_slot {
@@ -145,6 +143,105 @@ static const struct sdhci_pci_fixes sdhci_cafe = {
                           SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
 };
 
+/*
+ * ADMA operation is disabled for Moorestown platform due to
+ * hardware bugs.
+ */
+static int mrst_hc_probe(struct sdhci_pci_chip *chip)
+{
+        /*
+         * slots number is fixed here for MRST as SDIO3/5 are never used and
+         * have hardware bugs.
+         */
+        chip->num_slots = 1;
+        return 0;
+}
+
+static const struct sdhci_pci_fixes sdhci_intel_mrst_hc0 = {
+        .quirks         = SDHCI_QUIRK_BROKEN_ADMA | SDHCI_QUIRK_NO_HISPD_BIT,
+};
+
+static const struct sdhci_pci_fixes sdhci_intel_mrst_hc1_hc2 = {
+        .quirks         = SDHCI_QUIRK_BROKEN_ADMA | SDHCI_QUIRK_NO_HISPD_BIT,
+        .probe          = mrst_hc_probe,
+};
+
+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 = {
+        .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
+};
+
+/* O2Micro extra registers */
+#define O2_SD_LOCK_WP           0xD3
+#define O2_SD_MULTI_VCC3V       0xEE
+#define O2_SD_CLKREQ            0xEC
+#define O2_SD_CAPS              0xE0
+#define O2_SD_ADMA1             0xE2
+#define O2_SD_ADMA2             0xE7
+#define O2_SD_INF_MOD           0xF1
+
+static int o2_probe(struct sdhci_pci_chip *chip)
+{
+        int ret;
+        u8 scratch;
+
+        switch (chip->pdev->device) {
+        case PCI_DEVICE_ID_O2_8220:
+        case PCI_DEVICE_ID_O2_8221:
+        case PCI_DEVICE_ID_O2_8320:
+        case PCI_DEVICE_ID_O2_8321:
+                /* This extra setup is required due to broken ADMA. */
+                ret = pci_read_config_byte(chip->pdev, O2_SD_LOCK_WP, &scratch);
+                if (ret)
+                        return ret;
+                scratch &= 0x7f;
+                pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
+
+                /* Set Multi 3 to VCC3V# */
+                pci_write_config_byte(chip->pdev, O2_SD_MULTI_VCC3V, 0x08);
+
+                /* Disable CLK_REQ# support after media DET */
+                ret = pci_read_config_byte(chip->pdev, O2_SD_CLKREQ, &scratch);
+                if (ret)
+                        return ret;
+                scratch |= 0x20;
+                pci_write_config_byte(chip->pdev, O2_SD_CLKREQ, scratch);
+
+                /* Choose capabilities, enable SDMA.  We have to write 0x01
+                 * to the capabilities register first to unlock it.
+                 */
+                ret = pci_read_config_byte(chip->pdev, O2_SD_CAPS, &scratch);
+                if (ret)
+                        return ret;
+                scratch |= 0x01;
+                pci_write_config_byte(chip->pdev, O2_SD_CAPS, scratch);
+                pci_write_config_byte(chip->pdev, O2_SD_CAPS, 0x73);
+
+                /* Disable ADMA1/2 */
+                pci_write_config_byte(chip->pdev, O2_SD_ADMA1, 0x39);
+                pci_write_config_byte(chip->pdev, O2_SD_ADMA2, 0x08);
+
+                /* Disable the infinite transfer mode */
+                ret = pci_read_config_byte(chip->pdev, O2_SD_INF_MOD, &scratch);
+                if (ret)
+                        return ret;
+                scratch |= 0x08;
+                pci_write_config_byte(chip->pdev, O2_SD_INF_MOD, scratch);
+
+                /* Lock WP */
+                ret = pci_read_config_byte(chip->pdev, O2_SD_LOCK_WP, &scratch);
+                if (ret)
+                        return ret;
+                scratch |= 0x80;
+                pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
+        }
+
+        return 0;
+}
+
 static int jmicron_pmos(struct sdhci_pci_chip *chip, int on)
 {
         u8 scratch;
@@ -173,6 +270,7 @@ static int jmicron_pmos(struct sdhci_pci_chip *chip, int on)
 static int jmicron_probe(struct sdhci_pci_chip *chip)
 {
         int ret;
+        u16 mmcdev = 0;
 
         if (chip->pdev->revision == 0) {
                 chip->quirks |= SDHCI_QUIRK_32BIT_DMA_ADDR |
@@ -194,12 +292,17 @@ static int jmicron_probe(struct sdhci_pci_chip *chip)
          * 2. The MMC interface has a lower subfunction number
          *    than the SD interface.
          */
-        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_SD) {
+        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_SD)
+                mmcdev = PCI_DEVICE_ID_JMICRON_JMB38X_MMC;
+        else if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_SD)
+                mmcdev = PCI_DEVICE_ID_JMICRON_JMB388_ESD;
+
+        if (mmcdev) {
                 struct pci_dev *sd_dev;
 
                 sd_dev = NULL;
                 while ((sd_dev = pci_get_device(PCI_VENDOR_ID_JMICRON,
-                        PCI_DEVICE_ID_JMICRON_JMB38X_MMC, sd_dev)) != NULL) {
+                                                mmcdev, sd_dev)) != NULL) {
                         if ((PCI_SLOT(chip->pdev->devfn) ==
                                 PCI_SLOT(sd_dev->devfn)) &&
                                 (chip->pdev->bus == sd_dev->bus))
@@ -224,6 +327,11 @@ static int jmicron_probe(struct sdhci_pci_chip *chip)
                 return ret;
         }
 
+        /* quirk for unsable RO-detection on JM388 chips */
+        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_SD ||
+            chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD)
+                chip->quirks |= SDHCI_QUIRK_UNSTABLE_RO_DETECT;
+
         return 0;
 }
 
@@ -259,13 +367,25 @@ static int jmicron_probe_slot(struct sdhci_pci_slot *slot)
                         slot->host->quirks |= SDHCI_QUIRK_BROKEN_ADMA;
         }
 
+        /* JM388 MMC doesn't support 1.8V while SD supports it */
+        if (slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD) {
+                slot->host->ocr_avail_sd = MMC_VDD_32_33 | MMC_VDD_33_34 |
+                        MMC_VDD_29_30 | MMC_VDD_30_31 |
+                        MMC_VDD_165_195; /* allow 1.8V */
+                slot->host->ocr_avail_mmc = MMC_VDD_32_33 | MMC_VDD_33_34 |
+                        MMC_VDD_29_30 | MMC_VDD_30_31; /* no 1.8V for MMC */
+        }
+
         /*
          * The secondary interface requires a bit set to get the
          * interrupts.
          */
-        if (slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC)
+        if (slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC ||
+            slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD)
                 jmicron_enable_mmc(slot->host, 1);
 
+        slot->host->mmc->caps |= MMC_CAP_BUS_WIDTH_TEST;
+
         return 0;
 }
 
@@ -274,7 +394,8 @@ static void jmicron_remove_slot(struct sdhci_pci_slot *slot, int dead)
         if (dead)
                 return;
 
-        if (slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC)
+        if (slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC ||
+            slot->chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD)
                 jmicron_enable_mmc(slot->host, 0);
 }
 
@@ -282,8 +403,9 @@ static int jmicron_suspend(struct sdhci_pci_chip *chip, pm_message_t state)
 {
         int i;
 
-        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC) {
-                for (i = 0;i < chip->num_slots;i++)
+        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC ||
+            chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD) {
+                for (i = 0; i < chip->num_slots; i++)
                         jmicron_enable_mmc(chip->slots[i]->host, 0);
         }
 
@@ -294,8 +416,9 @@ static int jmicron_resume(struct sdhci_pci_chip *chip)
 {
         int ret, i;
 
-        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC) {
-                for (i = 0;i < chip->num_slots;i++)
+        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC ||
+            chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB388_ESD) {
+                for (i = 0; i < chip->num_slots; i++)
                         jmicron_enable_mmc(chip->slots[i]->host, 1);
         }
 
@@ -308,6 +431,10 @@ static int jmicron_resume(struct sdhci_pci_chip *chip)
         return 0;
 }
 
+static const struct sdhci_pci_fixes sdhci_o2 = {
+        .probe          = o2_probe,
+};
+
 static const struct sdhci_pci_fixes sdhci_jmicron = {
         .probe          = jmicron_probe,
 
@@ -423,6 +550,14 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
         },
 
         {
+                .vendor         = PCI_VENDOR_ID_RICOH,
+                .device         = 0xe823,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_ricoh_mmc,
+        },
+
+        {
                 .vendor         = PCI_VENDOR_ID_ENE,
                 .device         = PCI_DEVICE_ID_ENE_CB712_SD,
                 .subvendor      = PCI_ANY_ID,
@@ -479,6 +614,22 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
         },
 
         {
+                .vendor         = PCI_VENDOR_ID_JMICRON,
+                .device         = PCI_DEVICE_ID_JMICRON_JMB388_SD,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_jmicron,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_JMICRON,
+                .device         = PCI_DEVICE_ID_JMICRON_JMB388_ESD,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_jmicron,
+        },
+
+        {
                 .vendor         = PCI_VENDOR_ID_SYSKONNECT,
                 .device         = 0x8000,
                 .subvendor      = PCI_ANY_ID,
@@ -494,6 +645,110 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .driver_data    = (kernel_ulong_t)&sdhci_via,
         },
 
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_MRST_SD0,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mrst_hc0,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_MRST_SD1,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mrst_hc1_hc2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_MRST_SD2,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mrst_hc1_hc2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_MFD_SD,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_mfd_sd,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .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,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .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,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .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,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .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,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_O2,
+                .device         = PCI_DEVICE_ID_O2_8120,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_o2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_O2,
+                .device         = PCI_DEVICE_ID_O2_8220,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_o2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_O2,
+                .device         = PCI_DEVICE_ID_O2_8221,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_o2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_O2,
+                .device         = PCI_DEVICE_ID_O2_8320,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_o2,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_O2,
+                .device         = PCI_DEVICE_ID_O2_8321,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_o2,
+        },
+
         {       /* Generic SD host controller */
                 PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)
         },
@@ -546,10 +801,11 @@ static struct sdhci_ops sdhci_pci_ops = {
 
 #ifdef CONFIG_PM
 
-static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
+static int sdhci_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 {
         struct sdhci_pci_chip *chip;
         struct sdhci_pci_slot *slot;
+        mmc_pm_flag_t slot_pm_flags;
         mmc_pm_flag_t pm_flags = 0;
         int i, ret;
 
@@ -557,7 +813,7 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
         if (!chip)
                 return 0;
 
-        for (i = 0;i < chip->num_slots;i++) {
+        for (i = 0; i < chip->num_slots; i++) {
                 slot = chip->slots[i];
                 if (!slot)
                         continue;
@@ -565,18 +821,22 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
                 ret = sdhci_suspend_host(slot->host, state);
 
                 if (ret) {
-                        for (i--;i >= 0;i--)
+                        for (i--; i >= 0; i--)
                                 sdhci_resume_host(chip->slots[i]->host);
                         return ret;
                 }
 
-                pm_flags |= slot->host->mmc->pm_flags;
+                slot_pm_flags = slot->host->mmc->pm_flags;
+                if (slot_pm_flags & MMC_PM_WAKE_SDIO_IRQ)
+                        sdhci_enable_irq_wakeups(slot->host);
+
+                pm_flags |= slot_pm_flags;
         }
 
         if (chip->fixes && chip->fixes->suspend) {
                 ret = chip->fixes->suspend(chip, state);
                 if (ret) {
-                        for (i = chip->num_slots - 1;i >= 0;i--)
+                        for (i = chip->num_slots - 1; i >= 0; i--)
                                 sdhci_resume_host(chip->slots[i]->host);
                         return ret;
                 }
@@ -584,8 +844,10 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
 
         pci_save_state(pdev);
         if (pm_flags & MMC_PM_KEEP_POWER) {
-                if (pm_flags & MMC_PM_WAKE_SDIO_IRQ)
+                if (pm_flags & MMC_PM_WAKE_SDIO_IRQ) {
+                        pci_pme_active(pdev, true);
                         pci_enable_wake(pdev, PCI_D3hot, 1);
+                }
                 pci_set_power_state(pdev, PCI_D3hot);
         } else {
                 pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
@@ -596,7 +858,7 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
         return 0;
 }
 
-static int sdhci_pci_resume (struct pci_dev *pdev)
+static int sdhci_pci_resume(struct pci_dev *pdev)
 {
         struct sdhci_pci_chip *chip;
         struct sdhci_pci_slot *slot;
@@ -618,7 +880,7 @@ static int sdhci_pci_resume (struct pci_dev *pdev)
                         return ret;
         }
 
-        for (i = 0;i < chip->num_slots;i++) {
+        for (i = 0; i < chip->num_slots; i++) {
                 slot = chip->slots[i];
                 if (!slot)
                         continue;
@@ -649,9 +911,6 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
 {
         struct sdhci_pci_slot *slot;
         struct sdhci_host *host;
-
-        resource_size_t addr;
-
         int ret;
 
         if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
@@ -698,10 +957,10 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
                 goto free;
         }
 
-        addr = pci_resource_start(pdev, bar);
         host->ioaddr = pci_ioremap_bar(pdev, bar);
         if (!host->ioaddr) {
                 dev_err(&pdev->dev, "failed to remap registers\n");
+                ret = -ENOMEM;
                 goto release;
         }
 
@@ -761,16 +1020,14 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
         struct sdhci_pci_chip *chip;
         struct sdhci_pci_slot *slot;
 
-        u8 slots, rev, first_bar;
+        u8 slots, first_bar;
         int ret, i;
 
         BUG_ON(pdev == NULL);
         BUG_ON(ent == NULL);
 
-        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &rev);
-
         dev_info(&pdev->dev, "SDHCI controller found [%04x:%04x] (rev %x)\n",
-                 (int)pdev->vendor, (int)pdev->device, (int)rev);
+                 (int)pdev->vendor, (int)pdev->device, (int)pdev->revision);
 
         ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
         if (ret)
@@ -805,7 +1062,7 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
         }
 
         chip->pdev = pdev;
-        chip->fixes = (const struct sdhci_pci_fixes*)ent->driver_data;
+        chip->fixes = (const struct sdhci_pci_fixes *)ent->driver_data;
         if (chip->fixes)
                 chip->quirks = chip->fixes->quirks;
         chip->num_slots = slots;
@@ -818,10 +1075,12 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
                         goto free;
         }
 
-        for (i = 0;i < slots;i++) {
+        slots = chip->num_slots;        /* Quirk may have changed this */
+
+        for (i = 0; i < slots; i++) {
                 slot = sdhci_pci_probe_slot(pdev, chip, first_bar + i);
                 if (IS_ERR(slot)) {
-                        for (i--;i >= 0;i--)
+                        for (i--; i >= 0; i--)
                                 sdhci_pci_remove_slot(chip->slots[i]);
                         ret = PTR_ERR(slot);
                         goto free;
@@ -849,7 +1108,7 @@ static void __devexit sdhci_pci_remove(struct pci_dev *pdev)
         chip = pci_get_drvdata(pdev);
 
         if (chip) {
-                for (i = 0;i < chip->num_slots; i++)
+                for (i = 0; i < chip->num_slots; i++)
                         sdhci_pci_remove_slot(chip->slots[i]);
 
                 pci_set_drvdata(pdev, NULL);
@@ -860,9 +1119,9 @@ static void __devexit sdhci_pci_remove(struct pci_dev *pdev)
 }
 
 static struct pci_driver sdhci_driver = {
-        .name =         "sdhci-pci",
+        .name =         "sdhci-pci",
         .id_table =     pci_ids,
-        .probe =        sdhci_pci_probe,
+        .probe =        sdhci_pci_probe,
         .remove =       __devexit_p(sdhci_pci_remove),
         .suspend =      sdhci_pci_suspend,
         .resume =       sdhci_pci_resume,
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index e045e3c61dde..dbab0407f4b6 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -30,7 +30,7 @@
 #include <linux/mmc/host.h>
 
 #include <linux/io.h>
-#include <linux/sdhci-pltfm.h>
+#include <linux/mmc/sdhci-pltfm.h>
 
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
@@ -52,14 +52,17 @@ static struct sdhci_ops sdhci_pltfm_ops = {
 
 static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
 {
-        struct sdhci_pltfm_data *pdata = pdev->dev.platform_data;
         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 resource *iomem;
         int ret;
 
-        if (!pdata && platid && platid->driver_data)
+        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) {
@@ -71,16 +74,19 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Invalid iomem size. You may "
                         "experience problems.\n");
 
-        if (pdev->dev.parent)
-                host = sdhci_alloc_host(pdev->dev.parent, 0);
+        /* Some PCI-based MFD need the parent here */
+        if (pdev->dev.parent != &platform_bus)
+                host = sdhci_alloc_host(pdev->dev.parent, sizeof(*pltfm_host));
         else
-                host = sdhci_alloc_host(&pdev->dev, 0);
+                host = sdhci_alloc_host(&pdev->dev, sizeof(*pltfm_host));
 
         if (IS_ERR(host)) {
                 ret = PTR_ERR(host);
                 goto err;
         }
 
+        pltfm_host = sdhci_priv(host);
+
         host->hw_name = "platform";
         if (pdata && pdata->ops)
                 host->ops = pdata->ops;
@@ -105,7 +111,7 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
         }
 
         if (pdata && pdata->init) {
-                ret = pdata->init(host);
+                ret = pdata->init(host, pdata);
                 if (ret)
                         goto err_plat_init;
         }
@@ -161,10 +167,38 @@ static const struct platform_device_id sdhci_pltfm_ids[] = {
 #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);
 
+#ifdef CONFIG_PM
+static int sdhci_pltfm_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_pltfm_resume(struct platform_device *dev)
+{
+        struct sdhci_host *host = platform_get_drvdata(dev);
+
+        return sdhci_resume_host(host);
+}
+#else
+#define sdhci_pltfm_suspend     NULL
+#define sdhci_pltfm_resume      NULL
+#endif  /* CONFIG_PM */
+
 static struct platform_driver sdhci_pltfm_driver = {
         .driver = {
                 .name   = "sdhci",
@@ -173,6 +207,8 @@ static struct platform_driver sdhci_pltfm_driver = {
         .probe          = sdhci_pltfm_probe,
         .remove         = __devexit_p(sdhci_pltfm_remove),
         .id_table       = sdhci_pltfm_ids,
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
 };
 
 /*****************************************************************************\
diff --git a/drivers/mmc/host/sdhci-pltfm.h b/drivers/mmc/host/sdhci-pltfm.h
index 900f32902f73..2b37016ad0ac 100644
--- a/drivers/mmc/host/sdhci-pltfm.h
+++ b/drivers/mmc/host/sdhci-pltfm.h
@@ -11,8 +11,18 @@
 #ifndef _DRIVERS_MMC_SDHCI_PLTFM_H
 #define _DRIVERS_MMC_SDHCI_PLTFM_H
 
-#include <linux/sdhci-pltfm.h>
+#include <linux/clk.h>
+#include <linux/types.h>
+#include <linux/mmc/sdhci-pltfm.h>
+
+struct sdhci_pltfm_host {
+        struct clk *clk;
+        void *priv; /* to handle quirks across io-accessor calls */
+};
 
 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;
 
 #endif /* _DRIVERS_MMC_SDHCI_PLTFM_H */
diff --git a/drivers/mmc/host/sdhci-pxa.c b/drivers/mmc/host/sdhci-pxa.c
new file mode 100644
index 000000000000..089c9a68b7b1
--- /dev/null
+++ b/drivers/mmc/host/sdhci-pxa.c
@@ -0,0 +1,303 @@
+/* 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-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index aacb862ecc8a..69e3ee321eb5 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -130,6 +130,15 @@ static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c *ourhost,
         if (!clksrc)
                 return UINT_MAX;
 
+        /*
+         * Clock divider's step is different as 1 from that of host controller
+         * when 'clk_type' is S3C_SDHCI_CLK_DIV_EXTERNAL.
+         */
+        if (ourhost->pdata->clk_type) {
+                rate = clk_round_rate(clksrc, wanted);
+                return wanted - rate;
+        }
+
         rate = clk_get_rate(clksrc);
 
         for (div = 1; div < 256; div *= 2) {
@@ -232,10 +241,79 @@ static unsigned int sdhci_s3c_get_min_clock(struct sdhci_host *host)
         return min;
 }
 
+/* sdhci_cmu_get_max_clk - callback to get maximum clock frequency.*/
+static unsigned int sdhci_cmu_get_max_clock(struct sdhci_host *host)
+{
+        struct sdhci_s3c *ourhost = to_s3c(host);
+
+        return clk_round_rate(ourhost->clk_bus[ourhost->cur_clk], UINT_MAX);
+}
+
+/* sdhci_cmu_get_min_clock - callback to get minimal supported clock value. */
+static unsigned int sdhci_cmu_get_min_clock(struct sdhci_host *host)
+{
+        struct sdhci_s3c *ourhost = to_s3c(host);
+
+        /*
+         * initial clock can be in the frequency range of
+         * 100KHz-400KHz, so we set it as max value.
+         */
+        return clk_round_rate(ourhost->clk_bus[ourhost->cur_clk], 400000);
+}
+
+/* sdhci_cmu_set_clock - callback on clock change.*/
+static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
+{
+        struct sdhci_s3c *ourhost = to_s3c(host);
+
+        /* don't bother if the clock is going off */
+        if (clock == 0)
+                return;
+
+        sdhci_s3c_set_clock(host, clock);
+
+        clk_set_rate(ourhost->clk_bus[ourhost->cur_clk], clock);
+
+        host->clock = clock;
+}
+
+/**
+ * sdhci_s3c_platform_8bit_width - support 8bit buswidth
+ * @host: The SDHCI host being queried
+ * @width: MMC_BUS_WIDTH_ macro for the bus width being requested
+ *
+ * We have 8-bit width support but is not a v3 controller.
+ * So we add platform_8bit_width() and support 8bit width.
+ */
+static int sdhci_s3c_platform_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:
+                break;
+        }
+
+        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+
+        return 0;
+}
+
 static struct sdhci_ops sdhci_s3c_ops = {
         .get_max_clock          = sdhci_s3c_get_max_clk,
         .set_clock              = sdhci_s3c_set_clock,
         .get_min_clock          = sdhci_s3c_get_min_clock,
+        .platform_8bit_width    = sdhci_s3c_platform_8bit_width,
 };
 
 static void sdhci_s3c_notify_change(struct platform_device *dev, int state)
@@ -361,6 +439,13 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
                 clks++;
                 sc->clk_bus[ptr] = clk;
+
+                /*
+                 * save current clock index to know which clock bus
+                 * is used later in overriding functions.
+                 */
+                sc->cur_clk = ptr;
+
                 clk_enable(clk);
 
                 dev_info(dev, "clock source %d: %s (%ld Hz)\n",
@@ -414,6 +499,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
          * SDHCI block, or a missing configuration that needs to be set. */
         host->quirks |= SDHCI_QUIRK_NO_BUSY_IRQ;
 
+        /* This host supports the Auto CMD12 */
+        host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
+
         if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
             pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
@@ -421,12 +509,29 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->mmc->caps = MMC_CAP_NONREMOVABLE;
 
+        if (pdata->host_caps)
+                host->mmc->caps |= pdata->host_caps;
+
         host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR |
                          SDHCI_QUIRK_32BIT_DMA_SIZE);
 
         /* HSMMC on Samsung SoCs uses SDCLK as timeout clock */
         host->quirks |= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK;
 
+        /*
+         * If controller does not have internal clock divider,
+         * we can use overriding functions instead of default.
+         */
+        if (pdata->clk_type) {
+                sdhci_s3c_ops.set_clock = sdhci_cmu_set_clock;
+                sdhci_s3c_ops.get_min_clock = sdhci_cmu_get_min_clock;
+                sdhci_s3c_ops.get_max_clock = sdhci_cmu_get_max_clock;
+        }
+
+        /* It supports additional host capabilities if needed */
+        if (pdata->host_caps)
+                host->mmc->caps |= pdata->host_caps;
+
         ret = sdhci_add_host(host);
         if (ret) {
                 dev_err(dev, "sdhci_add_host() failed\n");
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index d70c54c7b70a..60a4c97d3d18 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -50,7 +50,7 @@ static irqreturn_t sdhci_gpio_irq(int irq, void *dev_id)
         /* val == 1 -> card removed, val == 0 -> card inserted */
         /* if card removed - set irq for low level, else vice versa */
         gpio_irq_type = val ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
-        set_irq_type(irq, gpio_irq_type);
+        irq_set_irq_type(irq, gpio_irq_type);
 
         if (sdhci->data->card_power_gpio >= 0) {
                 if (!sdhci->data->power_always_enb) {
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
new file mode 100644
index 000000000000..343c97edba32
--- /dev/null
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * 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 <mach/gpio.h>
+#include <mach/sdhci.h>
+
+#include "sdhci.h"
+#include "sdhci-pltfm.h"
+
+static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
+{
+        u32 val;
+
+        if (unlikely(reg == SDHCI_PRESENT_STATE)) {
+                /* Use wp_gpio here instead? */
+                val = readl(host->ioaddr + reg);
+                return val | SDHCI_WRITE_PROTECT;
+        }
+
+        return readl(host->ioaddr + reg);
+}
+
+static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
+{
+        if (unlikely(reg == SDHCI_HOST_VERSION)) {
+                /* Erratum: Version register is invalid in HW. */
+                return SDHCI_SPEC_200;
+        }
+
+        return readw(host->ioaddr + reg);
+}
+
+static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
+{
+        /* Seems like we're getting spurious timeout and crc errors, so
+         * disable signalling of them. In case of real errors software
+         * timers should take care of eventually detecting them.
+         */
+        if (unlikely(reg == SDHCI_SIGNAL_ENABLE))
+                val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC);
+
+        writel(val, host->ioaddr + reg);
+
+        if (unlikely(reg == SDHCI_INT_ENABLE)) {
+                /* Erratum: Must enable block gap interrupt detection */
+                u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
+                if (val & SDHCI_INT_CARD_INT)
+                        gap_ctrl |= 0x8;
+                else
+                        gap_ctrl &= ~0x8;
+                writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
+        }
+}
+
+static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
+{
+        struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
+        struct tegra_sdhci_platform_data *plat;
+
+        plat = pdev->dev.platform_data;
+
+        if (!gpio_is_valid(plat->wp_gpio))
+                return -1;
+
+        return gpio_get_value(plat->wp_gpio);
+}
+
+static irqreturn_t carddetect_irq(int irq, void *data)
+{
+        struct sdhci_host *sdhost = (struct sdhci_host *)data;
+
+        tasklet_schedule(&sdhost->card_tasklet);
+        return IRQ_HANDLED;
+};
+
+static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
+{
+        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct tegra_sdhci_platform_data *plat;
+        u32 ctrl;
+
+        plat = pdev->dev.platform_data;
+
+        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
+        if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                ctrl |= SDHCI_CTRL_8BITBUS;
+        } else {
+                ctrl &= ~SDHCI_CTRL_8BITBUS;
+                if (bus_width == MMC_BUS_WIDTH_4)
+                        ctrl |= SDHCI_CTRL_4BITBUS;
+                else
+                        ctrl &= ~SDHCI_CTRL_4BITBUS;
+        }
+        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+        return 0;
+}
+
+
+static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
+                                  struct sdhci_pltfm_data *pdata)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct tegra_sdhci_platform_data *plat;
+        struct clk *clk;
+        int rc;
+
+        plat = pdev->dev.platform_data;
+        if (plat == NULL) {
+                dev_err(mmc_dev(host->mmc), "missing platform data\n");
+                return -ENXIO;
+        }
+
+        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;
+                }
+                tegra_gpio_enable(plat->power_gpio);
+                gpio_direction_output(plat->power_gpio, 1);
+        }
+
+        if (gpio_is_valid(plat->cd_gpio)) {
+                rc = gpio_request(plat->cd_gpio, "sdhci_cd");
+                if (rc) {
+                        dev_err(mmc_dev(host->mmc),
+                                "failed to allocate cd gpio\n");
+                        goto out_power;
+                }
+                tegra_gpio_enable(plat->cd_gpio);
+                gpio_direction_input(plat->cd_gpio);
+
+                rc = request_irq(gpio_to_irq(plat->cd_gpio), 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;
+                }
+
+        }
+
+        if (gpio_is_valid(plat->wp_gpio)) {
+                rc = gpio_request(plat->wp_gpio, "sdhci_wp");
+                if (rc) {
+                        dev_err(mmc_dev(host->mmc),
+                                "failed to allocate wp gpio\n");
+                        goto out_irq;
+                }
+                tegra_gpio_enable(plat->wp_gpio);
+                gpio_direction_input(plat->wp_gpio);
+        }
+
+        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;
+        }
+        clk_enable(clk);
+        pltfm_host->clk = clk;
+
+        host->mmc->pm_caps = plat->pm_flags;
+
+        if (plat->is_8bit)
+                host->mmc->caps |= MMC_CAP_8_BIT_DATA;
+
+        return 0;
+
+out_wp:
+        if (gpio_is_valid(plat->wp_gpio)) {
+                tegra_gpio_disable(plat->wp_gpio);
+                gpio_free(plat->wp_gpio);
+        }
+
+out_irq:
+        if (gpio_is_valid(plat->cd_gpio))
+                free_irq(gpio_to_irq(plat->cd_gpio), host);
+out_cd:
+        if (gpio_is_valid(plat->cd_gpio)) {
+                tegra_gpio_disable(plat->cd_gpio);
+                gpio_free(plat->cd_gpio);
+        }
+
+out_power:
+        if (gpio_is_valid(plat->power_gpio)) {
+                tegra_gpio_disable(plat->power_gpio);
+                gpio_free(plat->power_gpio);
+        }
+
+out:
+        return rc;
+}
+
+static void tegra_sdhci_pltfm_exit(struct sdhci_host *host)
+{
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+        struct tegra_sdhci_platform_data *plat;
+
+        plat = pdev->dev.platform_data;
+
+        if (gpio_is_valid(plat->wp_gpio)) {
+                tegra_gpio_disable(plat->wp_gpio);
+                gpio_free(plat->wp_gpio);
+        }
+
+        if (gpio_is_valid(plat->cd_gpio)) {
+                free_irq(gpio_to_irq(plat->cd_gpio), host);
+                tegra_gpio_disable(plat->cd_gpio);
+                gpio_free(plat->cd_gpio);
+        }
+
+        if (gpio_is_valid(plat->power_gpio)) {
+                tegra_gpio_disable(plat->power_gpio);
+                gpio_free(plat->power_gpio);
+        }
+
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+}
+
+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,
+};
+
+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,
+};
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 401527d273b5..58d5436ff649 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -23,6 +23,7 @@
 
 #include <linux/leds.h>
 
+#include <linux/mmc/mmc.h>
 #include <linux/mmc/host.h>
 
 #include "sdhci.h"
@@ -37,17 +38,21 @@
 #define SDHCI_USE_LEDS_CLASS
 #endif
 
+#define MAX_TUNING_LOOP 40
+
 static unsigned int debug_quirks = 0;
 
-static void sdhci_prepare_data(struct sdhci_host *, struct mmc_data *);
 static void sdhci_finish_data(struct sdhci_host *);
 
 static void sdhci_send_command(struct sdhci_host *, struct mmc_command *);
 static void sdhci_finish_command(struct sdhci_host *);
+static int sdhci_execute_tuning(struct mmc_host *mmc);
+static void sdhci_tuning_timer(unsigned long data);
 
 static void sdhci_dumpregs(struct sdhci_host *host)
 {
-        printk(KERN_DEBUG DRIVER_NAME ": ============== REGISTER DUMP ==============\n");
+        printk(KERN_DEBUG DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
+                mmc_hostname(host->mmc));
 
         printk(KERN_DEBUG DRIVER_NAME ": Sys addr: 0x%08x | Version:  0x%08x\n",
                 sdhci_readl(host, SDHCI_DMA_ADDRESS),
@@ -76,9 +81,14 @@ static void sdhci_dumpregs(struct sdhci_host *host)
         printk(KERN_DEBUG DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n",
                 sdhci_readw(host, SDHCI_ACMD12_ERR),
                 sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
-        printk(KERN_DEBUG DRIVER_NAME ": Caps:     0x%08x | Max curr: 0x%08x\n",
+        printk(KERN_DEBUG DRIVER_NAME ": Caps:     0x%08x | Caps_1:   0x%08x\n",
                 sdhci_readl(host, SDHCI_CAPABILITIES),
+                sdhci_readl(host, SDHCI_CAPABILITIES_1));
+        printk(KERN_DEBUG DRIVER_NAME ": Cmd:      0x%08x | Max curr: 0x%08x\n",
+                sdhci_readw(host, SDHCI_COMMAND),
                 sdhci_readl(host, SDHCI_MAX_CURRENT));
+        printk(KERN_DEBUG DRIVER_NAME ": Host ctl2: 0x%08x\n",
+                sdhci_readw(host, SDHCI_HOST_CONTROL2));
 
         if (host->flags & SDHCI_USE_ADMA)
                 printk(KERN_DEBUG DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
@@ -152,6 +162,9 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
         if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
                 ier = sdhci_readl(host, SDHCI_INT_ENABLE);
 
+        if (host->ops->platform_reset_enter)
+                host->ops->platform_reset_enter(host, mask);
+
         sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
 
         if (mask & SDHCI_RESET_ALL)
@@ -172,6 +185,9 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
                 mdelay(1);
         }
 
+        if (host->ops->platform_reset_exit)
+                host->ops->platform_reset_exit(host, mask);
+
         if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
                 sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK, ier);
 }
@@ -586,9 +602,10 @@ static void sdhci_adma_table_post(struct sdhci_host *host,
                 data->sg_len, direction);
 }
 
-static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
+static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
 {
         u8 count;
+        struct mmc_data *data = cmd->data;
         unsigned target_timeout, current_timeout;
 
         /*
@@ -600,9 +617,16 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
         if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
                 return 0xE;
 
+        /* Unspecified timeout, assume max */
+        if (!data && !cmd->cmd_timeout_ms)
+                return 0xE;
+
         /* timeout in us */
-        target_timeout = data->timeout_ns / 1000 +
-                data->timeout_clks / host->clock;
+        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;
@@ -617,6 +641,7 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
          *     =>
          *     (1) / (2) > 2^6
          */
+        BUG_ON(!host->timeout_clk);
         count = 0;
         current_timeout = (1 << 13) * 1000 / host->timeout_clk;
         while (current_timeout < target_timeout) {
@@ -627,8 +652,8 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
         }
 
         if (count >= 0xF) {
-                printk(KERN_WARNING "%s: Too large timeout requested!\n",
-                        mmc_hostname(host->mmc));
+                printk(KERN_WARNING "%s: Too large timeout requested for CMD%d!\n",
+                       mmc_hostname(host->mmc), cmd->opcode);
                 count = 0xE;
         }
 
@@ -646,15 +671,21 @@ static void sdhci_set_transfer_irqs(struct sdhci_host *host)
                 sdhci_clear_set_irqs(host, dma_irqs, pio_irqs);
 }
 
-static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
+static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
 {
         u8 count;
         u8 ctrl;
+        struct mmc_data *data = cmd->data;
         int ret;
 
         WARN_ON(host->data);
 
-        if (data == NULL)
+        if (data || (cmd->flags & MMC_RSP_BUSY)) {
+                count = sdhci_calc_timeout(host, cmd);
+                sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
+        }
+
+        if (!data)
                 return;
 
         /* Sanity checks */
@@ -664,9 +695,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
 
         host->data = data;
         host->data_early = 0;
-
-        count = sdhci_calc_timeout(host, data);
-        sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
+        host->data->bytes_xfered = 0;
 
         if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))
                 host->flags |= SDHCI_REQ_USE_DMA;
@@ -802,15 +831,17 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
 
         sdhci_set_transfer_irqs(host);
 
-        /* We do not handle DMA boundaries, so set it to max (512 KiB) */
-        sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, data->blksz), SDHCI_BLOCK_SIZE);
+        /* Set the DMA boundary value and block size */
+        sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
+                data->blksz), SDHCI_BLOCK_SIZE);
         sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
 }
 
 static void sdhci_set_transfer_mode(struct sdhci_host *host,
-        struct mmc_data *data)
+        struct mmc_command *cmd)
 {
         u16 mode;
+        struct mmc_data *data = cmd->data;
 
         if (data == NULL)
                 return;
@@ -818,12 +849,20 @@ static void sdhci_set_transfer_mode(struct sdhci_host *host,
         WARN_ON(!host->data);
 
         mode = SDHCI_TRNS_BLK_CNT_EN;
-        if (data->blocks > 1) {
-                if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
-                        mode |= SDHCI_TRNS_MULTI | SDHCI_TRNS_ACMD12;
-                else
-                        mode |= SDHCI_TRNS_MULTI;
+        if (mmc_op_multi(cmd->opcode) || data->blocks > 1) {
+                mode |= SDHCI_TRNS_MULTI;
+                /*
+                 * If we are sending CMD23, CMD12 never gets sent
+                 * on successful completion (so no Auto-CMD12).
+                 */
+                if (!host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD12))
+                        mode |= SDHCI_TRNS_AUTO_CMD12;
+                else if (host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD23)) {
+                        mode |= SDHCI_TRNS_AUTO_CMD23;
+                        sdhci_writel(host, host->mrq->sbc->arg, SDHCI_ARGUMENT2);
+                }
         }
+
         if (data->flags & MMC_DATA_READ)
                 mode |= SDHCI_TRNS_READ;
         if (host->flags & SDHCI_REQ_USE_DMA)
@@ -863,7 +902,15 @@ static void sdhci_finish_data(struct sdhci_host *host)
         else
                 data->bytes_xfered = data->blksz * data->blocks;
 
-        if (data->stop) {
+        /*
+         * Need to send CMD12 if -
+         * a) open-ended multiblock transfer (no CMD23)
+         * b) error in multiblock transfer
+         */
+        if (data->stop &&
+            (data->error ||
+             !host->mrq->sbc)) {
+
                 /*
                  * The controller needs a reset of internal state machines
                  * upon error conditions.
@@ -915,11 +962,11 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
 
         host->cmd = cmd;
 
-        sdhci_prepare_data(host, cmd->data);
+        sdhci_prepare_data(host, cmd);
 
         sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
 
-        sdhci_set_transfer_mode(host, cmd->data);
+        sdhci_set_transfer_mode(host, cmd);
 
         if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
                 printk(KERN_ERR "%s: Unsupported response type!\n",
@@ -942,7 +989,9 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
                 flags |= SDHCI_CMD_CRC;
         if (cmd->flags & MMC_RSP_OPCODE)
                 flags |= SDHCI_CMD_INDEX;
-        if (cmd->data)
+
+        /* CMD19 is special in that the Data Present Select should be set */
+        if (cmd->data || (cmd->opcode == MMC_SEND_TUNING_BLOCK))
                 flags |= SDHCI_CMD_DATA;
 
         sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
@@ -972,19 +1021,27 @@ static void sdhci_finish_command(struct sdhci_host *host)
 
         host->cmd->error = 0;
 
-        if (host->data && host->data_early)
-                sdhci_finish_data(host);
+        /* Finished CMD23, now send actual command. */
+        if (host->cmd == host->mrq->sbc) {
+                host->cmd = NULL;
+                sdhci_send_command(host, host->mrq->cmd);
+        } else {
 
-        if (!host->cmd->data)
-                tasklet_schedule(&host->finish_tasklet);
+                /* Processed actual command. */
+                if (host->data && host->data_early)
+                        sdhci_finish_data(host);
 
-        host->cmd = NULL;
+                if (!host->cmd->data)
+                        tasklet_schedule(&host->finish_tasklet);
+
+                host->cmd = NULL;
+        }
 }
 
 static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
 {
-        int div;
-        u16 clk;
+        int div = 0; /* Initialized for compiler warning */
+        u16 clk = 0;
         unsigned long timeout;
 
         if (clock == host->clock)
@@ -1001,13 +1058,59 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
         if (clock == 0)
                 goto out;
 
-        for (div = 1;div < 256;div *= 2) {
-                if ((host->max_clk / div) <= clock)
-                        break;
+        if (host->version >= SDHCI_SPEC_300) {
+                /*
+                 * Check if the Host Controller supports Programmable Clock
+                 * Mode.
+                 */
+                if (host->clk_mul) {
+                        u16 ctrl;
+
+                        /*
+                         * We need to figure out whether the Host Driver needs
+                         * to select Programmable Clock Mode, or the value can
+                         * be set automatically by the Host Controller based on
+                         * the Preset Value registers.
+                         */
+                        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                        if (!(ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
+                                for (div = 1; div <= 1024; div++) {
+                                        if (((host->max_clk * host->clk_mul) /
+                                              div) <= clock)
+                                                break;
+                                }
+                                /*
+                                 * Set Programmable Clock Mode in the Clock
+                                 * Control register.
+                                 */
+                                clk = SDHCI_PROG_CLOCK_MODE;
+                                div--;
+                        }
+                } else {
+                        /* Version 3.00 divisors must be a multiple of 2. */
+                        if (host->max_clk <= clock)
+                                div = 1;
+                        else {
+                                for (div = 2; div < SDHCI_MAX_DIV_SPEC_300;
+                                     div += 2) {
+                                        if ((host->max_clk / div) <= clock)
+                                                break;
+                                }
+                        }
+                        div >>= 1;
+                }
+        } else {
+                /* Version 2.00 divisors must be a power of 2. */
+                for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
+                        if ((host->max_clk / div) <= clock)
+                                break;
+                }
+                div >>= 1;
         }
-        div >>= 1;
 
-        clk = div << SDHCI_DIVIDER_SHIFT;
+        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(host, clk, SDHCI_CLOCK_CONTROL);
 
@@ -1034,11 +1137,9 @@ out:
 
 static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
 {
-        u8 pwr;
+        u8 pwr = 0;
 
-        if (power == (unsigned short)-1)
-                pwr = 0;
-        else {
+        if (power != (unsigned short)-1) {
                 switch (1 << power) {
                 case MMC_VDD_165_195:
                         pwr = SDHCI_POWER_180;
@@ -1113,7 +1214,12 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 #ifndef SDHCI_USE_LEDS_CLASS
         sdhci_activate_led(host);
 #endif
-        if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12) {
+
+        /*
+         * Ensure we don't send the STOP for non-SET_BLOCK_COUNTED
+         * requests if Auto-CMD12 is enabled.
+         */
+        if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) {
                 if (mrq->stop) {
                         mrq->data->stop = NULL;
                         mrq->stop = NULL;
@@ -1132,8 +1238,30 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         if (!present || host->flags & SDHCI_DEVICE_DEAD) {
                 host->mrq->cmd->error = -ENOMEDIUM;
                 tasklet_schedule(&host->finish_tasklet);
-        } else
-                sdhci_send_command(host, mrq->cmd);
+        } else {
+                u32 present_state;
+
+                present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
+                /*
+                 * Check if the re-tuning timer has already expired and there
+                 * is no on-going data transfer. If so, we need to execute
+                 * tuning procedure before sending command.
+                 */
+                if ((host->flags & SDHCI_NEEDS_RETUNING) &&
+                    !(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ))) {
+                        spin_unlock_irqrestore(&host->lock, flags);
+                        sdhci_execute_tuning(mmc);
+                        spin_lock_irqsave(&host->lock, flags);
+
+                        /* Restore original mmc_request structure */
+                        host->mrq = mrq;
+                }
+
+                if (mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23))
+                        sdhci_send_command(host, mrq->sbc);
+                else
+                        sdhci_send_command(host, mrq->cmd);
+        }
 
         mmiowb();
         spin_unlock_irqrestore(&host->lock, flags);
@@ -1168,25 +1296,120 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         else
                 sdhci_set_power(host, ios->vdd);
 
-        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
+        if (host->ops->platform_send_init_74_clocks)
+                host->ops->platform_send_init_74_clocks(host, ios->power_mode);
 
-        if (ios->bus_width == MMC_BUS_WIDTH_8)
-                ctrl |= SDHCI_CTRL_8BITBUS;
-        else
-                ctrl &= ~SDHCI_CTRL_8BITBUS;
+        /*
+         * If your platform has 8-bit width support but is not a v3 controller,
+         * or if it requires special setup code, you should implement that in
+         * platform_8bit_width().
+         */
+        if (host->ops->platform_8bit_width)
+                host->ops->platform_8bit_width(host, ios->bus_width);
+        else {
+                ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
+                if (ios->bus_width == MMC_BUS_WIDTH_8) {
+                        ctrl &= ~SDHCI_CTRL_4BITBUS;
+                        if (host->version >= SDHCI_SPEC_300)
+                                ctrl |= SDHCI_CTRL_8BITBUS;
+                } else {
+                        if (host->version >= SDHCI_SPEC_300)
+                                ctrl &= ~SDHCI_CTRL_8BITBUS;
+                        if (ios->bus_width == MMC_BUS_WIDTH_4)
+                                ctrl |= SDHCI_CTRL_4BITBUS;
+                        else
+                                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                }
+                sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+        }
 
-        if (ios->bus_width == MMC_BUS_WIDTH_4)
-                ctrl |= SDHCI_CTRL_4BITBUS;
-        else
-                ctrl &= ~SDHCI_CTRL_4BITBUS;
+        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
 
-        if (ios->timing == MMC_TIMING_SD_HS &&
-            !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
+        if ((ios->timing == MMC_TIMING_SD_HS ||
+             ios->timing == MMC_TIMING_MMC_HS)
+            && !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
                 ctrl |= SDHCI_CTRL_HISPD;
         else
                 ctrl &= ~SDHCI_CTRL_HISPD;
 
-        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+        if (host->version >= SDHCI_SPEC_300) {
+                u16 clk, ctrl_2;
+                unsigned int clock;
+
+                /* In case of UHS-I modes, set High Speed Enable */
+                if ((ios->timing == MMC_TIMING_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))
+                        ctrl |= SDHCI_CTRL_HISPD;
+
+                ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                if (!(ctrl_2 & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
+                        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+                        /*
+                         * We only need to set Driver Strength if the
+                         * preset value enable is not set.
+                         */
+                        ctrl_2 &= ~SDHCI_CTRL_DRV_TYPE_MASK;
+                        if (ios->drv_type == MMC_SET_DRIVER_TYPE_A)
+                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_A;
+                        else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C)
+                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_C;
+
+                        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
+                } else {
+                        /*
+                         * According to SDHC Spec v3.00, if the Preset Value
+                         * Enable in the Host Control 2 register is set, we
+                         * need to reset SD Clock Enable before changing High
+                         * Speed Enable to avoid generating clock gliches.
+                         */
+
+                        /* Reset SD Clock Enable */
+                        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                        clk &= ~SDHCI_CLOCK_CARD_EN;
+                        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+
+                        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
+
+                        /* Re-enable SD Clock */
+                        clock = host->clock;
+                        host->clock = 0;
+                        sdhci_set_clock(host, clock);
+                }
+
+
+                /* Reset SD Clock Enable */
+                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                clk &= ~SDHCI_CLOCK_CARD_EN;
+                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+
+                if (host->ops->set_uhs_signaling)
+                        host->ops->set_uhs_signaling(host, ios->timing);
+                else {
+                        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                        /* Select Bus Speed Mode for host */
+                        ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
+                        if (ios->timing == MMC_TIMING_UHS_SDR12)
+                                ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
+                        else if (ios->timing == MMC_TIMING_UHS_SDR25)
+                                ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
+                        else if (ios->timing == MMC_TIMING_UHS_SDR50)
+                                ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
+                        else if (ios->timing == MMC_TIMING_UHS_SDR104)
+                                ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
+                        else if (ios->timing == MMC_TIMING_UHS_DDR50)
+                                ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
+                        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
+                }
+
+                /* Re-enable SD Clock */
+                clock = host->clock;
+                host->clock = 0;
+                sdhci_set_clock(host, clock);
+        } else
+                sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
         /*
          * Some (ENE) controllers go apeshit on some ios operation,
@@ -1201,26 +1424,49 @@ out:
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int sdhci_get_ro(struct mmc_host *mmc)
+static int check_ro(struct sdhci_host *host)
 {
-        struct sdhci_host *host;
         unsigned long flags;
-        int present;
-
-        host = mmc_priv(mmc);
+        int is_readonly;
 
         spin_lock_irqsave(&host->lock, flags);
 
         if (host->flags & SDHCI_DEVICE_DEAD)
-                present = 0;
+                is_readonly = 0;
+        else if (host->ops->get_ro)
+                is_readonly = host->ops->get_ro(host);
         else
-                present = sdhci_readl(host, SDHCI_PRESENT_STATE);
+                is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
+                                & SDHCI_WRITE_PROTECT);
 
         spin_unlock_irqrestore(&host->lock, flags);
 
-        if (host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT)
-                return !!(present & SDHCI_WRITE_PROTECT);
-        return !(present & SDHCI_WRITE_PROTECT);
+        /* This quirk needs to be replaced by a callback-function later */
+        return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
+                !is_readonly : is_readonly;
+}
+
+#define SAMPLE_COUNT    5
+
+static int sdhci_get_ro(struct mmc_host *mmc)
+{
+        struct sdhci_host *host;
+        int i, ro_count;
+
+        host = mmc_priv(mmc);
+
+        if (!(host->quirks & SDHCI_QUIRK_UNSTABLE_RO_DETECT))
+                return check_ro(host);
+
+        ro_count = 0;
+        for (i = 0; i < SAMPLE_COUNT; i++) {
+                if (check_ro(host)) {
+                        if (++ro_count > SAMPLE_COUNT / 2)
+                                return 1;
+                }
+                msleep(30);
+        }
+        return 0;
 }
 
 static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
@@ -1245,11 +1491,322 @@ out:
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
+        struct mmc_ios *ios)
+{
+        struct sdhci_host *host;
+        u8 pwr;
+        u16 clk, ctrl;
+        u32 present_state;
+
+        host = mmc_priv(mmc);
+
+        /*
+         * Signal Voltage Switching is only applicable for Host Controllers
+         * v3.00 and above.
+         */
+        if (host->version < SDHCI_SPEC_300)
+                return 0;
+
+        /*
+         * We first check whether the request is to set signalling voltage
+         * to 3.3V. If so, we change the voltage to 3.3V and return quickly.
+         */
+        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+        if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
+                /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+                ctrl &= ~SDHCI_CTRL_VDD_180;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+                /* Wait for 5ms */
+                usleep_range(5000, 5500);
+
+                /* 3.3V regulator output should be stable within 5 ms */
+                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                if (!(ctrl & SDHCI_CTRL_VDD_180))
+                        return 0;
+                else {
+                        printk(KERN_INFO DRIVER_NAME ": Switching to 3.3V "
+                                "signalling voltage failed\n");
+                        return -EIO;
+                }
+        } else if (!(ctrl & SDHCI_CTRL_VDD_180) &&
+                  (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180)) {
+                /* Stop SDCLK */
+                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                clk &= ~SDHCI_CLOCK_CARD_EN;
+                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+
+                /* Check whether DAT[3:0] is 0000 */
+                present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
+                if (!((present_state & SDHCI_DATA_LVL_MASK) >>
+                       SDHCI_DATA_LVL_SHIFT)) {
+                        /*
+                         * Enable 1.8V Signal Enable in the Host Control2
+                         * register
+                         */
+                        ctrl |= SDHCI_CTRL_VDD_180;
+                        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+                        /* 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*/
+                                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+                                clk |= SDHCI_CLOCK_CARD_EN;
+                                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+                                usleep_range(1000, 1500);
+
+                                /*
+                                 * If DAT[3:0] level is 1111b, then the card
+                                 * was successfully switched to 1.8V signaling.
+                                 */
+                                present_state = sdhci_readl(host,
+                                                        SDHCI_PRESENT_STATE);
+                                if ((present_state & SDHCI_DATA_LVL_MASK) ==
+                                     SDHCI_DATA_LVL_MASK)
+                                        return 0;
+                        }
+                }
+
+                /*
+                 * If we are here, that means the switch to 1.8V signaling
+                 * failed. We power cycle the card, and retry initialization
+                 * sequence by setting S18R to 0.
+                 */
+                pwr = sdhci_readb(host, SDHCI_POWER_CONTROL);
+                pwr &= ~SDHCI_POWER_ON;
+                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+
+                /* Wait for 1ms as per the spec */
+                usleep_range(1000, 1500);
+                pwr |= SDHCI_POWER_ON;
+                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+
+                printk(KERN_INFO DRIVER_NAME ": Switching to 1.8V signalling "
+                        "voltage failed, retrying with S18R set to 0\n");
+                return -EAGAIN;
+        } else
+                /* No signal voltage switch required */
+                return 0;
+}
+
+static int sdhci_execute_tuning(struct mmc_host *mmc)
+{
+        struct sdhci_host *host;
+        u16 ctrl;
+        u32 ier;
+        int tuning_loop_counter = MAX_TUNING_LOOP;
+        unsigned long timeout;
+        int err = 0;
+
+        host = mmc_priv(mmc);
+
+        disable_irq(host->irq);
+        spin_lock(&host->lock);
+
+        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+        /*
+         * Host Controller needs tuning only in case of SDR104 mode
+         * and for SDR50 mode when Use Tuning for SDR50 is set in
+         * Capabilities register.
+         */
+        if (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
+            (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
+            (host->flags & SDHCI_SDR50_NEEDS_TUNING)))
+                ctrl |= SDHCI_CTRL_EXEC_TUNING;
+        else {
+                spin_unlock(&host->lock);
+                enable_irq(host->irq);
+                return 0;
+        }
+
+        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+        /*
+         * As per the Host Controller spec v3.00, tuning command
+         * generates Buffer Read Ready interrupt, so enable that.
+         *
+         * Note: The spec clearly says that when tuning sequence
+         * is being performed, the controller does not generate
+         * interrupts other than Buffer Read Ready interrupt. But
+         * to make sure we don't hit a controller bug, we _only_
+         * enable Buffer Read Ready interrupt here.
+         */
+        ier = sdhci_readl(host, SDHCI_INT_ENABLE);
+        sdhci_clear_set_irqs(host, ier, SDHCI_INT_DATA_AVAIL);
+
+        /*
+         * Issue CMD19 repeatedly till Execute Tuning is set to 0 or the number
+         * of loops reaches 40 times or a timeout of 150ms occurs.
+         */
+        timeout = 150;
+        do {
+                struct mmc_command cmd = {0};
+                struct mmc_request mrq = {0};
+
+                if (!tuning_loop_counter && !timeout)
+                        break;
+
+                cmd.opcode = MMC_SEND_TUNING_BLOCK;
+                cmd.arg = 0;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+                cmd.retries = 0;
+                cmd.data = NULL;
+                cmd.error = 0;
+
+                mrq.cmd = &cmd;
+                host->mrq = &mrq;
+
+                /*
+                 * 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(host, SDHCI_MAKE_BLKSZ(7, 64), SDHCI_BLOCK_SIZE);
+
+                /*
+                 * The tuning block is sent by the card to the host controller.
+                 * So we set the TRNS_READ bit in the Transfer Mode register.
+                 * This also takes care of setting DMA Enable and Multi Block
+                 * Select in the same register to 0.
+                 */
+                sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
+
+                sdhci_send_command(host, &cmd);
+
+                host->cmd = NULL;
+                host->mrq = NULL;
+
+                spin_unlock(&host->lock);
+                enable_irq(host->irq);
+
+                /* Wait for Buffer Read Ready interrupt */
+                wait_event_interruptible_timeout(host->buf_ready_int,
+                                        (host->tuning_done == 1),
+                                        msecs_to_jiffies(50));
+                disable_irq(host->irq);
+                spin_lock(&host->lock);
+
+                if (!host->tuning_done) {
+                        printk(KERN_INFO DRIVER_NAME ": Timeout waiting for "
+                                "Buffer Read Ready interrupt during tuning "
+                                "procedure, falling back to fixed sampling "
+                                "clock\n");
+                        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                        ctrl &= ~SDHCI_CTRL_TUNED_CLK;
+                        ctrl &= ~SDHCI_CTRL_EXEC_TUNING;
+                        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+
+                        err = -EIO;
+                        goto out;
+                }
+
+                host->tuning_done = 0;
+
+                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                tuning_loop_counter--;
+                timeout--;
+                mdelay(1);
+        } while (ctrl & SDHCI_CTRL_EXEC_TUNING);
+
+        /*
+         * The Host Driver has exhausted the maximum number of loops allowed,
+         * so use fixed sampling frequency.
+         */
+        if (!tuning_loop_counter || !timeout) {
+                ctrl &= ~SDHCI_CTRL_TUNED_CLK;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+        } else {
+                if (!(ctrl & SDHCI_CTRL_TUNED_CLK)) {
+                        printk(KERN_INFO DRIVER_NAME ": Tuning procedure"
+                                " failed, falling back to fixed sampling"
+                                " clock\n");
+                        err = -EIO;
+                }
+        }
+
+out:
+        /*
+         * If this is the very first time we are here, we start the retuning
+         * timer. Since only during the first time, SDHCI_NEEDS_RETUNING
+         * flag won't be set, we check this condition before actually starting
+         * the timer.
+         */
+        if (!(host->flags & SDHCI_NEEDS_RETUNING) && host->tuning_count &&
+            (host->tuning_mode == SDHCI_TUNING_MODE_1)) {
+                mod_timer(&host->tuning_timer, jiffies +
+                        host->tuning_count * HZ);
+                /* Tuning mode 1 limits the maximum data length to 4MB */
+                mmc->max_blk_count = (4 * 1024 * 1024) / mmc->max_blk_size;
+        } else {
+                host->flags &= ~SDHCI_NEEDS_RETUNING;
+                /* Reload the new initial value for timer */
+                if (host->tuning_mode == SDHCI_TUNING_MODE_1)
+                        mod_timer(&host->tuning_timer, jiffies +
+                                host->tuning_count * HZ);
+        }
+
+        /*
+         * In case tuning fails, host controllers which support re-tuning can
+         * try tuning again at a later time, when the re-tuning timer expires.
+         * So for these controllers, we return 0. Since there might be other
+         * controllers who do not have this capability, we return error for
+         * them.
+         */
+        if (err && host->tuning_count &&
+            host->tuning_mode == SDHCI_TUNING_MODE_1)
+                err = 0;
+
+        sdhci_clear_set_irqs(host, SDHCI_INT_DATA_AVAIL, ier);
+        spin_unlock(&host->lock);
+        enable_irq(host->irq);
+
+        return err;
+}
+
+static void sdhci_enable_preset_value(struct mmc_host *mmc, bool enable)
+{
+        struct sdhci_host *host;
+        u16 ctrl;
+        unsigned long flags;
+
+        host = mmc_priv(mmc);
+
+        /* Host Controller v3.00 defines preset value registers */
+        if (host->version < SDHCI_SPEC_300)
+                return;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+
+        /*
+         * We only enable or disable Preset Value if they are not already
+         * enabled or disabled respectively. Otherwise, we bail out.
+         */
+        if (enable && !(ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
+                ctrl |= SDHCI_CTRL_PRESET_VAL_ENABLE;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+        } else if (!enable && (ctrl & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
+                ctrl &= ~SDHCI_CTRL_PRESET_VAL_ENABLE;
+                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+        }
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
 static const struct mmc_host_ops sdhci_ops = {
         .request        = sdhci_request,
         .set_ios        = sdhci_set_ios,
         .get_ro         = sdhci_get_ro,
         .enable_sdio_irq = sdhci_enable_sdio_irq,
+        .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,
+        .execute_tuning                 = sdhci_execute_tuning,
+        .enable_preset_value            = sdhci_enable_preset_value,
 };
 
 /*****************************************************************************\
@@ -1295,10 +1852,20 @@ static void sdhci_tasklet_finish(unsigned long param)
 
         host = (struct sdhci_host*)param;
 
+        /*
+         * If this tasklet gets rescheduled while running, it will
+         * be run again afterwards but without any active request.
+         */
+        if (!host->mrq)
+                return;
+
         spin_lock_irqsave(&host->lock, flags);
 
         del_timer(&host->timer);
 
+        if (host->version >= SDHCI_SPEC_300)
+                del_timer(&host->tuning_timer);
+
         mrq = host->mrq;
 
         /*
@@ -1306,7 +1873,7 @@ static void sdhci_tasklet_finish(unsigned long param)
          * upon error conditions.
          */
         if (!(host->flags & SDHCI_DEVICE_DEAD) &&
-                (mrq->cmd->error ||
+            ((mrq->cmd && mrq->cmd->error) ||
                  (mrq->data && (mrq->data->error ||
                   (mrq->data->stop && mrq->data->stop->error))) ||
                    (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
@@ -1372,6 +1939,20 @@ static void sdhci_timeout_timer(unsigned long data)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static void sdhci_tuning_timer(unsigned long data)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+
+        host = (struct sdhci_host *)data;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        host->flags |= SDHCI_NEEDS_RETUNING;
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
 /*****************************************************************************\
  *                                                                           *
  * Interrupt handling                                                        *
@@ -1427,7 +2008,7 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
                 sdhci_finish_command(host);
 }
 
-#ifdef DEBUG
+#ifdef CONFIG_MMC_DEBUG
 static void sdhci_show_adma_error(struct sdhci_host *host)
 {
         const char *name = mmc_hostname(host->mmc);
@@ -1460,6 +2041,16 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
 {
         BUG_ON(intmask == 0);
 
+        /* CMD19 generates _only_ Buffer Read Ready interrupt */
+        if (intmask & SDHCI_INT_DATA_AVAIL) {
+                if (SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)) ==
+                    MMC_SEND_TUNING_BLOCK) {
+                        host->tuning_done = 1;
+                        wake_up(&host->buf_ready_int);
+                        return;
+                }
+        }
+
         if (!host->data) {
                 /*
                  * The "data complete" interrupt is also used to
@@ -1483,7 +2074,11 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
 
         if (intmask & SDHCI_INT_DATA_TIMEOUT)
                 host->data->error = -ETIMEDOUT;
-        else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
+        else if (intmask & SDHCI_INT_DATA_END_BIT)
+                host->data->error = -EILSEQ;
+        else if ((intmask & SDHCI_INT_DATA_CRC) &&
+                SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
+                        != MMC_BUS_TEST_R)
                 host->data->error = -EILSEQ;
         else if (intmask & SDHCI_INT_ADMA_ERROR) {
                 printk(KERN_ERR "%s: ADMA error\n", mmc_hostname(host->mmc));
@@ -1501,10 +2096,28 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
                  * We currently don't do anything fancy with DMA
                  * boundaries, but as we can't disable the feature
                  * we need to at least restart the transfer.
+                 *
+                 * According to the spec sdhci_readl(host, SDHCI_DMA_ADDRESS)
+                 * should return a valid address to continue from, but as
+                 * some controllers are faulty, don't trust them.
                  */
-                if (intmask & SDHCI_INT_DMA_END)
-                        sdhci_writel(host, sdhci_readl(host, SDHCI_DMA_ADDRESS),
-                                SDHCI_DMA_ADDRESS);
+                if (intmask & SDHCI_INT_DMA_END) {
+                        u32 dmastart, dmanow;
+                        dmastart = sg_dma_address(host->data->sg);
+                        dmanow = dmastart + host->data->bytes_xfered;
+                        /*
+                         * Force update to the next DMA block boundary.
+                         */
+                        dmanow = (dmanow &
+                                ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) +
+                                SDHCI_DEFAULT_BOUNDARY_SIZE;
+                        host->data->bytes_xfered = dmanow - dmastart;
+                        DBG("%s: DMA base 0x%08x, transferred 0x%06x bytes,"
+                                " next 0x%08x\n",
+                                mmc_hostname(host->mmc), dmastart,
+                                host->data->bytes_xfered, dmanow);
+                        sdhci_writel(host, dmanow, SDHCI_DMA_ADDRESS);
+                }
 
                 if (intmask & SDHCI_INT_DATA_END) {
                         if (host->cmd) {
@@ -1614,6 +2227,14 @@ int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state)
 
         sdhci_disable_card_detection(host);
 
+        /* Disable tuning since we are suspending */
+        if (host->version >= SDHCI_SPEC_300 && host->tuning_count &&
+            host->tuning_mode == SDHCI_TUNING_MODE_1) {
+                host->flags &= ~SDHCI_NEEDS_RETUNING;
+                mod_timer(&host->tuning_timer, jiffies +
+                        host->tuning_count * HZ);
+        }
+
         ret = mmc_suspend_host(host->mmc);
         if (ret)
                 return ret;
@@ -1655,11 +2276,26 @@ int sdhci_resume_host(struct sdhci_host *host)
         ret = mmc_resume_host(host->mmc);
         sdhci_enable_card_detection(host);
 
+        /* Set the re-tuning expiration flag */
+        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
+            (host->tuning_mode == SDHCI_TUNING_MODE_1))
+                host->flags |= SDHCI_NEEDS_RETUNING;
+
         return ret;
 }
 
 EXPORT_SYMBOL_GPL(sdhci_resume_host);
 
+void sdhci_enable_irq_wakeups(struct sdhci_host *host)
+{
+        u8 val;
+        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
+        val |= SDHCI_WAKE_ON_INT;
+        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
+}
+
+EXPORT_SYMBOL_GPL(sdhci_enable_irq_wakeups);
+
 #endif /* CONFIG_PM */
 
 /*****************************************************************************\
@@ -1691,7 +2327,9 @@ EXPORT_SYMBOL_GPL(sdhci_alloc_host);
 int sdhci_add_host(struct sdhci_host *host)
 {
         struct mmc_host *mmc;
-        unsigned int caps;
+        u32 caps[2];
+        u32 max_current_caps;
+        unsigned int ocr_avail;
         int ret;
 
         WARN_ON(host == NULL);
@@ -1708,18 +2346,21 @@ int sdhci_add_host(struct sdhci_host *host)
         host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
         host->version = (host->version & SDHCI_SPEC_VER_MASK)
                                 >> SDHCI_SPEC_VER_SHIFT;
-        if (host->version > SDHCI_SPEC_200) {
+        if (host->version > SDHCI_SPEC_300) {
                 printk(KERN_ERR "%s: Unknown controller version (%d). "
                         "You may experience problems.\n", mmc_hostname(mmc),
                         host->version);
         }
 
-        caps = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
+        caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
                 sdhci_readl(host, SDHCI_CAPABILITIES);
 
+        caps[1] = (host->version >= SDHCI_SPEC_300) ?
+                sdhci_readl(host, SDHCI_CAPABILITIES_1) : 0;
+
         if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
                 host->flags |= SDHCI_USE_SDMA;
-        else if (!(caps & SDHCI_CAN_DO_SDMA))
+        else if (!(caps[0] & SDHCI_CAN_DO_SDMA))
                 DBG("Controller doesn't have SDMA capability\n");
         else
                 host->flags |= SDHCI_USE_SDMA;
@@ -1730,7 +2371,8 @@ int sdhci_add_host(struct sdhci_host *host)
                 host->flags &= ~SDHCI_USE_SDMA;
         }
 
-        if ((host->version >= SDHCI_SPEC_200) && (caps & SDHCI_CAN_DO_ADMA2))
+        if ((host->version >= SDHCI_SPEC_200) &&
+                (caps[0] & SDHCI_CAN_DO_ADMA2))
                 host->flags |= SDHCI_USE_ADMA;
 
         if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
@@ -1779,8 +2421,13 @@ int sdhci_add_host(struct sdhci_host *host)
                 mmc_dev(host->mmc)->dma_mask = &host->dma_mask;
         }
 
-        host->max_clk =
-                (caps & SDHCI_CLOCK_BASE_MASK) >> SDHCI_CLOCK_BASE_SHIFT;
+        if (host->version >= SDHCI_SPEC_300)
+                host->max_clk = (caps[0] & SDHCI_CLOCK_V3_BASE_MASK)
+                        >> SDHCI_CLOCK_BASE_SHIFT;
+        else
+                host->max_clk = (caps[0] & SDHCI_CLOCK_BASE_MASK)
+                        >> SDHCI_CLOCK_BASE_SHIFT;
+
         host->max_clk *= 1000000;
         if (host->max_clk == 0 || host->quirks &
                         SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN) {
@@ -1794,7 +2441,7 @@ int sdhci_add_host(struct sdhci_host *host)
         }
 
         host->timeout_clk =
-                (caps & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
+                (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);
@@ -1806,36 +2453,185 @@ int sdhci_add_host(struct sdhci_host *host)
                         return -ENODEV;
                 }
         }
-        if (caps & SDHCI_TIMEOUT_CLK_UNIT)
+        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.
+         */
+        host->clk_mul = (caps[1] & SDHCI_CLOCK_MUL_MASK) >>
+                        SDHCI_CLOCK_MUL_SHIFT;
+
+        /*
+         * In case the value in Clock Multiplier is 0, then programmable
+         * clock mode is not supported, otherwise the actual clock
+         * multiplier is one more than the value of Clock Multiplier
+         * in the Capabilities Register.
+         */
+        if (host->clk_mul)
+                host->clk_mul += 1;
+
+        /*
          * Set host parameters.
          */
         mmc->ops = &sdhci_ops;
+        mmc->f_max = host->max_clk;
         if (host->ops->get_min_clock)
                 mmc->f_min = host->ops->get_min_clock(host);
-        else
-                mmc->f_min = host->max_clk / 256;
-        mmc->f_max = host->max_clk;
-        mmc->caps |= MMC_CAP_SDIO_IRQ;
+        else if (host->version >= SDHCI_SPEC_300) {
+                if (host->clk_mul) {
+                        mmc->f_min = (host->max_clk * host->clk_mul) / 1024;
+                        mmc->f_max = host->max_clk * host->clk_mul;
+                } else
+                        mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
+        } else
+                mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
+
+        mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
+
+        if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
+                host->flags |= SDHCI_AUTO_CMD12;
+
+        /* Auto-CMD23 stuff only works in ADMA or PIO. */
+        if ((host->version >= SDHCI_SPEC_300) &&
+            ((host->flags & SDHCI_USE_ADMA) ||
+             !(host->flags & SDHCI_USE_SDMA))) {
+                host->flags |= SDHCI_AUTO_CMD23;
+                DBG("%s: Auto-CMD23 available\n", mmc_hostname(mmc));
+        } else {
+                DBG("%s: Auto-CMD23 unavailable\n", mmc_hostname(mmc));
+        }
 
+        /*
+         * A controller may support 8-bit width, but the board itself
+         * might not have the pins brought out.  Boards that support
+         * 8-bit width must set "mmc->caps |= MMC_CAP_8_BIT_DATA;" in
+         * their platform code before calling sdhci_add_host(), and we
+         * won't assume 8-bit width for hosts without that CAP.
+         */
         if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
                 mmc->caps |= MMC_CAP_4_BIT_DATA;
 
-        if (caps & SDHCI_CAN_DO_HISPD)
-                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+        if (caps[0] & SDHCI_CAN_DO_HISPD)
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
-        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
+            mmc_card_is_removable(mmc))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
-        mmc->ocr_avail = 0;
-        if (caps & SDHCI_CAN_VDD_330)
-                mmc->ocr_avail |= MMC_VDD_32_33|MMC_VDD_33_34;
-        if (caps & SDHCI_CAN_VDD_300)
-                mmc->ocr_avail |= MMC_VDD_29_30|MMC_VDD_30_31;
-        if (caps & SDHCI_CAN_VDD_180)
-                mmc->ocr_avail |= MMC_VDD_165_195;
+        /* UHS-I mode(s) supported by the host controller. */
+        if (host->version >= SDHCI_SPEC_300)
+                mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;
+
+        /* SDR104 supports also implies SDR50 support */
+        if (caps[1] & SDHCI_SUPPORT_SDR104)
+                mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50;
+        else if (caps[1] & SDHCI_SUPPORT_SDR50)
+                mmc->caps |= MMC_CAP_UHS_SDR50;
+
+        if (caps[1] & SDHCI_SUPPORT_DDR50)
+                mmc->caps |= MMC_CAP_UHS_DDR50;
+
+        /* Does the host needs tuning for SDR50? */
+        if (caps[1] & SDHCI_USE_SDR50_TUNING)
+                host->flags |= SDHCI_SDR50_NEEDS_TUNING;
+
+        /* Driver Type(s) (A, C, D) supported by the host */
+        if (caps[1] & SDHCI_DRIVER_TYPE_A)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
+        if (caps[1] & SDHCI_DRIVER_TYPE_C)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_C;
+        if (caps[1] & SDHCI_DRIVER_TYPE_D)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_D;
+
+        /* Initial value for re-tuning timer count */
+        host->tuning_count = (caps[1] & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
+                              SDHCI_RETUNING_TIMER_COUNT_SHIFT;
+
+        /*
+         * In case Re-tuning Timer is not disabled, the actual value of
+         * re-tuning timer will be 2 ^ (n - 1).
+         */
+        if (host->tuning_count)
+                host->tuning_count = 1 << (host->tuning_count - 1);
+
+        /* Re-tuning mode supported by the Host Controller */
+        host->tuning_mode = (caps[1] & SDHCI_RETUNING_MODE_MASK) >>
+                             SDHCI_RETUNING_MODE_SHIFT;
+
+        ocr_avail = 0;
+        /*
+         * According to SD Host Controller spec v3.00, if the Host System
+         * can afford more than 150mA, Host Driver should set XPC to 1. Also
+         * the value is meaningful only if Voltage Support in the Capabilities
+         * register is set. The actual current value is 4 times the register
+         * value.
+         */
+        max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
+
+        if (caps[0] & SDHCI_CAN_VDD_330) {
+                int max_current_330;
+
+                ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;
+
+                max_current_330 = ((max_current_caps &
+                                   SDHCI_MAX_CURRENT_330_MASK) >>
+                                   SDHCI_MAX_CURRENT_330_SHIFT) *
+                                   SDHCI_MAX_CURRENT_MULTIPLIER;
+
+                if (max_current_330 > 150)
+                        mmc->caps |= MMC_CAP_SET_XPC_330;
+        }
+        if (caps[0] & SDHCI_CAN_VDD_300) {
+                int max_current_300;
+
+                ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
+
+                max_current_300 = ((max_current_caps &
+                                   SDHCI_MAX_CURRENT_300_MASK) >>
+                                   SDHCI_MAX_CURRENT_300_SHIFT) *
+                                   SDHCI_MAX_CURRENT_MULTIPLIER;
+
+                if (max_current_300 > 150)
+                        mmc->caps |= MMC_CAP_SET_XPC_300;
+        }
+        if (caps[0] & SDHCI_CAN_VDD_180) {
+                int max_current_180;
+
+                ocr_avail |= MMC_VDD_165_195;
+
+                max_current_180 = ((max_current_caps &
+                                   SDHCI_MAX_CURRENT_180_MASK) >>
+                                   SDHCI_MAX_CURRENT_180_SHIFT) *
+                                   SDHCI_MAX_CURRENT_MULTIPLIER;
+
+                if (max_current_180 > 150)
+                        mmc->caps |= MMC_CAP_SET_XPC_180;
+
+                /* Maximum current capabilities of the host at 1.8V */
+                if (max_current_180 >= 800)
+                        mmc->caps |= MMC_CAP_MAX_CURRENT_800;
+                else if (max_current_180 >= 600)
+                        mmc->caps |= MMC_CAP_MAX_CURRENT_600;
+                else if (max_current_180 >= 400)
+                        mmc->caps |= MMC_CAP_MAX_CURRENT_400;
+                else
+                        mmc->caps |= MMC_CAP_MAX_CURRENT_200;
+        }
+
+        mmc->ocr_avail = ocr_avail;
+        mmc->ocr_avail_sdio = ocr_avail;
+        if (host->ocr_avail_sdio)
+                mmc->ocr_avail_sdio &= host->ocr_avail_sdio;
+        mmc->ocr_avail_sd = ocr_avail;
+        if (host->ocr_avail_sd)
+                mmc->ocr_avail_sd &= host->ocr_avail_sd;
+        else /* normal SD controllers don't support 1.8V */
+                mmc->ocr_avail_sd &= ~MMC_VDD_165_195;
+        mmc->ocr_avail_mmc = ocr_avail;
+        if (host->ocr_avail_mmc)
+                mmc->ocr_avail_mmc &= host->ocr_avail_mmc;
 
         if (mmc->ocr_avail == 0) {
                 printk(KERN_ERR "%s: Hardware doesn't report any "
@@ -1850,12 +2646,11 @@ int sdhci_add_host(struct sdhci_host *host)
          * can do scatter/gather or not.
          */
         if (host->flags & SDHCI_USE_ADMA)
-                mmc->max_hw_segs = 128;
+                mmc->max_segs = 128;
         else if (host->flags & SDHCI_USE_SDMA)
-                mmc->max_hw_segs = 1;
+                mmc->max_segs = 1;
         else /* PIO */
-                mmc->max_hw_segs = 128;
-        mmc->max_phys_segs = 128;
+                mmc->max_segs = 128;
 
         /*
          * Maximum number of sectors in one transfer. Limited by DMA boundary
@@ -1868,10 +2663,14 @@ int sdhci_add_host(struct sdhci_host *host)
          * of bytes. When doing hardware scatter/gather, each entry cannot
          * be larger than 64 KiB though.
          */
-        if (host->flags & SDHCI_USE_ADMA)
-                mmc->max_seg_size = 65536;
-        else
+        if (host->flags & SDHCI_USE_ADMA) {
+                if (host->quirks & SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC)
+                        mmc->max_seg_size = 65535;
+                else
+                        mmc->max_seg_size = 65536;
+        } else {
                 mmc->max_seg_size = mmc->max_req_size;
+        }
 
         /*
          * Maximum block size. This varies from controller to controller and
@@ -1880,7 +2679,7 @@ int sdhci_add_host(struct sdhci_host *host)
         if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) {
                 mmc->max_blk_size = 2;
         } else {
-                mmc->max_blk_size = (caps & SDHCI_MAX_BLOCK_MASK) >>
+                mmc->max_blk_size = (caps[0] & SDHCI_MAX_BLOCK_MASK) >>
                                 SDHCI_MAX_BLOCK_SHIFT;
                 if (mmc->max_blk_size >= 3) {
                         printk(KERN_WARNING "%s: Invalid maximum block size, "
@@ -1906,6 +2705,15 @@ int sdhci_add_host(struct sdhci_host *host)
 
         setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host);
 
+        if (host->version >= SDHCI_SPEC_300) {
+                init_waitqueue_head(&host->buf_ready_int);
+
+                /* Initialize re-tuning timer */
+                init_timer(&host->tuning_timer);
+                host->tuning_timer.data = (unsigned long)host;
+                host->tuning_timer.function = sdhci_tuning_timer;
+        }
+
         ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
                 mmc_hostname(mmc), host);
         if (ret)
@@ -1999,6 +2807,8 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
         free_irq(host->irq, host);
 
         del_timer_sync(&host->timer);
+        if (host->version >= SDHCI_SPEC_300)
+                del_timer_sync(&host->tuning_timer);
 
         tasklet_kill(&host->card_tasklet);
         tasklet_kill(&host->finish_tasklet);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index d316bc79b636..745c42fa41ed 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -1,6 +1,8 @@
 /*
  *  linux/drivers/mmc/host/sdhci.h - Secure Digital Host Controller Interface driver
  *
+ * Header file for Host Controller registers and I/O accessors.
+ *
  *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -8,19 +10,22 @@
  * the Free Software Foundation; either version 2 of the License, or (at
  * your option) any later version.
  */
-#ifndef __SDHCI_H
-#define __SDHCI_H
+#ifndef __SDHCI_HW_H
+#define __SDHCI_HW_H
 
 #include <linux/scatterlist.h>
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <linux/io.h>
 
+#include <linux/mmc/sdhci.h>
+
 /*
  * Controller registers
  */
 
 #define SDHCI_DMA_ADDRESS       0x00
+#define SDHCI_ARGUMENT2         SDHCI_DMA_ADDRESS
 
 #define SDHCI_BLOCK_SIZE        0x04
 #define  SDHCI_MAKE_BLKSZ(dma, blksz) (((dma & 0x7) << 12) | (blksz & 0xFFF))
@@ -32,7 +37,8 @@
 #define SDHCI_TRANSFER_MODE     0x0C
 #define  SDHCI_TRNS_DMA         0x01
 #define  SDHCI_TRNS_BLK_CNT_EN  0x02
-#define  SDHCI_TRNS_ACMD12      0x04
+#define  SDHCI_TRNS_AUTO_CMD12  0x04
+#define  SDHCI_TRNS_AUTO_CMD23  0x08
 #define  SDHCI_TRNS_READ        0x10
 #define  SDHCI_TRNS_MULTI       0x20
 
@@ -41,6 +47,7 @@
 #define  SDHCI_CMD_CRC          0x08
 #define  SDHCI_CMD_INDEX        0x10
 #define  SDHCI_CMD_DATA         0x20
+#define  SDHCI_CMD_ABORTCMD     0xC0
 
 #define  SDHCI_CMD_RESP_NONE    0x00
 #define  SDHCI_CMD_RESP_LONG    0x01
@@ -48,6 +55,7 @@
 #define  SDHCI_CMD_RESP_SHORT_BUSY 0x03
 
 #define SDHCI_MAKE_CMD(c, f) (((c & 0xff) << 8) | (f & 0xff))
+#define SDHCI_GET_CMD(c) ((c>>8) & 0x3f)
 
 #define SDHCI_RESPONSE          0x10
 
@@ -62,8 +70,10 @@
 #define  SDHCI_DATA_AVAILABLE   0x00000800
 #define  SDHCI_CARD_PRESENT     0x00010000
 #define  SDHCI_WRITE_PROTECT    0x00080000
+#define  SDHCI_DATA_LVL_MASK    0x00F00000
+#define   SDHCI_DATA_LVL_SHIFT  20
 
-#define SDHCI_HOST_CONTROL      0x28
+#define SDHCI_HOST_CONTROL      0x28
 #define  SDHCI_CTRL_LED         0x01
 #define  SDHCI_CTRL_4BITBUS     0x02
 #define  SDHCI_CTRL_HISPD       0x04
@@ -72,7 +82,7 @@
 #define   SDHCI_CTRL_ADMA1      0x08
 #define   SDHCI_CTRL_ADMA32     0x10
 #define   SDHCI_CTRL_ADMA64     0x18
-#define  SDHCI_CTRL_8BITBUS     0x20
+#define   SDHCI_CTRL_8BITBUS    0x20
 
 #define SDHCI_POWER_CONTROL     0x29
 #define  SDHCI_POWER_ON         0x01
@@ -83,9 +93,17 @@
 #define SDHCI_BLOCK_GAP_CONTROL 0x2A
 
 #define SDHCI_WAKE_UP_CONTROL   0x2B
+#define  SDHCI_WAKE_ON_INT      0x01
+#define  SDHCI_WAKE_ON_INSERT   0x02
+#define  SDHCI_WAKE_ON_REMOVE   0x04
 
 #define SDHCI_CLOCK_CONTROL     0x2C
 #define  SDHCI_DIVIDER_SHIFT    8
+#define  SDHCI_DIVIDER_HI_SHIFT 6
+#define  SDHCI_DIV_MASK 0xFF
+#define  SDHCI_DIV_MASK_LEN     8
+#define  SDHCI_DIV_HI_MASK      0x300
+#define  SDHCI_PROG_CLOCK_MODE  0x0020
 #define  SDHCI_CLOCK_CARD_EN    0x0004
 #define  SDHCI_CLOCK_INT_STABLE 0x0002
 #define  SDHCI_CLOCK_INT_EN     0x0001
@@ -133,16 +151,33 @@
 
 #define SDHCI_ACMD12_ERR        0x3C
 
-/* 3E-3F reserved */
+#define SDHCI_HOST_CONTROL2             0x3E
+#define  SDHCI_CTRL_UHS_MASK            0x0007
+#define   SDHCI_CTRL_UHS_SDR12          0x0000
+#define   SDHCI_CTRL_UHS_SDR25          0x0001
+#define   SDHCI_CTRL_UHS_SDR50          0x0002
+#define   SDHCI_CTRL_UHS_SDR104         0x0003
+#define   SDHCI_CTRL_UHS_DDR50          0x0004
+#define  SDHCI_CTRL_VDD_180             0x0008
+#define  SDHCI_CTRL_DRV_TYPE_MASK       0x0030
+#define   SDHCI_CTRL_DRV_TYPE_B         0x0000
+#define   SDHCI_CTRL_DRV_TYPE_A         0x0010
+#define   SDHCI_CTRL_DRV_TYPE_C         0x0020
+#define   SDHCI_CTRL_DRV_TYPE_D         0x0030
+#define  SDHCI_CTRL_EXEC_TUNING         0x0040
+#define  SDHCI_CTRL_TUNED_CLK           0x0080
+#define  SDHCI_CTRL_PRESET_VAL_ENABLE   0x8000
 
 #define SDHCI_CAPABILITIES      0x40
 #define  SDHCI_TIMEOUT_CLK_MASK 0x0000003F
 #define  SDHCI_TIMEOUT_CLK_SHIFT 0
 #define  SDHCI_TIMEOUT_CLK_UNIT 0x00000080
 #define  SDHCI_CLOCK_BASE_MASK  0x00003F00
+#define  SDHCI_CLOCK_V3_BASE_MASK       0x0000FF00
 #define  SDHCI_CLOCK_BASE_SHIFT 8
 #define  SDHCI_MAX_BLOCK_MASK   0x00030000
 #define  SDHCI_MAX_BLOCK_SHIFT  16
+#define  SDHCI_CAN_DO_8BIT      0x00040000
 #define  SDHCI_CAN_DO_ADMA2     0x00080000
 #define  SDHCI_CAN_DO_ADMA1     0x00100000
 #define  SDHCI_CAN_DO_HISPD     0x00200000
@@ -152,9 +187,30 @@
 #define  SDHCI_CAN_VDD_180      0x04000000
 #define  SDHCI_CAN_64BIT        0x10000000
 
-/* 44-47 reserved for more caps */
-
-#define SDHCI_MAX_CURRENT       0x48
+#define  SDHCI_SUPPORT_SDR50    0x00000001
+#define  SDHCI_SUPPORT_SDR104   0x00000002
+#define  SDHCI_SUPPORT_DDR50    0x00000004
+#define  SDHCI_DRIVER_TYPE_A    0x00000010
+#define  SDHCI_DRIVER_TYPE_C    0x00000020
+#define  SDHCI_DRIVER_TYPE_D    0x00000040
+#define  SDHCI_RETUNING_TIMER_COUNT_MASK        0x00000F00
+#define  SDHCI_RETUNING_TIMER_COUNT_SHIFT       8
+#define  SDHCI_USE_SDR50_TUNING                 0x00002000
+#define  SDHCI_RETUNING_MODE_MASK               0x0000C000
+#define  SDHCI_RETUNING_MODE_SHIFT              14
+#define  SDHCI_CLOCK_MUL_MASK   0x00FF0000
+#define  SDHCI_CLOCK_MUL_SHIFT  16
+
+#define SDHCI_CAPABILITIES_1    0x44
+
+#define SDHCI_MAX_CURRENT               0x48
+#define  SDHCI_MAX_CURRENT_330_MASK     0x0000FF
+#define  SDHCI_MAX_CURRENT_330_SHIFT    0
+#define  SDHCI_MAX_CURRENT_300_MASK     0x00FF00
+#define  SDHCI_MAX_CURRENT_300_SHIFT    8
+#define  SDHCI_MAX_CURRENT_180_MASK     0xFF0000
+#define  SDHCI_MAX_CURRENT_180_SHIFT    16
+#define   SDHCI_MAX_CURRENT_MULTIPLIER  4
 
 /* 4C-4F reserved for more max current */
 
@@ -178,134 +234,20 @@
 #define  SDHCI_SPEC_VER_SHIFT   0
 #define   SDHCI_SPEC_100        0
 #define   SDHCI_SPEC_200        1
+#define   SDHCI_SPEC_300        2
 
-struct sdhci_ops;
-
-struct sdhci_host {
-        /* Data set by hardware interface driver */
-        const char              *hw_name;       /* Hardware bus name */
-
-        unsigned int            quirks;         /* Deviations from spec. */
-
-/* Controller doesn't honor resets unless we touch the clock register */
-#define SDHCI_QUIRK_CLOCK_BEFORE_RESET                  (1<<0)
-/* Controller has bad caps bits, but really supports DMA */
-#define SDHCI_QUIRK_FORCE_DMA                           (1<<1)
-/* Controller doesn't like to be reset when there is no card inserted. */
-#define SDHCI_QUIRK_NO_CARD_NO_RESET                    (1<<2)
-/* Controller doesn't like clearing the power reg before a change */
-#define SDHCI_QUIRK_SINGLE_POWER_WRITE                  (1<<3)
-/* Controller has flaky internal state so reset it on each ios change */
-#define SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS               (1<<4)
-/* Controller has an unusable DMA engine */
-#define SDHCI_QUIRK_BROKEN_DMA                          (1<<5)
-/* Controller has an unusable ADMA engine */
-#define SDHCI_QUIRK_BROKEN_ADMA                         (1<<6)
-/* Controller can only DMA from 32-bit aligned addresses */
-#define SDHCI_QUIRK_32BIT_DMA_ADDR                      (1<<7)
-/* Controller can only DMA chunk sizes that are a multiple of 32 bits */
-#define SDHCI_QUIRK_32BIT_DMA_SIZE                      (1<<8)
-/* Controller can only ADMA chunks that are a multiple of 32 bits */
-#define SDHCI_QUIRK_32BIT_ADMA_SIZE                     (1<<9)
-/* Controller needs to be reset after each request to stay stable */
-#define SDHCI_QUIRK_RESET_AFTER_REQUEST                 (1<<10)
-/* Controller needs voltage and power writes to happen separately */
-#define SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER             (1<<11)
-/* Controller provides an incorrect timeout value for transfers */
-#define SDHCI_QUIRK_BROKEN_TIMEOUT_VAL                  (1<<12)
-/* Controller has an issue with buffer bits for small transfers */
-#define SDHCI_QUIRK_BROKEN_SMALL_PIO                    (1<<13)
-/* Controller does not provide transfer-complete interrupt when not busy */
-#define SDHCI_QUIRK_NO_BUSY_IRQ                         (1<<14)
-/* Controller has unreliable card detection */
-#define SDHCI_QUIRK_BROKEN_CARD_DETECTION               (1<<15)
-/* Controller reports inverted write-protect state */
-#define SDHCI_QUIRK_INVERTED_WRITE_PROTECT              (1<<16)
-/* Controller has nonstandard clock management */
-#define SDHCI_QUIRK_NONSTANDARD_CLOCK                   (1<<17)
-/* Controller does not like fast PIO transfers */
-#define SDHCI_QUIRK_PIO_NEEDS_DELAY                     (1<<18)
-/* Controller losing signal/interrupt enable states after reset */
-#define SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET            (1<<19)
-/* Controller has to be forced to use block size of 2048 bytes */
-#define SDHCI_QUIRK_FORCE_BLK_SZ_2048                   (1<<20)
-/* Controller cannot do multi-block transfers */
-#define SDHCI_QUIRK_NO_MULTIBLOCK                       (1<<21)
-/* Controller can only handle 1-bit data transfers */
-#define SDHCI_QUIRK_FORCE_1_BIT_DATA                    (1<<22)
-/* Controller needs 10ms delay between applying power and clock */
-#define SDHCI_QUIRK_DELAY_AFTER_POWER                   (1<<23)
-/* Controller uses SDCLK instead of TMCLK for data timeouts */
-#define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK             (1<<24)
-/* Controller reports wrong base clock capability */
-#define SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN               (1<<25)
-/* Controller cannot support End Attribute in NOP ADMA descriptor */
-#define SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC               (1<<26)
-/* Controller is missing device caps. Use caps provided by host */
-#define SDHCI_QUIRK_MISSING_CAPS                        (1<<27)
-/* Controller uses Auto CMD12 command to stop the transfer */
-#define SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12              (1<<28)
-/* Controller doesn't have HISPD bit field in HI-SPEED SD card */
-#define SDHCI_QUIRK_NO_HISPD_BIT                        (1<<29)
-
-        int                     irq;            /* Device IRQ */
-        void __iomem *          ioaddr;         /* Mapped address */
-
-        const struct sdhci_ops  *ops;           /* Low level hw interface */
-
-        struct regulator        *vmmc;          /* Power regulator */
-
-        /* Internal data */
-        struct mmc_host         *mmc;           /* MMC structure */
-        u64                     dma_mask;       /* custom DMA mask */
-
-#if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
-        struct led_classdev     led;            /* LED control */
-        char   led_name[32];
-#endif
-
-        spinlock_t              lock;           /* Mutex */
-
-        int                     flags;          /* Host attributes */
-#define SDHCI_USE_SDMA          (1<<0)          /* Host is SDMA capable */
-#define SDHCI_USE_ADMA          (1<<1)          /* Host is ADMA capable */
-#define SDHCI_REQ_USE_DMA       (1<<2)          /* Use DMA for this req. */
-#define SDHCI_DEVICE_DEAD       (1<<3)          /* Device unresponsive */
-
-        unsigned int            version;        /* SDHCI spec. version */
-
-        unsigned int            max_clk;        /* Max possible freq (MHz) */
-        unsigned int            timeout_clk;    /* Timeout freq (KHz) */
-
-        unsigned int            clock;          /* Current clock (MHz) */
-        u8                      pwr;            /* Current voltage */
-
-        struct mmc_request      *mrq;           /* Current request */
-        struct mmc_command      *cmd;           /* Current command */
-        struct mmc_data         *data;          /* Current data request */
-        unsigned int            data_early:1;   /* Data finished before cmd */
-
-        struct sg_mapping_iter  sg_miter;       /* SG state for PIO */
-        unsigned int            blocks;         /* remaining PIO blocks */
-
-        int                     sg_count;       /* Mapped sg entries */
-
-        u8                      *adma_desc;     /* ADMA descriptor table */
-        u8                      *align_buffer;  /* Bounce buffer */
-
-        dma_addr_t              adma_addr;      /* Mapped ADMA descr. table */
-        dma_addr_t              align_addr;     /* Mapped bounce buffer */
-
-        struct tasklet_struct   card_tasklet;   /* Tasklet structures */
-        struct tasklet_struct   finish_tasklet;
-
-        struct timer_list       timer;          /* Timer for timeouts */
-
-        unsigned int            caps;           /* Alternative capabilities */
+/*
+ * End of controller registers.
+ */
 
-        unsigned long           private[0] ____cacheline_aligned;
-};
+#define SDHCI_MAX_DIV_SPEC_200  256
+#define SDHCI_MAX_DIV_SPEC_300  2046
 
+/*
+ * Host SDMA buffer boundary. Valid values from 4K to 512K in powers of 2.
+ */
+#define SDHCI_DEFAULT_BOUNDARY_SIZE  (512 * 1024)
+#define SDHCI_DEFAULT_BOUNDARY_ARG   (ilog2(SDHCI_DEFAULT_BOUNDARY_SIZE) - 12)
 
 struct sdhci_ops {
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
@@ -323,6 +265,15 @@ struct sdhci_ops {
         unsigned int    (*get_max_clock)(struct sdhci_host *host);
         unsigned int    (*get_min_clock)(struct sdhci_host *host);
         unsigned int    (*get_timeout_clock)(struct sdhci_host *host);
+        int             (*platform_8bit_width)(struct sdhci_host *host,
+                                               int width);
+        void (*platform_send_init_74_clocks)(struct sdhci_host *host,
+                                             u8 power_mode);
+        unsigned int    (*get_ro)(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);
+
 };
 
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
@@ -425,6 +376,7 @@ extern void sdhci_remove_host(struct sdhci_host *host, int dead);
 #ifdef CONFIG_PM
 extern int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state);
 extern int sdhci_resume_host(struct sdhci_host *host);
+extern void sdhci_enable_irq_wakeups(struct sdhci_host *host);
 #endif
 
-#endif /* __SDHCI_H */
+#endif /* __SDHCI_HW_H */
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index 7aa65bb2af4a..496b7efbc6b0 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -30,7 +30,6 @@
 #include <linux/ioport.h>
 #include <linux/scatterlist.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <linux/io.h>
@@ -77,7 +76,7 @@ static unsigned int switchlocked;
 #define BUSY_TIMEOUT      32767
 
 /* list of supported pcmcia devices */
-static struct pcmcia_device_id pcmcia_ids[] = {
+static const struct pcmcia_device_id pcmcia_ids[] = {
         /* vendor and device strings followed by their crc32 hashes */
         PCMCIA_DEVICE_PROD_ID12("RICOH", "Bay1Controller", 0xd9f522ed,
                                 0xc3901202),
@@ -447,7 +446,7 @@ static int sdricoh_init_mmc(struct pci_dev *pci_dev,
         mmc->max_seg_size = 1024 * 512;
         mmc->max_blk_size = 512;
 
-        /* reset the controler */
+        /* reset the controller */
         if (sdricoh_reset(host)) {
                 dev_dbg(dev, "could not reset\n");
                 result = -EIO;
@@ -479,7 +478,7 @@ static int sdricoh_pcmcia_probe(struct pcmcia_device *pcmcia_dev)
         dev_info(&pcmcia_dev->dev, "Searching MMC controller for pcmcia device"
                 " %s %s ...\n", pcmcia_dev->prod_id[0], pcmcia_dev->prod_id[1]);
 
-        /* search pci cardbus bridge that contains the mmc controler */
+        /* search pci cardbus bridge that contains the mmc controller */
         /* the io region is already claimed by yenta_socket... */
         while ((pci_dev =
                 pci_get_device(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476,
@@ -536,9 +535,7 @@ static int sdricoh_pcmcia_resume(struct pcmcia_device *link)
 #endif
 
 static struct pcmcia_driver sdricoh_driver = {
-        .drv = {
-                .name = DRIVER_NAME,
-                },
+        .name = DRIVER_NAME,
         .probe = sdricoh_pcmcia_probe,
         .remove = sdricoh_pcmcia_detach,
         .id_table = pcmcia_ids,
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 5d3f824bb5a3..14f8edbaa195 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -16,16 +16,21 @@
  *
  */
 
+#include <linux/clk.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
 #include <linux/dma-mapping.h>
-#include <linux/mmc/host.h>
+#include <linux/dmaengine.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/core.h>
+#include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
-#include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
 #include <linux/mmc/sh_mmcif.h>
+#include <linux/pagemap.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/spinlock.h>
 
 #define DRIVER_NAME     "sh_mmcif"
 #define DRIVER_VERSION  "2010-04-28"
@@ -62,25 +67,6 @@
 /* CE_BLOCK_SET */
 #define BLOCK_SIZE_MASK         0x0000ffff
 
-/* CE_CLK_CTRL */
-#define CLK_ENABLE              (1 << 24) /* 1: output mmc clock */
-#define CLK_CLEAR               ((1 << 19) | (1 << 18) | (1 << 17) | (1 << 16))
-#define CLK_SUP_PCLK            ((1 << 19) | (1 << 18) | (1 << 17) | (1 << 16))
-#define SRSPTO_256              ((1 << 13) | (0 << 12)) /* resp timeout */
-#define SRBSYTO_29              ((1 << 11) | (1 << 10) |        \
-                                 (1 << 9) | (1 << 8)) /* resp busy timeout */
-#define SRWDTO_29               ((1 << 7) | (1 << 6) |          \
-                                 (1 << 5) | (1 << 4)) /* read/write timeout */
-#define SCCSTO_29               ((1 << 3) | (1 << 2) |          \
-                                 (1 << 1) | (1 << 0)) /* ccs timeout */
-
-/* CE_BUF_ACC */
-#define BUF_ACC_DMAWEN          (1 << 25)
-#define BUF_ACC_DMAREN          (1 << 24)
-#define BUF_ACC_BUSW_32         (0 << 17)
-#define BUF_ACC_BUSW_16         (1 << 17)
-#define BUF_ACC_ATYP            (1 << 16)
-
 /* CE_INT */
 #define INT_CCSDE               (1 << 29)
 #define INT_CMD12DRE            (1 << 26)
@@ -165,30 +151,38 @@
                                  STS2_AC12BSYTO | STS2_RSPBSYTO |       \
                                  STS2_AC12RSPTO | STS2_RSPTO)
 
-/* CE_VERSION */
-#define SOFT_RST_ON             (1 << 31)
-#define SOFT_RST_OFF            (0 << 31)
-
 #define CLKDEV_EMMC_DATA        52000000 /* 52MHz */
 #define CLKDEV_MMC_DATA         20000000 /* 20MHz */
 #define CLKDEV_INIT             400000   /* 400 KHz */
 
+enum mmcif_state {
+        STATE_IDLE,
+        STATE_REQUEST,
+        STATE_IOS,
+};
+
 struct sh_mmcif_host {
         struct mmc_host *mmc;
         struct mmc_data *data;
-        struct mmc_command *cmd;
         struct platform_device *pd;
         struct clk *hclk;
         unsigned int clk;
         int bus_width;
-        u16 wait_int;
-        u16 sd_error;
+        bool sd_error;
         long timeout;
         void __iomem *addr;
-        wait_queue_head_t intr_wait;
+        struct completion intr_wait;
+        enum mmcif_state state;
+        spinlock_t lock;
+        bool power;
+
+        /* DMA support */
+        struct dma_chan         *chan_rx;
+        struct dma_chan         *chan_tx;
+        struct completion       dma_complete;
+        bool                    dma_active;
 };
 
-
 static inline void sh_mmcif_bitset(struct sh_mmcif_host *host,
                                         unsigned int reg, u32 val)
 {
@@ -201,6 +195,182 @@ static inline void sh_mmcif_bitclr(struct sh_mmcif_host *host,
         writel(~val & readl(host->addr + reg), host->addr + reg);
 }
 
+static void mmcif_dma_complete(void *arg)
+{
+        struct sh_mmcif_host *host = arg;
+        dev_dbg(&host->pd->dev, "Command completed\n");
+
+        if (WARN(!host->data, "%s: NULL data in DMA completion!\n",
+                 dev_name(&host->pd->dev)))
+                return;
+
+        if (host->data->flags & MMC_DATA_READ)
+                dma_unmap_sg(host->chan_rx->device->dev,
+                             host->data->sg, host->data->sg_len,
+                             DMA_FROM_DEVICE);
+        else
+                dma_unmap_sg(host->chan_tx->device->dev,
+                             host->data->sg, host->data->sg_len,
+                             DMA_TO_DEVICE);
+
+        complete(&host->dma_complete);
+}
+
+static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
+{
+        struct scatterlist *sg = host->data->sg;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_rx;
+        dma_cookie_t cookie = -EINVAL;
+        int ret;
+
+        ret = dma_map_sg(chan->device->dev, sg, host->data->sg_len,
+                         DMA_FROM_DEVICE);
+        if (ret > 0) {
+                host->dma_active = true;
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        }
+
+        if (desc) {
+                desc->callback = mmcif_dma_complete;
+                desc->callback_param = host;
+                cookie = dmaengine_submit(desc);
+                sh_mmcif_bitset(host, MMCIF_CE_BUF_ACC, BUF_ACC_DMAREN);
+                dma_async_issue_pending(chan);
+        }
+        dev_dbg(&host->pd->dev, "%s(): mapped %d -> %d, cookie %d\n",
+                __func__, host->data->sg_len, ret, cookie);
+
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_rx = NULL;
+                host->dma_active = false;
+                dma_release_channel(chan);
+                /* Free the Tx channel too */
+                chan = host->chan_tx;
+                if (chan) {
+                        host->chan_tx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pd->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC, BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
+        }
+
+        dev_dbg(&host->pd->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
+                desc, cookie, host->data->sg_len);
+}
+
+static void sh_mmcif_start_dma_tx(struct sh_mmcif_host *host)
+{
+        struct scatterlist *sg = host->data->sg;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_tx;
+        dma_cookie_t cookie = -EINVAL;
+        int ret;
+
+        ret = dma_map_sg(chan->device->dev, sg, host->data->sg_len,
+                         DMA_TO_DEVICE);
+        if (ret > 0) {
+                host->dma_active = true;
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        }
+
+        if (desc) {
+                desc->callback = mmcif_dma_complete;
+                desc->callback_param = host;
+                cookie = dmaengine_submit(desc);
+                sh_mmcif_bitset(host, MMCIF_CE_BUF_ACC, BUF_ACC_DMAWEN);
+                dma_async_issue_pending(chan);
+        }
+        dev_dbg(&host->pd->dev, "%s(): mapped %d -> %d, cookie %d\n",
+                __func__, host->data->sg_len, ret, cookie);
+
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_tx = NULL;
+                host->dma_active = false;
+                dma_release_channel(chan);
+                /* Free the Rx channel too */
+                chan = host->chan_rx;
+                if (chan) {
+                        host->chan_rx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pd->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC, BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
+        }
+
+        dev_dbg(&host->pd->dev, "%s(): desc %p, cookie %d\n", __func__,
+                desc, cookie);
+}
+
+static bool sh_mmcif_filter(struct dma_chan *chan, void *arg)
+{
+        dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);
+        chan->private = arg;
+        return true;
+}
+
+static void sh_mmcif_request_dma(struct sh_mmcif_host *host,
+                                 struct sh_mmcif_plat_data *pdata)
+{
+        host->dma_active = false;
+
+        /* We can only either use DMA for both Tx and Rx or not use it at all */
+        if (pdata->dma) {
+                dma_cap_mask_t mask;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                host->chan_tx = dma_request_channel(mask, sh_mmcif_filter,
+                                                    &pdata->dma->chan_priv_tx);
+                dev_dbg(&host->pd->dev, "%s: TX: got channel %p\n", __func__,
+                        host->chan_tx);
+
+                if (!host->chan_tx)
+                        return;
+
+                host->chan_rx = dma_request_channel(mask, sh_mmcif_filter,
+                                                    &pdata->dma->chan_priv_rx);
+                dev_dbg(&host->pd->dev, "%s: RX: got channel %p\n", __func__,
+                        host->chan_rx);
+
+                if (!host->chan_rx) {
+                        dma_release_channel(host->chan_tx);
+                        host->chan_tx = NULL;
+                        return;
+                }
+
+                init_completion(&host->dma_complete);
+        }
+}
+
+static void sh_mmcif_release_dma(struct sh_mmcif_host *host)
+{
+        sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC, BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
+        /* Descriptors are freed automatically */
+        if (host->chan_tx) {
+                struct dma_chan *chan = host->chan_tx;
+                host->chan_tx = NULL;
+                dma_release_channel(chan);
+        }
+        if (host->chan_rx) {
+                struct dma_chan *chan = host->chan_rx;
+                host->chan_rx = NULL;
+                dma_release_channel(chan);
+        }
+
+        host->dma_active = false;
+}
 
 static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
 {
@@ -239,13 +409,12 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
         u32 state1, state2;
         int ret, timeout = 10000000;
 
-        host->sd_error = 0;
-        host->wait_int = 0;
+        host->sd_error = false;
 
         state1 = sh_mmcif_readl(host->addr, MMCIF_CE_HOST_STS1);
         state2 = sh_mmcif_readl(host->addr, MMCIF_CE_HOST_STS2);
-        pr_debug("%s: ERR HOST_STS1 = %08x\n", DRIVER_NAME, state1);
-        pr_debug("%s: ERR HOST_STS2 = %08x\n", DRIVER_NAME, state2);
+        dev_dbg(&host->pd->dev, "ERR HOST_STS1 = %08x\n", state1);
+        dev_dbg(&host->pd->dev, "ERR HOST_STS2 = %08x\n", state2);
 
         if (state1 & STS1_CMDSEQ) {
                 sh_mmcif_bitset(host, MMCIF_CE_CMD_CTRL, CMD_CTRL_BREAK);
@@ -253,8 +422,8 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
                 while (1) {
                         timeout--;
                         if (timeout < 0) {
-                                pr_err(DRIVER_NAME": Forceed end of " \
-                                        "command sequence timeout err\n");
+                                dev_err(&host->pd->dev,
+                                        "Forceed end of command sequence timeout err\n");
                                 return -EIO;
                         }
                         if (!(sh_mmcif_readl(host->addr, MMCIF_CE_HOST_STS1)
@@ -263,18 +432,18 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
                         mdelay(1);
                 }
                 sh_mmcif_sync_reset(host);
-                pr_debug(DRIVER_NAME": Forced end of command sequence\n");
+                dev_dbg(&host->pd->dev, "Forced end of command sequence\n");
                 return -EIO;
         }
 
         if (state2 & STS2_CRC_ERR) {
-                pr_debug(DRIVER_NAME": Happened CRC error\n");
+                dev_dbg(&host->pd->dev, ": Happened CRC error\n");
                 ret = -EIO;
         } else if (state2 & STS2_TIMEOUT_ERR) {
-                pr_debug(DRIVER_NAME": Happened Timeout error\n");
+                dev_dbg(&host->pd->dev, ": Happened Timeout error\n");
                 ret = -ETIMEDOUT;
         } else {
-                pr_debug(DRIVER_NAME": Happened End/Index error\n");
+                dev_dbg(&host->pd->dev, ": Happened End/Index error\n");
                 ret = -EIO;
         }
         return ret;
@@ -287,17 +456,13 @@ static int sh_mmcif_single_read(struct sh_mmcif_host *host,
         long time;
         u32 blocksize, i, *p = sg_virt(data->sg);
 
-        host->wait_int = 0;
-
         /* buf read enable */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                        host->wait_int == 1 ||
-                        host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                        host->timeout);
+        if (time <= 0 || host->sd_error)
                 return sh_mmcif_error_manage(host);
 
-        host->wait_int = 0;
         blocksize = (BLOCK_SIZE_MASK &
                         sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET)) + 3;
         for (i = 0; i < blocksize / 4; i++)
@@ -305,13 +470,11 @@ static int sh_mmcif_single_read(struct sh_mmcif_host *host,
 
         /* buffer read end */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                        host->wait_int == 1 ||
-                        host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                        host->timeout);
+        if (time <= 0 || host->sd_error)
                 return sh_mmcif_error_manage(host);
 
-        host->wait_int = 0;
         return 0;
 }
 
@@ -326,19 +489,15 @@ static int sh_mmcif_multi_read(struct sh_mmcif_host *host,
                                                      MMCIF_CE_BLOCK_SET);
         for (j = 0; j < data->sg_len; j++) {
                 p = sg_virt(data->sg);
-                host->wait_int = 0;
                 for (sec = 0; sec < data->sg->length / blocksize; sec++) {
                         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
                         /* buf read enable */
-                        time = wait_event_interruptible_timeout(host->intr_wait,
-                                host->wait_int == 1 ||
-                                host->sd_error == 1, host->timeout);
+                        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                                host->timeout);
 
-                        if (host->wait_int != 1 &&
-                            (time == 0 || host->sd_error != 0))
+                        if (time <= 0 || host->sd_error)
                                 return sh_mmcif_error_manage(host);
 
-                        host->wait_int = 0;
                         for (i = 0; i < blocksize / 4; i++)
                                 *p++ = sh_mmcif_readl(host->addr,
                                                       MMCIF_CE_DATA);
@@ -356,17 +515,14 @@ static int sh_mmcif_single_write(struct sh_mmcif_host *host,
         long time;
         u32 blocksize, i, *p = sg_virt(data->sg);
 
-        host->wait_int = 0;
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
 
         /* buf write enable */
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                        host->wait_int == 1 ||
-                        host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                        host->timeout);
+        if (time <= 0 || host->sd_error)
                 return sh_mmcif_error_manage(host);
 
-        host->wait_int = 0;
         blocksize = (BLOCK_SIZE_MASK &
                         sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET)) + 3;
         for (i = 0; i < blocksize / 4; i++)
@@ -375,13 +531,11 @@ static int sh_mmcif_single_write(struct sh_mmcif_host *host,
         /* buffer write end */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
 
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                        host->wait_int == 1 ||
-                        host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                        host->timeout);
+        if (time <= 0 || host->sd_error)
                 return sh_mmcif_error_manage(host);
 
-        host->wait_int = 0;
         return 0;
 }
 
@@ -397,19 +551,15 @@ static int sh_mmcif_multi_write(struct sh_mmcif_host *host,
 
         for (j = 0; j < data->sg_len; j++) {
                 p = sg_virt(data->sg);
-                host->wait_int = 0;
                 for (sec = 0; sec < data->sg->length / blocksize; sec++) {
                         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
                         /* buf write enable*/
-                        time = wait_event_interruptible_timeout(host->intr_wait,
-                                host->wait_int == 1 ||
-                                host->sd_error == 1, host->timeout);
+                        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                                host->timeout);
 
-                        if (host->wait_int != 1 &&
-                            (time == 0 || host->sd_error != 0))
+                        if (time <= 0 || host->sd_error)
                                 return sh_mmcif_error_manage(host);
 
-                        host->wait_int = 0;
                         for (i = 0; i < blocksize / 4; i++)
                                 sh_mmcif_writel(host->addr,
                                                 MMCIF_CE_DATA, *p++);
@@ -457,7 +607,7 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
                 tmp |= CMD_SET_RTYP_17B;
                 break;
         default:
-                pr_err(DRIVER_NAME": Not support type response.\n");
+                dev_err(&host->pd->dev, "Unsupported response type.\n");
                 break;
         }
         switch (opc) {
@@ -485,7 +635,7 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
                         tmp |= CMD_SET_DATW_8;
                         break;
                 default:
-                        pr_err(DRIVER_NAME": Not support bus width.\n");
+                        dev_err(&host->pd->dev, "Unsupported bus width.\n");
                         break;
                 }
         }
@@ -513,10 +663,10 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
         return opc = ((opc << 24) | tmp);
 }
 
-static u32 sh_mmcif_data_trans(struct sh_mmcif_host *host,
+static int sh_mmcif_data_trans(struct sh_mmcif_host *host,
                                 struct mmc_request *mrq, u32 opc)
 {
-        u32 ret;
+        int ret;
 
         switch (opc) {
         case MMC_READ_MULTIPLE_BLOCK:
@@ -533,7 +683,7 @@ static u32 sh_mmcif_data_trans(struct sh_mmcif_host *host,
                 ret = sh_mmcif_single_read(host, mrq);
                 break;
         default:
-                pr_err(DRIVER_NAME": NOT SUPPORT CMD = d'%08d\n", opc);
+                dev_err(&host->pd->dev, "UNSUPPORTED CMD = d'%08d\n", opc);
                 ret = -EINVAL;
                 break;
         }
@@ -547,8 +697,6 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
         int ret = 0, mask = 0;
         u32 opc = cmd->opcode;
 
-        host->cmd = cmd;
-
         switch (opc) {
         /* respons busy check */
         case MMC_SWITCH:
@@ -579,13 +727,12 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, mask);
         /* set arg */
         sh_mmcif_writel(host->addr, MMCIF_CE_ARG, cmd->arg);
-        host->wait_int = 0;
         /* set cmd */
         sh_mmcif_writel(host->addr, MMCIF_CE_CMD_SET, opc);
 
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                host->wait_int == 1 || host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && time == 0) {
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                host->timeout);
+        if (time <= 0) {
                 cmd->error = sh_mmcif_error_manage(host);
                 return;
         }
@@ -597,26 +744,34 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
                         cmd->error = -ETIMEDOUT;
                         break;
                 default:
-                        pr_debug("%s: Cmd(d'%d) err\n",
-                                        DRIVER_NAME, cmd->opcode);
+                        dev_dbg(&host->pd->dev, "Cmd(d'%d) err\n",
+                                        cmd->opcode);
                         cmd->error = sh_mmcif_error_manage(host);
                         break;
                 }
-                host->sd_error = 0;
-                host->wait_int = 0;
+                host->sd_error = false;
                 return;
         }
         if (!(cmd->flags & MMC_RSP_PRESENT)) {
-                cmd->error = ret;
-                host->wait_int = 0;
+                cmd->error = 0;
                 return;
         }
-        if (host->wait_int == 1) {
-                sh_mmcif_get_response(host, cmd);
-                host->wait_int = 0;
-        }
+        sh_mmcif_get_response(host, cmd);
         if (host->data) {
-                ret = sh_mmcif_data_trans(host, mrq, cmd->opcode);
+                if (!host->dma_active) {
+                        ret = sh_mmcif_data_trans(host, mrq, cmd->opcode);
+                } else {
+                        long time =
+                                wait_for_completion_interruptible_timeout(&host->dma_complete,
+                                                                          host->timeout);
+                        if (!time)
+                                ret = -ETIMEDOUT;
+                        else if (time < 0)
+                                ret = time;
+                        sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC,
+                                        BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
+                        host->dma_active = false;
+                }
                 if (ret < 0)
                         mrq->data->bytes_xfered = 0;
                 else
@@ -636,37 +791,49 @@ static void sh_mmcif_stop_cmd(struct sh_mmcif_host *host,
         else if (mrq->cmd->opcode == MMC_WRITE_MULTIPLE_BLOCK)
                 sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
         else {
-                pr_err(DRIVER_NAME": not support stop cmd\n");
+                dev_err(&host->pd->dev, "unsupported stop cmd\n");
                 cmd->error = sh_mmcif_error_manage(host);
                 return;
         }
 
-        time = wait_event_interruptible_timeout(host->intr_wait,
-                        host->wait_int == 1 ||
-                        host->sd_error == 1, host->timeout);
-        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0)) {
+        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
+                        host->timeout);
+        if (time <= 0 || host->sd_error) {
                 cmd->error = sh_mmcif_error_manage(host);
                 return;
         }
         sh_mmcif_get_cmd12response(host, cmd);
-        host->wait_int = 0;
         cmd->error = 0;
 }
 
 static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
         struct sh_mmcif_host *host = mmc_priv(mmc);
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        if (host->state != STATE_IDLE) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                mrq->cmd->error = -EAGAIN;
+                mmc_request_done(mmc, mrq);
+                return;
+        }
+
+        host->state = STATE_REQUEST;
+        spin_unlock_irqrestore(&host->lock, flags);
 
         switch (mrq->cmd->opcode) {
         /* MMCIF does not support SD/SDIO command */
         case SD_IO_SEND_OP_COND:
         case MMC_APP_CMD:
+                host->state = STATE_IDLE;
                 mrq->cmd->error = -ETIMEDOUT;
                 mmc_request_done(mmc, mrq);
                 return;
         case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
                 if (!mrq->data) {
                         /* send_if_cond cmd (not support) */
+                        host->state = STATE_IDLE;
                         mrq->cmd->error = -ETIMEDOUT;
                         mmc_request_done(mmc, mrq);
                         return;
@@ -676,15 +843,21 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 break;
         }
         host->data = mrq->data;
+        if (mrq->data) {
+                if (mrq->data->flags & MMC_DATA_READ) {
+                        if (host->chan_rx)
+                                sh_mmcif_start_dma_rx(host);
+                } else {
+                        if (host->chan_tx)
+                                sh_mmcif_start_dma_tx(host);
+                }
+        }
         sh_mmcif_start_cmd(host, mrq, mrq->cmd);
         host->data = NULL;
 
-        if (mrq->cmd->error != 0) {
-                mmc_request_done(mmc, mrq);
-                return;
-        }
-        if (mrq->stop)
+        if (!mrq->cmd->error && mrq->stop)
                 sh_mmcif_stop_cmd(host, mrq, mrq->stop);
+        host->state = STATE_IDLE;
         mmc_request_done(mmc, mrq);
 }
 
@@ -692,27 +865,64 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct sh_mmcif_host *host = mmc_priv(mmc);
         struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+        unsigned long flags;
 
-        if (ios->power_mode == MMC_POWER_OFF) {
-                /* clock stop */
-                sh_mmcif_clock_control(host, 0);
-                if (p->down_pwr)
-                        p->down_pwr(host->pd);
+        spin_lock_irqsave(&host->lock, flags);
+        if (host->state != STATE_IDLE) {
+                spin_unlock_irqrestore(&host->lock, flags);
                 return;
-        } else if (ios->power_mode == MMC_POWER_UP) {
+        }
+
+        host->state = STATE_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) {
+                        /* 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;
+                }
+        } 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);
+                                sh_mmcif_release_dma(host);
+                                host->power = false;
+                        }
+                        if (p->down_pwr)
+                                p->down_pwr(host->pd);
+                }
+                host->state = STATE_IDLE;
+                return;
         }
 
         if (ios->clock)
                 sh_mmcif_clock_control(host, ios->clock);
 
         host->bus_width = ios->bus_width;
+        host->state = STATE_IDLE;
+}
+
+static int sh_mmcif_get_cd(struct mmc_host *mmc)
+{
+        struct sh_mmcif_host *host = mmc_priv(mmc);
+        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+
+        if (!p->get_cd)
+                return -ENOSYS;
+        else
+                return p->get_cd(host->pd);
 }
 
 static struct mmc_host_ops sh_mmcif_ops = {
         .request        = sh_mmcif_request,
         .set_ios        = sh_mmcif_set_ios,
+        .get_cd         = sh_mmcif_get_cd,
 };
 
 static void sh_mmcif_detect(struct mmc_host *mmc)
@@ -723,7 +933,7 @@ static void sh_mmcif_detect(struct mmc_host *mmc)
 static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
 {
         struct sh_mmcif_host *host = dev_id;
-        u32 state = 0;
+        u32 state;
         int err = 0;
 
         state = sh_mmcif_readl(host->addr, MMCIF_CE_INT);
@@ -762,17 +972,19 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
                 err = 1;
         } else {
-                pr_debug("%s: Not support int\n", DRIVER_NAME);
+                dev_dbg(&host->pd->dev, "Unsupported interrupt: 0x%x\n", state);
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
                 err = 1;
         }
         if (err) {
-                host->sd_error = 1;
-                pr_debug("%s: int err state = %08x\n", DRIVER_NAME, state);
+                host->sd_error = true;
+                dev_dbg(&host->pd->dev, "int err state = %08x\n", state);
         }
-        host->wait_int = 1;
-        wake_up(&host->intr_wait);
+        if (state & ~(INT_CMD12RBE | INT_CMD12CRE))
+                complete(&host->intr_wait);
+        else
+                dev_dbg(&host->pd->dev, "Unexpected IRQ 0x%x\n", state);
 
         return IRQ_HANDLED;
 }
@@ -781,8 +993,8 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
 {
         int ret = 0, irq[2];
         struct mmc_host *mmc;
-        struct sh_mmcif_host *host = NULL;
-        struct sh_mmcif_plat_data *pd = NULL;
+        struct sh_mmcif_host *host;
+        struct sh_mmcif_plat_data *pd;
         struct resource *res;
         void __iomem *reg;
         char clk_name[8];
@@ -790,7 +1002,7 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         irq[0] = platform_get_irq(pdev, 0);
         irq[1] = platform_get_irq(pdev, 1);
         if (irq[0] < 0 || irq[1] < 0) {
-                pr_err(DRIVER_NAME": Get irq error\n");
+                dev_err(&pdev->dev, "Get irq error\n");
                 return -ENXIO;
         }
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -803,7 +1015,7 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "ioremap error.\n");
                 return -ENOMEM;
         }
-        pd = (struct sh_mmcif_plat_data *)(pdev->dev.platform_data);
+        pd = pdev->dev.platform_data;
         if (!pd) {
                 dev_err(&pdev->dev, "sh_mmcif plat data error.\n");
                 ret = -ENXIO;
@@ -830,7 +1042,8 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         host->clk = clk_get_rate(host->hclk);
         host->pd = pdev;
 
-        init_waitqueue_head(&host->intr_wait);
+        init_completion(&host->intr_wait);
+        spin_lock_init(&host->lock);
 
         mmc->ops = &sh_mmcif_ops;
         mmc->f_max = host->clk;
@@ -846,38 +1059,50 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         mmc->caps = MMC_CAP_MMC_HIGHSPEED;
         if (pd->caps)
                 mmc->caps |= pd->caps;
-        mmc->max_phys_segs = 128;
-        mmc->max_hw_segs = 128;
+        mmc->max_segs = 32;
         mmc->max_blk_size = 512;
-        mmc->max_blk_count = 65535;
-        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_req_size = PAGE_CACHE_SIZE * mmc->max_segs;
+        mmc->max_blk_count = mmc->max_req_size / mmc->max_blk_size;
         mmc->max_seg_size = mmc->max_req_size;
 
         sh_mmcif_sync_reset(host);
         platform_set_drvdata(pdev, host);
+
+        pm_runtime_enable(&pdev->dev);
+        host->power = false;
+
+        ret = pm_runtime_resume(&pdev->dev);
+        if (ret < 0)
+                goto clean_up2;
+
         mmc_add_host(mmc);
 
+        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
+
         ret = request_irq(irq[0], sh_mmcif_intr, 0, "sh_mmc:error", host);
         if (ret) {
-                pr_err(DRIVER_NAME": request_irq error (sh_mmc:error)\n");
-                goto clean_up2;
+                dev_err(&pdev->dev, "request_irq error (sh_mmc:error)\n");
+                goto clean_up3;
         }
         ret = request_irq(irq[1], sh_mmcif_intr, 0, "sh_mmc:int", host);
         if (ret) {
                 free_irq(irq[0], host);
-                pr_err(DRIVER_NAME": request_irq error (sh_mmc:int)\n");
-                goto clean_up2;
+                dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
+                goto clean_up3;
         }
 
-        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
         sh_mmcif_detect(host->mmc);
 
-        pr_info("%s: driver version %s\n", DRIVER_NAME, DRIVER_VERSION);
-        pr_debug("%s: chip ver H'%04x\n", DRIVER_NAME,
+        dev_info(&pdev->dev, "driver version %s\n", DRIVER_VERSION);
+        dev_dbg(&pdev->dev, "chip ver H'%04x\n",
                 sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
         return ret;
 
+clean_up3:
+        mmc_remove_host(mmc);
+        pm_runtime_suspend(&pdev->dev);
 clean_up2:
+        pm_runtime_disable(&pdev->dev);
         clk_disable(host->hclk);
 clean_up1:
         mmc_free_host(mmc);
@@ -892,31 +1117,70 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
         struct sh_mmcif_host *host = platform_get_drvdata(pdev);
         int irq[2];
 
-        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
+        pm_runtime_get_sync(&pdev->dev);
 
-        irq[0] = platform_get_irq(pdev, 0);
-        irq[1] = platform_get_irq(pdev, 1);
+        mmc_remove_host(host->mmc);
+        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
         if (host->addr)
                 iounmap(host->addr);
 
-        platform_set_drvdata(pdev, NULL);
-        mmc_remove_host(host->mmc);
+        irq[0] = platform_get_irq(pdev, 0);
+        irq[1] = platform_get_irq(pdev, 1);
 
         free_irq(irq[0], host);
         free_irq(irq[1], host);
 
+        platform_set_drvdata(pdev, NULL);
+
         clk_disable(host->hclk);
         mmc_free_host(host->mmc);
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
 
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int sh_mmcif_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+        int ret = mmc_suspend_host(host->mmc);
+
+        if (!ret) {
+                sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
+                clk_disable(host->hclk);
+        }
+
+        return ret;
+}
+
+static int sh_mmcif_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+
+        clk_enable(host->hclk);
+
+        return mmc_resume_host(host->mmc);
+}
+#else
+#define sh_mmcif_suspend        NULL
+#define sh_mmcif_resume         NULL
+#endif  /* CONFIG_PM */
+
+static const struct dev_pm_ops sh_mmcif_dev_pm_ops = {
+        .suspend = sh_mmcif_suspend,
+        .resume = sh_mmcif_resume,
+};
+
 static struct platform_driver sh_mmcif_driver = {
         .probe          = sh_mmcif_probe,
         .remove         = sh_mmcif_remove,
         .driver         = {
                 .name   = DRIVER_NAME,
+                .pm     = &sh_mmcif_dev_pm_ops,
         },
 };
 
@@ -936,5 +1200,5 @@ module_exit(sh_mmcif_exit);
 
 MODULE_DESCRIPTION("SuperH on-chip MMC/eMMC interface driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS(DRIVER_NAME);
+MODULE_ALIAS("platform:" DRIVER_NAME);
 MODULE_AUTHOR("Yusuke Goda <yusuke.goda.sx@renesas.com>");
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
new file mode 100644
index 000000000000..ce500f03df85
--- /dev/null
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -0,0 +1,216 @@
+/*
+ * SuperH Mobile SDHI
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * 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.
+ *
+ * Based on "Compaq ASIC3 support":
+ *
+ * Copyright 2001 Compaq Computer Corporation.
+ * Copyright 2004-2005 Phil Blundell
+ * Copyright 2007-2008 OpenedHand Ltd.
+ *
+ * Authors: Phil Blundell <pb@handhelds.org>,
+ *          Samuel Ortiz <sameo@openedhand.com>
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/sh_mobile_sdhi.h>
+#include <linux/mfd/tmio.h>
+#include <linux/sh_dma.h>
+
+#include "tmio_mmc.h"
+
+struct sh_mobile_sdhi {
+        struct clk *clk;
+        struct tmio_mmc_data mmc_data;
+        struct sh_dmae_slave param_tx;
+        struct sh_dmae_slave param_rx;
+        struct tmio_mmc_dma dma_priv;
+};
+
+static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
+{
+        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
+
+        if (p && p->set_pwr)
+                p->set_pwr(pdev, state);
+}
+
+static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
+{
+        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
+
+        if (p && p->get_cd)
+                return p->get_cd(pdev);
+        else
+                return -ENOSYS;
+}
+
+static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
+{
+        struct sh_mobile_sdhi *priv;
+        struct tmio_mmc_data *mmc_data;
+        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
+        struct tmio_mmc_host *host;
+        char clk_name[8];
+        int i, irq, ret;
+
+        priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
+        if (priv == NULL) {
+                dev_err(&pdev->dev, "kzalloc failed\n");
+                return -ENOMEM;
+        }
+
+        mmc_data = &priv->mmc_data;
+        p->pdata = mmc_data;
+
+        snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
+        priv->clk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(priv->clk)) {
+                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
+                ret = PTR_ERR(priv->clk);
+                goto eclkget;
+        }
+
+        clk_enable(priv->clk);
+
+        mmc_data->hclk = clk_get_rate(priv->clk);
+        mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
+        mmc_data->get_cd = sh_mobile_sdhi_get_cd;
+        mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
+        if (p) {
+                mmc_data->flags = p->tmio_flags;
+                mmc_data->ocr_mask = p->tmio_ocr_mask;
+                mmc_data->capabilities |= p->tmio_caps;
+
+                if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
+                        priv->param_tx.slave_id = p->dma_slave_tx;
+                        priv->param_rx.slave_id = p->dma_slave_rx;
+                        priv->dma_priv.chan_priv_tx = &priv->param_tx;
+                        priv->dma_priv.chan_priv_rx = &priv->param_rx;
+                        priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
+                        mmc_data->dma = &priv->dma_priv;
+                }
+        }
+
+        /*
+         * All SDHI blocks support 2-byte and larger block sizes in 4-bit
+         * bus width mode.
+         */
+        mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES;
+
+        /*
+         * All SDHI blocks support SDIO IRQ signalling.
+         */
+        mmc_data->flags |= TMIO_MMC_SDIO_IRQ;
+
+        ret = tmio_mmc_host_probe(&host, pdev, mmc_data);
+        if (ret < 0)
+                goto eprobe;
+
+        for (i = 0; i < 3; i++) {
+                irq = platform_get_irq(pdev, i);
+                if (irq < 0) {
+                        if (i) {
+                                continue;
+                        } else {
+                                ret = irq;
+                                goto eirq;
+                        }
+                }
+                ret = request_irq(irq, tmio_mmc_irq, 0,
+                                  dev_name(&pdev->dev), host);
+                if (ret) {
+                        while (i--) {
+                                irq = platform_get_irq(pdev, i);
+                                if (irq >= 0)
+                                        free_irq(irq, host);
+                        }
+                        goto eirq;
+                }
+        }
+        dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n",
+                 mmc_hostname(host->mmc), (unsigned long)
+                 (platform_get_resource(pdev,IORESOURCE_MEM, 0)->start),
+                 mmc_data->hclk / 1000000);
+
+        return ret;
+
+eirq:
+        tmio_mmc_host_remove(host);
+eprobe:
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+eclkget:
+        kfree(priv);
+        return ret;
+}
+
+static int sh_mobile_sdhi_remove(struct platform_device *pdev)
+{
+        struct mmc_host *mmc = platform_get_drvdata(pdev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
+        struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
+        int i, irq;
+
+        p->pdata = NULL;
+
+        tmio_mmc_host_remove(host);
+
+        for (i = 0; i < 3; i++) {
+                irq = platform_get_irq(pdev, i);
+                if (irq >= 0)
+                        free_irq(irq, host);
+        }
+
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+        kfree(priv);
+
+        return 0;
+}
+
+static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
+        .suspend = tmio_mmc_host_suspend,
+        .resume = tmio_mmc_host_resume,
+        .runtime_suspend = tmio_mmc_host_runtime_suspend,
+        .runtime_resume = tmio_mmc_host_runtime_resume,
+};
+
+static struct platform_driver sh_mobile_sdhi_driver = {
+        .driver         = {
+                .name   = "sh_mobile_sdhi",
+                .owner  = THIS_MODULE,
+                .pm     = &tmio_mmc_dev_pm_ops,
+        },
+        .probe          = sh_mobile_sdhi_probe,
+        .remove         = __devexit_p(sh_mobile_sdhi_remove),
+};
+
+static int __init sh_mobile_sdhi_init(void)
+{
+        return platform_driver_register(&sh_mobile_sdhi_driver);
+}
+
+static void __exit sh_mobile_sdhi_exit(void)
+{
+        platform_driver_unregister(&sh_mobile_sdhi_driver);
+}
+
+module_init(sh_mobile_sdhi_init);
+module_exit(sh_mobile_sdhi_exit);
+
+MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
+MODULE_AUTHOR("Magnus Damm");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sh_mobile_sdhi");
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index cec99958b652..457c26ea09de 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -978,11 +978,10 @@ static int tifm_sd_probe(struct tifm_dev *sock)
         mmc->f_max = 24000000;
 
         mmc->max_blk_count = 2048;
-        mmc->max_hw_segs = mmc->max_blk_count;
+        mmc->max_segs = mmc->max_blk_count;
         mmc->max_blk_size = min(TIFM_MMCSD_MAX_BLOCK_SIZE, PAGE_SIZE);
         mmc->max_seg_size = mmc->max_blk_count * mmc->max_blk_size;
         mmc->max_req_size = mmc->max_seg_size;
-        mmc->max_phys_segs = mmc->max_hw_segs;
 
         sock->card_event = tifm_sd_card_event;
         sock->data_event = tifm_sd_data_event;
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 69d98e3bf6ab..8d185de90d20 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -1,8 +1,8 @@
 /*
- *  linux/drivers/mmc/tmio_mmc.c
+ * linux/drivers/mmc/host/tmio_mmc.c
  *
- *  Copyright (C) 2004 Ian Molton
- *  Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
  *
  * 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
@@ -11,765 +11,26 @@
  * Driver for the MMC / SD / SDIO cell found in:
  *
  * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
- *
- * This driver draws mainly on scattered spec sheets, Reverse engineering
- * of the toshiba e800  SD driver and some parts of the 2.4 ASIC3 driver (4 bit
- * support). (Further 4 bit support from a later datasheet).
- *
- * TODO:
- *   Investigate using a workqueue for PIO transfers
- *   Eliminate FIXMEs
- *   SDIO support
- *   Better Power management
- *   Handle MMC errors better
- *   double buffer support
- *
  */
-#include <linux/module.h>
-#include <linux/irq.h>
+
 #include <linux/device.h>
-#include <linux/delay.h>
-#include <linux/dmaengine.h>
-#include <linux/mmc/host.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/tmio.h>
+#include <linux/mmc/host.h>
+#include <linux/module.h>
+#include <linux/pagemap.h>
+#include <linux/scatterlist.h>
 
 #include "tmio_mmc.h"
 
-static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
-{
-        u32 clk = 0, clock;
-
-        if (new_clock) {
-                for (clock = host->mmc->f_min, clk = 0x80000080;
-                        new_clock >= (clock<<1); clk >>= 1)
-                        clock <<= 1;
-                clk |= 0x100;
-        }
-
-        if (host->set_clk_div)
-                host->set_clk_div(host->pdev, (clk>>22) & 1);
-
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & 0x1ff);
-}
-
-static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
-{
-        sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
-        msleep(10);
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~0x0100 &
-                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
-        msleep(10);
-}
-
-static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
-{
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, 0x0100 |
-                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
-        msleep(10);
-        sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
-        msleep(10);
-}
-
-static void reset(struct tmio_mmc_host *host)
-{
-        /* FIXME - should we set stop clock reg here */
-        sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
-        sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
-        msleep(10);
-        sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
-        sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
-        msleep(10);
-}
-
-static void
-tmio_mmc_finish_request(struct tmio_mmc_host *host)
-{
-        struct mmc_request *mrq = host->mrq;
-
-        host->mrq = NULL;
-        host->cmd = NULL;
-        host->data = NULL;
-
-        mmc_request_done(host->mmc, mrq);
-}
-
-/* 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
-#define RESP_NONE      0x0300
-#define RESP_R1        0x0400
-#define RESP_R1B       0x0500
-#define RESP_R2        0x0600
-#define RESP_R3        0x0700
-#define DATA_PRESENT   0x0800
-#define TRANSFER_READ  0x1000
-#define TRANSFER_MULTI 0x2000
-#define SECURITY_CMD   0x4000
-
-static int
-tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
-{
-        struct mmc_data *data = host->data;
-        int c = cmd->opcode;
-
-        /* Command 12 is handled by hardware */
-        if (cmd->opcode == 12 && !cmd->arg) {
-                sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
-                return 0;
-        }
-
-        switch (mmc_resp_type(cmd)) {
-        case MMC_RSP_NONE: c |= RESP_NONE; break;
-        case MMC_RSP_R1:   c |= RESP_R1;   break;
-        case MMC_RSP_R1B:  c |= RESP_R1B;  break;
-        case MMC_RSP_R2:   c |= RESP_R2;   break;
-        case MMC_RSP_R3:   c |= RESP_R3;   break;
-        default:
-                pr_debug("Unknown response type %d\n", mmc_resp_type(cmd));
-                return -EINVAL;
-        }
-
-        host->cmd = cmd;
-
-/* FIXME - this seems to be ok commented out but the spec suggest this bit
- *         should be set when issuing app commands.
- *      if(cmd->flags & MMC_FLAG_ACMD)
- *              c |= APP_CMD;
- */
-        if (data) {
-                c |= DATA_PRESENT;
-                if (data->blocks > 1) {
-                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x100);
-                        c |= TRANSFER_MULTI;
-                }
-                if (data->flags & MMC_DATA_READ)
-                        c |= TRANSFER_READ;
-        }
-
-        enable_mmc_irqs(host, TMIO_MASK_CMD);
-
-        /* Fire off the command */
-        sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
-        sd_ctrl_write16(host, CTL_SD_CMD, c);
-
-        return 0;
-}
-
-/*
- * This chip always returns (at least?) as much data as you ask for.
- * I'm unsure what happens if you ask for less than a block. This should be
- * looked into to ensure that a funny length read doesnt hose the controller.
- */
-static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data = host->data;
-        void *sg_virt;
-        unsigned short *buf;
-        unsigned int count;
-        unsigned long flags;
-
-        if (!data) {
-                pr_debug("Spurious PIO IRQ\n");
-                return;
-        }
-
-        sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
-        buf = (unsigned short *)(sg_virt + host->sg_off);
-
-        count = host->sg_ptr->length - host->sg_off;
-        if (count > data->blksz)
-                count = data->blksz;
-
-        pr_debug("count: %08x offset: %08x flags %08x\n",
-                 count, host->sg_off, data->flags);
-
-        /* Transfer the data */
-        if (data->flags & MMC_DATA_READ)
-                sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
-        else
-                sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
-
-        host->sg_off += count;
-
-        tmio_mmc_kunmap_atomic(sg_virt, &flags);
-
-        if (host->sg_off == host->sg_ptr->length)
-                tmio_mmc_next_sg(host);
-
-        return;
-}
-
-static void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data = host->data;
-        struct mmc_command *stop;
-
-        host->data = NULL;
-
-        if (!data) {
-                dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
-                return;
-        }
-        stop = data->stop;
-
-        /* FIXME - return correct transfer count on errors */
-        if (!data->error)
-                data->bytes_xfered = data->blocks * data->blksz;
-        else
-                data->bytes_xfered = 0;
-
-        pr_debug("Completed data request\n");
-
-        /*
-         * FIXME: other drivers allow an optional stop command of any given type
-         *        which we dont do, as the chip can auto generate them.
-         *        Perhaps we can be smarter about when to use auto CMD12 and
-         *        only issue the auto request when we know this is the desired
-         *        stop command, allowing fallback to the stop command the
-         *        upper layers expect. For now, we do what works.
-         */
-
-        if (data->flags & MMC_DATA_READ) {
-                if (!host->chan_rx)
-                        disable_mmc_irqs(host, TMIO_MASK_READOP);
-                dev_dbg(&host->pdev->dev, "Complete Rx request %p\n",
-                        host->mrq);
-        } else {
-                if (!host->chan_tx)
-                        disable_mmc_irqs(host, TMIO_MASK_WRITEOP);
-                dev_dbg(&host->pdev->dev, "Complete Tx request %p\n",
-                        host->mrq);
-        }
-
-        if (stop) {
-                if (stop->opcode == 12 && !stop->arg)
-                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
-                else
-                        BUG();
-        }
-
-        tmio_mmc_finish_request(host);
-}
-
-static void tmio_mmc_data_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data = host->data;
-
-        if (!data)
-                return;
-
-        if (host->chan_tx && (data->flags & MMC_DATA_WRITE)) {
-                /*
-                 * Has all data been written out yet? Testing on SuperH showed,
-                 * that in most cases the first interrupt comes already with the
-                 * BUSY status bit clear, but on some operations, like mount or
-                 * in the beginning of a write / sync / umount, there is one
-                 * DATAEND interrupt with the BUSY bit set, in this cases
-                 * waiting for one more interrupt fixes the problem.
-                 */
-                if (!(sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_CMD_BUSY)) {
-                        disable_mmc_irqs(host, TMIO_STAT_DATAEND);
-                        tasklet_schedule(&host->dma_complete);
-                }
-        } else if (host->chan_rx && (data->flags & MMC_DATA_READ)) {
-                disable_mmc_irqs(host, TMIO_STAT_DATAEND);
-                tasklet_schedule(&host->dma_complete);
-        } else {
-                tmio_mmc_do_data_irq(host);
-        }
-}
-
-static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
-        unsigned int stat)
-{
-        struct mmc_command *cmd = host->cmd;
-        int i, addr;
-
-        if (!host->cmd) {
-                pr_debug("Spurious CMD irq\n");
-                return;
-        }
-
-        host->cmd = NULL;
-
-        /* This controller is sicker than the PXA one. Not only do we need to
-         * drop the top 8 bits of the first response word, we also need to
-         * modify the order of the response for short response command types.
-         */
-
-        for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
-                cmd->resp[i] = sd_ctrl_read32(host, addr);
-
-        if (cmd->flags &  MMC_RSP_136) {
-                cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
-                cmd->resp[1] = (cmd->resp[1] << 8) | (cmd->resp[2] >> 24);
-                cmd->resp[2] = (cmd->resp[2] << 8) | (cmd->resp[3] >> 24);
-                cmd->resp[3] <<= 8;
-        } else if (cmd->flags & MMC_RSP_R3) {
-                cmd->resp[0] = cmd->resp[3];
-        }
-
-        if (stat & TMIO_STAT_CMDTIMEOUT)
-                cmd->error = -ETIMEDOUT;
-        else if (stat & TMIO_STAT_CRCFAIL && cmd->flags & MMC_RSP_CRC)
-                cmd->error = -EILSEQ;
-
-        /* If there is data to handle we enable data IRQs here, and
-         * we will ultimatley finish the request in the data_end handler.
-         * If theres no data or we encountered an error, finish now.
-         */
-        if (host->data && !cmd->error) {
-                if (host->data->flags & MMC_DATA_READ) {
-                        if (!host->chan_rx)
-                                enable_mmc_irqs(host, TMIO_MASK_READOP);
-                } else {
-                        struct dma_chan *chan = host->chan_tx;
-                        if (!chan)
-                                enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
-                        else
-                                tasklet_schedule(&host->dma_issue);
-                }
-        } else {
-                tmio_mmc_finish_request(host);
-        }
-
-        return;
-}
-
-static irqreturn_t tmio_mmc_irq(int irq, void *devid)
-{
-        struct tmio_mmc_host *host = devid;
-        unsigned int ireg, irq_mask, status;
-
-        pr_debug("MMC IRQ begin\n");
-
-        status = sd_ctrl_read32(host, CTL_STATUS);
-        irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
-        ireg = status & TMIO_MASK_IRQ & ~irq_mask;
-
-        pr_debug_status(status);
-        pr_debug_status(ireg);
-
-        if (!ireg) {
-                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);
-
-                goto out;
-        }
-
-        while (ireg) {
-                /* Card insert / remove attempts */
-                if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
-                        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);
- */
-
-                /* Command completion */
-                if (ireg & TMIO_MASK_CMD) {
-                        ack_mmc_irqs(host, TMIO_MASK_CMD);
-                        tmio_mmc_cmd_irq(host, status);
-                }
-
-                /* Data transfer */
-                if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
-                        ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
-                        tmio_mmc_pio_irq(host);
-                }
-
-                /* Data transfer completion */
-                if (ireg & TMIO_STAT_DATAEND) {
-                        ack_mmc_irqs(host, TMIO_STAT_DATAEND);
-                        tmio_mmc_data_irq(host);
-                }
-
-                /* 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;
-
-                pr_debug("Status at end of loop: %08x\n", status);
-                pr_debug_status(status);
-        }
-        pr_debug("MMC IRQ end\n");
-
-out:
-        return IRQ_HANDLED;
-}
-
-#ifdef CONFIG_TMIO_MMC_DMA
-static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
-{
-#if defined(CONFIG_SUPERH) || defined(CONFIG_ARCH_SHMOBILE)
-        /* Switch DMA mode on or off - SuperH specific? */
-        sd_ctrl_write16(host, 0xd8, enable ? 2 : 0);
-#endif
-}
-
-static void tmio_dma_complete(void *arg)
-{
-        struct tmio_mmc_host *host = arg;
-
-        dev_dbg(&host->pdev->dev, "Command completed\n");
-
-        if (!host->data)
-                dev_warn(&host->pdev->dev, "NULL data in DMA completion!\n");
-        else
-                enable_mmc_irqs(host, TMIO_STAT_DATAEND);
-}
-
-static int tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
-{
-        struct scatterlist *sg = host->sg_ptr;
-        struct dma_async_tx_descriptor *desc = NULL;
-        struct dma_chan *chan = host->chan_rx;
-        int ret;
-
-        ret = dma_map_sg(&host->pdev->dev, sg, host->sg_len, DMA_FROM_DEVICE);
-        if (ret > 0) {
-                host->dma_sglen = ret;
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                        DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        }
-
-        if (desc) {
-                host->desc = desc;
-                desc->callback = tmio_dma_complete;
-                desc->callback_param = host;
-                host->cookie = desc->tx_submit(desc);
-                if (host->cookie < 0) {
-                        host->desc = NULL;
-                        ret = host->cookie;
-                } else {
-                        chan->device->device_issue_pending(chan);
-                }
-        }
-        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
-                __func__, host->sg_len, ret, host->cookie, host->mrq);
-
-        if (!host->desc) {
-                /* DMA failed, fall back to PIO */
-                if (ret >= 0)
-                        ret = -EIO;
-                host->chan_rx = NULL;
-                dma_release_channel(chan);
-                /* Free the Tx channel too */
-                chan = host->chan_tx;
-                if (chan) {
-                        host->chan_tx = NULL;
-                        dma_release_channel(chan);
-                }
-                dev_warn(&host->pdev->dev,
-                         "DMA failed: %d, falling back to PIO\n", ret);
-                tmio_mmc_enable_dma(host, false);
-                reset(host);
-                /* Fail this request, let above layers recover */
-                host->mrq->cmd->error = ret;
-                tmio_mmc_finish_request(host);
-        }
-
-        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
-                desc, host->cookie, host->sg_len);
-
-        return ret > 0 ? 0 : ret;
-}
-
-static int tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
-{
-        struct scatterlist *sg = host->sg_ptr;
-        struct dma_async_tx_descriptor *desc = NULL;
-        struct dma_chan *chan = host->chan_tx;
-        int ret;
-
-        ret = dma_map_sg(&host->pdev->dev, sg, host->sg_len, DMA_TO_DEVICE);
-        if (ret > 0) {
-                host->dma_sglen = ret;
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                        DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        }
-
-        if (desc) {
-                host->desc = desc;
-                desc->callback = tmio_dma_complete;
-                desc->callback_param = host;
-                host->cookie = desc->tx_submit(desc);
-                if (host->cookie < 0) {
-                        host->desc = NULL;
-                        ret = host->cookie;
-                }
-        }
-        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
-                __func__, host->sg_len, ret, host->cookie, host->mrq);
-
-        if (!host->desc) {
-                /* DMA failed, fall back to PIO */
-                if (ret >= 0)
-                        ret = -EIO;
-                host->chan_tx = NULL;
-                dma_release_channel(chan);
-                /* Free the Rx channel too */
-                chan = host->chan_rx;
-                if (chan) {
-                        host->chan_rx = NULL;
-                        dma_release_channel(chan);
-                }
-                dev_warn(&host->pdev->dev,
-                         "DMA failed: %d, falling back to PIO\n", ret);
-                tmio_mmc_enable_dma(host, false);
-                reset(host);
-                /* Fail this request, let above layers recover */
-                host->mrq->cmd->error = ret;
-                tmio_mmc_finish_request(host);
-        }
-
-        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d\n", __func__,
-                desc, host->cookie);
-
-        return ret > 0 ? 0 : ret;
-}
-
-static int tmio_mmc_start_dma(struct tmio_mmc_host *host,
-                               struct mmc_data *data)
-{
-        if (data->flags & MMC_DATA_READ) {
-                if (host->chan_rx)
-                        return tmio_mmc_start_dma_rx(host);
-        } else {
-                if (host->chan_tx)
-                        return tmio_mmc_start_dma_tx(host);
-        }
-
-        return 0;
-}
-
-static void tmio_issue_tasklet_fn(unsigned long priv)
-{
-        struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;
-        struct dma_chan *chan = host->chan_tx;
-
-        chan->device->device_issue_pending(chan);
-}
-
-static void tmio_tasklet_fn(unsigned long arg)
-{
-        struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
-
-        if (host->data->flags & MMC_DATA_READ)
-                dma_unmap_sg(&host->pdev->dev, host->sg_ptr, host->dma_sglen,
-                             DMA_FROM_DEVICE);
-        else
-                dma_unmap_sg(&host->pdev->dev, host->sg_ptr, host->dma_sglen,
-                             DMA_TO_DEVICE);
-
-        tmio_mmc_do_data_irq(host);
-}
-
-/* It might be necessary to make filter MFD specific */
-static bool tmio_mmc_filter(struct dma_chan *chan, void *arg)
-{
-        dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);
-        chan->private = arg;
-        return true;
-}
-
-static void tmio_mmc_request_dma(struct tmio_mmc_host *host,
-                                 struct tmio_mmc_data *pdata)
-{
-        host->cookie = -EINVAL;
-        host->desc = NULL;
-
-        /* We can only either use DMA for both Tx and Rx or not use it at all */
-        if (pdata->dma) {
-                dma_cap_mask_t mask;
-
-                dma_cap_zero(mask);
-                dma_cap_set(DMA_SLAVE, mask);
-
-                host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,
-                                                    pdata->dma->chan_priv_tx);
-                dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,
-                        host->chan_tx);
-
-                if (!host->chan_tx)
-                        return;
-
-                host->chan_rx = dma_request_channel(mask, tmio_mmc_filter,
-                                                    pdata->dma->chan_priv_rx);
-                dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,
-                        host->chan_rx);
-
-                if (!host->chan_rx) {
-                        dma_release_channel(host->chan_tx);
-                        host->chan_tx = NULL;
-                        return;
-                }
-
-                tasklet_init(&host->dma_complete, tmio_tasklet_fn, (unsigned long)host);
-                tasklet_init(&host->dma_issue, tmio_issue_tasklet_fn, (unsigned long)host);
-
-                tmio_mmc_enable_dma(host, true);
-        }
-}
-
-static void tmio_mmc_release_dma(struct tmio_mmc_host *host)
-{
-        if (host->chan_tx) {
-                struct dma_chan *chan = host->chan_tx;
-                host->chan_tx = NULL;
-                dma_release_channel(chan);
-        }
-        if (host->chan_rx) {
-                struct dma_chan *chan = host->chan_rx;
-                host->chan_rx = NULL;
-                dma_release_channel(chan);
-        }
-
-        host->cookie = -EINVAL;
-        host->desc = NULL;
-}
-#else
-static int tmio_mmc_start_dma(struct tmio_mmc_host *host,
-                               struct mmc_data *data)
-{
-        return 0;
-}
-
-static void tmio_mmc_request_dma(struct tmio_mmc_host *host,
-                                 struct tmio_mmc_data *pdata)
-{
-        host->chan_tx = NULL;
-        host->chan_rx = NULL;
-}
-
-static void tmio_mmc_release_dma(struct tmio_mmc_host *host)
-{
-}
-#endif
-
-static int tmio_mmc_start_data(struct tmio_mmc_host *host,
-        struct mmc_data *data)
-{
-        pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
-                 data->blksz, data->blocks);
-
-        /* Hardware cannot perform 1 and 2 byte requests in 4 bit mode */
-        if (data->blksz < 4 && host->mmc->ios.bus_width == MMC_BUS_WIDTH_4) {
-                pr_err("%s: %d byte block unsupported in 4 bit mode\n",
-                       mmc_hostname(host->mmc), data->blksz);
-                return -EINVAL;
-        }
-
-        tmio_mmc_init_sg(host, data);
-        host->data = data;
-
-        /* Set transfer length / blocksize */
-        sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
-        sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);
-
-        return tmio_mmc_start_dma(host, data);
-}
-
-/* Process requests from the MMC layer */
-static void tmio_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        int ret;
-
-        if (host->mrq)
-                pr_debug("request not null\n");
-
-        host->mrq = mrq;
-
-        if (mrq->data) {
-                ret = tmio_mmc_start_data(host, mrq->data);
-                if (ret)
-                        goto fail;
-        }
-
-        ret = tmio_mmc_start_command(host, mrq->cmd);
-        if (!ret)
-                return;
-
-fail:
-        mrq->cmd->error = ret;
-        mmc_request_done(mmc, mrq);
-}
-
-/* Set MMC clock / power.
- * Note: This controller uses a simple divider scheme therefore it cannot
- * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
- * MMC wont run that fast, it has to be clocked at 12MHz which is the next
- * slowest setting.
- */
-static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-
-        if (ios->clock)
-                tmio_mmc_set_clock(host, ios->clock);
-
-        /* Power sequence - OFF -> ON -> UP */
-        switch (ios->power_mode) {
-        case MMC_POWER_OFF: /* power down SD bus */
-                if (host->set_pwr)
-                        host->set_pwr(host->pdev, 0);
-                tmio_mmc_clk_stop(host);
-                break;
-        case MMC_POWER_ON: /* power up SD bus */
-                if (host->set_pwr)
-                        host->set_pwr(host->pdev, 1);
-                break;
-        case MMC_POWER_UP: /* start bus clock */
-                tmio_mmc_clk_start(host);
-                break;
-        }
-
-        switch (ios->bus_width) {
-        case MMC_BUS_WIDTH_1:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
-        break;
-        case MMC_BUS_WIDTH_4:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
-        break;
-        }
-
-        /* Let things settle. delay taken from winCE driver */
-        udelay(140);
-}
-
-static int tmio_mmc_get_ro(struct mmc_host *mmc)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct mfd_cell *cell = host->pdev->dev.platform_data;
-        struct tmio_mmc_data *pdata = cell->driver_data;
-
-        return ((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
-                (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT)) ? 0 : 1;
-}
-
-static const struct mmc_host_ops tmio_mmc_ops = {
-        .request        = tmio_mmc_request,
-        .set_ios        = tmio_mmc_set_ios,
-        .get_ro         = tmio_mmc_get_ro,
-};
-
 #ifdef CONFIG_PM
 static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct mfd_cell *cell = (struct mfd_cell *)dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret;
 
-        ret = mmc_suspend_host(mmc);
+        ret = tmio_mmc_host_suspend(&dev->dev);
 
         /* Tell MFD core it can disable us now.*/
         if (!ret && cell->disable)
@@ -780,20 +41,17 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 
 static int tmio_mmc_resume(struct platform_device *dev)
 {
-        struct mfd_cell *cell = (struct mfd_cell *)dev->dev.platform_data;
+        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 */
-        if (cell->resume) {
+        if (cell->resume)
                 ret = cell->resume(dev);
-                if (ret)
-                        goto out;
-        }
 
-        mmc_resume_host(mmc);
+        if (!ret)
+                ret = tmio_mmc_host_resume(&dev->dev);
 
-out:
         return ret;
 }
 #else
@@ -801,125 +59,69 @@ out:
 #define tmio_mmc_resume NULL
 #endif
 
-static int __devinit tmio_mmc_probe(struct platform_device *dev)
+static int __devinit tmio_mmc_probe(struct platform_device *pdev)
 {
-        struct mfd_cell *cell = (struct mfd_cell *)dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(pdev);
         struct tmio_mmc_data *pdata;
-        struct resource *res_ctl;
         struct tmio_mmc_host *host;
-        struct mmc_host *mmc;
-        int ret = -EINVAL;
-        u32 irq_mask = TMIO_MASK_CMD;
-
-        if (dev->num_resources != 2)
-                goto out;
+        int ret = -EINVAL, irq;
 
-        res_ctl = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res_ctl)
+        if (pdev->num_resources != 2)
                 goto out;
 
-        pdata = cell->driver_data;
+        pdata = pdev->dev.platform_data;
         if (!pdata || !pdata->hclk)
                 goto out;
 
-        ret = -ENOMEM;
-
-        mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
-        if (!mmc)
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                ret = irq;
                 goto out;
-
-        host = mmc_priv(mmc);
-        host->mmc = mmc;
-        host->pdev = dev;
-        platform_set_drvdata(dev, mmc);
-
-        host->set_pwr = pdata->set_pwr;
-        host->set_clk_div = pdata->set_clk_div;
-
-        /* SD control register space size is 0x200, 0x400 for bus_shift=1 */
-        host->bus_shift = resource_size(res_ctl) >> 10;
-
-        host->ctl = ioremap(res_ctl->start, resource_size(res_ctl));
-        if (!host->ctl)
-                goto host_free;
-
-        mmc->ops = &tmio_mmc_ops;
-        mmc->caps = MMC_CAP_4_BIT_DATA;
-        mmc->caps |= pdata->capabilities;
-        mmc->f_max = pdata->hclk;
-        mmc->f_min = mmc->f_max / 512;
-        if (pdata->ocr_mask)
-                mmc->ocr_avail = pdata->ocr_mask;
-        else
-                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        }
 
         /* Tell the MFD core we are ready to be enabled */
         if (cell->enable) {
-                ret = cell->enable(dev);
+                ret = cell->enable(pdev);
                 if (ret)
-                        goto unmap_ctl;
+                        goto out;
         }
 
-        tmio_mmc_clk_stop(host);
-        reset(host);
-
-        ret = platform_get_irq(dev, 0);
-        if (ret >= 0)
-                host->irq = ret;
-        else
-                goto cell_disable;
-
-        disable_mmc_irqs(host, TMIO_MASK_ALL);
-
-        ret = request_irq(host->irq, tmio_mmc_irq, IRQF_DISABLED |
-                IRQF_TRIGGER_FALLING, dev_name(&dev->dev), host);
+        ret = tmio_mmc_host_probe(&host, pdev, pdata);
         if (ret)
                 goto cell_disable;
 
-        /* See if we also get DMA */
-        tmio_mmc_request_dma(host, pdata);
-
-        mmc_add_host(mmc);
+        ret = request_irq(irq, tmio_mmc_irq, IRQF_DISABLED |
+                          IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), host);
+        if (ret)
+                goto host_remove;
 
         pr_info("%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc),
-                (unsigned long)host->ctl, host->irq);
-
-        /* Unmask the IRQs we want to know about */
-        if (!host->chan_rx)
-                irq_mask |= TMIO_MASK_READOP;
-        if (!host->chan_tx)
-                irq_mask |= TMIO_MASK_WRITEOP;
-        enable_mmc_irqs(host, irq_mask);
+                (unsigned long)host->ctl, irq);
 
         return 0;
 
+host_remove:
+        tmio_mmc_host_remove(host);
 cell_disable:
         if (cell->disable)
-                cell->disable(dev);
-unmap_ctl:
-        iounmap(host->ctl);
-host_free:
-        mmc_free_host(mmc);
+                cell->disable(pdev);
 out:
         return ret;
 }
 
-static int __devexit tmio_mmc_remove(struct platform_device *dev)
+static int __devexit tmio_mmc_remove(struct platform_device *pdev)
 {
-        struct mfd_cell *cell = (struct mfd_cell *)dev->dev.platform_data;
-        struct mmc_host *mmc = platform_get_drvdata(dev);
+        const struct mfd_cell *cell = mfd_get_cell(pdev);
+        struct mmc_host *mmc = platform_get_drvdata(pdev);
 
-        platform_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         if (mmc) {
                 struct tmio_mmc_host *host = mmc_priv(mmc);
-                mmc_remove_host(mmc);
-                tmio_mmc_release_dma(host);
-                free_irq(host->irq, host);
+                free_irq(platform_get_irq(pdev, 0), host);
+                tmio_mmc_host_remove(host);
                 if (cell->disable)
-                        cell->disable(dev);
-                iounmap(host->ctl);
-                mmc_free_host(mmc);
+                        cell->disable(pdev);
         }
 
         return 0;
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index 0fedc78e3ea5..8260bc2c34e3 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -1,58 +1,31 @@
-/* Definitons for use with the tmio_mmc.c
+/*
+ * linux/drivers/mmc/host/tmio_mmc.h
  *
- * (c) 2004 Ian Molton <spyro@f2s.com>
- * (c) 2007 Ian Molton <spyro@f2s.com>
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
  *
  * 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.
  *
+ * Driver for the MMC / SD / SDIO cell found in:
+ *
+ * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
  */
 
+#ifndef TMIO_MMC_H
+#define TMIO_MMC_H
+
 #include <linux/highmem.h>
-#include <linux/interrupt.h>
-#include <linux/dmaengine.h>
-
-#define CTL_SD_CMD 0x00
-#define CTL_ARG_REG 0x04
-#define CTL_STOP_INTERNAL_ACTION 0x08
-#define CTL_XFER_BLK_COUNT 0xa
-#define CTL_RESPONSE 0x0c
-#define CTL_STATUS 0x1c
-#define CTL_IRQ_MASK 0x20
-#define CTL_SD_CARD_CLK_CTL 0x24
-#define CTL_SD_XFER_LEN 0x26
-#define CTL_SD_MEM_CARD_OPT 0x28
-#define CTL_SD_ERROR_DETAIL_STATUS 0x2c
-#define CTL_SD_DATA_PORT 0x30
-#define CTL_TRANSACTION_CTL 0x34
-#define CTL_RESET_SD 0xe0
-#define CTL_SDIO_REGS 0x100
-#define CTL_CLK_AND_WAIT_CTL 0x138
-#define CTL_RESET_SDIO 0x1e0
-
-/* Definitions for values the CTRL_STATUS register can take. */
-#define TMIO_STAT_CMDRESPEND    0x00000001
-#define TMIO_STAT_DATAEND       0x00000004
-#define TMIO_STAT_CARD_REMOVE   0x00000008
-#define TMIO_STAT_CARD_INSERT   0x00000010
-#define TMIO_STAT_SIGSTATE      0x00000020
-#define TMIO_STAT_WRPROTECT     0x00000080
-#define TMIO_STAT_CARD_REMOVE_A 0x00000100
-#define TMIO_STAT_CARD_INSERT_A 0x00000200
-#define TMIO_STAT_SIGSTATE_A    0x00000400
-#define TMIO_STAT_CMD_IDX_ERR   0x00010000
-#define TMIO_STAT_CRCFAIL       0x00020000
-#define TMIO_STAT_STOPBIT_ERR   0x00040000
-#define TMIO_STAT_DATATIMEOUT   0x00080000
-#define TMIO_STAT_RXOVERFLOW    0x00100000
-#define TMIO_STAT_TXUNDERRUN    0x00200000
-#define TMIO_STAT_CMDTIMEOUT    0x00400000
-#define TMIO_STAT_RXRDY         0x01000000
-#define TMIO_STAT_TXRQ          0x02000000
-#define TMIO_STAT_ILL_FUNC      0x20000000
-#define TMIO_STAT_CMD_BUSY      0x40000000
-#define TMIO_STAT_ILL_ACCESS    0x80000000
+#include <linux/mmc/tmio.h>
+#include <linux/pagemap.h>
+#include <linux/spinlock.h>
+
+/* Definitions for values the CTRL_SDIO_STATUS register can take. */
+#define TMIO_SDIO_STAT_IOIRQ    0x0001
+#define TMIO_SDIO_STAT_EXPUB52  0x4000
+#define TMIO_SDIO_STAT_EXWT     0x8000
+#define TMIO_SDIO_MASK_ALL      0xc007
 
 /* Define some IRQ masks */
 /* This is the mask used at reset by the chip */
@@ -63,28 +36,7 @@
                 TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT)
 #define TMIO_MASK_IRQ     (TMIO_MASK_READOP | TMIO_MASK_WRITEOP | TMIO_MASK_CMD)
 
-
-#define enable_mmc_irqs(host, i) \
-        do { \
-                u32 mask;\
-                mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
-                mask &= ~((i) & TMIO_MASK_IRQ); \
-                sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
-        } while (0)
-
-#define disable_mmc_irqs(host, i) \
-        do { \
-                u32 mask;\
-                mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
-                mask |= ((i) & TMIO_MASK_IRQ); \
-                sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
-        } while (0)
-
-#define ack_mmc_irqs(host, i) \
-        do { \
-                sd_ctrl_write32((host), CTL_STATUS, ~(i)); \
-        } while (0)
-
+struct tmio_mmc_data;
 
 struct tmio_mmc_host {
         void __iomem *ctl;
@@ -93,136 +45,93 @@ struct tmio_mmc_host {
         struct mmc_request      *mrq;
         struct mmc_data         *data;
         struct mmc_host         *mmc;
-        int                     irq;
+        unsigned int            sdio_irq_enabled;
 
         /* Callbacks for clock / power control */
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
 
+        int                     pm_error;
+
         /* pio related stuff */
         struct scatterlist      *sg_ptr;
+        struct scatterlist      *sg_orig;
         unsigned int            sg_len;
         unsigned int            sg_off;
 
         struct platform_device *pdev;
+        struct tmio_mmc_data *pdata;
 
         /* DMA support */
+        bool                    force_pio;
         struct dma_chan         *chan_rx;
         struct dma_chan         *chan_tx;
         struct tasklet_struct   dma_complete;
         struct tasklet_struct   dma_issue;
-#ifdef CONFIG_TMIO_MMC_DMA
-        struct dma_async_tx_descriptor *desc;
-        unsigned int            dma_sglen;
-        dma_cookie_t            cookie;
-#endif
-};
-
-#include <linux/io.h>
+        struct scatterlist      bounce_sg;
+        u8                      *bounce_buf;
 
-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);
-}
+        /* Track lost interrupts */
+        struct delayed_work     delayed_reset_work;
+        spinlock_t              lock;
+        unsigned long           last_req_ts;
+};
 
-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;
-}
+int tmio_mmc_host_probe(struct tmio_mmc_host **host,
+                        struct platform_device *pdev,
+                        struct tmio_mmc_data *pdata);
+void tmio_mmc_host_remove(struct tmio_mmc_host *host);
+void tmio_mmc_do_data_irq(struct tmio_mmc_host *host);
 
-static inline void sd_ctrl_write16(struct tmio_mmc_host *host, int addr,
-                u16 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-}
+void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i);
+void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i);
+irqreturn_t tmio_mmc_irq(int irq, void *devid);
 
-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)
+static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,
+                                         unsigned long *flags)
 {
-        writew(val, host->ctl + (addr << host->bus_shift));
-        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
+        local_irq_save(*flags);
+        return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 }
 
-#include <linux/scatterlist.h>
-#include <linux/blkdev.h>
-
-static inline void tmio_mmc_init_sg(struct tmio_mmc_host *host,
-        struct mmc_data *data)
+static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg,
+                                          unsigned long *flags, void *virt)
 {
-        host->sg_len = data->sg_len;
-        host->sg_ptr = data->sg;
-        host->sg_off = 0;
+        kunmap_atomic(virt - sg->offset, KM_BIO_SRC_IRQ);
+        local_irq_restore(*flags);
 }
 
-static inline int tmio_mmc_next_sg(struct tmio_mmc_host *host)
+#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_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata);
+void tmio_mmc_release_dma(struct tmio_mmc_host *host);
+#else
+static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,
+                               struct mmc_data *data)
 {
-        host->sg_ptr = sg_next(host->sg_ptr);
-        host->sg_off = 0;
-        return --host->sg_len;
 }
 
-static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,
-        unsigned long *flags)
+static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
+                                 struct tmio_mmc_data *pdata)
 {
-        local_irq_save(*flags);
-        return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+        host->chan_tx = NULL;
+        host->chan_rx = NULL;
 }
 
-static inline void tmio_mmc_kunmap_atomic(void *virt,
-        unsigned long *flags)
+static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)
 {
-        kunmap_atomic(virt, KM_BIO_SRC_IRQ);
-        local_irq_restore(*flags);
 }
+#endif
 
-#ifdef CONFIG_MMC_DEBUG
-
-#define STATUS_TO_TEXT(a) \
-        do { \
-                if (status & TMIO_STAT_##a) \
-                        printk(#a); \
-        } while (0)
+#ifdef CONFIG_PM
+int tmio_mmc_host_suspend(struct device *dev);
+int tmio_mmc_host_resume(struct device *dev);
+#else
+#define tmio_mmc_host_suspend NULL
+#define tmio_mmc_host_resume NULL
+#endif
 
-void pr_debug_status(u32 status)
-{
-        printk(KERN_DEBUG "status: %08x = ", status);
-        STATUS_TO_TEXT(CARD_REMOVE);
-        STATUS_TO_TEXT(CARD_INSERT);
-        STATUS_TO_TEXT(SIGSTATE);
-        STATUS_TO_TEXT(WRPROTECT);
-        STATUS_TO_TEXT(CARD_REMOVE_A);
-        STATUS_TO_TEXT(CARD_INSERT_A);
-        STATUS_TO_TEXT(SIGSTATE_A);
-        STATUS_TO_TEXT(CMD_IDX_ERR);
-        STATUS_TO_TEXT(STOPBIT_ERR);
-        STATUS_TO_TEXT(ILL_FUNC);
-        STATUS_TO_TEXT(CMD_BUSY);
-        STATUS_TO_TEXT(CMDRESPEND);
-        STATUS_TO_TEXT(DATAEND);
-        STATUS_TO_TEXT(CRCFAIL);
-        STATUS_TO_TEXT(DATATIMEOUT);
-        STATUS_TO_TEXT(CMDTIMEOUT);
-        STATUS_TO_TEXT(RXOVERFLOW);
-        STATUS_TO_TEXT(TXUNDERRUN);
-        STATUS_TO_TEXT(RXRDY);
-        STATUS_TO_TEXT(TXRQ);
-        STATUS_TO_TEXT(ILL_ACCESS);
-        printk("\n");
-}
+int tmio_mmc_host_runtime_suspend(struct device *dev);
+int tmio_mmc_host_runtime_resume(struct device *dev);
 
-#else
-#define pr_debug_status(s)  do { } while (0)
 #endif
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
new file mode 100644
index 000000000000..25f1ad6cbe09
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -0,0 +1,320 @@
+/*
+ * linux/drivers/mmc/tmio_mmc_dma.c
+ *
+ * Copyright (C) 2010-2011 Guennadi Liakhovetski
+ *
+ * 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.
+ *
+ * DMA function for TMIO MMC implementations
+ */
+
+#include <linux/device.h>
+#include <linux/dmaengine.h>
+#include <linux/mfd/tmio.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/tmio.h>
+#include <linux/pagemap.h>
+#include <linux/scatterlist.h>
+
+#include "tmio_mmc.h"
+
+#define TMIO_MMC_MIN_DMA_LEN 8
+
+static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
+{
+#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));
+#endif
+}
+
+static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
+{
+        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_rx;
+        struct tmio_mmc_data *pdata = host->pdata;
+        dma_cookie_t cookie;
+        int ret, i;
+        bool aligned = true, multiple = true;
+        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
+
+        for_each_sg(sg, sg_tmp, host->sg_len, i) {
+                if (sg_tmp->offset & align)
+                        aligned = false;
+                if (sg_tmp->length & align) {
+                        multiple = false;
+                        break;
+                }
+        }
+
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+                          (align & PAGE_MASK))) || !multiple) {
+                ret = -EINVAL;
+                goto pio;
+        }
+
+        if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
+                host->force_pio = true;
+                return;
+        }
+
+        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_RXRDY);
+
+        /* The only sg element can be unaligned, use our bounce buffer then */
+        if (!aligned) {
+                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
+                host->sg_ptr = &host->bounce_sg;
+                sg = host->sg_ptr;
+        }
+
+        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
+        if (ret > 0)
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_FROM_DEVICE, DMA_CTRL_ACK);
+
+        if (desc) {
+                cookie = dmaengine_submit(desc);
+                if (cookie < 0) {
+                        desc = NULL;
+                        ret = cookie;
+                }
+        }
+        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
+                __func__, host->sg_len, ret, cookie, host->mrq);
+
+pio:
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_rx = NULL;
+                dma_release_channel(chan);
+                /* Free the Tx channel too */
+                chan = host->chan_tx;
+                if (chan) {
+                        host->chan_tx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pdev->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                tmio_mmc_enable_dma(host, false);
+        }
+
+        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
+                desc, cookie, host->sg_len);
+}
+
+static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
+{
+        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_tx;
+        struct tmio_mmc_data *pdata = host->pdata;
+        dma_cookie_t cookie;
+        int ret, i;
+        bool aligned = true, multiple = true;
+        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
+
+        for_each_sg(sg, sg_tmp, host->sg_len, i) {
+                if (sg_tmp->offset & align)
+                        aligned = false;
+                if (sg_tmp->length & align) {
+                        multiple = false;
+                        break;
+                }
+        }
+
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+                          (align & PAGE_MASK))) || !multiple) {
+                ret = -EINVAL;
+                goto pio;
+        }
+
+        if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
+                host->force_pio = true;
+                return;
+        }
+
+        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_TXRQ);
+
+        /* The only sg element can be unaligned, use our bounce buffer then */
+        if (!aligned) {
+                unsigned long flags;
+                void *sg_vaddr = tmio_mmc_kmap_atomic(sg, &flags);
+                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
+                memcpy(host->bounce_buf, sg_vaddr, host->bounce_sg.length);
+                tmio_mmc_kunmap_atomic(sg, &flags, sg_vaddr);
+                host->sg_ptr = &host->bounce_sg;
+                sg = host->sg_ptr;
+        }
+
+        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
+        if (ret > 0)
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_TO_DEVICE, DMA_CTRL_ACK);
+
+        if (desc) {
+                cookie = dmaengine_submit(desc);
+                if (cookie < 0) {
+                        desc = NULL;
+                        ret = cookie;
+                }
+        }
+        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
+                __func__, host->sg_len, ret, cookie, host->mrq);
+
+pio:
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_tx = NULL;
+                dma_release_channel(chan);
+                /* Free the Rx channel too */
+                chan = host->chan_rx;
+                if (chan) {
+                        host->chan_rx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pdev->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                tmio_mmc_enable_dma(host, false);
+        }
+
+        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d\n", __func__,
+                desc, cookie);
+}
+
+void tmio_mmc_start_dma(struct tmio_mmc_host *host,
+                               struct mmc_data *data)
+{
+        if (data->flags & MMC_DATA_READ) {
+                if (host->chan_rx)
+                        tmio_mmc_start_dma_rx(host);
+        } else {
+                if (host->chan_tx)
+                        tmio_mmc_start_dma_tx(host);
+        }
+}
+
+static void tmio_mmc_issue_tasklet_fn(unsigned long priv)
+{
+        struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;
+        struct dma_chan *chan = NULL;
+
+        spin_lock_irq(&host->lock);
+
+        if (host && host->data) {
+                if (host->data->flags & MMC_DATA_READ)
+                        chan = host->chan_rx;
+                else
+                        chan = host->chan_tx;
+        }
+
+        spin_unlock_irq(&host->lock);
+
+        tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
+
+        if (chan)
+                dma_async_issue_pending(chan);
+}
+
+static void tmio_mmc_tasklet_fn(unsigned long arg)
+{
+        struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
+
+        spin_lock_irq(&host->lock);
+
+        if (!host->data)
+                goto out;
+
+        if (host->data->flags & MMC_DATA_READ)
+                dma_unmap_sg(host->chan_rx->device->dev,
+                             host->sg_ptr, host->sg_len,
+                             DMA_FROM_DEVICE);
+        else
+                dma_unmap_sg(host->chan_tx->device->dev,
+                             host->sg_ptr, host->sg_len,
+                             DMA_TO_DEVICE);
+
+        tmio_mmc_do_data_irq(host);
+out:
+        spin_unlock_irq(&host->lock);
+}
+
+/* It might be necessary to make filter MFD specific */
+static bool tmio_mmc_filter(struct dma_chan *chan, void *arg)
+{
+        dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);
+        chan->private = arg;
+        return true;
+}
+
+void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata)
+{
+        /* We can only either use DMA for both Tx and Rx or not use it at all */
+        if (!pdata->dma)
+                return;
+
+        if (!host->chan_tx && !host->chan_rx) {
+                dma_cap_mask_t mask;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,
+                                                    pdata->dma->chan_priv_tx);
+                dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,
+                        host->chan_tx);
+
+                if (!host->chan_tx)
+                        return;
+
+                host->chan_rx = dma_request_channel(mask, tmio_mmc_filter,
+                                                    pdata->dma->chan_priv_rx);
+                dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,
+                        host->chan_rx);
+
+                if (!host->chan_rx)
+                        goto ereqrx;
+
+                host->bounce_buf = (u8 *)__get_free_page(GFP_KERNEL | GFP_DMA);
+                if (!host->bounce_buf)
+                        goto ebouncebuf;
+
+                tasklet_init(&host->dma_complete, tmio_mmc_tasklet_fn, (unsigned long)host);
+                tasklet_init(&host->dma_issue, tmio_mmc_issue_tasklet_fn, (unsigned long)host);
+        }
+
+        tmio_mmc_enable_dma(host, true);
+
+        return;
+
+ebouncebuf:
+        dma_release_channel(host->chan_rx);
+        host->chan_rx = NULL;
+ereqrx:
+        dma_release_channel(host->chan_tx);
+        host->chan_tx = NULL;
+}
+
+void tmio_mmc_release_dma(struct tmio_mmc_host *host)
+{
+        if (host->chan_tx) {
+                struct dma_chan *chan = host->chan_tx;
+                host->chan_tx = NULL;
+                dma_release_channel(chan);
+        }
+        if (host->chan_rx) {
+                struct dma_chan *chan = host->chan_rx;
+                host->chan_rx = NULL;
+                dma_release_channel(chan);
+        }
+        if (host->bounce_buf) {
+                free_pages((unsigned long)host->bounce_buf, 0);
+                host->bounce_buf = NULL;
+        }
+}
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
new file mode 100644
index 000000000000..0b09e8239aa0
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -0,0 +1,1037 @@
+/*
+ * linux/drivers/mmc/host/tmio_mmc_pio.c
+ *
+ * Copyright (C) 2011 Guennadi Liakhovetski
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
+ *
+ * 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.
+ *
+ * Driver for the MMC / SD / SDIO IP found in:
+ *
+ * TC6393XB, TC6391XB, TC6387XB, T7L66XB, ASIC3, SH-Mobile SoCs
+ *
+ * This driver draws mainly on scattered spec sheets, Reverse engineering
+ * of the toshiba e800  SD driver and some parts of the 2.4 ASIC3 driver (4 bit
+ * support). (Further 4 bit support from a later datasheet).
+ *
+ * TODO:
+ *   Investigate using a workqueue for PIO transfers
+ *   Eliminate FIXMEs
+ *   SDIO support
+ *   Better Power management
+ *   Handle MMC errors better
+ *   double buffer support
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/highmem.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/mfd/tmio.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/tmio.h>
+#include <linux/module.h>
+#include <linux/pagemap.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/scatterlist.h>
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+
+#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);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
+}
+
+void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
+{
+        u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) | (i & TMIO_MASK_IRQ);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
+}
+
+static void tmio_mmc_ack_mmc_irqs(struct tmio_mmc_host *host, u32 i)
+{
+        sd_ctrl_write32(host, CTL_STATUS, ~i);
+}
+
+static void tmio_mmc_init_sg(struct tmio_mmc_host *host, struct mmc_data *data)
+{
+        host->sg_len = data->sg_len;
+        host->sg_ptr = data->sg;
+        host->sg_orig = data->sg;
+        host->sg_off = 0;
+}
+
+static int tmio_mmc_next_sg(struct tmio_mmc_host *host)
+{
+        host->sg_ptr = sg_next(host->sg_ptr);
+        host->sg_off = 0;
+        return --host->sg_len;
+}
+
+#ifdef CONFIG_MMC_DEBUG
+
+#define STATUS_TO_TEXT(a, status, i) \
+        do { \
+                if (status & TMIO_STAT_##a) { \
+                        if (i++) \
+                                printk(" | "); \
+                        printk(#a); \
+                } \
+        } while (0)
+
+static void pr_debug_status(u32 status)
+{
+        int i = 0;
+        printk(KERN_DEBUG "status: %08x = ", status);
+        STATUS_TO_TEXT(CARD_REMOVE, status, i);
+        STATUS_TO_TEXT(CARD_INSERT, status, i);
+        STATUS_TO_TEXT(SIGSTATE, status, i);
+        STATUS_TO_TEXT(WRPROTECT, status, i);
+        STATUS_TO_TEXT(CARD_REMOVE_A, status, i);
+        STATUS_TO_TEXT(CARD_INSERT_A, status, i);
+        STATUS_TO_TEXT(SIGSTATE_A, status, i);
+        STATUS_TO_TEXT(CMD_IDX_ERR, status, i);
+        STATUS_TO_TEXT(STOPBIT_ERR, status, i);
+        STATUS_TO_TEXT(ILL_FUNC, status, i);
+        STATUS_TO_TEXT(CMD_BUSY, status, i);
+        STATUS_TO_TEXT(CMDRESPEND, status, i);
+        STATUS_TO_TEXT(DATAEND, status, i);
+        STATUS_TO_TEXT(CRCFAIL, status, i);
+        STATUS_TO_TEXT(DATATIMEOUT, status, i);
+        STATUS_TO_TEXT(CMDTIMEOUT, status, i);
+        STATUS_TO_TEXT(RXOVERFLOW, status, i);
+        STATUS_TO_TEXT(TXUNDERRUN, status, i);
+        STATUS_TO_TEXT(RXRDY, status, i);
+        STATUS_TO_TEXT(TXRQ, status, i);
+        STATUS_TO_TEXT(ILL_ACCESS, status, i);
+        printk("\n");
+}
+
+#else
+#define pr_debug_status(s)  do { } while (0)
+#endif
+
+static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+
+        if (enable) {
+                host->sdio_irq_enabled = 1;
+                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK,
+                        (TMIO_SDIO_MASK_ALL & ~TMIO_SDIO_STAT_IOIRQ));
+        } else {
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, TMIO_SDIO_MASK_ALL);
+                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0000);
+                host->sdio_irq_enabled = 0;
+        }
+}
+
+static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
+{
+        u32 clk = 0, clock;
+
+        if (new_clock) {
+                for (clock = host->mmc->f_min, clk = 0x80000080;
+                        new_clock >= (clock<<1); clk >>= 1)
+                        clock <<= 1;
+                clk |= 0x100;
+        }
+
+        if (host->set_clk_div)
+                host->set_clk_div(host->pdev, (clk>>22) & 1);
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & 0x1ff);
+}
+
+static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100) {
+                sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
+                msleep(10);
+        }
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~0x0100 &
+                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
+        msleep(10);
+}
+
+static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, 0x0100 |
+                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
+        msleep(10);
+
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100) {
+                sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
+                msleep(10);
+        }
+}
+
+static void tmio_mmc_reset(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        /* FIXME - should we set stop clock reg here */
+        sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100)
+                sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
+        msleep(10);
+        sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
+        if (resource_size(res) > 0x100)
+                sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
+        msleep(10);
+}
+
+static void tmio_mmc_reset_work(struct work_struct *work)
+{
+        struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
+                                                  delayed_reset_work.work);
+        struct mmc_request *mrq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        mrq = host->mrq;
+
+        /*
+         * is request already finished? Since we use a non-blocking
+         * cancel_delayed_work(), it can happen, that a .set_ios() call preempts
+         * us, so, have to check for IS_ERR(host->mrq)
+         */
+        if (IS_ERR_OR_NULL(mrq)
+            || time_is_after_jiffies(host->last_req_ts +
+                msecs_to_jiffies(2000))) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                return;
+        }
+
+        dev_warn(&host->pdev->dev,
+                "timeout waiting for hardware interrupt (CMD%u)\n",
+                mrq->cmd->opcode);
+
+        if (host->data)
+                host->data->error = -ETIMEDOUT;
+        else if (host->cmd)
+                host->cmd->error = -ETIMEDOUT;
+        else
+                mrq->cmd->error = -ETIMEDOUT;
+
+        host->cmd = NULL;
+        host->data = NULL;
+        host->force_pio = false;
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        tmio_mmc_reset(host);
+
+        /* Ready for new calls */
+        host->mrq = NULL;
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+/* called with host->lock held, interrupts disabled */
+static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
+{
+        struct mmc_request *mrq = host->mrq;
+
+        if (!mrq)
+                return;
+
+        host->cmd = NULL;
+        host->data = NULL;
+        host->force_pio = false;
+
+        cancel_delayed_work(&host->delayed_reset_work);
+
+        host->mrq = NULL;
+
+        /* FIXME: mmc_request_done() can schedule! */
+        mmc_request_done(host->mmc, mrq);
+}
+
+/* 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
+#define RESP_NONE      0x0300
+#define RESP_R1        0x0400
+#define RESP_R1B       0x0500
+#define RESP_R2        0x0600
+#define RESP_R3        0x0700
+#define DATA_PRESENT   0x0800
+#define TRANSFER_READ  0x1000
+#define TRANSFER_MULTI 0x2000
+#define SECURITY_CMD   0x4000
+
+static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
+{
+        struct mmc_data *data = host->data;
+        int c = cmd->opcode;
+
+        /* Command 12 is handled by hardware */
+        if (cmd->opcode == 12 && !cmd->arg) {
+                sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
+                return 0;
+        }
+
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE: c |= RESP_NONE; break;
+        case MMC_RSP_R1:   c |= RESP_R1;   break;
+        case MMC_RSP_R1B:  c |= RESP_R1B;  break;
+        case MMC_RSP_R2:   c |= RESP_R2;   break;
+        case MMC_RSP_R3:   c |= RESP_R3;   break;
+        default:
+                pr_debug("Unknown response type %d\n", mmc_resp_type(cmd));
+                return -EINVAL;
+        }
+
+        host->cmd = cmd;
+
+/* FIXME - this seems to be ok commented out but the spec suggest this bit
+ *         should be set when issuing app commands.
+ *      if(cmd->flags & MMC_FLAG_ACMD)
+ *              c |= APP_CMD;
+ */
+        if (data) {
+                c |= DATA_PRESENT;
+                if (data->blocks > 1) {
+                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x100);
+                        c |= TRANSFER_MULTI;
+                }
+                if (data->flags & MMC_DATA_READ)
+                        c |= TRANSFER_READ;
+        }
+
+        tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_CMD);
+
+        /* Fire off the command */
+        sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
+        sd_ctrl_write16(host, CTL_SD_CMD, c);
+
+        return 0;
+}
+
+/*
+ * This chip always returns (at least?) as much data as you ask for.
+ * I'm unsure what happens if you ask for less than a block. This should be
+ * looked into to ensure that a funny length read doesn't hose the controller.
+ */
+static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data = host->data;
+        void *sg_virt;
+        unsigned short *buf;
+        unsigned int count;
+        unsigned long flags;
+
+        if ((host->chan_tx || host->chan_rx) && !host->force_pio) {
+                pr_err("PIO IRQ in DMA mode!\n");
+                return;
+        } else if (!data) {
+                pr_debug("Spurious PIO IRQ\n");
+                return;
+        }
+
+        sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
+        buf = (unsigned short *)(sg_virt + host->sg_off);
+
+        count = host->sg_ptr->length - host->sg_off;
+        if (count > data->blksz)
+                count = data->blksz;
+
+        pr_debug("count: %08x offset: %08x flags %08x\n",
+                 count, host->sg_off, data->flags);
+
+        /* Transfer the data */
+        if (data->flags & MMC_DATA_READ)
+                sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
+        else
+                sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
+
+        host->sg_off += count;
+
+        tmio_mmc_kunmap_atomic(host->sg_ptr, &flags, sg_virt);
+
+        if (host->sg_off == host->sg_ptr->length)
+                tmio_mmc_next_sg(host);
+
+        return;
+}
+
+static void tmio_mmc_check_bounce_buffer(struct tmio_mmc_host *host)
+{
+        if (host->sg_ptr == &host->bounce_sg) {
+                unsigned long flags;
+                void *sg_vaddr = tmio_mmc_kmap_atomic(host->sg_orig, &flags);
+                memcpy(sg_vaddr, host->bounce_buf, host->bounce_sg.length);
+                tmio_mmc_kunmap_atomic(host->sg_orig, &flags, sg_vaddr);
+        }
+}
+
+/* needs to be called with host->lock held */
+void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data = host->data;
+        struct mmc_command *stop;
+
+        host->data = NULL;
+
+        if (!data) {
+                dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
+                return;
+        }
+        stop = data->stop;
+
+        /* FIXME - return correct transfer count on errors */
+        if (!data->error)
+                data->bytes_xfered = data->blocks * data->blksz;
+        else
+                data->bytes_xfered = 0;
+
+        pr_debug("Completed data request\n");
+
+        /*
+         * FIXME: other drivers allow an optional stop command of any given type
+         *        which we dont do, as the chip can auto generate them.
+         *        Perhaps we can be smarter about when to use auto CMD12 and
+         *        only issue the auto request when we know this is the desired
+         *        stop command, allowing fallback to the stop command the
+         *        upper layers expect. For now, we do what works.
+         */
+
+        if (data->flags & MMC_DATA_READ) {
+                if (host->chan_rx && !host->force_pio)
+                        tmio_mmc_check_bounce_buffer(host);
+                dev_dbg(&host->pdev->dev, "Complete Rx request %p\n",
+                        host->mrq);
+        } else {
+                dev_dbg(&host->pdev->dev, "Complete Tx request %p\n",
+                        host->mrq);
+        }
+
+        if (stop) {
+                if (stop->opcode == 12 && !stop->arg)
+                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
+                else
+                        BUG();
+        }
+
+        tmio_mmc_finish_request(host);
+}
+
+static void tmio_mmc_data_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data;
+        spin_lock(&host->lock);
+        data = host->data;
+
+        if (!data)
+                goto out;
+
+        if (host->chan_tx && (data->flags & MMC_DATA_WRITE) && !host->force_pio) {
+                /*
+                 * Has all data been written out yet? Testing on SuperH showed,
+                 * that in most cases the first interrupt comes already with the
+                 * BUSY status bit clear, but on some operations, like mount or
+                 * in the beginning of a write / sync / umount, there is one
+                 * DATAEND interrupt with the BUSY bit set, in this cases
+                 * waiting for one more interrupt fixes the problem.
+                 */
+                if (!(sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_CMD_BUSY)) {
+                        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
+                        tasklet_schedule(&host->dma_complete);
+                }
+        } else if (host->chan_rx && (data->flags & MMC_DATA_READ) && !host->force_pio) {
+                tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
+                tasklet_schedule(&host->dma_complete);
+        } else {
+                tmio_mmc_do_data_irq(host);
+                tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_READOP | TMIO_MASK_WRITEOP);
+        }
+out:
+        spin_unlock(&host->lock);
+}
+
+static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
+        unsigned int stat)
+{
+        struct mmc_command *cmd = host->cmd;
+        int i, addr;
+
+        spin_lock(&host->lock);
+
+        if (!host->cmd) {
+                pr_debug("Spurious CMD irq\n");
+                goto out;
+        }
+
+        host->cmd = NULL;
+
+        /* This controller is sicker than the PXA one. Not only do we need to
+         * drop the top 8 bits of the first response word, we also need to
+         * modify the order of the response for short response command types.
+         */
+
+        for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
+                cmd->resp[i] = sd_ctrl_read32(host, addr);
+
+        if (cmd->flags &  MMC_RSP_136) {
+                cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
+                cmd->resp[1] = (cmd->resp[1] << 8) | (cmd->resp[2] >> 24);
+                cmd->resp[2] = (cmd->resp[2] << 8) | (cmd->resp[3] >> 24);
+                cmd->resp[3] <<= 8;
+        } else if (cmd->flags & MMC_RSP_R3) {
+                cmd->resp[0] = cmd->resp[3];
+        }
+
+        if (stat & TMIO_STAT_CMDTIMEOUT)
+                cmd->error = -ETIMEDOUT;
+        else if (stat & TMIO_STAT_CRCFAIL && cmd->flags & MMC_RSP_CRC)
+                cmd->error = -EILSEQ;
+
+        /* If there is data to handle we enable data IRQs here, and
+         * we will ultimatley finish the request in the data_end handler.
+         * If theres no data or we encountered an error, finish now.
+         */
+        if (host->data && !cmd->error) {
+                if (host->data->flags & MMC_DATA_READ) {
+                        if (host->force_pio || !host->chan_rx)
+                                tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_READOP);
+                        else
+                                tasklet_schedule(&host->dma_issue);
+                } else {
+                        if (host->force_pio || !host->chan_tx)
+                                tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
+                        else
+                                tasklet_schedule(&host->dma_issue);
+                }
+        } else {
+                tmio_mmc_finish_request(host);
+        }
+
+out:
+        spin_unlock(&host->lock);
+}
+
+irqreturn_t tmio_mmc_irq(int irq, void *devid)
+{
+        struct tmio_mmc_host *host = devid;
+        struct tmio_mmc_data *pdata = host->pdata;
+        unsigned int ireg, irq_mask, status;
+        unsigned int sdio_ireg, sdio_irq_mask, sdio_status;
+
+        pr_debug("MMC IRQ begin\n");
+
+        status = sd_ctrl_read32(host, CTL_STATUS);
+        irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
+        ireg = status & TMIO_MASK_IRQ & ~irq_mask;
+
+        sdio_ireg = 0;
+        if (!ireg && pdata->flags & TMIO_MMC_SDIO_IRQ) {
+                sdio_status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
+                sdio_irq_mask = sd_ctrl_read16(host, CTL_SDIO_IRQ_MASK);
+                sdio_ireg = sdio_status & TMIO_SDIO_MASK_ALL & ~sdio_irq_mask;
+
+                sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status & ~TMIO_SDIO_MASK_ALL);
+
+                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);
+                        goto out;
+                }
+
+                if (host->mmc->caps & MMC_CAP_SDIO_IRQ &&
+                        sdio_ireg & TMIO_SDIO_STAT_IOIRQ)
+                        mmc_signal_sdio_irq(host->mmc);
+
+                if (sdio_ireg)
+                        goto out;
+        }
+
+        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);
+
+                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);
+ */
+
+                /* 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);
+                }
+
+                /* 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;
+
+                pr_debug("Status at end of loop: %08x\n", status);
+                pr_debug_status(status);
+        }
+        pr_debug("MMC IRQ end\n");
+
+out:
+        return IRQ_HANDLED;
+}
+EXPORT_SYMBOL(tmio_mmc_irq);
+
+static int tmio_mmc_start_data(struct tmio_mmc_host *host,
+        struct mmc_data *data)
+{
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
+                 data->blksz, data->blocks);
+
+        /* Some hardware cannot perform 2 byte requests in 4 bit mode */
+        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4) {
+                int blksz_2bytes = pdata->flags & TMIO_MMC_BLKSZ_2BYTES;
+
+                if (data->blksz < 2 || (data->blksz < 4 && !blksz_2bytes)) {
+                        pr_err("%s: %d byte block unsupported in 4 bit mode\n",
+                               mmc_hostname(host->mmc), data->blksz);
+                        return -EINVAL;
+                }
+        }
+
+        tmio_mmc_init_sg(host, data);
+        host->data = data;
+
+        /* Set transfer length / blocksize */
+        sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
+        sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);
+
+        tmio_mmc_start_dma(host, data);
+
+        return 0;
+}
+
+/* Process requests from the MMC layer */
+static void tmio_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        if (host->mrq) {
+                pr_debug("request not null\n");
+                if (IS_ERR(host->mrq)) {
+                        spin_unlock_irqrestore(&host->lock, flags);
+                        mrq->cmd->error = -EAGAIN;
+                        mmc_request_done(mmc, mrq);
+                        return;
+                }
+        }
+
+        host->last_req_ts = jiffies;
+        wmb();
+        host->mrq = mrq;
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        if (mrq->data) {
+                ret = tmio_mmc_start_data(host, mrq->data);
+                if (ret)
+                        goto fail;
+        }
+
+        ret = tmio_mmc_start_command(host, mrq->cmd);
+        if (!ret) {
+                schedule_delayed_work(&host->delayed_reset_work,
+                                      msecs_to_jiffies(2000));
+                return;
+        }
+
+fail:
+        host->force_pio = false;
+        host->mrq = NULL;
+        mrq->cmd->error = ret;
+        mmc_request_done(mmc, mrq);
+}
+
+/* Set MMC clock / power.
+ * Note: This controller uses a simple divider scheme therefore it cannot
+ * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
+ * MMC wont run that fast, it has to be clocked at 12MHz which is the next
+ * slowest setting.
+ */
+static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        if (host->mrq) {
+                if (IS_ERR(host->mrq)) {
+                        dev_dbg(&host->pdev->dev,
+                                "%s.%d: concurrent .set_ios(), clk %u, mode %u\n",
+                                current->comm, task_pid_nr(current),
+                                ios->clock, ios->power_mode);
+                        host->mrq = ERR_PTR(-EINTR);
+                } else {
+                        dev_dbg(&host->pdev->dev,
+                                "%s.%d: CMD%u active since %lu, now %lu!\n",
+                                current->comm, task_pid_nr(current),
+                                host->mrq->cmd->opcode, host->last_req_ts, jiffies);
+                }
+                spin_unlock_irqrestore(&host->lock, flags);
+                return;
+        }
+
+        host->mrq = ERR_PTR(-EBUSY);
+
+        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) {
+                        pm_runtime_get_sync(&host->pdev->dev);
+                        pdata->power = true;
+                }
+                /* 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);
+        }
+
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_1:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
+        break;
+        case MMC_BUS_WIDTH_4:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+        break;
+        }
+
+        /* Let things settle. delay taken from winCE driver */
+        udelay(140);
+        if (PTR_ERR(host->mrq) == -EINTR)
+                dev_dbg(&host->pdev->dev,
+                        "%s.%d: IOS interrupted: clk %u, mode %u",
+                        current->comm, task_pid_nr(current),
+                        ios->clock, ios->power_mode);
+        host->mrq = NULL;
+}
+
+static int tmio_mmc_get_ro(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        return !((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
+                 (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT));
+}
+
+static int tmio_mmc_get_cd(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        if (!pdata->get_cd)
+                return -ENOSYS;
+        else
+                return pdata->get_cd(host->pdev);
+}
+
+static const struct mmc_host_ops tmio_mmc_ops = {
+        .request        = tmio_mmc_request,
+        .set_ios        = tmio_mmc_set_ios,
+        .get_ro         = tmio_mmc_get_ro,
+        .get_cd         = tmio_mmc_get_cd,
+        .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
+};
+
+int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
+                                  struct platform_device *pdev,
+                                  struct tmio_mmc_data *pdata)
+{
+        struct tmio_mmc_host *_host;
+        struct mmc_host *mmc;
+        struct resource *res_ctl;
+        int ret;
+        u32 irq_mask = TMIO_MASK_CMD;
+
+        res_ctl = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res_ctl)
+                return -EINVAL;
+
+        mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &pdev->dev);
+        if (!mmc)
+                return -ENOMEM;
+
+        pdata->dev = &pdev->dev;
+        _host = mmc_priv(mmc);
+        _host->pdata = pdata;
+        _host->mmc = mmc;
+        _host->pdev = pdev;
+        platform_set_drvdata(pdev, mmc);
+
+        _host->set_pwr = pdata->set_pwr;
+        _host->set_clk_div = pdata->set_clk_div;
+
+        /* SD control register space size is 0x200, 0x400 for bus_shift=1 */
+        _host->bus_shift = resource_size(res_ctl) >> 10;
+
+        _host->ctl = ioremap(res_ctl->start, resource_size(res_ctl));
+        if (!_host->ctl) {
+                ret = -ENOMEM;
+                goto host_free;
+        }
+
+        mmc->ops = &tmio_mmc_ops;
+        mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
+        mmc->f_max = pdata->hclk;
+        mmc->f_min = mmc->f_max / 512;
+        mmc->max_segs = 32;
+        mmc->max_blk_size = 512;
+        mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
+                mmc->max_segs;
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
+        if (pdata->ocr_mask)
+                mmc->ocr_avail = pdata->ocr_mask;
+        else
+                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+
+        pdata->power = false;
+        pm_runtime_enable(&pdev->dev);
+        ret = pm_runtime_resume(&pdev->dev);
+        if (ret < 0)
+                goto pm_disable;
+
+        tmio_mmc_clk_stop(_host);
+        tmio_mmc_reset(_host);
+
+        tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
+        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
+                tmio_mmc_enable_sdio_irq(mmc, 0);
+
+        spin_lock_init(&_host->lock);
+
+        /* Init delayed work for request timeouts */
+        INIT_DELAYED_WORK(&_host->delayed_reset_work, tmio_mmc_reset_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))
+                pm_runtime_get_noresume(&pdev->dev);
+
+        mmc_add_host(mmc);
+
+        /* Unmask the IRQs we want to know about */
+        if (!_host->chan_rx)
+                irq_mask |= TMIO_MASK_READOP;
+        if (!_host->chan_tx)
+                irq_mask |= TMIO_MASK_WRITEOP;
+
+        tmio_mmc_enable_mmc_irqs(_host, irq_mask);
+
+        *host = _host;
+
+        return 0;
+
+pm_disable:
+        pm_runtime_disable(&pdev->dev);
+        iounmap(_host->ctl);
+host_free:
+        mmc_free_host(mmc);
+
+        return ret;
+}
+EXPORT_SYMBOL(tmio_mmc_host_probe);
+
+void tmio_mmc_host_remove(struct tmio_mmc_host *host)
+{
+        struct platform_device *pdev = host->pdev;
+
+        /*
+         * We don't have to manipulate pdata->power here: if there is a card in
+         * the slot, the runtime PM is active and our .runtime_resume() will not
+         * be run. If there is no card in the slot and the platform can suspend
+         * the controller, the runtime PM is suspended and pdata->power == false,
+         * so, our .runtime_resume() will not try to detect a card in the slot.
+         */
+        if (host->pdata->flags & TMIO_MMC_HAS_COLD_CD)
+                pm_runtime_get_sync(&pdev->dev);
+
+        mmc_remove_host(host->mmc);
+        cancel_delayed_work_sync(&host->delayed_reset_work);
+        tmio_mmc_release_dma(host);
+
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+
+        iounmap(host->ctl);
+        mmc_free_host(host->mmc);
+}
+EXPORT_SYMBOL(tmio_mmc_host_remove);
+
+#ifdef CONFIG_PM
+int tmio_mmc_host_suspend(struct device *dev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        int ret = mmc_suspend_host(mmc);
+
+        if (!ret)
+                tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_ALL);
+
+        host->pm_error = pm_runtime_put_sync(dev);
+
+        return ret;
+}
+EXPORT_SYMBOL(tmio_mmc_host_suspend);
+
+int tmio_mmc_host_resume(struct device *dev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+
+        /* The MMC core will perform the complete set up */
+        host->pdata->power = false;
+
+        if (!host->pm_error)
+                pm_runtime_get_sync(dev);
+
+        tmio_mmc_reset(mmc_priv(mmc));
+        tmio_mmc_request_dma(host, host->pdata);
+
+        return mmc_resume_host(mmc);
+}
+EXPORT_SYMBOL(tmio_mmc_host_resume);
+
+#endif  /* CONFIG_PM */
+
+int tmio_mmc_host_runtime_suspend(struct device *dev)
+{
+        return 0;
+}
+EXPORT_SYMBOL(tmio_mmc_host_runtime_suspend);
+
+int tmio_mmc_host_runtime_resume(struct device *dev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        tmio_mmc_reset(host);
+
+        if (pdata->power) {
+                /* Only entered after a card-insert interrupt */
+                tmio_mmc_set_ios(mmc, &mmc->ios);
+                mmc_detect_change(mmc, msecs_to_jiffies(100));
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(tmio_mmc_host_runtime_resume);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/ushc.c b/drivers/mmc/host/ushc.c
new file mode 100644
index 000000000000..f08f944ac53c
--- /dev/null
+++ b/drivers/mmc/host/ushc.c
@@ -0,0 +1,579 @@
+/*
+ * USB SD Host Controller (USHC) controller driver.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * Notes:
+ *   - Only version 2 devices are supported.
+ *   - Version 2 devices only support SDIO cards/devices (R2 response is
+ *     unsupported).
+ *
+ * References:
+ *   [USHC] USB SD Host Controller specification (CS-118793-SP)
+ */
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+#include <linux/mmc/host.h>
+
+enum ushc_request {
+        USHC_GET_CAPS  = 0x00,
+        USHC_HOST_CTRL = 0x01,
+        USHC_PWR_CTRL  = 0x02,
+        USHC_CLK_FREQ  = 0x03,
+        USHC_EXEC_CMD  = 0x04,
+        USHC_READ_RESP = 0x05,
+        USHC_RESET     = 0x06,
+};
+
+enum ushc_request_type {
+        USHC_GET_CAPS_TYPE  = USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_HOST_CTRL_TYPE = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_PWR_CTRL_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_CLK_FREQ_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_EXEC_CMD_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_READ_RESP_TYPE = USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+        USHC_RESET_TYPE     = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+};
+
+#define USHC_GET_CAPS_VERSION_MASK 0xff
+#define USHC_GET_CAPS_3V3      (1 << 8)
+#define USHC_GET_CAPS_3V0      (1 << 9)
+#define USHC_GET_CAPS_1V8      (1 << 10)
+#define USHC_GET_CAPS_HIGH_SPD (1 << 16)
+
+#define USHC_HOST_CTRL_4BIT     (1 << 1)
+#define USHC_HOST_CTRL_HIGH_SPD (1 << 0)
+
+#define USHC_PWR_CTRL_OFF 0x00
+#define USHC_PWR_CTRL_3V3 0x01
+#define USHC_PWR_CTRL_3V0 0x02
+#define USHC_PWR_CTRL_1V8 0x03
+
+#define USHC_READ_RESP_BUSY        (1 << 4)
+#define USHC_READ_RESP_ERR_TIMEOUT (1 << 3)
+#define USHC_READ_RESP_ERR_CRC     (1 << 2)
+#define USHC_READ_RESP_ERR_DAT     (1 << 1)
+#define USHC_READ_RESP_ERR_CMD     (1 << 0)
+#define USHC_READ_RESP_ERR_MASK    0x0f
+
+struct ushc_cbw {
+        __u8 signature;
+        __u8 cmd_idx;
+        __le16 block_size;
+        __le32 arg;
+} __attribute__((packed));
+
+#define USHC_CBW_SIGNATURE 'C'
+
+struct ushc_csw {
+        __u8 signature;
+        __u8 status;
+        __le32 response;
+} __attribute__((packed));
+
+#define USHC_CSW_SIGNATURE 'S'
+
+struct ushc_int_data {
+        u8 status;
+        u8 reserved[3];
+};
+
+#define USHC_INT_STATUS_SDIO_INT     (1 << 1)
+#define USHC_INT_STATUS_CARD_PRESENT (1 << 0)
+
+
+struct ushc_data {
+        struct usb_device *usb_dev;
+        struct mmc_host *mmc;
+
+        struct urb *int_urb;
+        struct ushc_int_data *int_data;
+
+        struct urb *cbw_urb;
+        struct ushc_cbw *cbw;
+
+        struct urb *data_urb;
+
+        struct urb *csw_urb;
+        struct ushc_csw *csw;
+
+        spinlock_t lock;
+        struct mmc_request *current_req;
+        u32 caps;
+        u16 host_ctrl;
+        unsigned long flags;
+        u8 last_status;
+        int clock_freq;
+};
+
+#define DISCONNECTED    0
+#define INT_EN          1
+#define IGNORE_NEXT_INT 2
+
+static void data_callback(struct urb *urb);
+
+static int ushc_hw_reset(struct ushc_data *ushc)
+{
+        return usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
+                               USHC_RESET, USHC_RESET_TYPE,
+                               0, 0, NULL, 0, 100);
+}
+
+static int ushc_hw_get_caps(struct ushc_data *ushc)
+{
+        int ret;
+        int version;
+
+        ret = usb_control_msg(ushc->usb_dev, usb_rcvctrlpipe(ushc->usb_dev, 0),
+                              USHC_GET_CAPS, USHC_GET_CAPS_TYPE,
+                              0, 0, &ushc->caps, sizeof(ushc->caps), 100);
+        if (ret < 0)
+                return ret;
+
+        ushc->caps = le32_to_cpu(ushc->caps);
+
+        version = ushc->caps & USHC_GET_CAPS_VERSION_MASK;
+        if (version != 0x02) {
+                dev_err(&ushc->usb_dev->dev, "controller version %d is not supported\n", version);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int ushc_hw_set_host_ctrl(struct ushc_data *ushc, u16 mask, u16 val)
+{
+        u16 host_ctrl;
+        int ret;
+
+        host_ctrl = (ushc->host_ctrl & ~mask) | val;
+        ret = usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
+                              USHC_HOST_CTRL, USHC_HOST_CTRL_TYPE,
+                              host_ctrl, 0, NULL, 0, 100);
+        if (ret < 0)
+                return ret;
+        ushc->host_ctrl = host_ctrl;
+        return 0;
+}
+
+static void int_callback(struct urb *urb)
+{
+        struct ushc_data *ushc = urb->context;
+        u8 status, last_status;
+
+        if (urb->status < 0)
+                return;
+
+        status = ushc->int_data->status;
+        last_status = ushc->last_status;
+        ushc->last_status = status;
+
+        /*
+         * Ignore the card interrupt status on interrupt transfers that
+         * were submitted while card interrupts where disabled.
+         *
+         * This avoid occasional spurious interrupts when enabling
+         * interrupts immediately after clearing the source on the card.
+         */
+
+        if (!test_and_clear_bit(IGNORE_NEXT_INT, &ushc->flags)
+            && test_bit(INT_EN, &ushc->flags)
+            && status & USHC_INT_STATUS_SDIO_INT) {
+                mmc_signal_sdio_irq(ushc->mmc);
+        }
+
+        if ((status ^ last_status) & USHC_INT_STATUS_CARD_PRESENT)
+                mmc_detect_change(ushc->mmc, msecs_to_jiffies(100));
+
+        if (!test_bit(INT_EN, &ushc->flags))
+                set_bit(IGNORE_NEXT_INT, &ushc->flags);
+        usb_submit_urb(ushc->int_urb, GFP_ATOMIC);
+}
+
+static void cbw_callback(struct urb *urb)
+{
+        struct ushc_data *ushc = urb->context;
+
+        if (urb->status != 0) {
+                usb_unlink_urb(ushc->data_urb);
+                usb_unlink_urb(ushc->csw_urb);
+        }
+}
+
+static void data_callback(struct urb *urb)
+{
+        struct ushc_data *ushc = urb->context;
+
+        if (urb->status != 0)
+                usb_unlink_urb(ushc->csw_urb);
+}
+
+static void csw_callback(struct urb *urb)
+{
+        struct ushc_data *ushc = urb->context;
+        struct mmc_request *req = ushc->current_req;
+        int status;
+
+        status = ushc->csw->status;
+
+        if (urb->status != 0) {
+                req->cmd->error = urb->status;
+        } else if (status & USHC_READ_RESP_ERR_CMD) {
+                if (status & USHC_READ_RESP_ERR_CRC)
+                        req->cmd->error = -EIO;
+                else
+                        req->cmd->error = -ETIMEDOUT;
+        }
+        if (req->data) {
+                if (status & USHC_READ_RESP_ERR_DAT) {
+                        if (status & USHC_READ_RESP_ERR_CRC)
+                                req->data->error = -EIO;
+                        else
+                                req->data->error = -ETIMEDOUT;
+                        req->data->bytes_xfered = 0;
+                } else {
+                        req->data->bytes_xfered = req->data->blksz * req->data->blocks;
+                }
+        }
+
+        req->cmd->resp[0] = le32_to_cpu(ushc->csw->response);
+
+        mmc_request_done(ushc->mmc, req);
+}
+
+static void ushc_request(struct mmc_host *mmc, struct mmc_request *req)
+{
+        struct ushc_data *ushc = mmc_priv(mmc);
+        int ret;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ushc->lock, flags);
+
+        if (test_bit(DISCONNECTED, &ushc->flags)) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        /* Version 2 firmware doesn't support the R2 response format. */
+        if (req->cmd->flags & MMC_RSP_136) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* The Astoria's data FIFOs don't work with clock speeds < 5MHz so
+           limit commands with data to 6MHz or more. */
+        if (req->data && ushc->clock_freq < 6000000) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ushc->current_req = req;
+
+        /* Start cmd with CBW. */
+        ushc->cbw->cmd_idx = cpu_to_le16(req->cmd->opcode);
+        if (req->data)
+                ushc->cbw->block_size = cpu_to_le16(req->data->blksz);
+        else
+                ushc->cbw->block_size = 0;
+        ushc->cbw->arg = cpu_to_le32(req->cmd->arg);
+
+        ret = usb_submit_urb(ushc->cbw_urb, GFP_ATOMIC);
+        if (ret < 0)
+                goto out;
+
+        /* Submit data (if any). */
+        if (req->data) {
+                struct mmc_data *data = req->data;
+                int pipe;
+
+                if (data->flags & MMC_DATA_READ)
+                        pipe = usb_rcvbulkpipe(ushc->usb_dev, 6);
+                else
+                        pipe = usb_sndbulkpipe(ushc->usb_dev, 2);
+
+                usb_fill_bulk_urb(ushc->data_urb, ushc->usb_dev, pipe,
+                                  sg_virt(data->sg), data->sg->length,
+                                  data_callback, ushc);
+                ret = usb_submit_urb(ushc->data_urb, GFP_ATOMIC);
+                if (ret < 0)
+                        goto out;
+        }
+
+        /* Submit CSW. */
+        ret = usb_submit_urb(ushc->csw_urb, GFP_ATOMIC);
+        if (ret < 0)
+                goto out;
+
+out:
+        spin_unlock_irqrestore(&ushc->lock, flags);
+        if (ret < 0) {
+                usb_unlink_urb(ushc->cbw_urb);
+                usb_unlink_urb(ushc->data_urb);
+                req->cmd->error = ret;
+                mmc_request_done(mmc, req);
+        }
+}
+
+static int ushc_set_power(struct ushc_data *ushc, unsigned char power_mode)
+{
+        u16 voltage;
+
+        switch (power_mode) {
+        case MMC_POWER_OFF:
+                voltage = USHC_PWR_CTRL_OFF;
+                break;
+        case MMC_POWER_UP:
+        case MMC_POWER_ON:
+                voltage = USHC_PWR_CTRL_3V3;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
+                               USHC_PWR_CTRL, USHC_PWR_CTRL_TYPE,
+                               voltage, 0, NULL, 0, 100);
+}
+
+static int ushc_set_bus_width(struct ushc_data *ushc, int bus_width)
+{
+        return ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_4BIT,
+                                     bus_width == 4 ? USHC_HOST_CTRL_4BIT : 0);
+}
+
+static int ushc_set_bus_freq(struct ushc_data *ushc, int clk, bool enable_hs)
+{
+        int ret;
+
+        /* Hardware can't detect interrupts while the clock is off. */
+        if (clk == 0)
+                clk = 400000;
+
+        ret = ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_HIGH_SPD,
+                                    enable_hs ? USHC_HOST_CTRL_HIGH_SPD : 0);
+        if (ret < 0)
+                return ret;
+
+        ret = usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
+                              USHC_CLK_FREQ, USHC_CLK_FREQ_TYPE,
+                              clk & 0xffff, (clk >> 16) & 0xffff, NULL, 0, 100);
+        if (ret < 0)
+                return ret;
+
+        ushc->clock_freq = clk;
+        return 0;
+}
+
+static void ushc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct ushc_data *ushc = mmc_priv(mmc);
+
+        ushc_set_power(ushc, ios->power_mode);
+        ushc_set_bus_width(ushc, 1 << ios->bus_width);
+        ushc_set_bus_freq(ushc, ios->clock, ios->timing == MMC_TIMING_SD_HS);
+}
+
+static int ushc_get_cd(struct mmc_host *mmc)
+{
+        struct ushc_data *ushc = mmc_priv(mmc);
+
+        return !!(ushc->last_status & USHC_INT_STATUS_CARD_PRESENT);
+}
+
+static void ushc_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct ushc_data *ushc = mmc_priv(mmc);
+
+        if (enable)
+                set_bit(INT_EN, &ushc->flags);
+        else
+                clear_bit(INT_EN, &ushc->flags);
+}
+
+static void ushc_clean_up(struct ushc_data *ushc)
+{
+        usb_free_urb(ushc->int_urb);
+        usb_free_urb(ushc->csw_urb);
+        usb_free_urb(ushc->data_urb);
+        usb_free_urb(ushc->cbw_urb);
+
+        kfree(ushc->int_data);
+        kfree(ushc->cbw);
+        kfree(ushc->csw);
+
+        mmc_free_host(ushc->mmc);
+}
+
+static const struct mmc_host_ops ushc_ops = {
+        .request         = ushc_request,
+        .set_ios         = ushc_set_ios,
+        .get_cd          = ushc_get_cd,
+        .enable_sdio_irq = ushc_enable_sdio_irq,
+};
+
+static int ushc_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+        struct usb_device *usb_dev = interface_to_usbdev(intf);
+        struct mmc_host *mmc;
+        struct ushc_data *ushc;
+        int ret;
+
+        mmc = mmc_alloc_host(sizeof(struct ushc_data), &intf->dev);
+        if (mmc == NULL)
+                return -ENOMEM;
+        ushc = mmc_priv(mmc);
+        usb_set_intfdata(intf, ushc);
+
+        ushc->usb_dev = usb_dev;
+        ushc->mmc = mmc;
+
+        spin_lock_init(&ushc->lock);
+
+        ret = ushc_hw_reset(ushc);
+        if (ret < 0)
+                goto err;
+
+        /* Read capabilities. */
+        ret = ushc_hw_get_caps(ushc);
+        if (ret < 0)
+                goto err;
+
+        mmc->ops = &ushc_ops;
+
+        mmc->f_min = 400000;
+        mmc->f_max = 50000000;
+        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
+        mmc->caps |= (ushc->caps & USHC_GET_CAPS_HIGH_SPD) ? MMC_CAP_SD_HIGHSPEED : 0;
+
+        mmc->max_seg_size  = 512*511;
+        mmc->max_segs      = 1;
+        mmc->max_req_size  = 512*511;
+        mmc->max_blk_size  = 512;
+        mmc->max_blk_count = 511;
+
+        ushc->int_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (ushc->int_urb == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        ushc->int_data = kzalloc(sizeof(struct ushc_int_data), GFP_KERNEL);
+        if (ushc->int_data == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        usb_fill_int_urb(ushc->int_urb, ushc->usb_dev,
+                         usb_rcvintpipe(usb_dev,
+                                        intf->cur_altsetting->endpoint[0].desc.bEndpointAddress),
+                         ushc->int_data, sizeof(struct ushc_int_data),
+                         int_callback, ushc,
+                         intf->cur_altsetting->endpoint[0].desc.bInterval);
+
+        ushc->cbw_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (ushc->cbw_urb == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        ushc->cbw = kzalloc(sizeof(struct ushc_cbw), GFP_KERNEL);
+        if (ushc->cbw == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        ushc->cbw->signature = USHC_CBW_SIGNATURE;
+
+        usb_fill_bulk_urb(ushc->cbw_urb, ushc->usb_dev, usb_sndbulkpipe(usb_dev, 2),
+                          ushc->cbw, sizeof(struct ushc_cbw),
+                          cbw_callback, ushc);
+
+        ushc->data_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (ushc->data_urb == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        ushc->csw_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (ushc->csw_urb == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        ushc->csw = kzalloc(sizeof(struct ushc_cbw), GFP_KERNEL);
+        if (ushc->csw == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        usb_fill_bulk_urb(ushc->csw_urb, ushc->usb_dev, usb_rcvbulkpipe(usb_dev, 6),
+                          ushc->csw, sizeof(struct ushc_csw),
+                          csw_callback, ushc);
+
+        ret = mmc_add_host(ushc->mmc);
+        if (ret)
+                goto err;
+
+        ret = usb_submit_urb(ushc->int_urb, GFP_KERNEL);
+        if (ret < 0) {
+                mmc_remove_host(ushc->mmc);
+                goto err;
+        }
+
+        return 0;
+
+err:
+        ushc_clean_up(ushc);
+        return ret;
+}
+
+static void ushc_disconnect(struct usb_interface *intf)
+{
+        struct ushc_data *ushc = usb_get_intfdata(intf);
+
+        spin_lock_irq(&ushc->lock);
+        set_bit(DISCONNECTED, &ushc->flags);
+        spin_unlock_irq(&ushc->lock);
+
+        usb_kill_urb(ushc->int_urb);
+        usb_kill_urb(ushc->cbw_urb);
+        usb_kill_urb(ushc->data_urb);
+        usb_kill_urb(ushc->csw_urb);
+
+        mmc_remove_host(ushc->mmc);
+
+        ushc_clean_up(ushc);
+}
+
+static struct usb_device_id ushc_id_table[] = {
+        /* CSR USB SD Host Controller */
+        { USB_DEVICE(0x0a12, 0x5d10) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, ushc_id_table);
+
+static struct usb_driver ushc_driver = {
+        .name       = "ushc",
+        .id_table   = ushc_id_table,
+        .probe      = ushc_probe,
+        .disconnect = ushc_disconnect,
+};
+
+static int __init ushc_init(void)
+{
+        return usb_register(&ushc_driver);
+}
+module_init(ushc_init);
+
+static void __exit ushc_exit(void)
+{
+        usb_deregister(&ushc_driver);
+}
+module_exit(ushc_exit);
+
+MODULE_DESCRIPTION("USB SD Host Controller driver");
+MODULE_AUTHOR("David Vrabel <david.vrabel@csr.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/via-sdmmc.c b/drivers/mmc/host/via-sdmmc.c
index 19f2d72dbca5..4dfe2c02ea91 100644
--- a/drivers/mmc/host/via-sdmmc.c
+++ b/drivers/mmc/host/via-sdmmc.c
@@ -802,12 +802,9 @@ static const struct mmc_host_ops via_sdc_ops = {
 
 static void via_reset_pcictrl(struct via_crdr_mmc_host *host)
 {
-        void __iomem *addrbase;
         unsigned long flags;
         u8 gatt;
 
-        addrbase = host->pcictrl_mmiobase;
-
         spin_lock_irqsave(&host->lock, flags);
 
         via_save_pcictrlreg(host);
@@ -1050,8 +1047,7 @@ static void via_init_mmc_host(struct via_crdr_mmc_host *host)
         mmc->ops = &via_sdc_ops;
 
         /*Hardware cannot do scatter lists*/
-        mmc->max_hw_segs = 1;
-        mmc->max_phys_segs = 1;
+        mmc->max_segs = 1;
 
         mmc->max_blk_size = VIA_CRDR_MAX_BLOCK_LENGTH;
         mmc->max_blk_count = VIA_CRDR_MAX_BLOCK_COUNT;
@@ -1091,14 +1087,13 @@ static int __devinit via_sd_probe(struct pci_dev *pcidev,
         struct mmc_host *mmc;
         struct via_crdr_mmc_host *sdhost;
         u32 base, len;
-        u8 rev, gatt;
+        u8  gatt;
         int ret;
 
-        pci_read_config_byte(pcidev, PCI_CLASS_REVISION, &rev);
         pr_info(DRV_NAME
                 ": VIA SDMMC controller found at %s [%04x:%04x] (rev %x)\n",
                 pci_name(pcidev), (int)pcidev->vendor, (int)pcidev->device,
-                (int)rev);
+                (int)pcidev->revision);
 
         ret = pci_enable_device(pcidev);
         if (ret)
diff --git a/drivers/mmc/host/vub300.c b/drivers/mmc/host/vub300.c
new file mode 100644
index 000000000000..d4455ffbefd8
--- /dev/null
+++ b/drivers/mmc/host/vub300.c
@@ -0,0 +1,2503 @@
+/*
+ * Remote VUB300 SDIO/SDmem Host Controller Driver
+ *
+ * Copyright (C) 2010 Elan Digital Systems Limited
+ *
+ * based on USB Skeleton driver - 2.2
+ *
+ * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.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, version 2
+ *
+ * VUB300: is a USB 2.0 client device with a single SDIO/SDmem/MMC slot
+ *         Any SDIO/SDmem/MMC device plugged into the VUB300 will appear,
+ *         by virtue of this driver, to have been plugged into a local
+ *         SDIO host controller, similar to, say, a PCI Ricoh controller
+ *         This is because this kernel device driver is both a USB 2.0
+ *         client device driver AND an MMC host controller driver. Thus
+ *         if there is an existing driver for the inserted SDIO/SDmem/MMC
+ *         device then that driver will be used by the kernel to manage
+ *         the device in exactly the same fashion as if it had been
+ *         directly plugged into, say, a local pci bus Ricoh controller
+ *
+ * RANT: this driver was written using a display 128x48 - converting it
+ *       to a line width of 80 makes it very difficult to support. In
+ *       particular functions have been broken down into sub functions
+ *       and the original meaningful names have been shortened into
+ *       cryptic ones.
+ *       The problem is that executing a fragment of code subject to
+ *       two conditions means an indentation of 24, thus leaving only
+ *       56 characters for a C statement. And that is quite ridiculous!
+ *
+ * Data types: data passed to/from the VUB300 is fixed to a number of
+ *             bits and driver data fields reflect that limit by using
+ *             u8, u16, u32
+ */
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/uaccess.h>
+#include <linux/usb.h>
+#include <linux/mutex.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
+#include <linux/workqueue.h>
+#include <linux/ctype.h>
+#include <linux/firmware.h>
+#include <linux/scatterlist.h>
+
+struct host_controller_info {
+        u8 info_size;
+        u16 firmware_version;
+        u8 number_of_ports;
+} __packed;
+
+#define FIRMWARE_BLOCK_BOUNDARY 1024
+struct sd_command_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u8 command_type; /* Bit7 - Rd/Wr */
+        u8 command_index;
+        u8 transfer_size[4]; /* ReadSize + ReadSize */
+        u8 response_type;
+        u8 arguments[4];
+        u8 block_count[2];
+        u8 block_size[2];
+        u8 block_boundary[2];
+        u8 reserved[44]; /* to pad out to 64 bytes */
+} __packed;
+
+struct sd_irqpoll_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u8 command_type; /* Bit7 - Rd/Wr */
+        u8 padding[16]; /* don't ask why !! */
+        u8 poll_timeout_msb;
+        u8 poll_timeout_lsb;
+        u8 reserved[42]; /* to pad out to 64 bytes */
+} __packed;
+
+struct sd_common_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+} __packed;
+
+struct sd_response_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u8 command_type;
+        u8 command_index;
+        u8 command_response[0];
+} __packed;
+
+struct sd_status_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u16 port_flags;
+        u32 sdio_clock;
+        u16 host_header_size;
+        u16 func_header_size;
+        u16 ctrl_header_size;
+} __packed;
+
+struct sd_error_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u8 error_code;
+} __packed;
+
+struct sd_interrupt_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+} __packed;
+
+struct offload_registers_access {
+        u8 command_byte[4];
+        u8 Respond_Byte[4];
+} __packed;
+
+#define INTERRUPT_REGISTER_ACCESSES 15
+struct sd_offloaded_interrupt {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        struct offload_registers_access reg[INTERRUPT_REGISTER_ACCESSES];
+} __packed;
+
+struct sd_register_header {
+        u8 header_size;
+        u8 header_type;
+        u8 port_number;
+        u8 command_type;
+        u8 command_index;
+        u8 command_response[6];
+} __packed;
+
+#define PIGGYBACK_REGISTER_ACCESSES 14
+struct sd_offloaded_piggyback {
+        struct sd_register_header sdio;
+        struct offload_registers_access reg[PIGGYBACK_REGISTER_ACCESSES];
+} __packed;
+
+union sd_response {
+        struct sd_common_header common;
+        struct sd_status_header status;
+        struct sd_error_header error;
+        struct sd_interrupt_header interrupt;
+        struct sd_response_header response;
+        struct sd_offloaded_interrupt irq;
+        struct sd_offloaded_piggyback pig;
+} __packed;
+
+union sd_command {
+        struct sd_command_header head;
+        struct sd_irqpoll_header poll;
+} __packed;
+
+enum SD_RESPONSE_TYPE {
+        SDRT_UNSPECIFIED = 0,
+        SDRT_NONE,
+        SDRT_1,
+        SDRT_1B,
+        SDRT_2,
+        SDRT_3,
+        SDRT_4,
+        SDRT_5,
+        SDRT_5B,
+        SDRT_6,
+        SDRT_7,
+};
+
+#define RESPONSE_INTERRUPT                      0x01
+#define RESPONSE_ERROR                          0x02
+#define RESPONSE_STATUS                         0x03
+#define RESPONSE_IRQ_DISABLED                   0x05
+#define RESPONSE_IRQ_ENABLED                    0x06
+#define RESPONSE_PIGGYBACKED                    0x07
+#define RESPONSE_NO_INTERRUPT                   0x08
+#define RESPONSE_PIG_DISABLED                   0x09
+#define RESPONSE_PIG_ENABLED                    0x0A
+#define SD_ERROR_1BIT_TIMEOUT                   0x01
+#define SD_ERROR_4BIT_TIMEOUT                   0x02
+#define SD_ERROR_1BIT_CRC_WRONG                 0x03
+#define SD_ERROR_4BIT_CRC_WRONG                 0x04
+#define SD_ERROR_1BIT_CRC_ERROR                 0x05
+#define SD_ERROR_4BIT_CRC_ERROR                 0x06
+#define SD_ERROR_NO_CMD_ENDBIT                  0x07
+#define SD_ERROR_NO_1BIT_DATEND                 0x08
+#define SD_ERROR_NO_4BIT_DATEND                 0x09
+#define SD_ERROR_1BIT_UNEXPECTED_TIMEOUT        0x0A
+#define SD_ERROR_4BIT_UNEXPECTED_TIMEOUT        0x0B
+#define SD_ERROR_ILLEGAL_COMMAND                0x0C
+#define SD_ERROR_NO_DEVICE                      0x0D
+#define SD_ERROR_TRANSFER_LENGTH                0x0E
+#define SD_ERROR_1BIT_DATA_TIMEOUT              0x0F
+#define SD_ERROR_4BIT_DATA_TIMEOUT              0x10
+#define SD_ERROR_ILLEGAL_STATE                  0x11
+#define SD_ERROR_UNKNOWN_ERROR                  0x12
+#define SD_ERROR_RESERVED_ERROR                 0x13
+#define SD_ERROR_INVALID_FUNCTION               0x14
+#define SD_ERROR_OUT_OF_RANGE                   0x15
+#define SD_ERROR_STAT_CMD                       0x16
+#define SD_ERROR_STAT_DATA                      0x17
+#define SD_ERROR_STAT_CMD_TIMEOUT               0x18
+#define SD_ERROR_SDCRDY_STUCK                   0x19
+#define SD_ERROR_UNHANDLED                      0x1A
+#define SD_ERROR_OVERRUN                        0x1B
+#define SD_ERROR_PIO_TIMEOUT                    0x1C
+
+#define FUN(c) (0x000007 & (c->arg>>28))
+#define REG(c) (0x01FFFF & (c->arg>>9))
+
+static int limit_speed_to_24_MHz;
+module_param(limit_speed_to_24_MHz, bool, 0644);
+MODULE_PARM_DESC(limit_speed_to_24_MHz, "Limit Max SDIO Clock Speed to 24 MHz");
+
+static int pad_input_to_usb_pkt;
+module_param(pad_input_to_usb_pkt, bool, 0644);
+MODULE_PARM_DESC(pad_input_to_usb_pkt,
+                 "Pad USB data input transfers to whole USB Packet");
+
+static int disable_offload_processing;
+module_param(disable_offload_processing, bool, 0644);
+MODULE_PARM_DESC(disable_offload_processing, "Disable Offload Processing");
+
+static int force_1_bit_data_xfers;
+module_param(force_1_bit_data_xfers, bool, 0644);
+MODULE_PARM_DESC(force_1_bit_data_xfers,
+                 "Force SDIO Data Transfers to 1-bit Mode");
+
+static int force_polling_for_irqs;
+module_param(force_polling_for_irqs, bool, 0644);
+MODULE_PARM_DESC(force_polling_for_irqs, "Force Polling for SDIO interrupts");
+
+static int firmware_irqpoll_timeout = 1024;
+module_param(firmware_irqpoll_timeout, int, 0644);
+MODULE_PARM_DESC(firmware_irqpoll_timeout, "VUB300 firmware irqpoll timeout");
+
+static int force_max_req_size = 128;
+module_param(force_max_req_size, int, 0644);
+MODULE_PARM_DESC(force_max_req_size, "set max request size in kBytes");
+
+#ifdef SMSC_DEVELOPMENT_BOARD
+static int firmware_rom_wait_states = 0x04;
+#else
+static int firmware_rom_wait_states = 0x1C;
+#endif
+
+module_param(firmware_rom_wait_states, bool, 0644);
+MODULE_PARM_DESC(firmware_rom_wait_states,
+                 "ROM wait states byte=RRRIIEEE (Reserved Internal External)");
+
+#define ELAN_VENDOR_ID          0x2201
+#define VUB300_VENDOR_ID        0x0424
+#define VUB300_PRODUCT_ID       0x012C
+static struct usb_device_id vub300_table[] = {
+        {USB_DEVICE(ELAN_VENDOR_ID, VUB300_PRODUCT_ID)},
+        {USB_DEVICE(VUB300_VENDOR_ID, VUB300_PRODUCT_ID)},
+        {} /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, vub300_table);
+
+static struct workqueue_struct *cmndworkqueue;
+static struct workqueue_struct *pollworkqueue;
+static struct workqueue_struct *deadworkqueue;
+
+static inline int interface_to_InterfaceNumber(struct usb_interface *interface)
+{
+        if (!interface)
+                return -1;
+        if (!interface->cur_altsetting)
+                return -1;
+        return interface->cur_altsetting->desc.bInterfaceNumber;
+}
+
+struct sdio_register {
+        unsigned func_num:3;
+        unsigned sdio_reg:17;
+        unsigned activate:1;
+        unsigned prepared:1;
+        unsigned regvalue:8;
+        unsigned response:8;
+        unsigned sparebit:26;
+};
+
+struct vub300_mmc_host {
+        struct usb_device *udev;
+        struct usb_interface *interface;
+        struct kref kref;
+        struct mutex cmd_mutex;
+        struct mutex irq_mutex;
+        char vub_name[3 + (9 * 8) + 4 + 1]; /* max of 7 sdio fn's */
+        u8 cmnd_out_ep; /* EndPoint for commands */
+        u8 cmnd_res_ep; /* EndPoint for responses */
+        u8 data_out_ep; /* EndPoint for out data */
+        u8 data_inp_ep; /* EndPoint for inp data */
+        bool card_powered;
+        bool card_present;
+        bool read_only;
+        bool large_usb_packets;
+        bool app_spec; /* ApplicationSpecific */
+        bool irq_enabled; /* by the MMC CORE */
+        bool irq_disabled; /* in the firmware */
+        unsigned bus_width:4;
+        u8 total_offload_count;
+        u8 dynamic_register_count;
+        u8 resp_len;
+        u32 datasize;
+        int errors;
+        int usb_transport_fail;
+        int usb_timed_out;
+        int irqs_queued;
+        struct sdio_register sdio_register[16];
+        struct offload_interrupt_function_register {
+#define MAXREGBITS 4
+#define MAXREGS (1<<MAXREGBITS)
+#define MAXREGMASK (MAXREGS-1)
+                u8 offload_count;
+                u32 offload_point;
+                struct offload_registers_access reg[MAXREGS];
+        } fn[8];
+        u16 fbs[8]; /* Function Block Size */
+        struct mmc_command *cmd;
+        struct mmc_request *req;
+        struct mmc_data *data;
+        struct mmc_host *mmc;
+        struct urb *urb;
+        struct urb *command_out_urb;
+        struct urb *command_res_urb;
+        struct completion command_complete;
+        struct completion irqpoll_complete;
+        union sd_command cmnd;
+        union sd_response resp;
+        struct timer_list sg_transfer_timer;
+        struct usb_sg_request sg_request;
+        struct timer_list inactivity_timer;
+        struct work_struct deadwork;
+        struct work_struct cmndwork;
+        struct delayed_work pollwork;
+        struct host_controller_info hc_info;
+        struct sd_status_header system_port_status;
+        u8 padded_buffer[64];
+};
+
+#define kref_to_vub300_mmc_host(d) container_of(d, struct vub300_mmc_host, kref)
+#define SET_TRANSFER_PSEUDOCODE         21
+#define SET_INTERRUPT_PSEUDOCODE        20
+#define SET_FAILURE_MODE                18
+#define SET_ROM_WAIT_STATES             16
+#define SET_IRQ_ENABLE                  13
+#define SET_CLOCK_SPEED                 11
+#define SET_FUNCTION_BLOCK_SIZE         9
+#define SET_SD_DATA_MODE                6
+#define SET_SD_POWER                    4
+#define ENTER_DFU_MODE                  3
+#define GET_HC_INF0                     1
+#define GET_SYSTEM_PORT_STATUS          0
+
+static void vub300_delete(struct kref *kref)
+{                               /* kref callback - softirq */
+        struct vub300_mmc_host *vub300 = kref_to_vub300_mmc_host(kref);
+        struct mmc_host *mmc = vub300->mmc;
+        usb_free_urb(vub300->command_out_urb);
+        vub300->command_out_urb = NULL;
+        usb_free_urb(vub300->command_res_urb);
+        vub300->command_res_urb = NULL;
+        usb_put_dev(vub300->udev);
+        mmc_free_host(mmc);
+        /*
+         * and hence also frees vub300
+         * which is contained at the end of struct mmc
+         */
+}
+
+static void vub300_queue_cmnd_work(struct vub300_mmc_host *vub300)
+{
+        kref_get(&vub300->kref);
+        if (queue_work(cmndworkqueue, &vub300->cmndwork)) {
+                /*
+                 * then the cmndworkqueue was not previously
+                 * running and the above get ref is obvious
+                 * required and will be put when the thread
+                 * terminates by a specific call
+                 */
+        } else {
+                /*
+                 * the cmndworkqueue was already running from
+                 * a previous invocation and thus to keep the
+                 * kref counts correct we must undo the get
+                 */
+                kref_put(&vub300->kref, vub300_delete);
+        }
+}
+
+static void vub300_queue_poll_work(struct vub300_mmc_host *vub300, int delay)
+{
+        kref_get(&vub300->kref);
+        if (queue_delayed_work(pollworkqueue, &vub300->pollwork, delay)) {
+                /*
+                 * then the pollworkqueue was not previously
+                 * running and the above get ref is obvious
+                 * required and will be put when the thread
+                 * terminates by a specific call
+                 */
+        } else {
+                /*
+                 * the pollworkqueue was already running from
+                 * a previous invocation and thus to keep the
+                 * kref counts correct we must undo the get
+                 */
+                kref_put(&vub300->kref, vub300_delete);
+        }
+}
+
+static void vub300_queue_dead_work(struct vub300_mmc_host *vub300)
+{
+        kref_get(&vub300->kref);
+        if (queue_work(deadworkqueue, &vub300->deadwork)) {
+                /*
+                 * then the deadworkqueue was not previously
+                 * running and the above get ref is obvious
+                 * required and will be put when the thread
+                 * terminates by a specific call
+                 */
+        } else {
+                /*
+                 * the deadworkqueue was already running from
+                 * a previous invocation and thus to keep the
+                 * kref counts correct we must undo the get
+                 */
+                kref_put(&vub300->kref, vub300_delete);
+        }
+}
+
+static void irqpoll_res_completed(struct urb *urb)
+{                               /* urb completion handler - hardirq */
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
+        if (urb->status)
+                vub300->usb_transport_fail = urb->status;
+        complete(&vub300->irqpoll_complete);
+}
+
+static void irqpoll_out_completed(struct urb *urb)
+{                               /* urb completion handler - hardirq */
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
+        if (urb->status) {
+                vub300->usb_transport_fail = urb->status;
+                complete(&vub300->irqpoll_complete);
+                return;
+        } else {
+                int ret;
+                unsigned int pipe =
+                        usb_rcvbulkpipe(vub300->udev, vub300->cmnd_res_ep);
+                usb_fill_bulk_urb(vub300->command_res_urb, vub300->udev, pipe,
+                                  &vub300->resp, sizeof(vub300->resp),
+                                  irqpoll_res_completed, vub300);
+                vub300->command_res_urb->actual_length = 0;
+                ret = usb_submit_urb(vub300->command_res_urb, GFP_ATOMIC);
+                if (ret) {
+                        vub300->usb_transport_fail = ret;
+                        complete(&vub300->irqpoll_complete);
+                }
+                return;
+        }
+}
+
+static void send_irqpoll(struct vub300_mmc_host *vub300)
+{
+        /* cmd_mutex is held by vub300_pollwork_thread */
+        int retval;
+        int timeout = 0xFFFF & (0x0001FFFF - firmware_irqpoll_timeout);
+        vub300->cmnd.poll.header_size = 22;
+        vub300->cmnd.poll.header_type = 1;
+        vub300->cmnd.poll.port_number = 0;
+        vub300->cmnd.poll.command_type = 2;
+        vub300->cmnd.poll.poll_timeout_lsb = 0xFF & (unsigned)timeout;
+        vub300->cmnd.poll.poll_timeout_msb = 0xFF & (unsigned)(timeout >> 8);
+        usb_fill_bulk_urb(vub300->command_out_urb, vub300->udev,
+                          usb_sndbulkpipe(vub300->udev, vub300->cmnd_out_ep)
+                          , &vub300->cmnd, sizeof(vub300->cmnd)
+                          , irqpoll_out_completed, vub300);
+        retval = usb_submit_urb(vub300->command_out_urb, GFP_KERNEL);
+        if (0 > retval) {
+                vub300->usb_transport_fail = retval;
+                vub300_queue_poll_work(vub300, 1);
+                complete(&vub300->irqpoll_complete);
+                return;
+        } else {
+                return;
+        }
+}
+
+static void new_system_port_status(struct vub300_mmc_host *vub300)
+{
+        int old_card_present = vub300->card_present;
+        int new_card_present =
+                (0x0001 & vub300->system_port_status.port_flags) ? 1 : 0;
+        vub300->read_only =
+                (0x0010 & vub300->system_port_status.port_flags) ? 1 : 0;
+        if (new_card_present && !old_card_present) {
+                dev_info(&vub300->udev->dev, "card just inserted\n");
+                vub300->card_present = 1;
+                vub300->bus_width = 0;
+                if (disable_offload_processing)
+                        strncpy(vub300->vub_name, "EMPTY Processing Disabled",
+                                sizeof(vub300->vub_name));
+                else
+                        vub300->vub_name[0] = 0;
+                mmc_detect_change(vub300->mmc, 1);
+        } else if (!new_card_present && old_card_present) {
+                dev_info(&vub300->udev->dev, "card just ejected\n");
+                vub300->card_present = 0;
+                mmc_detect_change(vub300->mmc, 0);
+        } else {
+                /* no change */
+        }
+}
+
+static void __add_offloaded_reg_to_fifo(struct vub300_mmc_host *vub300,
+                                        struct offload_registers_access
+                                        *register_access, u8 func)
+{
+        u8 r = vub300->fn[func].offload_point + vub300->fn[func].offload_count;
+        memcpy(&vub300->fn[func].reg[MAXREGMASK & r], register_access,
+               sizeof(struct offload_registers_access));
+        vub300->fn[func].offload_count += 1;
+        vub300->total_offload_count += 1;
+}
+
+static void add_offloaded_reg(struct vub300_mmc_host *vub300,
+                              struct offload_registers_access *register_access)
+{
+        u32 Register = ((0x03 & register_access->command_byte[0]) << 15)
+                        | ((0xFF & register_access->command_byte[1]) << 7)
+                        | ((0xFE & register_access->command_byte[2]) >> 1);
+        u8 func = ((0x70 & register_access->command_byte[0]) >> 4);
+        u8 regs = vub300->dynamic_register_count;
+        u8 i = 0;
+        while (0 < regs-- && 1 == vub300->sdio_register[i].activate) {
+                if (vub300->sdio_register[i].func_num == func &&
+                    vub300->sdio_register[i].sdio_reg == Register) {
+                        if (vub300->sdio_register[i].prepared == 0)
+                                vub300->sdio_register[i].prepared = 1;
+                        vub300->sdio_register[i].response =
+                                register_access->Respond_Byte[2];
+                        vub300->sdio_register[i].regvalue =
+                                register_access->Respond_Byte[3];
+                        return;
+                } else {
+                        i += 1;
+                        continue;
+                }
+        };
+        __add_offloaded_reg_to_fifo(vub300, register_access, func);
+}
+
+static void check_vub300_port_status(struct vub300_mmc_host *vub300)
+{
+        /*
+         * cmd_mutex is held by vub300_pollwork_thread,
+         * vub300_deadwork_thread or vub300_cmndwork_thread
+         */
+        int retval;
+        retval =
+                usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
+                                GET_SYSTEM_PORT_STATUS,
+                                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x0000, 0x0000, &vub300->system_port_status,
+                                sizeof(vub300->system_port_status), HZ);
+        if (sizeof(vub300->system_port_status) == retval)
+                new_system_port_status(vub300);
+}
+
+static void __vub300_irqpoll_response(struct vub300_mmc_host *vub300)
+{
+        /* cmd_mutex is held by vub300_pollwork_thread */
+        if (vub300->command_res_urb->actual_length == 0)
+                return;
+
+        switch (vub300->resp.common.header_type) {
+        case RESPONSE_INTERRUPT:
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irq_enabled)
+                        mmc_signal_sdio_irq(vub300->mmc);
+                else
+                        vub300->irqs_queued += 1;
+                vub300->irq_disabled = 1;
+                mutex_unlock(&vub300->irq_mutex);
+                break;
+        case RESPONSE_ERROR:
+                if (vub300->resp.error.error_code == SD_ERROR_NO_DEVICE)
+                        check_vub300_port_status(vub300);
+                break;
+        case RESPONSE_STATUS:
+                vub300->system_port_status = vub300->resp.status;
+                new_system_port_status(vub300);
+                if (!vub300->card_present)
+                        vub300_queue_poll_work(vub300, HZ / 5);
+                break;
+        case RESPONSE_IRQ_DISABLED:
+        {
+                int offloaded_data_length = vub300->resp.common.header_size - 3;
+                int register_count = offloaded_data_length >> 3;
+                int ri = 0;
+                while (register_count--) {
+                        add_offloaded_reg(vub300, &vub300->resp.irq.reg[ri]);
+                        ri += 1;
+                }
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irq_enabled)
+                        mmc_signal_sdio_irq(vub300->mmc);
+                else
+                        vub300->irqs_queued += 1;
+                vub300->irq_disabled = 1;
+                mutex_unlock(&vub300->irq_mutex);
+                break;
+        }
+        case RESPONSE_IRQ_ENABLED:
+        {
+                int offloaded_data_length = vub300->resp.common.header_size - 3;
+                int register_count = offloaded_data_length >> 3;
+                int ri = 0;
+                while (register_count--) {
+                        add_offloaded_reg(vub300, &vub300->resp.irq.reg[ri]);
+                        ri += 1;
+                }
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irq_enabled)
+                        mmc_signal_sdio_irq(vub300->mmc);
+                else if (vub300->irqs_queued)
+                        vub300->irqs_queued += 1;
+                else
+                        vub300->irqs_queued += 1;
+                vub300->irq_disabled = 0;
+                mutex_unlock(&vub300->irq_mutex);
+                break;
+        }
+        case RESPONSE_NO_INTERRUPT:
+                vub300_queue_poll_work(vub300, 1);
+                break;
+        default:
+                break;
+        }
+}
+
+static void __do_poll(struct vub300_mmc_host *vub300)
+{
+        /* cmd_mutex is held by vub300_pollwork_thread */
+        long commretval;
+        mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+        init_completion(&vub300->irqpoll_complete);
+        send_irqpoll(vub300);
+        commretval = wait_for_completion_timeout(&vub300->irqpoll_complete,
+                                                 msecs_to_jiffies(500));
+        if (vub300->usb_transport_fail) {
+                /* no need to do anything */
+        } else if (commretval == 0) {
+                vub300->usb_timed_out = 1;
+                usb_kill_urb(vub300->command_out_urb);
+                usb_kill_urb(vub300->command_res_urb);
+        } else if (commretval < 0) {
+                vub300_queue_poll_work(vub300, 1);
+        } else { /* commretval > 0 */
+                __vub300_irqpoll_response(vub300);
+        }
+}
+
+/* this thread runs only when the driver
+ * is trying to poll the device for an IRQ
+ */
+static void vub300_pollwork_thread(struct work_struct *work)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = container_of(work,
+                              struct vub300_mmc_host, pollwork.work);
+        if (!vub300->interface) {
+                kref_put(&vub300->kref, vub300_delete);
+                return;
+        }
+        mutex_lock(&vub300->cmd_mutex);
+        if (vub300->cmd) {
+                vub300_queue_poll_work(vub300, 1);
+        } else if (!vub300->card_present) {
+                /* no need to do anything */
+        } else { /* vub300->card_present */
+                mutex_lock(&vub300->irq_mutex);
+                if (!vub300->irq_enabled) {
+                        mutex_unlock(&vub300->irq_mutex);
+                } else if (vub300->irqs_queued) {
+                        vub300->irqs_queued -= 1;
+                        mmc_signal_sdio_irq(vub300->mmc);
+                        mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+                        mutex_unlock(&vub300->irq_mutex);
+                } else { /* NOT vub300->irqs_queued */
+                        mutex_unlock(&vub300->irq_mutex);
+                        __do_poll(vub300);
+                }
+        }
+        mutex_unlock(&vub300->cmd_mutex);
+        kref_put(&vub300->kref, vub300_delete);
+}
+
+static void vub300_deadwork_thread(struct work_struct *work)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 =
+                container_of(work, struct vub300_mmc_host, deadwork);
+        if (!vub300->interface) {
+                kref_put(&vub300->kref, vub300_delete);
+                return;
+        }
+        mutex_lock(&vub300->cmd_mutex);
+        if (vub300->cmd) {
+                /*
+                 * a command got in as the inactivity
+                 * timer expired - so we just let the
+                 * processing of the command show if
+                 * the device is dead
+                 */
+        } else if (vub300->card_present) {
+                check_vub300_port_status(vub300);
+        } else if (vub300->mmc && vub300->mmc->card &&
+                   mmc_card_present(vub300->mmc->card)) {
+                /*
+                 * the MMC core must not have responded
+                 * to the previous indication - lets
+                 * hope that it eventually does so we
+                 * will just ignore this for now
+                 */
+        } else {
+                check_vub300_port_status(vub300);
+        }
+        mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+        mutex_unlock(&vub300->cmd_mutex);
+        kref_put(&vub300->kref, vub300_delete);
+}
+
+static void vub300_inactivity_timer_expired(unsigned long data)
+{                               /* softirq */
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)data;
+        if (!vub300->interface) {
+                kref_put(&vub300->kref, vub300_delete);
+        } else if (vub300->cmd) {
+                mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+        } else {
+                vub300_queue_dead_work(vub300);
+                mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+        }
+}
+
+static int vub300_response_error(u8 error_code)
+{
+        switch (error_code) {
+        case SD_ERROR_PIO_TIMEOUT:
+        case SD_ERROR_1BIT_TIMEOUT:
+        case SD_ERROR_4BIT_TIMEOUT:
+                return -ETIMEDOUT;
+        case SD_ERROR_STAT_DATA:
+        case SD_ERROR_OVERRUN:
+        case SD_ERROR_STAT_CMD:
+        case SD_ERROR_STAT_CMD_TIMEOUT:
+        case SD_ERROR_SDCRDY_STUCK:
+        case SD_ERROR_UNHANDLED:
+        case SD_ERROR_1BIT_CRC_WRONG:
+        case SD_ERROR_4BIT_CRC_WRONG:
+        case SD_ERROR_1BIT_CRC_ERROR:
+        case SD_ERROR_4BIT_CRC_ERROR:
+        case SD_ERROR_NO_CMD_ENDBIT:
+        case SD_ERROR_NO_1BIT_DATEND:
+        case SD_ERROR_NO_4BIT_DATEND:
+        case SD_ERROR_1BIT_DATA_TIMEOUT:
+        case SD_ERROR_4BIT_DATA_TIMEOUT:
+        case SD_ERROR_1BIT_UNEXPECTED_TIMEOUT:
+        case SD_ERROR_4BIT_UNEXPECTED_TIMEOUT:
+                return -EILSEQ;
+        case 33:
+                return -EILSEQ;
+        case SD_ERROR_ILLEGAL_COMMAND:
+                return -EINVAL;
+        case SD_ERROR_NO_DEVICE:
+                return -ENOMEDIUM;
+        default:
+                return -ENODEV;
+        }
+}
+
+static void command_res_completed(struct urb *urb)
+{                               /* urb completion handler - hardirq */
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
+        if (urb->status) {
+                /* we have to let the initiator handle the error */
+        } else if (vub300->command_res_urb->actual_length == 0) {
+                /*
+                 * we have seen this happen once or twice and
+                 * we suspect a buggy USB host controller
+                 */
+        } else if (!vub300->data) {
+                /* this means that the command (typically CMD52) suceeded */
+        } else if (vub300->resp.common.header_type != 0x02) {
+                /*
+                 * this is an error response from the VUB300 chip
+                 * and we let the initiator handle it
+                 */
+        } else if (vub300->urb) {
+                vub300->cmd->error =
+                        vub300_response_error(vub300->resp.error.error_code);
+                usb_unlink_urb(vub300->urb);
+        } else {
+                vub300->cmd->error =
+                        vub300_response_error(vub300->resp.error.error_code);
+                usb_sg_cancel(&vub300->sg_request);
+        }
+        complete(&vub300->command_complete);    /* got_response_in */
+}
+
+static void command_out_completed(struct urb *urb)
+{                               /* urb completion handler - hardirq */
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
+        if (urb->status) {
+                complete(&vub300->command_complete);
+        } else {
+                int ret;
+                unsigned int pipe =
+                        usb_rcvbulkpipe(vub300->udev, vub300->cmnd_res_ep);
+                usb_fill_bulk_urb(vub300->command_res_urb, vub300->udev, pipe,
+                                  &vub300->resp, sizeof(vub300->resp),
+                                  command_res_completed, vub300);
+                vub300->command_res_urb->actual_length = 0;
+                ret = usb_submit_urb(vub300->command_res_urb, GFP_ATOMIC);
+                if (ret == 0) {
+                        /*
+                         * the urb completion handler will call
+                         * our completion handler
+                         */
+                } else {
+                        /*
+                         * and thus we only call it directly
+                         * when it will not be called
+                         */
+                        complete(&vub300->command_complete);
+                }
+        }
+}
+
+/*
+ * the STUFF bits are masked out for the comparisons
+ */
+static void snoop_block_size_and_bus_width(struct vub300_mmc_host *vub300,
+                                           u32 cmd_arg)
+{
+        if ((0xFBFFFE00 & cmd_arg) == 0x80022200)
+                vub300->fbs[1] = (cmd_arg << 8) | (0x00FF & vub300->fbs[1]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80022000)
+                vub300->fbs[1] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[1]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80042200)
+                vub300->fbs[2] = (cmd_arg << 8) | (0x00FF & vub300->fbs[2]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80042000)
+                vub300->fbs[2] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[2]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80062200)
+                vub300->fbs[3] = (cmd_arg << 8) | (0x00FF & vub300->fbs[3]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80062000)
+                vub300->fbs[3] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[3]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80082200)
+                vub300->fbs[4] = (cmd_arg << 8) | (0x00FF & vub300->fbs[4]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x80082000)
+                vub300->fbs[4] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[4]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800A2200)
+                vub300->fbs[5] = (cmd_arg << 8) | (0x00FF & vub300->fbs[5]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800A2000)
+                vub300->fbs[5] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[5]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800C2200)
+                vub300->fbs[6] = (cmd_arg << 8) | (0x00FF & vub300->fbs[6]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800C2000)
+                vub300->fbs[6] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[6]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800E2200)
+                vub300->fbs[7] = (cmd_arg << 8) | (0x00FF & vub300->fbs[7]);
+        else if ((0xFBFFFE00 & cmd_arg) == 0x800E2000)
+                vub300->fbs[7] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[7]);
+        else if ((0xFBFFFE03 & cmd_arg) == 0x80000E00)
+                vub300->bus_width = 1;
+        else if ((0xFBFFFE03 & cmd_arg) == 0x80000E02)
+                vub300->bus_width = 4;
+}
+
+static void send_command(struct vub300_mmc_host *vub300)
+{
+        /* cmd_mutex is held by vub300_cmndwork_thread */
+        struct mmc_command *cmd = vub300->cmd;
+        struct mmc_data *data = vub300->data;
+        int retval;
+        int i;
+        u8 response_type;
+        if (vub300->app_spec) {
+                switch (cmd->opcode) {
+                case 6:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        if (0x00000000 == (0x00000003 & cmd->arg))
+                                vub300->bus_width = 1;
+                        else if (0x00000002 == (0x00000003 & cmd->arg))
+                                vub300->bus_width = 4;
+                        else
+                                dev_err(&vub300->udev->dev,
+                                        "unexpected ACMD6 bus_width=%d\n",
+                                        0x00000003 & cmd->arg);
+                        break;
+                case 13:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 22:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 23:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 41:
+                        response_type = SDRT_3;
+                        vub300->resp_len = 6;
+                        break;
+                case 42:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 51:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 55:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                default:
+                        vub300->resp_len = 0;
+                        cmd->error = -EINVAL;
+                        complete(&vub300->command_complete);
+                        return;
+                }
+                vub300->app_spec = 0;
+        } else {
+                switch (cmd->opcode) {
+                case 0:
+                        response_type = SDRT_NONE;
+                        vub300->resp_len = 0;
+                        break;
+                case 1:
+                        response_type = SDRT_3;
+                        vub300->resp_len = 6;
+                        break;
+                case 2:
+                        response_type = SDRT_2;
+                        vub300->resp_len = 17;
+                        break;
+                case 3:
+                        response_type = SDRT_6;
+                        vub300->resp_len = 6;
+                        break;
+                case 4:
+                        response_type = SDRT_NONE;
+                        vub300->resp_len = 0;
+                        break;
+                case 5:
+                        response_type = SDRT_4;
+                        vub300->resp_len = 6;
+                        break;
+                case 6:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 7:
+                        response_type = SDRT_1B;
+                        vub300->resp_len = 6;
+                        break;
+                case 8:
+                        response_type = SDRT_7;
+                        vub300->resp_len = 6;
+                        break;
+                case 9:
+                        response_type = SDRT_2;
+                        vub300->resp_len = 17;
+                        break;
+                case 10:
+                        response_type = SDRT_2;
+                        vub300->resp_len = 17;
+                        break;
+                case 12:
+                        response_type = SDRT_1B;
+                        vub300->resp_len = 6;
+                        break;
+                case 13:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 15:
+                        response_type = SDRT_NONE;
+                        vub300->resp_len = 0;
+                        break;
+                case 16:
+                        for (i = 0; i < ARRAY_SIZE(vub300->fbs); i++)
+                                vub300->fbs[i] = 0xFFFF & cmd->arg;
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 17:
+                case 18:
+                case 24:
+                case 25:
+                case 27:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 28:
+                case 29:
+                        response_type = SDRT_1B;
+                        vub300->resp_len = 6;
+                        break;
+                case 30:
+                case 32:
+                case 33:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 38:
+                        response_type = SDRT_1B;
+                        vub300->resp_len = 6;
+                        break;
+                case 42:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                case 52:
+                        response_type = SDRT_5;
+                        vub300->resp_len = 6;
+                        snoop_block_size_and_bus_width(vub300, cmd->arg);
+                        break;
+                case 53:
+                        response_type = SDRT_5;
+                        vub300->resp_len = 6;
+                        break;
+                case 55:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        vub300->app_spec = 1;
+                        break;
+                case 56:
+                        response_type = SDRT_1;
+                        vub300->resp_len = 6;
+                        break;
+                default:
+                        vub300->resp_len = 0;
+                        cmd->error = -EINVAL;
+                        complete(&vub300->command_complete);
+                        return;
+                }
+        }
+        /*
+         * it is a shame that we can not use "sizeof(struct sd_command_header)"
+         * this is because the packet _must_ be padded to 64 bytes
+         */
+        vub300->cmnd.head.header_size = 20;
+        vub300->cmnd.head.header_type = 0x00;
+        vub300->cmnd.head.port_number = 0; /* "0" means port 1 */
+        vub300->cmnd.head.command_type = 0x00; /* standard read command */
+        vub300->cmnd.head.response_type = response_type;
+        vub300->cmnd.head.command_index = cmd->opcode;
+        vub300->cmnd.head.arguments[0] = cmd->arg >> 24;
+        vub300->cmnd.head.arguments[1] = cmd->arg >> 16;
+        vub300->cmnd.head.arguments[2] = cmd->arg >> 8;
+        vub300->cmnd.head.arguments[3] = cmd->arg >> 0;
+        if (cmd->opcode == 52) {
+                int fn = 0x7 & (cmd->arg >> 28);
+                vub300->cmnd.head.block_count[0] = 0;
+                vub300->cmnd.head.block_count[1] = 0;
+                vub300->cmnd.head.block_size[0] = (vub300->fbs[fn] >> 8) & 0xFF;
+                vub300->cmnd.head.block_size[1] = (vub300->fbs[fn] >> 0) & 0xFF;
+                vub300->cmnd.head.command_type = 0x00;
+                vub300->cmnd.head.transfer_size[0] = 0;
+                vub300->cmnd.head.transfer_size[1] = 0;
+                vub300->cmnd.head.transfer_size[2] = 0;
+                vub300->cmnd.head.transfer_size[3] = 0;
+        } else if (!data) {
+                vub300->cmnd.head.block_count[0] = 0;
+                vub300->cmnd.head.block_count[1] = 0;
+                vub300->cmnd.head.block_size[0] = (vub300->fbs[0] >> 8) & 0xFF;
+                vub300->cmnd.head.block_size[1] = (vub300->fbs[0] >> 0) & 0xFF;
+                vub300->cmnd.head.command_type = 0x00;
+                vub300->cmnd.head.transfer_size[0] = 0;
+                vub300->cmnd.head.transfer_size[1] = 0;
+                vub300->cmnd.head.transfer_size[2] = 0;
+                vub300->cmnd.head.transfer_size[3] = 0;
+        } else if (cmd->opcode == 53) {
+                int fn = 0x7 & (cmd->arg >> 28);
+                if (0x08 & vub300->cmnd.head.arguments[0]) { /* BLOCK MODE */
+                        vub300->cmnd.head.block_count[0] =
+                                (data->blocks >> 8) & 0xFF;
+                        vub300->cmnd.head.block_count[1] =
+                                (data->blocks >> 0) & 0xFF;
+                        vub300->cmnd.head.block_size[0] =
+                                (data->blksz >> 8) & 0xFF;
+                        vub300->cmnd.head.block_size[1] =
+                                (data->blksz >> 0) & 0xFF;
+                } else {        /* BYTE MODE */
+                        vub300->cmnd.head.block_count[0] = 0;
+                        vub300->cmnd.head.block_count[1] = 0;
+                        vub300->cmnd.head.block_size[0] =
+                                (vub300->datasize >> 8) & 0xFF;
+                        vub300->cmnd.head.block_size[1] =
+                                (vub300->datasize >> 0) & 0xFF;
+                }
+                vub300->cmnd.head.command_type =
+                        (MMC_DATA_READ & data->flags) ? 0x00 : 0x80;
+                vub300->cmnd.head.transfer_size[0] =
+                        (vub300->datasize >> 24) & 0xFF;
+                vub300->cmnd.head.transfer_size[1] =
+                        (vub300->datasize >> 16) & 0xFF;
+                vub300->cmnd.head.transfer_size[2] =
+                        (vub300->datasize >> 8) & 0xFF;
+                vub300->cmnd.head.transfer_size[3] =
+                        (vub300->datasize >> 0) & 0xFF;
+                if (vub300->datasize < vub300->fbs[fn]) {
+                        vub300->cmnd.head.block_count[0] = 0;
+                        vub300->cmnd.head.block_count[1] = 0;
+                }
+        } else {
+                vub300->cmnd.head.block_count[0] = (data->blocks >> 8) & 0xFF;
+                vub300->cmnd.head.block_count[1] = (data->blocks >> 0) & 0xFF;
+                vub300->cmnd.head.block_size[0] = (data->blksz >> 8) & 0xFF;
+                vub300->cmnd.head.block_size[1] = (data->blksz >> 0) & 0xFF;
+                vub300->cmnd.head.command_type =
+                        (MMC_DATA_READ & data->flags) ? 0x00 : 0x80;
+                vub300->cmnd.head.transfer_size[0] =
+                        (vub300->datasize >> 24) & 0xFF;
+                vub300->cmnd.head.transfer_size[1] =
+                        (vub300->datasize >> 16) & 0xFF;
+                vub300->cmnd.head.transfer_size[2] =
+                        (vub300->datasize >> 8) & 0xFF;
+                vub300->cmnd.head.transfer_size[3] =
+                        (vub300->datasize >> 0) & 0xFF;
+                if (vub300->datasize < vub300->fbs[0]) {
+                        vub300->cmnd.head.block_count[0] = 0;
+                        vub300->cmnd.head.block_count[1] = 0;
+                }
+        }
+        if (vub300->cmnd.head.block_size[0] || vub300->cmnd.head.block_size[1]) {
+                u16 block_size = vub300->cmnd.head.block_size[1] |
+                        (vub300->cmnd.head.block_size[0] << 8);
+                u16 block_boundary = FIRMWARE_BLOCK_BOUNDARY -
+                        (FIRMWARE_BLOCK_BOUNDARY % block_size);
+                vub300->cmnd.head.block_boundary[0] =
+                        (block_boundary >> 8) & 0xFF;
+                vub300->cmnd.head.block_boundary[1] =
+                        (block_boundary >> 0) & 0xFF;
+        } else {
+                vub300->cmnd.head.block_boundary[0] = 0;
+                vub300->cmnd.head.block_boundary[1] = 0;
+        }
+        usb_fill_bulk_urb(vub300->command_out_urb, vub300->udev,
+                          usb_sndbulkpipe(vub300->udev, vub300->cmnd_out_ep),
+                          &vub300->cmnd, sizeof(vub300->cmnd),
+                          command_out_completed, vub300);
+        retval = usb_submit_urb(vub300->command_out_urb, GFP_KERNEL);
+        if (retval < 0) {
+                cmd->error = retval;
+                complete(&vub300->command_complete);
+                return;
+        } else {
+                return;
+        }
+}
+
+/*
+ * timer callback runs in atomic mode
+ *       so it cannot call usb_kill_urb()
+ */
+static void vub300_sg_timed_out(unsigned long data)
+{
+        struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)data;
+        vub300->usb_timed_out = 1;
+        usb_sg_cancel(&vub300->sg_request);
+        usb_unlink_urb(vub300->command_out_urb);
+        usb_unlink_urb(vub300->command_res_urb);
+}
+
+static u16 roundup_to_multiple_of_64(u16 number)
+{
+        return 0xFFC0 & (0x3F + number);
+}
+
+/*
+ * this is a separate function to solve the 80 column width restriction
+ */
+static void __download_offload_pseudocode(struct vub300_mmc_host *vub300,
+                                          const struct firmware *fw)
+{
+        u8 register_count = 0;
+        u16 ts = 0;
+        u16 interrupt_size = 0;
+        const u8 *data = fw->data;
+        int size = fw->size;
+        u8 c;
+        dev_info(&vub300->udev->dev, "using %s for SDIO offload processing\n",
+                 vub300->vub_name);
+        do {
+                c = *data++;
+        } while (size-- && c); /* skip comment */
+        dev_info(&vub300->udev->dev, "using offload firmware %s %s\n", fw->data,
+                 vub300->vub_name);
+        if (size < 4) {
+                dev_err(&vub300->udev->dev,
+                        "corrupt offload pseudocode in firmware %s\n",
+                        vub300->vub_name);
+                strncpy(vub300->vub_name, "corrupt offload pseudocode",
+                        sizeof(vub300->vub_name));
+                return;
+        }
+        interrupt_size += *data++;
+        size -= 1;
+        interrupt_size <<= 8;
+        interrupt_size += *data++;
+        size -= 1;
+        if (interrupt_size < size) {
+                u16 xfer_length = roundup_to_multiple_of_64(interrupt_size);
+                u8 *xfer_buffer = kmalloc(xfer_length, GFP_KERNEL);
+                if (xfer_buffer) {
+                        int retval;
+                        memcpy(xfer_buffer, data, interrupt_size);
+                        memset(xfer_buffer + interrupt_size, 0,
+                               xfer_length - interrupt_size);
+                        size -= interrupt_size;
+                        data += interrupt_size;
+                        retval =
+                                usb_control_msg(vub300->udev,
+                                                usb_sndctrlpipe(vub300->udev, 0),
+                                                SET_INTERRUPT_PSEUDOCODE,
+                                                USB_DIR_OUT | USB_TYPE_VENDOR |
+                                                USB_RECIP_DEVICE, 0x0000, 0x0000,
+                                                xfer_buffer, xfer_length, HZ);
+                        kfree(xfer_buffer);
+                        if (retval < 0) {
+                                strncpy(vub300->vub_name,
+                                        "SDIO pseudocode download failed",
+                                        sizeof(vub300->vub_name));
+                                return;
+                        }
+                } else {
+                        dev_err(&vub300->udev->dev,
+                                "not enough memory for xfer buffer to send"
+                                " INTERRUPT_PSEUDOCODE for %s %s\n", fw->data,
+                                vub300->vub_name);
+                        strncpy(vub300->vub_name,
+                                "SDIO interrupt pseudocode download failed",
+                                sizeof(vub300->vub_name));
+                        return;
+                }
+        } else {
+                dev_err(&vub300->udev->dev,
+                        "corrupt interrupt pseudocode in firmware %s %s\n",
+                        fw->data, vub300->vub_name);
+                strncpy(vub300->vub_name, "corrupt interrupt pseudocode",
+                        sizeof(vub300->vub_name));
+                return;
+        }
+        ts += *data++;
+        size -= 1;
+        ts <<= 8;
+        ts += *data++;
+        size -= 1;
+        if (ts < size) {
+                u16 xfer_length = roundup_to_multiple_of_64(ts);
+                u8 *xfer_buffer = kmalloc(xfer_length, GFP_KERNEL);
+                if (xfer_buffer) {
+                        int retval;
+                        memcpy(xfer_buffer, data, ts);
+                        memset(xfer_buffer + ts, 0,
+                               xfer_length - ts);
+                        size -= ts;
+                        data += ts;
+                        retval =
+                                usb_control_msg(vub300->udev,
+                                                usb_sndctrlpipe(vub300->udev, 0),
+                                                SET_TRANSFER_PSEUDOCODE,
+                                                USB_DIR_OUT | USB_TYPE_VENDOR |
+                                                USB_RECIP_DEVICE, 0x0000, 0x0000,
+                                                xfer_buffer, xfer_length, HZ);
+                        kfree(xfer_buffer);
+                        if (retval < 0) {
+                                strncpy(vub300->vub_name,
+                                        "SDIO pseudocode download failed",
+                                        sizeof(vub300->vub_name));
+                                return;
+                        }
+                } else {
+                        dev_err(&vub300->udev->dev,
+                                "not enough memory for xfer buffer to send"
+                                " TRANSFER_PSEUDOCODE for %s %s\n", fw->data,
+                                vub300->vub_name);
+                        strncpy(vub300->vub_name,
+                                "SDIO transfer pseudocode download failed",
+                                sizeof(vub300->vub_name));
+                        return;
+                }
+        } else {
+                dev_err(&vub300->udev->dev,
+                        "corrupt transfer pseudocode in firmware %s %s\n",
+                        fw->data, vub300->vub_name);
+                strncpy(vub300->vub_name, "corrupt transfer pseudocode",
+                        sizeof(vub300->vub_name));
+                return;
+        }
+        register_count += *data++;
+        size -= 1;
+        if (register_count * 4 == size) {
+                int I = vub300->dynamic_register_count = register_count;
+                int i = 0;
+                while (I--) {
+                        unsigned int func_num = 0;
+                        vub300->sdio_register[i].func_num = *data++;
+                        size -= 1;
+                        func_num += *data++;
+                        size -= 1;
+                        func_num <<= 8;
+                        func_num += *data++;
+                        size -= 1;
+                        func_num <<= 8;
+                        func_num += *data++;
+                        size -= 1;
+                        vub300->sdio_register[i].sdio_reg = func_num;
+                        vub300->sdio_register[i].activate = 1;
+                        vub300->sdio_register[i].prepared = 0;
+                        i += 1;
+                }
+                dev_info(&vub300->udev->dev,
+                         "initialized %d dynamic pseudocode registers\n",
+                         vub300->dynamic_register_count);
+                return;
+        } else {
+                dev_err(&vub300->udev->dev,
+                        "corrupt dynamic registers in firmware %s\n",
+                        vub300->vub_name);
+                strncpy(vub300->vub_name, "corrupt dynamic registers",
+                        sizeof(vub300->vub_name));
+                return;
+        }
+}
+
+/*
+ * if the binary containing the EMPTY PseudoCode can not be found
+ * vub300->vub_name is set anyway in order to prevent an automatic retry
+ */
+static void download_offload_pseudocode(struct vub300_mmc_host *vub300)
+{
+        struct mmc_card *card = vub300->mmc->card;
+        int sdio_funcs = card->sdio_funcs;
+        const struct firmware *fw = NULL;
+        int l = snprintf(vub300->vub_name, sizeof(vub300->vub_name),
+                         "vub_%04X%04X", card->cis.vendor, card->cis.device);
+        int n = 0;
+        int retval;
+        for (n = 0; n < sdio_funcs; n++) {
+                struct sdio_func *sf = card->sdio_func[n];
+                l += snprintf(vub300->vub_name + l,
+                              sizeof(vub300->vub_name) - l, "_%04X%04X",
+                              sf->vendor, sf->device);
+        };
+        snprintf(vub300->vub_name + l, sizeof(vub300->vub_name) - l, ".bin");
+        dev_info(&vub300->udev->dev, "requesting offload firmware %s\n",
+                 vub300->vub_name);
+        retval = request_firmware(&fw, vub300->vub_name, &card->dev);
+        if (retval < 0) {
+                strncpy(vub300->vub_name, "vub_default.bin",
+                        sizeof(vub300->vub_name));
+                retval = request_firmware(&fw, vub300->vub_name, &card->dev);
+                if (retval < 0) {
+                        strncpy(vub300->vub_name,
+                                "no SDIO offload firmware found",
+                                sizeof(vub300->vub_name));
+                } else {
+                        __download_offload_pseudocode(vub300, fw);
+                        release_firmware(fw);
+                }
+        } else {
+                __download_offload_pseudocode(vub300, fw);
+                release_firmware(fw);
+        }
+}
+
+static void vub300_usb_bulk_msg_completion(struct urb *urb)
+{                               /* urb completion handler - hardirq */
+        complete((struct completion *)urb->context);
+}
+
+static int vub300_usb_bulk_msg(struct vub300_mmc_host *vub300,
+                               unsigned int pipe, void *data, int len,
+                               int *actual_length, int timeout_msecs)
+{
+        /* cmd_mutex is held by vub300_cmndwork_thread */
+        struct usb_device *usb_dev = vub300->udev;
+        struct completion done;
+        int retval;
+        vub300->urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!vub300->urb)
+                return -ENOMEM;
+        usb_fill_bulk_urb(vub300->urb, usb_dev, pipe, data, len,
+                          vub300_usb_bulk_msg_completion, NULL);
+        init_completion(&done);
+        vub300->urb->context = &done;
+        vub300->urb->actual_length = 0;
+        retval = usb_submit_urb(vub300->urb, GFP_KERNEL);
+        if (unlikely(retval))
+                goto out;
+        if (!wait_for_completion_timeout
+            (&done, msecs_to_jiffies(timeout_msecs))) {
+                retval = -ETIMEDOUT;
+                usb_kill_urb(vub300->urb);
+        } else {
+                retval = vub300->urb->status;
+        }
+out:
+        *actual_length = vub300->urb->actual_length;
+        usb_free_urb(vub300->urb);
+        vub300->urb = NULL;
+        return retval;
+}
+
+static int __command_read_data(struct vub300_mmc_host *vub300,
+                               struct mmc_command *cmd, struct mmc_data *data)
+{
+        /* cmd_mutex is held by vub300_cmndwork_thread */
+        int linear_length = vub300->datasize;
+        int padded_length = vub300->large_usb_packets ?
+                ((511 + linear_length) >> 9) << 9 :
+                ((63 + linear_length) >> 6) << 6;
+        if ((padded_length == linear_length) || !pad_input_to_usb_pkt) {
+                int result;
+                unsigned pipe;
+                pipe = usb_rcvbulkpipe(vub300->udev, vub300->data_inp_ep);
+                result = usb_sg_init(&vub300->sg_request, vub300->udev,
+                                     pipe, 0, data->sg,
+                                     data->sg_len, 0, GFP_KERNEL);
+                if (result < 0) {
+                        usb_unlink_urb(vub300->command_out_urb);
+                        usb_unlink_urb(vub300->command_res_urb);
+                        cmd->error = result;
+                        data->bytes_xfered = 0;
+                        return 0;
+                } else {
+                        vub300->sg_transfer_timer.expires =
+                                jiffies + msecs_to_jiffies(2000 +
+                                                  (linear_length / 16384));
+                        add_timer(&vub300->sg_transfer_timer);
+                        usb_sg_wait(&vub300->sg_request);
+                        del_timer(&vub300->sg_transfer_timer);
+                        if (vub300->sg_request.status < 0) {
+                                cmd->error = vub300->sg_request.status;
+                                data->bytes_xfered = 0;
+                                return 0;
+                        } else {
+                                data->bytes_xfered = vub300->datasize;
+                                return linear_length;
+                        }
+                }
+        } else {
+                u8 *buf = kmalloc(padded_length, GFP_KERNEL);
+                if (buf) {
+                        int result;
+                        unsigned pipe = usb_rcvbulkpipe(vub300->udev,
+                                                        vub300->data_inp_ep);
+                        int actual_length = 0;
+                        result = vub300_usb_bulk_msg(vub300, pipe, buf,
+                                             padded_length, &actual_length,
+                                             2000 + (padded_length / 16384));
+                        if (result < 0) {
+                                cmd->error = result;
+                                data->bytes_xfered = 0;
+                                kfree(buf);
+                                return 0;
+                        } else if (actual_length < linear_length) {
+                                cmd->error = -EREMOTEIO;
+                                data->bytes_xfered = 0;
+                                kfree(buf);
+                                return 0;
+                        } else {
+                                sg_copy_from_buffer(data->sg, data->sg_len, buf,
+                                                    linear_length);
+                                kfree(buf);
+                                data->bytes_xfered = vub300->datasize;
+                                return linear_length;
+                        }
+                } else {
+                        cmd->error = -ENOMEM;
+                        data->bytes_xfered = 0;
+                        return 0;
+                }
+        }
+}
+
+static int __command_write_data(struct vub300_mmc_host *vub300,
+                                struct mmc_command *cmd, struct mmc_data *data)
+{
+        /* cmd_mutex is held by vub300_cmndwork_thread */
+        unsigned pipe = usb_sndbulkpipe(vub300->udev, vub300->data_out_ep);
+        int linear_length = vub300->datasize;
+        int modulo_64_length = linear_length & 0x003F;
+        int modulo_512_length = linear_length & 0x01FF;
+        if (linear_length < 64) {
+                int result;
+                int actual_length;
+                sg_copy_to_buffer(data->sg, data->sg_len,
+                                  vub300->padded_buffer,
+                                  sizeof(vub300->padded_buffer));
+                memset(vub300->padded_buffer + linear_length, 0,
+                       sizeof(vub300->padded_buffer) - linear_length);
+                result = vub300_usb_bulk_msg(vub300, pipe, vub300->padded_buffer,
+                                             sizeof(vub300->padded_buffer),
+                                             &actual_length, 2000 +
+                                             (sizeof(vub300->padded_buffer) /
+                                              16384));
+                if (result < 0) {
+                        cmd->error = result;
+                        data->bytes_xfered = 0;
+                } else {
+                        data->bytes_xfered = vub300->datasize;
+                }
+        } else if ((!vub300->large_usb_packets && (0 < modulo_64_length)) ||
+                    (vub300->large_usb_packets && (64 > modulo_512_length))
+                ) {             /* don't you just love these work-rounds */
+                int padded_length = ((63 + linear_length) >> 6) << 6;
+                u8 *buf = kmalloc(padded_length, GFP_KERNEL);
+                if (buf) {
+                        int result;
+                        int actual_length;
+                        sg_copy_to_buffer(data->sg, data->sg_len, buf,
+                                          padded_length);
+                        memset(buf + linear_length, 0,
+                               padded_length - linear_length);
+                        result =
+                                vub300_usb_bulk_msg(vub300, pipe, buf,
+                                                    padded_length, &actual_length,
+                                                    2000 + padded_length / 16384);
+                        kfree(buf);
+                        if (result < 0) {
+                                cmd->error = result;
+                                data->bytes_xfered = 0;
+                        } else {
+                                data->bytes_xfered = vub300->datasize;
+                        }
+                } else {
+                        cmd->error = -ENOMEM;
+                        data->bytes_xfered = 0;
+                }
+        } else {                /* no data padding required */
+                int result;
+                unsigned char buf[64 * 4];
+                sg_copy_to_buffer(data->sg, data->sg_len, buf, sizeof(buf));
+                result = usb_sg_init(&vub300->sg_request, vub300->udev,
+                                     pipe, 0, data->sg,
+                                     data->sg_len, 0, GFP_KERNEL);
+                if (result < 0) {
+                        usb_unlink_urb(vub300->command_out_urb);
+                        usb_unlink_urb(vub300->command_res_urb);
+                        cmd->error = result;
+                        data->bytes_xfered = 0;
+                } else {
+                        vub300->sg_transfer_timer.expires =
+                                jiffies + msecs_to_jiffies(2000 +
+                                                           linear_length / 16384);
+                        add_timer(&vub300->sg_transfer_timer);
+                        usb_sg_wait(&vub300->sg_request);
+                        if (cmd->error) {
+                                data->bytes_xfered = 0;
+                        } else {
+                                del_timer(&vub300->sg_transfer_timer);
+                                if (vub300->sg_request.status < 0) {
+                                        cmd->error = vub300->sg_request.status;
+                                        data->bytes_xfered = 0;
+                                } else {
+                                        data->bytes_xfered = vub300->datasize;
+                                }
+                        }
+                }
+        }
+        return linear_length;
+}
+
+static void __vub300_command_response(struct vub300_mmc_host *vub300,
+                                      struct mmc_command *cmd,
+                                      struct mmc_data *data, int data_length)
+{
+        /* cmd_mutex is held by vub300_cmndwork_thread */
+        long respretval;
+        int msec_timeout = 1000 + data_length / 4;
+        respretval =
+                wait_for_completion_timeout(&vub300->command_complete,
+                                            msecs_to_jiffies(msec_timeout));
+        if (respretval == 0) { /* TIMED OUT */
+                /* we don't know which of "out" and "res" if any failed */
+                int result;
+                vub300->usb_timed_out = 1;
+                usb_kill_urb(vub300->command_out_urb);
+                usb_kill_urb(vub300->command_res_urb);
+                cmd->error = -ETIMEDOUT;
+                result = usb_lock_device_for_reset(vub300->udev,
+                                                   vub300->interface);
+                if (result == 0) {
+                        result = usb_reset_device(vub300->udev);
+                        usb_unlock_device(vub300->udev);
+                }
+        } else if (respretval < 0) {
+                /* we don't know which of "out" and "res" if any failed */
+                usb_kill_urb(vub300->command_out_urb);
+                usb_kill_urb(vub300->command_res_urb);
+                cmd->error = respretval;
+        } else if (cmd->error) {
+                /*
+                 * the error occured sending the command
+                 * or recieving the response
+                 */
+        } else if (vub300->command_out_urb->status) {
+                vub300->usb_transport_fail = vub300->command_out_urb->status;
+                cmd->error = -EPROTO == vub300->command_out_urb->status ?
+                        -ESHUTDOWN : vub300->command_out_urb->status;
+        } else if (vub300->command_res_urb->status) {
+                vub300->usb_transport_fail = vub300->command_res_urb->status;
+                cmd->error = -EPROTO == vub300->command_res_urb->status ?
+                        -ESHUTDOWN : vub300->command_res_urb->status;
+        } else if (vub300->resp.common.header_type == 0x00) {
+                /*
+                 * the command completed successfully
+                 * and there was no piggybacked data
+                 */
+        } else if (vub300->resp.common.header_type == RESPONSE_ERROR) {
+                cmd->error =
+                        vub300_response_error(vub300->resp.error.error_code);
+                if (vub300->data)
+                        usb_sg_cancel(&vub300->sg_request);
+        } else if (vub300->resp.common.header_type == RESPONSE_PIGGYBACKED) {
+                int offloaded_data_length =
+                        vub300->resp.common.header_size -
+                        sizeof(struct sd_register_header);
+                int register_count = offloaded_data_length >> 3;
+                int ri = 0;
+                while (register_count--) {
+                        add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
+                        ri += 1;
+                }
+                vub300->resp.common.header_size =
+                        sizeof(struct sd_register_header);
+                vub300->resp.common.header_type = 0x00;
+                cmd->error = 0;
+        } else if (vub300->resp.common.header_type == RESPONSE_PIG_DISABLED) {
+                int offloaded_data_length =
+                        vub300->resp.common.header_size -
+                        sizeof(struct sd_register_header);
+                int register_count = offloaded_data_length >> 3;
+                int ri = 0;
+                while (register_count--) {
+                        add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
+                        ri += 1;
+                }
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irqs_queued) {
+                        vub300->irqs_queued += 1;
+                } else if (vub300->irq_enabled) {
+                        vub300->irqs_queued += 1;
+                        vub300_queue_poll_work(vub300, 0);
+                } else {
+                        vub300->irqs_queued += 1;
+                }
+                vub300->irq_disabled = 1;
+                mutex_unlock(&vub300->irq_mutex);
+                vub300->resp.common.header_size =
+                        sizeof(struct sd_register_header);
+                vub300->resp.common.header_type = 0x00;
+                cmd->error = 0;
+        } else if (vub300->resp.common.header_type == RESPONSE_PIG_ENABLED) {
+                int offloaded_data_length =
+                        vub300->resp.common.header_size -
+                        sizeof(struct sd_register_header);
+                int register_count = offloaded_data_length >> 3;
+                int ri = 0;
+                while (register_count--) {
+                        add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
+                        ri += 1;
+                }
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irqs_queued) {
+                        vub300->irqs_queued += 1;
+                } else if (vub300->irq_enabled) {
+                        vub300->irqs_queued += 1;
+                        vub300_queue_poll_work(vub300, 0);
+                } else {
+                        vub300->irqs_queued += 1;
+                }
+                vub300->irq_disabled = 0;
+                mutex_unlock(&vub300->irq_mutex);
+                vub300->resp.common.header_size =
+                        sizeof(struct sd_register_header);
+                vub300->resp.common.header_type = 0x00;
+                cmd->error = 0;
+        } else {
+                cmd->error = -EINVAL;
+        }
+}
+
+static void construct_request_response(struct vub300_mmc_host *vub300,
+                                       struct mmc_command *cmd)
+{
+        int resp_len = vub300->resp_len;
+        int less_cmd = (17 == resp_len) ? resp_len : resp_len - 1;
+        int bytes = 3 & less_cmd;
+        int words = less_cmd >> 2;
+        u8 *r = vub300->resp.response.command_response;
+        if (bytes == 3) {
+                cmd->resp[words] = (r[1 + (words << 2)] << 24)
+                        | (r[2 + (words << 2)] << 16)
+                        | (r[3 + (words << 2)] << 8);
+        } else if (bytes == 2) {
+                cmd->resp[words] = (r[1 + (words << 2)] << 24)
+                        | (r[2 + (words << 2)] << 16);
+        } else if (bytes == 1) {
+                cmd->resp[words] = (r[1 + (words << 2)] << 24);
+        }
+        while (words-- > 0) {
+                cmd->resp[words] = (r[1 + (words << 2)] << 24)
+                        | (r[2 + (words << 2)] << 16)
+                        | (r[3 + (words << 2)] << 8)
+                        | (r[4 + (words << 2)] << 0);
+        }
+        if ((cmd->opcode == 53) && (0x000000FF & cmd->resp[0]))
+                cmd->resp[0] &= 0xFFFFFF00;
+}
+
+/* this thread runs only when there is an upper level command req outstanding */
+static void vub300_cmndwork_thread(struct work_struct *work)
+{
+        struct vub300_mmc_host *vub300 =
+                container_of(work, struct vub300_mmc_host, cmndwork);
+        if (!vub300->interface) {
+                kref_put(&vub300->kref, vub300_delete);
+                return;
+        } else {
+                struct mmc_request *req = vub300->req;
+                struct mmc_command *cmd = vub300->cmd;
+                struct mmc_data *data = vub300->data;
+                int data_length;
+                mutex_lock(&vub300->cmd_mutex);
+                init_completion(&vub300->command_complete);
+                if (likely(vub300->vub_name[0]) || !vub300->mmc->card ||
+                    !mmc_card_present(vub300->mmc->card)) {
+                        /*
+                         * the name of the EMPTY Pseudo firmware file
+                         * is used as a flag to indicate that the file
+                         * has been already downloaded to the VUB300 chip
+                         */
+                } else if (0 == vub300->mmc->card->sdio_funcs) {
+                        strncpy(vub300->vub_name, "SD memory device",
+                                sizeof(vub300->vub_name));
+                } else {
+                        download_offload_pseudocode(vub300);
+                }
+                send_command(vub300);
+                if (!data)
+                        data_length = 0;
+                else if (MMC_DATA_READ & data->flags)
+                        data_length = __command_read_data(vub300, cmd, data);
+                else
+                        data_length = __command_write_data(vub300, cmd, data);
+                __vub300_command_response(vub300, cmd, data, data_length);
+                vub300->req = NULL;
+                vub300->cmd = NULL;
+                vub300->data = NULL;
+                if (cmd->error) {
+                        if (cmd->error == -ENOMEDIUM)
+                                check_vub300_port_status(vub300);
+                        mutex_unlock(&vub300->cmd_mutex);
+                        mmc_request_done(vub300->mmc, req);
+                        kref_put(&vub300->kref, vub300_delete);
+                        return;
+                } else {
+                        construct_request_response(vub300, cmd);
+                        vub300->resp_len = 0;
+                        mutex_unlock(&vub300->cmd_mutex);
+                        kref_put(&vub300->kref, vub300_delete);
+                        mmc_request_done(vub300->mmc, req);
+                        return;
+                }
+        }
+}
+
+static int examine_cyclic_buffer(struct vub300_mmc_host *vub300,
+                                 struct mmc_command *cmd, u8 Function)
+{
+        /* cmd_mutex is held by vub300_mmc_request */
+        u8 cmd0 = 0xFF & (cmd->arg >> 24);
+        u8 cmd1 = 0xFF & (cmd->arg >> 16);
+        u8 cmd2 = 0xFF & (cmd->arg >> 8);
+        u8 cmd3 = 0xFF & (cmd->arg >> 0);
+        int first = MAXREGMASK & vub300->fn[Function].offload_point;
+        struct offload_registers_access *rf = &vub300->fn[Function].reg[first];
+        if (cmd0 == rf->command_byte[0] &&
+            cmd1 == rf->command_byte[1] &&
+            cmd2 == rf->command_byte[2] &&
+            cmd3 == rf->command_byte[3]) {
+                u8 checksum = 0x00;
+                cmd->resp[1] = checksum << 24;
+                cmd->resp[0] = (rf->Respond_Byte[0] << 24)
+                        | (rf->Respond_Byte[1] << 16)
+                        | (rf->Respond_Byte[2] << 8)
+                        | (rf->Respond_Byte[3] << 0);
+                vub300->fn[Function].offload_point += 1;
+                vub300->fn[Function].offload_count -= 1;
+                vub300->total_offload_count -= 1;
+                return 1;
+        } else {
+                int delta = 1;  /* because it does not match the first one */
+                u8 register_count = vub300->fn[Function].offload_count - 1;
+                u32 register_point = vub300->fn[Function].offload_point + 1;
+                while (0 < register_count) {
+                        int point = MAXREGMASK & register_point;
+                        struct offload_registers_access *r =
+                                &vub300->fn[Function].reg[point];
+                        if (cmd0 == r->command_byte[0] &&
+                            cmd1 == r->command_byte[1] &&
+                            cmd2 == r->command_byte[2] &&
+                            cmd3 == r->command_byte[3]) {
+                                u8 checksum = 0x00;
+                                cmd->resp[1] = checksum << 24;
+                                cmd->resp[0] = (r->Respond_Byte[0] << 24)
+                                        | (r->Respond_Byte[1] << 16)
+                                        | (r->Respond_Byte[2] << 8)
+                                        | (r->Respond_Byte[3] << 0);
+                                vub300->fn[Function].offload_point += delta;
+                                vub300->fn[Function].offload_count -= delta;
+                                vub300->total_offload_count -= delta;
+                                return 1;
+                        } else {
+                                register_point += 1;
+                                register_count -= 1;
+                                delta += 1;
+                                continue;
+                        }
+                }
+                return 0;
+        }
+}
+
+static int satisfy_request_from_offloaded_data(struct vub300_mmc_host *vub300,
+                                               struct mmc_command *cmd)
+{
+        /* cmd_mutex is held by vub300_mmc_request */
+        u8 regs = vub300->dynamic_register_count;
+        u8 i = 0;
+        u8 func = FUN(cmd);
+        u32 reg = REG(cmd);
+        while (0 < regs--) {
+                if ((vub300->sdio_register[i].func_num == func) &&
+                    (vub300->sdio_register[i].sdio_reg == reg)) {
+                        if (!vub300->sdio_register[i].prepared) {
+                                return 0;
+                        } else if ((0x80000000 & cmd->arg) == 0x80000000) {
+                                /*
+                                 * a write to a dynamic register
+                                 * nullifies our offloaded value
+                                 */
+                                vub300->sdio_register[i].prepared = 0;
+                                return 0;
+                        } else {
+                                u8 checksum = 0x00;
+                                u8 rsp0 = 0x00;
+                                u8 rsp1 = 0x00;
+                                u8 rsp2 = vub300->sdio_register[i].response;
+                                u8 rsp3 = vub300->sdio_register[i].regvalue;
+                                vub300->sdio_register[i].prepared = 0;
+                                cmd->resp[1] = checksum << 24;
+                                cmd->resp[0] = (rsp0 << 24)
+                                        | (rsp1 << 16)
+                                        | (rsp2 << 8)
+                                        | (rsp3 << 0);
+                                return 1;
+                        }
+                } else {
+                        i += 1;
+                        continue;
+                }
+        };
+        if (vub300->total_offload_count == 0)
+                return 0;
+        else if (vub300->fn[func].offload_count == 0)
+                return 0;
+        else
+                return examine_cyclic_buffer(vub300, cmd, func);
+}
+
+static void vub300_mmc_request(struct mmc_host *mmc, struct mmc_request *req)
+{                               /* NOT irq */
+        struct mmc_command *cmd = req->cmd;
+        struct vub300_mmc_host *vub300 = mmc_priv(mmc);
+        if (!vub300->interface) {
+                cmd->error = -ESHUTDOWN;
+                mmc_request_done(mmc, req);
+                return;
+        } else {
+                struct mmc_data *data = req->data;
+                if (!vub300->card_powered) {
+                        cmd->error = -ENOMEDIUM;
+                        mmc_request_done(mmc, req);
+                        return;
+                }
+                if (!vub300->card_present) {
+                        cmd->error = -ENOMEDIUM;
+                        mmc_request_done(mmc, req);
+                        return;
+                }
+                if (vub300->usb_transport_fail) {
+                        cmd->error = vub300->usb_transport_fail;
+                        mmc_request_done(mmc, req);
+                        return;
+                }
+                if (!vub300->interface) {
+                        cmd->error = -ENODEV;
+                        mmc_request_done(mmc, req);
+                        return;
+                }
+                kref_get(&vub300->kref);
+                mutex_lock(&vub300->cmd_mutex);
+                mod_timer(&vub300->inactivity_timer, jiffies + HZ);
+                /*
+                 * for performance we have to return immediately
+                 * if the requested data has been offloaded
+                 */
+                if (cmd->opcode == 52 &&
+                    satisfy_request_from_offloaded_data(vub300, cmd)) {
+                        cmd->error = 0;
+                        mutex_unlock(&vub300->cmd_mutex);
+                        kref_put(&vub300->kref, vub300_delete);
+                        mmc_request_done(mmc, req);
+                        return;
+                } else {
+                        vub300->cmd = cmd;
+                        vub300->req = req;
+                        vub300->data = data;
+                        if (data)
+                                vub300->datasize = data->blksz * data->blocks;
+                        else
+                                vub300->datasize = 0;
+                        vub300_queue_cmnd_work(vub300);
+                        mutex_unlock(&vub300->cmd_mutex);
+                        kref_put(&vub300->kref, vub300_delete);
+                        /*
+                         * the kernel lock diagnostics complain
+                         * if the cmd_mutex * is "passed on"
+                         * to the cmndwork thread,
+                         * so we must release it now
+                         * and re-acquire it in the cmndwork thread
+                         */
+                }
+        }
+}
+
+static void __set_clock_speed(struct vub300_mmc_host *vub300, u8 buf[8],
+                              struct mmc_ios *ios)
+{
+        int buf_array_size = 8; /* ARRAY_SIZE(buf) does not work !!! */
+        int retval;
+        u32 kHzClock;
+        if (ios->clock >= 48000000)
+                kHzClock = 48000;
+        else if (ios->clock >= 24000000)
+                kHzClock = 24000;
+        else if (ios->clock >= 20000000)
+                kHzClock = 20000;
+        else if (ios->clock >= 15000000)
+                kHzClock = 15000;
+        else if (ios->clock >= 200000)
+                kHzClock = 200;
+        else
+                kHzClock = 0;
+        {
+                int i;
+                u64 c = kHzClock;
+                for (i = 0; i < buf_array_size; i++) {
+                        buf[i] = c;
+                        c >>= 8;
+                }
+        }
+        retval =
+                usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
+                                SET_CLOCK_SPEED,
+                                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x00, 0x00, buf, buf_array_size, HZ);
+        if (retval != 8) {
+                dev_err(&vub300->udev->dev, "SET_CLOCK_SPEED"
+                        " %dkHz failed with retval=%d\n", kHzClock, retval);
+        } else {
+                dev_dbg(&vub300->udev->dev, "SET_CLOCK_SPEED"
+                        " %dkHz\n", kHzClock);
+        }
+}
+
+static void vub300_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = mmc_priv(mmc);
+        if (!vub300->interface)
+                return;
+        kref_get(&vub300->kref);
+        mutex_lock(&vub300->cmd_mutex);
+        if ((ios->power_mode == MMC_POWER_OFF) && vub300->card_powered) {
+                vub300->card_powered = 0;
+                usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
+                                SET_SD_POWER,
+                                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x0000, 0x0000, NULL, 0, HZ);
+                /* must wait for the VUB300 u-proc to boot up */
+                msleep(600);
+        } else if ((ios->power_mode == MMC_POWER_UP) && !vub300->card_powered) {
+                usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
+                                SET_SD_POWER,
+                                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x0001, 0x0000, NULL, 0, HZ);
+                msleep(600);
+                vub300->card_powered = 1;
+        } else if (ios->power_mode == MMC_POWER_ON) {
+                u8 *buf = kmalloc(8, GFP_KERNEL);
+                if (buf) {
+                        __set_clock_speed(vub300, buf, ios);
+                        kfree(buf);
+                }
+        } else {
+                /* this should mean no change of state */
+        }
+        mutex_unlock(&vub300->cmd_mutex);
+        kref_put(&vub300->kref, vub300_delete);
+}
+
+static int vub300_mmc_get_ro(struct mmc_host *mmc)
+{
+        struct vub300_mmc_host *vub300 = mmc_priv(mmc);
+        return vub300->read_only;
+}
+
+static void vub300_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = mmc_priv(mmc);
+        if (!vub300->interface)
+                return;
+        kref_get(&vub300->kref);
+        if (enable) {
+                mutex_lock(&vub300->irq_mutex);
+                if (vub300->irqs_queued) {
+                        vub300->irqs_queued -= 1;
+                        mmc_signal_sdio_irq(vub300->mmc);
+                } else if (vub300->irq_disabled) {
+                        vub300->irq_disabled = 0;
+                        vub300->irq_enabled = 1;
+                        vub300_queue_poll_work(vub300, 0);
+                } else if (vub300->irq_enabled) {
+                        /* this should not happen, so we will just ignore it */
+                } else {
+                        vub300->irq_enabled = 1;
+                        vub300_queue_poll_work(vub300, 0);
+                }
+                mutex_unlock(&vub300->irq_mutex);
+        } else {
+                vub300->irq_enabled = 0;
+        }
+        kref_put(&vub300->kref, vub300_delete);
+}
+
+void vub300_init_card(struct mmc_host *mmc, struct mmc_card *card)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = mmc_priv(mmc);
+        dev_info(&vub300->udev->dev, "NO host QUIRKS for this card\n");
+}
+
+static struct mmc_host_ops vub300_mmc_ops = {
+        .request = vub300_mmc_request,
+        .set_ios = vub300_mmc_set_ios,
+        .get_ro = vub300_mmc_get_ro,
+        .enable_sdio_irq = vub300_enable_sdio_irq,
+        .init_card = vub300_init_card,
+};
+
+static int vub300_probe(struct usb_interface *interface,
+                        const struct usb_device_id *id)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300;
+        struct usb_host_interface *iface_desc;
+        struct usb_device *udev = usb_get_dev(interface_to_usbdev(interface));
+        int i;
+        int retval = -ENOMEM;
+        struct urb *command_out_urb;
+        struct urb *command_res_urb;
+        struct mmc_host *mmc;
+        char manufacturer[48];
+        char product[32];
+        char serial_number[32];
+        usb_string(udev, udev->descriptor.iManufacturer, manufacturer,
+                   sizeof(manufacturer));
+        usb_string(udev, udev->descriptor.iProduct, product, sizeof(product));
+        usb_string(udev, udev->descriptor.iSerialNumber, serial_number,
+                   sizeof(serial_number));
+        dev_info(&udev->dev, "probing VID:PID(%04X:%04X) %s %s %s\n",
+                 udev->descriptor.idVendor, udev->descriptor.idProduct,
+                 manufacturer, product, serial_number);
+        command_out_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!command_out_urb) {
+                retval = -ENOMEM;
+                dev_err(&udev->dev, "not enough memory for command_out_urb\n");
+                goto error0;
+        }
+        command_res_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!command_res_urb) {
+                retval = -ENOMEM;
+                dev_err(&udev->dev, "not enough memory for command_res_urb\n");
+                goto error1;
+        }
+        /* this also allocates memory for our VUB300 mmc host device */
+        mmc = mmc_alloc_host(sizeof(struct vub300_mmc_host), &udev->dev);
+        if (!mmc) {
+                retval = -ENOMEM;
+                dev_err(&udev->dev, "not enough memory for the mmc_host\n");
+                goto error4;
+        }
+        /* MMC core transfer sizes tunable parameters */
+        mmc->caps = 0;
+        if (!force_1_bit_data_xfers)
+                mmc->caps |= MMC_CAP_4_BIT_DATA;
+        if (!force_polling_for_irqs)
+                mmc->caps |= MMC_CAP_SDIO_IRQ;
+        mmc->caps &= ~MMC_CAP_NEEDS_POLL;
+        /*
+         * MMC_CAP_NEEDS_POLL causes core.c:mmc_rescan() to poll
+         * for devices which results in spurious CMD7's being
+         * issued which stops some SDIO cards from working
+         */
+        if (limit_speed_to_24_MHz) {
+                mmc->caps |= MMC_CAP_MMC_HIGHSPEED;
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+                mmc->f_max = 24000000;
+                dev_info(&udev->dev, "limiting SDIO speed to 24_MHz\n");
+        } else {
+                mmc->caps |= MMC_CAP_MMC_HIGHSPEED;
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+                mmc->f_max = 48000000;
+        }
+        mmc->f_min = 200000;
+        mmc->max_blk_count = 511;
+        mmc->max_blk_size = 512;
+        mmc->max_segs = 128;
+        if (force_max_req_size)
+                mmc->max_req_size = force_max_req_size * 1024;
+        else
+                mmc->max_req_size = 64 * 1024;
+        mmc->max_seg_size = mmc->max_req_size;
+        mmc->ocr_avail = 0;
+        mmc->ocr_avail |= MMC_VDD_165_195;
+        mmc->ocr_avail |= MMC_VDD_20_21;
+        mmc->ocr_avail |= MMC_VDD_21_22;
+        mmc->ocr_avail |= MMC_VDD_22_23;
+        mmc->ocr_avail |= MMC_VDD_23_24;
+        mmc->ocr_avail |= MMC_VDD_24_25;
+        mmc->ocr_avail |= MMC_VDD_25_26;
+        mmc->ocr_avail |= MMC_VDD_26_27;
+        mmc->ocr_avail |= MMC_VDD_27_28;
+        mmc->ocr_avail |= MMC_VDD_28_29;
+        mmc->ocr_avail |= MMC_VDD_29_30;
+        mmc->ocr_avail |= MMC_VDD_30_31;
+        mmc->ocr_avail |= MMC_VDD_31_32;
+        mmc->ocr_avail |= MMC_VDD_32_33;
+        mmc->ocr_avail |= MMC_VDD_33_34;
+        mmc->ocr_avail |= MMC_VDD_34_35;
+        mmc->ocr_avail |= MMC_VDD_35_36;
+        mmc->ops = &vub300_mmc_ops;
+        vub300 = mmc_priv(mmc);
+        vub300->mmc = mmc;
+        vub300->card_powered = 0;
+        vub300->bus_width = 0;
+        vub300->cmnd.head.block_size[0] = 0x00;
+        vub300->cmnd.head.block_size[1] = 0x00;
+        vub300->app_spec = 0;
+        mutex_init(&vub300->cmd_mutex);
+        mutex_init(&vub300->irq_mutex);
+        vub300->command_out_urb = command_out_urb;
+        vub300->command_res_urb = command_res_urb;
+        vub300->usb_timed_out = 0;
+        vub300->dynamic_register_count = 0;
+
+        for (i = 0; i < ARRAY_SIZE(vub300->fn); i++) {
+                vub300->fn[i].offload_point = 0;
+                vub300->fn[i].offload_count = 0;
+        }
+
+        vub300->total_offload_count = 0;
+        vub300->irq_enabled = 0;
+        vub300->irq_disabled = 0;
+        vub300->irqs_queued = 0;
+
+        for (i = 0; i < ARRAY_SIZE(vub300->sdio_register); i++)
+                vub300->sdio_register[i++].activate = 0;
+
+        vub300->udev = udev;
+        vub300->interface = interface;
+        vub300->cmnd_res_ep = 0;
+        vub300->cmnd_out_ep = 0;
+        vub300->data_inp_ep = 0;
+        vub300->data_out_ep = 0;
+
+        for (i = 0; i < ARRAY_SIZE(vub300->fbs); i++)
+                vub300->fbs[i] = 512;
+
+        /*
+         *      set up the endpoint information
+         *
+         * use the first pair of bulk-in and bulk-out
+         *     endpoints for Command/Response+Interrupt
+         *
+         * use the second pair of bulk-in and bulk-out
+         *     endpoints for Data In/Out
+         */
+        vub300->large_usb_packets = 0;
+        iface_desc = interface->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+                struct usb_endpoint_descriptor *endpoint =
+                        &iface_desc->endpoint[i].desc;
+                dev_info(&vub300->udev->dev,
+                         "vub300 testing %s EndPoint(%d) %02X\n",
+                         usb_endpoint_is_bulk_in(endpoint) ? "BULK IN" :
+                         usb_endpoint_is_bulk_out(endpoint) ? "BULK OUT" :
+                         "UNKNOWN", i, endpoint->bEndpointAddress);
+                if (endpoint->wMaxPacketSize > 64)
+                        vub300->large_usb_packets = 1;
+                if (usb_endpoint_is_bulk_in(endpoint)) {
+                        if (!vub300->cmnd_res_ep) {
+                                vub300->cmnd_res_ep =
+                                        endpoint->bEndpointAddress;
+                        } else if (!vub300->data_inp_ep) {
+                                vub300->data_inp_ep =
+                                        endpoint->bEndpointAddress;
+                        } else {
+                                dev_warn(&vub300->udev->dev,
+                                         "ignoring"
+                                         " unexpected bulk_in endpoint");
+                        }
+                } else if (usb_endpoint_is_bulk_out(endpoint)) {
+                        if (!vub300->cmnd_out_ep) {
+                                vub300->cmnd_out_ep =
+                                        endpoint->bEndpointAddress;
+                        } else if (!vub300->data_out_ep) {
+                                vub300->data_out_ep =
+                                        endpoint->bEndpointAddress;
+                        } else {
+                                dev_warn(&vub300->udev->dev,
+                                         "ignoring"
+                                         " unexpected bulk_out endpoint");
+                        }
+                } else {
+                        dev_warn(&vub300->udev->dev,
+                                 "vub300 ignoring EndPoint(%d) %02X", i,
+                                 endpoint->bEndpointAddress);
+                }
+        }
+        if (vub300->cmnd_res_ep && vub300->cmnd_out_ep &&
+            vub300->data_inp_ep && vub300->data_out_ep) {
+                dev_info(&vub300->udev->dev,
+                         "vub300 %s packets"
+                         " using EndPoints %02X %02X %02X %02X\n",
+                         vub300->large_usb_packets ? "LARGE" : "SMALL",
+                         vub300->cmnd_out_ep, vub300->cmnd_res_ep,
+                         vub300->data_out_ep, vub300->data_inp_ep);
+                /* we have the expected EndPoints */
+        } else {
+                dev_err(&vub300->udev->dev,
+                    "Could not find two sets of bulk-in/out endpoint pairs\n");
+                retval = -EINVAL;
+                goto error5;
+        }
+        retval =
+                usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
+                                GET_HC_INF0,
+                                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x0000, 0x0000, &vub300->hc_info,
+                                sizeof(vub300->hc_info), HZ);
+        if (retval < 0)
+                goto error5;
+        retval =
+                usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
+                                SET_ROM_WAIT_STATES,
+                                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                firmware_rom_wait_states, 0x0000, NULL, 0, HZ);
+        if (retval < 0)
+                goto error5;
+        dev_info(&vub300->udev->dev,
+                 "operating_mode = %s %s %d MHz %s %d byte USB packets\n",
+                 (mmc->caps & MMC_CAP_SDIO_IRQ) ? "IRQs" : "POLL",
+                 (mmc->caps & MMC_CAP_4_BIT_DATA) ? "4-bit" : "1-bit",
+                 mmc->f_max / 1000000,
+                 pad_input_to_usb_pkt ? "padding input data to" : "with",
+                 vub300->large_usb_packets ? 512 : 64);
+        retval =
+                usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
+                                GET_SYSTEM_PORT_STATUS,
+                                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                0x0000, 0x0000, &vub300->system_port_status,
+                                sizeof(vub300->system_port_status), HZ);
+        if (retval < 0) {
+                goto error4;
+        } else if (sizeof(vub300->system_port_status) == retval) {
+                vub300->card_present =
+                        (0x0001 & vub300->system_port_status.port_flags) ? 1 : 0;
+                vub300->read_only =
+                        (0x0010 & vub300->system_port_status.port_flags) ? 1 : 0;
+        } else {
+                goto error4;
+        }
+        usb_set_intfdata(interface, vub300);
+        INIT_DELAYED_WORK(&vub300->pollwork, vub300_pollwork_thread);
+        INIT_WORK(&vub300->cmndwork, vub300_cmndwork_thread);
+        INIT_WORK(&vub300->deadwork, vub300_deadwork_thread);
+        kref_init(&vub300->kref);
+        init_timer(&vub300->sg_transfer_timer);
+        vub300->sg_transfer_timer.data = (unsigned long)vub300;
+        vub300->sg_transfer_timer.function = vub300_sg_timed_out;
+        kref_get(&vub300->kref);
+        init_timer(&vub300->inactivity_timer);
+        vub300->inactivity_timer.data = (unsigned long)vub300;
+        vub300->inactivity_timer.function = vub300_inactivity_timer_expired;
+        vub300->inactivity_timer.expires = jiffies + HZ;
+        add_timer(&vub300->inactivity_timer);
+        if (vub300->card_present)
+                dev_info(&vub300->udev->dev,
+                         "USB vub300 remote SDIO host controller[%d]"
+                         "connected with SD/SDIO card inserted\n",
+                         interface_to_InterfaceNumber(interface));
+        else
+                dev_info(&vub300->udev->dev,
+                         "USB vub300 remote SDIO host controller[%d]"
+                         "connected with no SD/SDIO card inserted\n",
+                         interface_to_InterfaceNumber(interface));
+        mmc_add_host(mmc);
+        return 0;
+error5:
+        mmc_free_host(mmc);
+        /*
+         * and hence also frees vub300
+         * which is contained at the end of struct mmc
+         */
+error4:
+        usb_free_urb(command_out_urb);
+error1:
+        usb_free_urb(command_res_urb);
+error0:
+        return retval;
+}
+
+static void vub300_disconnect(struct usb_interface *interface)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = usb_get_intfdata(interface);
+        if (!vub300 || !vub300->mmc) {
+                return;
+        } else {
+                struct mmc_host *mmc = vub300->mmc;
+                if (!vub300->mmc) {
+                        return;
+                } else {
+                        int ifnum = interface_to_InterfaceNumber(interface);
+                        usb_set_intfdata(interface, NULL);
+                        /* prevent more I/O from starting */
+                        vub300->interface = NULL;
+                        kref_put(&vub300->kref, vub300_delete);
+                        mmc_remove_host(mmc);
+                        pr_info("USB vub300 remote SDIO host controller[%d]"
+                                " now disconnected", ifnum);
+                        return;
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+static int vub300_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
+        if (!vub300 || !vub300->mmc) {
+                return 0;
+        } else {
+                struct mmc_host *mmc = vub300->mmc;
+                mmc_suspend_host(mmc);
+                return 0;
+        }
+}
+
+static int vub300_resume(struct usb_interface *intf)
+{
+        struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
+        if (!vub300 || !vub300->mmc) {
+                return 0;
+        } else {
+                struct mmc_host *mmc = vub300->mmc;
+                mmc_resume_host(mmc);
+                return 0;
+        }
+}
+#else
+#define vub300_suspend NULL
+#define vub300_resume NULL
+#endif
+static int vub300_pre_reset(struct usb_interface *intf)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
+        mutex_lock(&vub300->cmd_mutex);
+        return 0;
+}
+
+static int vub300_post_reset(struct usb_interface *intf)
+{                               /* NOT irq */
+        struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
+        /* we are sure no URBs are active - no locking needed */
+        vub300->errors = -EPIPE;
+        mutex_unlock(&vub300->cmd_mutex);
+        return 0;
+}
+
+static struct usb_driver vub300_driver = {
+        .name = "vub300",
+        .probe = vub300_probe,
+        .disconnect = vub300_disconnect,
+        .suspend = vub300_suspend,
+        .resume = vub300_resume,
+        .pre_reset = vub300_pre_reset,
+        .post_reset = vub300_post_reset,
+        .id_table = vub300_table,
+        .supports_autosuspend = 1,
+};
+
+static int __init vub300_init(void)
+{                               /* NOT irq */
+        int result;
+
+        pr_info("VUB300 Driver rom wait states = %02X irqpoll timeout = %04X",
+                firmware_rom_wait_states, 0x0FFFF & firmware_irqpoll_timeout);
+        cmndworkqueue = create_singlethread_workqueue("kvub300c");
+        if (!cmndworkqueue) {
+                pr_err("not enough memory for the REQUEST workqueue");
+                result = -ENOMEM;
+                goto out1;
+        }
+        pollworkqueue = create_singlethread_workqueue("kvub300p");
+        if (!pollworkqueue) {
+                pr_err("not enough memory for the IRQPOLL workqueue");
+                result = -ENOMEM;
+                goto out2;
+        }
+        deadworkqueue = create_singlethread_workqueue("kvub300d");
+        if (!deadworkqueue) {
+                pr_err("not enough memory for the EXPIRED workqueue");
+                result = -ENOMEM;
+                goto out3;
+        }
+        result = usb_register(&vub300_driver);
+        if (result) {
+                pr_err("usb_register failed. Error number %d", result);
+                goto out4;
+        }
+        return 0;
+out4:
+        destroy_workqueue(deadworkqueue);
+out3:
+        destroy_workqueue(pollworkqueue);
+out2:
+        destroy_workqueue(cmndworkqueue);
+out1:
+        return result;
+}
+
+static void __exit vub300_exit(void)
+{
+        usb_deregister(&vub300_driver);
+        flush_workqueue(cmndworkqueue);
+        flush_workqueue(pollworkqueue);
+        flush_workqueue(deadworkqueue);
+        destroy_workqueue(cmndworkqueue);
+        destroy_workqueue(pollworkqueue);
+        destroy_workqueue(deadworkqueue);
+}
+
+module_init(vub300_init);
+module_exit(vub300_exit);
+
+MODULE_AUTHOR("Tony Olech <tony.olech@elandigitalsystems.com>");
+MODULE_DESCRIPTION("VUB300 USB to SD/MMC/SDIO adapter driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/wbsd.c b/drivers/mmc/host/wbsd.c
index 0012f5d13d28..62e5a4d171e1 100644
--- a/drivers/mmc/host/wbsd.c
+++ b/drivers/mmc/host/wbsd.c
@@ -484,7 +484,7 @@ static void wbsd_fill_fifo(struct wbsd_host *host)
 
         /*
          * Check that we aren't being called after the
-         * entire buffer has been transfered.
+         * entire buffer has been transferred.
          */
         if (host->num_sg == 0)
                 return;
@@ -828,7 +828,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
         /*
          * If this is a data transfer the request
          * will be finished after the data has
-         * transfered.
+         * transferred.
          */
         if (cmd->data && !cmd->error) {
                 /*
@@ -904,7 +904,7 @@ static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         setup &= ~WBSD_DAT3_H;
 
                         /*
-                         * We cannot resume card detection immediatly
+                         * We cannot resume card detection immediately
                          * because of capacitance and delays in the chip.
                          */
                         mod_timer(&host->ignore_timer, jiffies + HZ / 100);
@@ -1235,8 +1235,7 @@ static int __devinit wbsd_alloc_mmc(struct device *dev)
          * Maximum number of segments. Worst case is one sector per segment
          * so this will be 64kB/512.
          */
-        mmc->max_hw_segs = 128;
-        mmc->max_phys_segs = 128;
+        mmc->max_segs = 128;
 
         /*
          * Maximum request size. Also limited by 64KiB buffer.