67 files changed, 7642 insertions, 1738 deletions

diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
index 57e4416b9ef0..3b1f783bf924 100644
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -16,6 +16,7 @@ config MMC_BLOCK
 
 config MMC_BLOCK_MINORS
         int "Number of minors per block device"
+        depends on MMC_BLOCK
         range 4 256
         default 8
         help
@@ -57,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/block.c b/drivers/mmc/card/block.c
index 217f82037fc1..61d233a7c118 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -257,7 +257,7 @@ static u32 get_card_status(struct mmc_card *card, struct request *req)
         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];
 }
@@ -621,6 +621,7 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
         md->disk->private_data = md;
         md->disk->queue = md->queue.queue;
         md->disk->driverfs_dev = &card->dev;
+        set_disk_ro(md->disk, md->read_only);
 
         /*
          * As discussed on lkml, GENHD_FL_REMOVABLE should:
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 21adc27f4132..abc1a63bcc5e 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -88,6 +88,7 @@ struct mmc_test_area {
  * @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;
@@ -95,6 +96,7 @@ struct mmc_test_transfer_result {
         unsigned int sectors;
         struct timespec ts;
         unsigned int rate;
+        unsigned int iops;
 };
 
 /**
@@ -226,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));
 
@@ -289,7 +292,7 @@ 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
+ * 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.
@@ -494,7 +497,7 @@ static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
  */
 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 rate, unsigned int iops)
 {
         struct mmc_test_transfer_result *tr;
 
@@ -509,6 +512,7 @@ static void mmc_test_save_transfer_result(struct mmc_test_card *test,
         tr->sectors = sectors;
         tr->ts = ts;
         tr->rate = rate;
+        tr->iops = iops;
 
         list_add_tail(&tr->link, &test->gr->tr_lst);
 }
@@ -519,20 +523,22 @@ static void mmc_test_save_transfer_result(struct mmc_test_card *test,
 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);
+                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024,
+                         iops / 100, iops % 100);
 
-        mmc_test_save_transfer_result(test, 1, sectors, ts, rate);
+        mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
 }
 
 /*
@@ -542,22 +548,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" : ""),
                          (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);
+        mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
 }
 
 /*
@@ -1425,28 +1433,29 @@ 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;
@@ -1766,6 +1775,187 @@ 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)
+{
+        unsigned int next;
+        unsigned long sz;
+        int ret;
+
+        for (sz = 512; sz < test->area.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 = test->area.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)
+{
+        unsigned int dev_addr, i, cnt, sz, ssz;
+        struct timespec ts1, ts2;
+        int ret;
+
+        sz = test->area.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) {
+                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;
+        }
+
+        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)",
@@ -2005,6 +2195,34 @@ 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);
@@ -2148,11 +2366,11 @@ static int mtf_test_show(struct seq_file *sf, void *data)
                 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\n",
+                        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->rate, tr->iops / 100, tr->iops % 100);
                 }
         }
 
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 4e42d030e097..2ae727568df9 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);
 
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 86b479119332..639501970b41 100644
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -6,6 +6,7 @@ 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 af8dc6a2a317..d6d62fd07ee9 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -284,6 +284,7 @@ int mmc_add_card(struct mmc_card *card)
                 type = "SD-combo";
                 if (mmc_card_blockaddr(card))
                         type = "SDHC-combo";
+                break;
         default:
                 type = "?";
                 break;
@@ -303,14 +304,14 @@ int mmc_add_card(struct mmc_card *card)
                         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/core.c b/drivers/mmc/core/core.c
index 31ae07a36576..1f453acc8682 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>
@@ -130,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);
         }
 }
 
@@ -164,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) {
@@ -190,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);
 }
 
@@ -295,8 +298,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)
                         /*
@@ -523,7 +527,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;
 
@@ -538,6 +549,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)
 {
@@ -614,6 +626,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);
 }
 
@@ -641,6 +655,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.
  */
@@ -940,6 +1009,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;
@@ -1424,35 +1500,63 @@ int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
 }
 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;
         int i;
-        const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
-
-        spin_lock_irqsave(&host->lock, flags);
 
-        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 */
@@ -1461,8 +1565,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.
@@ -1472,72 +1574,16 @@ void mmc_rescan(struct work_struct *work)
         if (host->ops->get_cd && host->ops->get_cd(host) == 0)
                 goto out;
 
+        mmc_claim_host(host);
         for (i = 0; i < ARRAY_SIZE(freqs); i++) {
-                mmc_claim_host(host);
-
-                if (freqs[i] >= host->f_min)
-                        host->f_init = freqs[i];
-                else if (!i || freqs[i-1] > host->f_min)
-                        host->f_init = host->f_min;
-                else {
-                        mmc_release_host(host);
-                        goto out;
-                }
-#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(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;
-                }
-
-out_fail:
-                mmc_release_host(host);
-                mmc_power_off(host);
+                if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
+                        break;
+                if (freqs[i] < host->f_min)
+                        break;
         }
-out:
+        mmc_release_host(host);
+
+ out:
         if (host->caps & MMC_CAP_NEEDS_POLL)
                 mmc_schedule_delayed_work(&host->detect, HZ);
 }
@@ -1721,6 +1767,18 @@ int mmc_resume_host(struct mmc_host *host)
                 if (!(host->pm_flags & MMC_PM_KEEP_POWER)) {
                         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);
@@ -1773,6 +1831,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;
@@ -1789,7 +1848,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 77240cd11bcf..20b1c0831eac 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -33,6 +33,9 @@ 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);
 void mmc_set_bus_width_ddr(struct mmc_host *host, unsigned int width,
@@ -54,9 +57,11 @@ 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);
+
+void mmc_fixup_device(struct mmc_card *card);
 
 /* Module parameters */
 extern int use_spi_crc;
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index eed1405fd742..998797ed67a6 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -183,6 +183,11 @@ void mmc_add_host_debugfs(struct mmc_host *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_node:
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 10b8af27e03a..2b200c1cfbba 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,201 @@ 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;
+        }
+        mmc_claim_host(host);
+        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);
+        mmc_release_host(host);
+}
+
+/*
+ * 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;
+
+        mmc_claim_host(host);
+        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);
+        mmc_release_host(host);
+}
+
+/**
+ *      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);
+}
+
+/**
+ *      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 +279,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);
@@ -163,6 +362,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);
@@ -183,4 +384,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 77f93c3b8808..772d0d0a541b 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -302,6 +302,44 @@ static int mmc_read_ext_csd(struct mmc_card *card)
         }
 
         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 =
@@ -336,6 +374,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,
@@ -349,6 +390,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,
 };
 
@@ -378,6 +421,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         int err, ddr = 0;
         u32 cid[4];
         unsigned int max_dtr;
+        u32 rocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -391,7 +435,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;
 
@@ -479,11 +523,51 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 err = mmc_read_ext_csd(card);
                 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);
+
+                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);
+                }
+        }
+
+        /*
          * Activate high speed (if supported)
          */
         if ((card->ext_csd.hs_max_dtr != 0) &&
@@ -534,39 +618,57 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
          */
         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) {
-                        if (ddr)
-                                ext_csd_bit = EXT_CSD_DDR_BUS_WIDTH_8;
-                        else
-                                ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
-                        bus_width = MMC_BUS_WIDTH_8;
-                } else {
-                        if (ddr)
-                                ext_csd_bit = EXT_CSD_DDR_BUS_WIDTH_4;
-                        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]);
+                        if (!err) {
+                                mmc_set_bus_width_ddr(card->host,
+                                                      bus_width, MMC_SDR_MODE);
+                                /*
+                                 * If controller can't handle bus width test,
+                                 * use the highest bus width to maintain
+                                 * compatibility with previous MMC behavior.
+                                 */
+                                if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
+                                        break;
+                                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]);
+                }
                 if (err) {
                         printk(KERN_WARNING "%s: switch to bus width %d ddr %d "
-                               "failed\n", mmc_hostname(card->host),
-                               1 << bus_width, ddr);
-                        err = 0;
-                } else {
-                        if (ddr)
-                                mmc_card_set_ddr_mode(card);
-                        else
-                                ddr = MMC_SDR_MODE;
-
+                                "failed\n", mmc_hostname(card->host),
+                                1 << bus_width, ddr);
+                        goto free_card;
+                } else if (ddr) {
+                        mmc_card_set_ddr_mode(card);
                         mmc_set_bus_width_ddr(card->host, bus_width, ddr);
                 }
         }
@@ -737,14 +839,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.
@@ -784,20 +893,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..f3b22bf89cc9 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -105,7 +105,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)) {
@@ -462,3 +462,104 @@ 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;
+        struct mmc_command cmd;
+        struct mmc_data data;
+        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);
+
+        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;
+        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..e6d44b8a18db 100644
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -26,6 +26,7 @@ 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..11118b74eb20
--- /dev/null
+++ b/drivers/mmc/core/quirks.c
@@ -0,0 +1,84 @@
+/*
+ *  This file contains work-arounds for many known sdio hardware
+ *  bugs.
+ *
+ *  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>
+#include <linux/mod_devicetable.h>
+
+/*
+ *  The world is not perfect and supplies us with broken mmc/sdio devices.
+ *  For at least a part of these bugs we need a work-around
+ */
+
+struct mmc_fixup {
+        u16 vendor, device;     /* You can use SDIO_ANY_ID here of course */
+        void (*vendor_fixup)(struct mmc_card *card, int data);
+        int data;
+};
+
+/*
+ * This hook just adds a quirk unconditionnally
+ */
+static void __maybe_unused add_quirk(struct mmc_card *card, int data)
+{
+        card->quirks |= data;
+}
+
+/*
+ * This hook just removes a quirk unconditionnally
+ */
+static void __maybe_unused remove_quirk(struct mmc_card *card, int data)
+{
+        card->quirks &= ~data;
+}
+
+/*
+ * 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;
+}
+
+#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
+
+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_ANY_ID, SDIO_ANY_ID,
+                add_quirk_for_sdio_devices, MMC_QUIRK_BROKEN_CLK_GATING },
+        { SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                remove_quirk, MMC_QUIRK_BROKEN_CLK_GATING },
+        { 0 }
+};
+
+void mmc_fixup_device(struct mmc_card *card)
+{
+        const struct mmc_fixup *f;
+
+        for (f = mmc_fixup_methods; f->vendor_fixup; f++) {
+                if ((f->vendor == card->cis.vendor
+                     || f->vendor == (u16) SDIO_ANY_ID) &&
+                    (f->device == card->cis.device
+                     || f->device == (u16) SDIO_ANY_ID)) {
+                        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 49da4dffd28e..6dac89fe0535 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[] = {
@@ -764,14 +765,21 @@ 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);
 
+        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.
@@ -795,7 +803,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));
@@ -820,20 +829,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_ops.c b/drivers/mmc/core/sd_ops.c
index 797cdb5887fd..76af349c14b4 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>
 
@@ -252,6 +253,7 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         struct mmc_command cmd;
         struct mmc_data data;
         struct scatterlist sg;
+        void *data_buf;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
@@ -263,6 +265,13 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         if (err)
                 return err;
 
+        /* 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;
+
         memset(&mrq, 0, sizeof(struct mmc_request));
         memset(&cmd, 0, sizeof(struct mmc_command));
         memset(&data, 0, sizeof(struct mmc_data));
@@ -280,12 +289,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)
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index efef5f94ac42..db0f0b44d684 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -395,6 +395,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);
         }
 
@@ -458,6 +466,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
 
                 card = oldcard;
         }
+        mmc_fixup_device(card);
 
         if (card->type == MMC_TYPE_SD_COMBO) {
                 err = mmc_sd_setup_card(host, card, oldcard != NULL);
@@ -627,15 +636,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,
+
+        /* No need to reinitialize powered-resumed nonremovable cards */
+        if (mmc_card_is_removable(host) || !mmc_card_is_powered_resumed(host))
+                err = mmc_sdio_init_card(host, host->ocr, host->card,
                                  (host->pm_flags & MMC_PM_KEEP_POWER));
+        else if (mmc_card_is_powered_resumed(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);
@@ -690,16 +711,22 @@ static const struct mmc_bus_ops mmc_sdio_ops = {
 /*
  * 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
@@ -769,11 +796,10 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                         pm_runtime_enable(&card->sdio_func[i]->dev);
         }
 
-        mmc_release_host(host);
-
         /*
          * First add the card to the driver model...
          */
+        mmc_release_host(host);
         err = mmc_add_card(host->card);
         if (err)
                 goto remove_added;
@@ -787,6 +813,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                         goto remove_added;
         }
 
+        mmc_claim_host(host);
         return 0;
 
 
@@ -796,11 +823,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 203da443e339..d29b9c36919a 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -197,44 +197,12 @@ out:
 
 #ifdef CONFIG_PM_RUNTIME
 
-static int sdio_bus_pm_prepare(struct device *dev)
-{
-        struct sdio_func *func = dev_to_sdio_func(dev);
-
-        /*
-         * Resume an SDIO device which was suspended at run time at this
-         * point, in order to allow standard SDIO suspend/resume paths
-         * to keep working as usual.
-         *
-         * Ultimately, the SDIO driver itself will decide (in its
-         * suspend handler, or lack thereof) whether the card should be
-         * removed or kept, and if kept, at what power state.
-         *
-         * At this point, PM core have increased our use count, so it's
-         * safe to directly resume the device. After system is resumed
-         * again, PM core will drop back its runtime PM use count, and if
-         * needed device will be suspended again.
-         *
-         * The end result is guaranteed to be a power state that is
-         * coherent with the device's runtime PM use count.
-         *
-         * The return value of pm_runtime_resume is deliberately unchecked
-         * since there is little point in failing system suspend if a
-         * device can't be resumed.
-         */
-        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
-                pm_runtime_resume(dev);
-
-        return 0;
-}
-
 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
         )
-        .prepare = sdio_bus_pm_prepare,
 };
 
 #define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
diff --git a/drivers/mmc/core/sdio_irq.c b/drivers/mmc/core/sdio_irq.c
index bb192f90e8e9..b3001617e67d 100644
--- a/drivers/mmc/core/sdio_irq.c
+++ b/drivers/mmc/core/sdio_irq.c
@@ -45,7 +45,7 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
                         struct sdio_func *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) {
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index d618e8673996..94df40531c38 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)
@@ -140,6 +142,27 @@ config MMC_SDHCI_ESDHC_IMX
 
           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
+        tristate "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
@@ -202,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
@@ -288,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,
@@ -296,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
@@ -407,13 +439,25 @@ 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
@@ -458,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.
 
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 7b645ff43b30..4f1df0aae574 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -6,6 +6,7 @@ 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
@@ -28,9 +29,16 @@ 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_USHC)          += ushc.o
@@ -39,6 +47,8 @@ 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 591ab540b407..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;
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 301351a5d838..ea3888b65d5d 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);
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index 41e5a60493ad..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));
 }
 
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index bac7d62866b7..0371bf502249 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -462,7 +462,7 @@ 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;
diff --git a/drivers/mmc/host/cb710-mmc.c b/drivers/mmc/host/cb710-mmc.c
index 66b4ce587f4b..ce2a47b71dd6 100644
--- a/drivers/mmc/host/cb710-mmc.c
+++ b/drivers/mmc/host/cb710-mmc.c
@@ -205,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,
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index e15547cf701f..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
@@ -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;
@@ -1270,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",
@@ -1313,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..87e1f57ec9ba
--- /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);
+
+        if (host->vmmc)
+                regulator_enable(host->vmmc);
+
+        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->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/jz4740_mmc.c b/drivers/mmc/host/jz4740_mmc.c
index b3a0ab0e4c2b..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;
         }
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index fd877f633dd2..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
@@ -1516,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 87b4fc6c98c2..b4a7e4fba90f 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>
@@ -45,6 +49,8 @@ static unsigned int fmax = 515633;
  *            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
  */
 struct variant_data {
         unsigned int            clkreg;
@@ -52,6 +58,8 @@ struct variant_data {
         unsigned int            datalength_bits;
         unsigned int            fifosize;
         unsigned int            fifohalfsize;
+        bool                    sdio;
+        bool                    st_clkdiv;
 };
 
 static struct variant_data variant_arm = {
@@ -60,11 +68,18 @@ static struct variant_data variant_arm = {
         .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 = {
         .fifosize               = 16 * 4,
         .fifohalfsize           = 8 * 4,
         .clkreg_enable          = 1 << 13, /* HWFCEN */
         .datalength_bits        = 16,
+        .sdio                   = true,
 };
 
 static struct variant_data variant_ux500 = {
@@ -73,7 +88,10 @@ static struct variant_data variant_ux500 = {
         .clkreg                 = MCI_CLK_ENABLE,
         .clkreg_enable          = 1 << 14, /* HWFCEN */
         .datalength_bits        = 24,
+        .sdio                   = true,
+        .st_clkdiv              = true,
 };
+
 /*
  * This must be called with host->lock held
  */
@@ -86,7 +104,22 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
                 if (desired >= host->mclk) {
                         clk = MCI_CLK_BYPASS;
                         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;
@@ -117,9 +150,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...
@@ -129,10 +159,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;
 }
 
@@ -148,6 +194,248 @@ 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;
@@ -161,9 +449,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);
@@ -178,15 +464,29 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         BUG_ON(1 << blksz_bits != data->blksz);
 
         datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
-        if (data->flags & MMC_DATA_READ) {
+
+        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 < variant->fifosize)
+                if (host->size < variant->fifohalfsize)
                         irqmask |= MCI_RXDATAAVLBLMASK;
         } else {
                 /*
@@ -196,9 +496,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
@@ -233,49 +538,56 @@ 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_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 {
@@ -292,15 +604,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) {
@@ -356,7 +668,32 @@ static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int rem
                          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;
@@ -422,9 +759,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);
 
@@ -433,11 +767,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 < variant->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
@@ -446,7 +780,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);
         }
 
@@ -469,6 +803,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);
 
@@ -629,7 +971,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;
@@ -692,6 +1035,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;
@@ -806,19 +1150,27 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         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;
 
@@ -863,8 +1215,10 @@ 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);
@@ -929,10 +1283,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,
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 4ae887fc0189..ec9a7bc6d0df 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -137,14 +137,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)
+
+/* 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 +161,7 @@ struct mmci_host {
         int                     gpio_cd;
         int                     gpio_wp;
         int                     gpio_cd_irq;
-
-        unsigned int            data_xfered;
+        bool                    singleirq;
 
         spinlock_t              lock;
 
@@ -175,5 +181,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 1290d14c5839..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
          */
@@ -1256,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/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index bdd2cbb87cba..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");
 
@@ -807,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 =
@@ -846,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);
@@ -891,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);
@@ -915,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..e2aecb7f1d5c 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -15,9 +15,11 @@
 #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>
@@ -34,6 +36,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 +64,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 +140,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 0c7e37f496ef..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)
@@ -1387,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);
@@ -1415,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;
@@ -1455,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;
 
@@ -1512,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;
 }
 
@@ -1608,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 5d46021cbb57..259ece047afc 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
@@ -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 =
@@ -316,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)
 {
@@ -326,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 =
@@ -365,6 +371,12 @@ 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;
@@ -379,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;
@@ -1555,7 +1571,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.
                  */
@@ -1647,7 +1663,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 {
@@ -2031,8 +2047,7 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
 
         res->start += pdata->reg_offset;
         res->end += pdata->reg_offset;
-        res = request_mem_region(res->start, res->end - res->start + 1,
-                                                        pdev->name);
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
         if (res == NULL)
                 return -EBUSY;
 
@@ -2101,14 +2116,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;
@@ -2271,7 +2286,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;
 }
 
@@ -2290,7 +2305,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);
@@ -2308,7 +2323,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/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 1ccd4b256cee..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);
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
index 9b82910b9dbb..a19967d0bfc4 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -15,13 +15,41 @@
 #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);
@@ -30,6 +58,56 @@ static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, i
         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))
@@ -41,6 +119,7 @@ static u16 esdhc_readw_le(struct sdhci_host *host, int 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:
@@ -48,10 +127,22 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
                  * Postpone this write, we must do it together with a
                  * command write that is down below.
                  */
-                pltfm_host->scratchpad = val;
+                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:
-                writel(val << 16 | pltfm_host->scratchpad,
+                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:
@@ -100,10 +191,42 @@ static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *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)) {
@@ -113,35 +236,94 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
         clk_enable(clk);
         pltfm_host->clk = clk;
 
-        if (cpu_is_mx35() || cpu_is_mx51())
+        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;
 
-        /* Fix errata ENGcm07207 which is present on i.MX25 and i.MX35 */
-        if (cpu_is_mx25() || cpu_is_mx35())
+        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);
 }
 
-static struct sdhci_ops sdhci_esdhc_ops = {
-        .read_w = esdhc_readw_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,
-};
-
 struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
-        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA,
+        .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,
diff --git a/drivers/mmc/host/sdhci-esdhc.h b/drivers/mmc/host/sdhci-esdhc.h
index afaf1bc4913a..c3b08f111942 100644
--- a/drivers/mmc/host/sdhci-esdhc.h
+++ b/drivers/mmc/host/sdhci-esdhc.h
@@ -19,13 +19,11 @@
  */
 
 #define ESDHC_DEFAULT_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)
+                                SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
 
 #define ESDHC_SYSTEM_CONTROL    0x2c
 #define ESDHC_CLOCK_MASK        0x0000fff0
diff --git a/drivers/mmc/host/sdhci-of-core.c b/drivers/mmc/host/sdhci-of-core.c
index c51b71174c1d..f9b611fc773e 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,27 @@ 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 int __devinit sdhci_of_probe(struct platform_device *ofdev)
 {
         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;
 
+        if (!ofdev->dev.of_match)
+                return -EINVAL;
+        sdhci_of_data = ofdev->dev.of_match->data;
+
         if (!of_device_is_available(np))
                 return -ENODEV;
 
@@ -166,7 +178,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 +220,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 +234,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 fcd0e1fcba44..ba40d6d035c7 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -73,7 +73,9 @@ static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host)
 }
 
 struct sdhci_of_data sdhci_esdhc = {
-        .quirks = ESDHC_DEFAULT_QUIRKS,
+        /* 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,
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 3d9c2460d437..f8b5f37007b2 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -176,6 +176,74 @@ 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;
@@ -204,6 +272,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 |
@@ -225,12 +294,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))
@@ -290,13 +364,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;
 }
 
@@ -305,7 +391,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);
 }
 
@@ -313,7 +400,8 @@ 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) {
+        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);
         }
@@ -325,7 +413,8 @@ static int jmicron_resume(struct sdhci_pci_chip *chip)
 {
         int ret, i;
 
-        if (chip->pdev->device == PCI_DEVICE_ID_JMICRON_JMB38X_MMC) {
+        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);
         }
@@ -339,6 +428,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,
 
@@ -454,6 +547,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,
@@ -510,6 +611,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,
@@ -589,6 +706,46 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                 .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)
         },
@@ -751,9 +908,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)) {
@@ -800,10 +954,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;
         }
 
@@ -863,16 +1017,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)
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index 0502f89f662b..dbab0407f4b6 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -170,6 +170,12 @@ static const struct platform_device_id sdhci_pltfm_ids[] = {
 #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);
diff --git a/drivers/mmc/host/sdhci-pltfm.h b/drivers/mmc/host/sdhci-pltfm.h
index c1bfe48af56a..2b37016ad0ac 100644
--- a/drivers/mmc/host/sdhci-pltfm.h
+++ b/drivers/mmc/host/sdhci-pltfm.h
@@ -17,10 +17,12 @@
 
 struct sdhci_pltfm_host {
         struct clk *clk;
-        u32 scratchpad; /* to handle quirks across io-accessor calls */
+        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-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..f7e1f964395f
--- /dev/null
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -0,0 +1,261 @@
+/*
+ * 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;
+
+        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 a25db426c910..5d20661bc357 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"
@@ -77,8 +78,11 @@ 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));
 
         if (host->flags & SDHCI_USE_ADMA)
@@ -1330,6 +1334,13 @@ 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);
@@ -1341,7 +1352,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))) {
@@ -1518,7 +1529,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));
@@ -1736,7 +1751,7 @@ EXPORT_SYMBOL_GPL(sdhci_alloc_host);
 int sdhci_add_host(struct sdhci_host *host)
 {
         struct mmc_host *mmc;
-        unsigned int caps;
+        unsigned int caps, ocr_avail;
         int ret;
 
         WARN_ON(host == NULL);
@@ -1890,13 +1905,26 @@ int sdhci_add_host(struct sdhci_host *host)
             mmc_card_is_removable(mmc))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
-        mmc->ocr_avail = 0;
+        ocr_avail = 0;
         if (caps & SDHCI_CAN_VDD_330)
-                mmc->ocr_avail |= MMC_VDD_32_33|MMC_VDD_33_34;
+                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;
+                ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
         if (caps & SDHCI_CAN_VDD_180)
-                mmc->ocr_avail |= MMC_VDD_165_195;
+                ocr_avail |= MMC_VDD_165_195;
+
+        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 "
@@ -1928,10 +1956,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
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index e42d7f00c060..25e8bde600d1 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -45,6 +45,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
@@ -52,6 +53,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
 
@@ -165,7 +167,7 @@
 #define  SDHCI_CAN_VDD_180      0x04000000
 #define  SDHCI_CAN_64BIT        0x10000000
 
-/* 44-47 reserved for more caps */
+#define SDHCI_CAPABILITIES_1    0x44
 
 #define SDHCI_MAX_CURRENT       0x48
 
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index f472c2714eb8..bbc298fd2a15 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -446,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;
@@ -478,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,
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index ddd09840520b..af97015a2fc7 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -16,16 +16,19 @@
  *
  */
 
+#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>
 
 #define DRIVER_NAME     "sh_mmcif"
 #define DRIVER_VERSION  "2010-04-28"
@@ -62,25 +65,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,10 +149,6 @@
                                  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 */
@@ -176,18 +156,21 @@
 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;
 
+        /* 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 +184,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 +398,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 +411,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 +421,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 +445,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 +459,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 +478,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 +504,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 +520,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 +540,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 +596,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 +624,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 +652,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 +672,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 +686,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 +716,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 +733,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,20 +780,18 @@ 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;
 }
 
@@ -676,6 +818,15 @@ 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;
 
@@ -693,15 +844,15 @@ 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;
 
-        if (ios->power_mode == MMC_POWER_OFF) {
+        if (ios->power_mode == MMC_POWER_UP) {
+                if (p->set_pwr)
+                        p->set_pwr(host->pd, ios->power_mode);
+        } else if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
                 /* clock stop */
                 sh_mmcif_clock_control(host, 0);
-                if (p->down_pwr)
+                if (ios->power_mode == MMC_POWER_OFF && p->down_pwr)
                         p->down_pwr(host->pd);
                 return;
-        } else if (ios->power_mode == MMC_POWER_UP) {
-                if (p->set_pwr)
-                        p->set_pwr(host->pd, ios->power_mode);
         }
 
         if (ios->clock)
@@ -735,7 +886,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);
@@ -774,17 +925,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, "Not support int\n");
                 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;
 }
@@ -793,8 +946,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];
@@ -802,7 +955,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);
@@ -815,7 +968,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;
@@ -842,7 +995,7 @@ 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);
 
         mmc->ops = &sh_mmcif_ops;
         mmc->f_max = host->clk;
@@ -858,33 +1011,37 @@ 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_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);
+
+        /* See if we also get DMA */
+        sh_mmcif_request_dma(host, pd);
+
         mmc_add_host(mmc);
 
         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");
+                dev_err(&pdev->dev, "request_irq error (sh_mmc:error)\n");
                 goto clean_up2;
         }
         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");
+                dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
                 goto clean_up2;
         }
 
         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;
 
@@ -903,20 +1060,22 @@ 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);
-
-        irq[0] = platform_get_irq(pdev, 0);
-        irq[1] = platform_get_irq(pdev, 1);
+        mmc_remove_host(host->mmc);
+        sh_mmcif_release_dma(host);
 
         if (host->addr)
                 iounmap(host->addr);
 
-        platform_set_drvdata(pdev, NULL);
-        mmc_remove_host(host->mmc);
+        sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
+
+        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);
 
@@ -947,5 +1106,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..cc701236d16f
--- /dev/null
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -0,0 +1,171 @@
+/*
+ * 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 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;
+
+        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;
+
+        pr_info("%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc),
+                (unsigned long)host->ctl, host->irq);
+
+        return ret;
+
+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);
+
+        tmio_mmc_host_remove(host);
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+        kfree(priv);
+
+        return 0;
+}
+
+static struct platform_driver sh_mobile_sdhi_driver = {
+        .driver         = {
+                .name   = "sh_mobile_sdhi",
+                .owner  = THIS_MODULE,
+        },
+        .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/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index e7765a89593e..79c568461d59 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,781 +11,22 @@
  * 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)
-{
-        struct mfd_cell *cell = host->pdev->dev.platform_data;
-        struct tmio_mmc_data *pdata = cell->driver_data;
-
-        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);
-
-        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 int tmio_mmc_get_cd(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;
-
-        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,
-};
-
 #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;
 
@@ -800,7 +41,7 @@ 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;
 
@@ -821,125 +62,54 @@ 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)
+        if (pdev->num_resources != 2)
                 goto out;
 
-        res_ctl = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res_ctl)
-                goto out;
-
-        pdata = cell->driver_data;
+        pdata = mfd_get_data(pdev);
         if (!pdata || !pdata->hclk)
                 goto out;
 
-        ret = -ENOMEM;
-
-        mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
-        if (!mmc)
-                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);
-
         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);
-
         return 0;
 
 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);
+                tmio_mmc_host_remove(mmc_priv(mmc));
                 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..099ed49a259b 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -1,58 +1,30 @@
-/* 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>
+
+/* 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 +35,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;
@@ -94,6 +45,7 @@ struct tmio_mmc_host {
         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);
@@ -101,128 +53,71 @@ struct tmio_mmc_host {
 
         /* 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>
-
-static inline u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift));
-}
-
-static inline void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        readsw(host->ctl + (addr << host->bus_shift), buf, count);
-}
-
-static inline u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift)) |
-               readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
-}
-
-static inline void sd_ctrl_write16(struct tmio_mmc_host *host, int addr,
-                u16 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-}
-
-static inline void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        writesw(host->ctl + (addr << host->bus_shift), buf, count);
-}
+        struct scatterlist      bounce_sg;
+        u8                      *bounce_buf;
 
-static inline void sd_ctrl_write32(struct tmio_mmc_host *host, int addr,
-                u32 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
-}
-
-#include <linux/scatterlist.h>
-#include <linux/blkdev.h>
+        /* Track lost interrupts */
+        struct delayed_work     delayed_reset_work;
+        spinlock_t              lock;
+        unsigned long           last_req_ts;
+};
 
-static inline 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_off = 0;
-}
+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 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;
-}
+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);
 
 static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,
-        unsigned long *flags)
+                                         unsigned long *flags)
 {
         local_irq_save(*flags);
         return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 }
 
-static inline void tmio_mmc_kunmap_atomic(void *virt,
-        unsigned long *flags)
+static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg,
+                                          unsigned long *flags, void *virt)
 {
-        kunmap_atomic(virt, KM_BIO_SRC_IRQ);
+        kunmap_atomic(virt - sg->offset, KM_BIO_SRC_IRQ);
         local_irq_restore(*flags);
 }
 
-#ifdef CONFIG_MMC_DEBUG
+#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)
+{
+}
 
-#define STATUS_TO_TEXT(a) \
-        do { \
-                if (status & TMIO_STAT_##a) \
-                        printk(#a); \
-        } while (0)
+static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
+                                 struct tmio_mmc_data *pdata)
+{
+        host->chan_tx = NULL;
+        host->chan_rx = NULL;
+}
 
-void pr_debug_status(u32 status)
+static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)
 {
-        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");
 }
+#endif
 
-#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..d3de74ab633e
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -0,0 +1,317 @@
+/*
+ * 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) {
+                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;
+                return;
+        }
+}
+
+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..710339a85c84
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -0,0 +1,897 @@
+/*
+ * 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/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;
+
+        /* request already finished */
+        if (!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->mrq = NULL;
+        host->force_pio = false;
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        tmio_mmc_reset(host);
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
+{
+        struct mmc_request *mrq = host->mrq;
+
+        if (!mrq)
+                return;
+
+        host->mrq = NULL;
+        host->cmd = NULL;
+        host->data = NULL;
+        host->force_pio = false;
+
+        cancel_delayed_work(&host->delayed_reset_work);
+
+        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);
+}
+
+static 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;
+}
+
+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);
+        int ret;
+
+        if (host->mrq)
+                pr_debug("request not null\n");
+
+        host->last_req_ts = jiffies;
+        wmb();
+        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) {
+                schedule_delayed_work(&host->delayed_reset_work,
+                                      msecs_to_jiffies(2000));
+                return;
+        }
+
+fail:
+        host->mrq = NULL;
+        host->force_pio = false;
+        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 -> UP -> ON */
+        if (ios->power_mode == MMC_POWER_UP) {
+                /* 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 && host->set_pwr)
+                        host->set_pwr(host->pdev, 0);
+                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);
+}
+
+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;
+
+        _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;
+
+        tmio_mmc_clk_stop(_host);
+        tmio_mmc_reset(_host);
+
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0)
+                goto unmap_ctl;
+
+        _host->irq = ret;
+
+        tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
+        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
+                tmio_mmc_enable_sdio_irq(mmc, 0);
+
+        ret = request_irq(_host->irq, tmio_mmc_irq, IRQF_DISABLED |
+                IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), _host);
+        if (ret)
+                goto unmap_ctl;
+
+        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);
+
+        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;
+
+unmap_ctl:
+        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)
+{
+        mmc_remove_host(host->mmc);
+        cancel_delayed_work_sync(&host->delayed_reset_work);
+        tmio_mmc_release_dma(host);
+        free_irq(host->irq, host);
+        iounmap(host->ctl);
+        mmc_free_host(host->mmc);
+}
+EXPORT_SYMBOL(tmio_mmc_host_remove);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/ushc.c b/drivers/mmc/host/ushc.c
index f8f65df9b017..f08f944ac53c 100644
--- a/drivers/mmc/host/ushc.c
+++ b/drivers/mmc/host/ushc.c
@@ -19,7 +19,6 @@
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/kernel.h>
-#include <linux/usb.h>
 #include <linux/slab.h>
 #include <linux/dma-mapping.h>
 #include <linux/mmc/host.h>
diff --git a/drivers/mmc/host/via-sdmmc.c b/drivers/mmc/host/via-sdmmc.c
index 9ed84ddb4780..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);
@@ -1090,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/wbsd.c b/drivers/mmc/host/wbsd.c
index 7fca0a386ba0..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);