Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

20 files changed, 1844 insertions, 348 deletions

diff --git a/drivers/mmc/core/Kconfig b/drivers/mmc/core/Kconfig
index bb22ffd76ef8..ef103871517f 100644
--- a/drivers/mmc/core/Kconfig
+++ b/drivers/mmc/core/Kconfig
@@ -16,3 +16,14 @@ config MMC_UNSAFE_RESUME
 
           This option sets a default which can be overridden by the
           module parameter "removable=0" or "removable=1".
+
+config MMC_CLKGATE
+        bool "MMC host clock gating (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        help
+          This will attempt to aggressively gate the clock to the MMC card.
+          This is done to save power due to gating off the logic and bus
+          noise when the MMC card is not in use. Your host driver has to
+          support handling this in order for it to be of any use.
+
+          If unsure, say N.
diff --git a/drivers/mmc/core/Makefile b/drivers/mmc/core/Makefile
index 889e5f898f6f..639501970b41 100644
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -2,14 +2,11 @@
 # Makefile for the kernel mmc core.
 #
 
-ifeq ($(CONFIG_MMC_DEBUG),y)
-        EXTRA_CFLAGS            += -DDEBUG
-endif
-
 obj-$(CONFIG_MMC)               += mmc_core.o
 mmc_core-y                      := core.o bus.o host.o \
                                    mmc.o mmc_ops.o sd.o sd_ops.o \
                                    sdio.o sdio_ops.o sdio_bus.o \
-                                   sdio_cis.o sdio_io.o sdio_irq.o
+                                   sdio_cis.o sdio_io.o sdio_irq.o \
+                                   quirks.o
 
 mmc_core-$(CONFIG_DEBUG_FS)     += debugfs.o
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 7cd9749dc21d..393d817ed040 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -14,6 +14,7 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -22,13 +23,12 @@
 #include "sdio_cis.h"
 #include "bus.h"
 
-#define dev_to_mmc_card(d)      container_of(d, struct mmc_card, dev)
 #define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
 
 static ssize_t mmc_type_show(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         switch (card->type) {
         case MMC_TYPE_MMC:
@@ -62,7 +62,7 @@ static int mmc_bus_match(struct device *dev, struct device_driver *drv)
 static int
 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         const char *type;
         int retval = 0;
 
@@ -105,7 +105,7 @@ mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 static int mmc_bus_probe(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         return drv->probe(card);
 }
@@ -113,7 +113,7 @@ static int mmc_bus_probe(struct device *dev)
 static int mmc_bus_remove(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         drv->remove(card);
 
@@ -123,7 +123,7 @@ static int mmc_bus_remove(struct device *dev)
 static int mmc_bus_suspend(struct device *dev, pm_message_t state)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         int ret = 0;
 
         if (dev->driver && drv->suspend)
@@ -134,7 +134,7 @@ static int mmc_bus_suspend(struct device *dev, pm_message_t state)
 static int mmc_bus_resume(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
         int ret = 0;
 
         if (dev->driver && drv->resume)
@@ -142,6 +142,41 @@ static int mmc_bus_resume(struct device *dev)
         return ret;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static int mmc_runtime_suspend(struct device *dev)
+{
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
+        return mmc_power_save_host(card->host);
+}
+
+static int mmc_runtime_resume(struct device *dev)
+{
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
+        return mmc_power_restore_host(card->host);
+}
+
+static int mmc_runtime_idle(struct device *dev)
+{
+        return pm_runtime_suspend(dev);
+}
+
+static const struct dev_pm_ops mmc_bus_pm_ops = {
+        .runtime_suspend        = mmc_runtime_suspend,
+        .runtime_resume         = mmc_runtime_resume,
+        .runtime_idle           = mmc_runtime_idle,
+};
+
+#define MMC_PM_OPS_PTR  (&mmc_bus_pm_ops)
+
+#else /* !CONFIG_PM_RUNTIME */
+
+#define MMC_PM_OPS_PTR  NULL
+
+#endif /* !CONFIG_PM_RUNTIME */
+
 static struct bus_type mmc_bus_type = {
         .name           = "mmc",
         .dev_attrs      = mmc_dev_attrs,
@@ -151,6 +186,7 @@ static struct bus_type mmc_bus_type = {
         .remove         = mmc_bus_remove,
         .suspend        = mmc_bus_suspend,
         .resume         = mmc_bus_resume,
+        .pm             = MMC_PM_OPS_PTR,
 };
 
 int mmc_register_bus(void)
@@ -189,7 +225,7 @@ EXPORT_SYMBOL(mmc_unregister_driver);
 
 static void mmc_release_card(struct device *dev)
 {
-        struct mmc_card *card = dev_to_mmc_card(dev);
+        struct mmc_card *card = mmc_dev_to_card(dev);
 
         sdio_free_common_cis(card);
 
@@ -238,8 +274,12 @@ int mmc_add_card(struct mmc_card *card)
                 break;
         case MMC_TYPE_SD:
                 type = "SD";
-                if (mmc_card_blockaddr(card))
-                        type = "SDHC";
+                if (mmc_card_blockaddr(card)) {
+                        if (mmc_card_ext_capacity(card))
+                                type = "SDXC";
+                        else
+                                type = "SDHC";
+                }
                 break;
         case MMC_TYPE_SDIO:
                 type = "SDIO";
@@ -248,31 +288,35 @@ int mmc_add_card(struct mmc_card *card)
                 type = "SD-combo";
                 if (mmc_card_blockaddr(card))
                         type = "SDHC-combo";
+                break;
         default:
                 type = "?";
                 break;
         }
 
         if (mmc_host_is_spi(card->host)) {
-                printk(KERN_INFO "%s: new %s%s card on SPI\n",
+                printk(KERN_INFO "%s: new %s%s%s card on SPI\n",
                         mmc_hostname(card->host),
                         mmc_card_highspeed(card) ? "high speed " : "",
+                        mmc_card_ddr_mode(card) ? "DDR " : "",
                         type);
         } else {
-                printk(KERN_INFO "%s: new %s%s card at address %04x\n",
+                printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
                         mmc_hostname(card->host),
-                        mmc_card_highspeed(card) ? "high speed " : "",
+                        mmc_sd_card_uhs(card) ? "ultra high speed " :
+                        (mmc_card_highspeed(card) ? "high speed " : ""),
+                        mmc_card_ddr_mode(card) ? "DDR " : "",
                         type, card->rca);
         }
 
-        ret = device_add(&card->dev);
-        if (ret)
-                return ret;
-
 #ifdef CONFIG_DEBUG_FS
         mmc_add_card_debugfs(card);
 #endif
 
+        ret = device_add(&card->dev);
+        if (ret)
+                return ret;
+
         mmc_card_set_present(card);
 
         return 0;
diff --git a/drivers/mmc/core/bus.h b/drivers/mmc/core/bus.h
index 18178766ab46..00a19710b6b4 100644
--- a/drivers/mmc/core/bus.h
+++ b/drivers/mmc/core/bus.h
@@ -14,7 +14,7 @@
 #define MMC_DEV_ATTR(name, fmt, args...)                                        \
 static ssize_t mmc_##name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
 {                                                                               \
-        struct mmc_card *card = container_of(dev, struct mmc_card, dev);        \
+        struct mmc_card *card = mmc_dev_to_card(dev);                           \
         return sprintf(buf, fmt, args);                                         \
 }                                                                               \
 static DEVICE_ATTR(name, S_IRUGO, mmc_##name##_show, NULL)
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 09eee6df0653..7843efe22359 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -22,6 +22,7 @@
 #include <linux/scatterlist.h>
 #include <linux/log2.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -58,6 +59,7 @@ int mmc_assume_removable;
 #else
 int mmc_assume_removable = 1;
 #endif
+EXPORT_SYMBOL(mmc_assume_removable);
 module_param_named(removable, mmc_assume_removable, bool, 0644);
 MODULE_PARM_DESC(
         removable,
@@ -129,6 +131,8 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 
                 if (mrq->done)
                         mrq->done(mrq);
+
+                mmc_host_clk_gate(host);
         }
 }
 
@@ -163,8 +167,6 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 
         WARN_ON(!host->claimed);
 
-        led_trigger_event(host->led, LED_FULL);
-
         mrq->cmd->error = 0;
         mrq->cmd->mrq = mrq;
         if (mrq->data) {
@@ -189,6 +191,8 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
+        mmc_host_clk_ungate(host);
+        led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
 
@@ -232,12 +236,10 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  */
 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
 {
-        struct mmc_request mrq;
+        struct mmc_request mrq = {0};
 
         WARN_ON(!host->claimed);
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-
         memset(cmd->resp, 0, sizeof(cmd->resp));
         cmd->retries = retries;
 
@@ -294,8 +296,9 @@ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
                 unsigned int timeout_us, limit_us;
 
                 timeout_us = data->timeout_ns / 1000;
-                timeout_us += data->timeout_clks * 1000 /
-                        (card->host->ios.clock / 1000);
+                if (mmc_host_clk_rate(card->host))
+                        timeout_us += data->timeout_clks * 1000 /
+                                (mmc_host_clk_rate(card->host) / 1000);
 
                 if (data->flags & MMC_DATA_WRITE)
                         /*
@@ -522,7 +525,14 @@ int mmc_try_claim_host(struct mmc_host *host)
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 
-static void mmc_do_release_host(struct mmc_host *host)
+/**
+ *      mmc_do_release_host - release a claimed host
+ *      @host: mmc host to release
+ *
+ *      If you successfully claimed a host, this function will
+ *      release it again.
+ */
+void mmc_do_release_host(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -537,6 +547,7 @@ static void mmc_do_release_host(struct mmc_host *host)
                 wake_up(&host->wq);
         }
 }
+EXPORT_SYMBOL(mmc_do_release_host);
 
 void mmc_host_deeper_disable(struct work_struct *work)
 {
@@ -613,6 +624,8 @@ static inline void mmc_set_ios(struct mmc_host *host)
                  ios->power_mode, ios->chip_select, ios->vdd,
                  ios->bus_width, ios->timing);
 
+        if (ios->clock > 0)
+                mmc_set_ungated(host);
         host->ops->set_ios(host, ios);
 }
 
@@ -640,6 +653,61 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+#ifdef CONFIG_MMC_CLKGATE
+/*
+ * This gates the clock by setting it to 0 Hz.
+ */
+void mmc_gate_clock(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_old = host->ios.clock;
+        host->ios.clock = 0;
+        host->clk_gated = true;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mmc_set_ios(host);
+}
+
+/*
+ * This restores the clock from gating by using the cached
+ * clock value.
+ */
+void mmc_ungate_clock(struct mmc_host *host)
+{
+        /*
+         * We should previously have gated the clock, so the clock shall
+         * be 0 here! The clock may however be 0 during initialization,
+         * when some request operations are performed before setting
+         * the frequency. When ungate is requested in that situation
+         * we just ignore the call.
+         */
+        if (host->clk_old) {
+                BUG_ON(host->ios.clock);
+                /* This call will also set host->clk_gated to false */
+                mmc_set_clock(host, host->clk_old);
+        }
+}
+
+void mmc_set_ungated(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        /*
+         * We've been given a new frequency while the clock is gated,
+         * so make sure we regard this as ungating it.
+         */
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_gated = false;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+}
+
+#else
+void mmc_set_ungated(struct mmc_host *host)
+{
+}
+#endif
+
 /*
  * Change the bus mode (open drain/push-pull) of a host.
  */
@@ -771,8 +839,9 @@ EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
 
 /**
  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
- * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
+ * @mmc: the host to regulate
  * @supply: regulator to use
+ * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
  *
  * Returns zero on success, else negative errno.
  *
@@ -780,15 +849,12 @@ EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
  * a particular supply voltage.  This would normally be called from the
  * set_ios() method.
  */
-int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
+int mmc_regulator_set_ocr(struct mmc_host *mmc,
+                        struct regulator *supply,
+                        unsigned short vdd_bit)
 {
         int                     result = 0;
         int                     min_uV, max_uV;
-        int                     enabled;
-
-        enabled = regulator_is_enabled(supply);
-        if (enabled < 0)
-                return enabled;
 
         if (vdd_bit) {
                 int             tmp;
@@ -819,17 +885,25 @@ int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
                 else
                         result = 0;
 
-                if (result == 0 && !enabled)
+                if (result == 0 && !mmc->regulator_enabled) {
                         result = regulator_enable(supply);
-        } else if (enabled) {
+                        if (!result)
+                                mmc->regulator_enabled = true;
+                }
+        } else if (mmc->regulator_enabled) {
                 result = regulator_disable(supply);
+                if (result == 0)
+                        mmc->regulator_enabled = false;
         }
 
+        if (result)
+                dev_err(mmc_dev(mmc),
+                        "could not set regulator OCR (%d)\n", result);
         return result;
 }
 EXPORT_SYMBOL(mmc_regulator_set_ocr);
 
-#endif
+#endif /* CONFIG_REGULATOR */
 
 /*
  * Mask off any voltages we don't support and select
@@ -858,6 +932,38 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
         return ocr;
 }
 
+int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11)
+{
+        struct mmc_command cmd = {0};
+        int err = 0;
+
+        BUG_ON(!host);
+
+        /*
+         * Send CMD11 only if the request is to switch the card to
+         * 1.8V signalling.
+         */
+        if ((signal_voltage != MMC_SIGNAL_VOLTAGE_330) && cmd11) {
+                cmd.opcode = SD_SWITCH_VOLTAGE;
+                cmd.arg = 0;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+
+                err = mmc_wait_for_cmd(host, &cmd, 0);
+                if (err)
+                        return err;
+
+                if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
+                        return -EIO;
+        }
+
+        host->ios.signal_voltage = signal_voltage;
+
+        if (host->ops->start_signal_voltage_switch)
+                err = host->ops->start_signal_voltage_switch(host, &host->ios);
+
+        return err;
+}
+
 /*
  * Select timing parameters for host.
  */
@@ -868,6 +974,15 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 }
 
 /*
+ * Select appropriate driver type for host.
+ */
+void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
+{
+        host->ios.drv_type = drv_type;
+        mmc_set_ios(host);
+}
+
+/*
  * Apply power to the MMC stack.  This is a two-stage process.
  * First, we enable power to the card without the clock running.
  * We then wait a bit for the power to stabilise.  Finally,
@@ -907,12 +1022,7 @@ static void mmc_power_up(struct mmc_host *host)
          */
         mmc_delay(10);
 
-        if (host->f_min > 400000) {
-                pr_warning("%s: Minimum clock frequency too high for "
-                                "identification mode\n", mmc_hostname(host));
-                host->ios.clock = host->f_min;
-        } else
-                host->ios.clock = 400000;
+        host->ios.clock = host->f_init;
 
         host->ios.power_mode = MMC_POWER_ON;
         mmc_set_ios(host);
@@ -928,6 +1038,13 @@ static void mmc_power_off(struct mmc_host *host)
 {
         host->ios.clock = 0;
         host->ios.vdd = 0;
+
+        /*
+         * Reset ocr mask to be the highest possible voltage supported for
+         * this mmc host. This value will be used at next power up.
+         */
+        host->ocr = 1 << (fls(host->ocr_avail) - 1);
+
         if (!mmc_host_is_spi(host)) {
                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
                 host->ios.chip_select = MMC_CS_DONTCARE;
@@ -1099,9 +1216,8 @@ void mmc_init_erase(struct mmc_card *card)
         }
 }
 
-static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
-                                      struct mmc_command *cmd,
-                                      unsigned int arg, unsigned int qty)
+static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
+                                          unsigned int arg, unsigned int qty)
 {
         unsigned int erase_timeout;
 
@@ -1129,7 +1245,7 @@ static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
                  */
                 timeout_clks <<= 1;
                 timeout_us += (timeout_clks * 1000) /
-                              (card->host->ios.clock / 1000);
+                              (mmc_host_clk_rate(card->host) / 1000);
 
                 erase_timeout = timeout_us / 1000;
 
@@ -1158,44 +1274,48 @@ static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
         if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
                 erase_timeout = 1000;
 
-        cmd->erase_timeout = erase_timeout;
+        return erase_timeout;
 }
 
-static void mmc_set_sd_erase_timeout(struct mmc_card *card,
-                                     struct mmc_command *cmd, unsigned int arg,
-                                     unsigned int qty)
+static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
+                                         unsigned int arg,
+                                         unsigned int qty)
 {
+        unsigned int erase_timeout;
+
         if (card->ssr.erase_timeout) {
                 /* Erase timeout specified in SD Status Register (SSR) */
-                cmd->erase_timeout = card->ssr.erase_timeout * qty +
-                                     card->ssr.erase_offset;
+                erase_timeout = card->ssr.erase_timeout * qty +
+                                card->ssr.erase_offset;
         } else {
                 /*
                  * Erase timeout not specified in SD Status Register (SSR) so
                  * use 250ms per write block.
                  */
-                cmd->erase_timeout = 250 * qty;
+                erase_timeout = 250 * qty;
         }
 
         /* Must not be less than 1 second */
-        if (cmd->erase_timeout < 1000)
-                cmd->erase_timeout = 1000;
+        if (erase_timeout < 1000)
+                erase_timeout = 1000;
+
+        return erase_timeout;
 }
 
-static void mmc_set_erase_timeout(struct mmc_card *card,
-                                  struct mmc_command *cmd, unsigned int arg,
-                                  unsigned int qty)
+static unsigned int mmc_erase_timeout(struct mmc_card *card,
+                                      unsigned int arg,
+                                      unsigned int qty)
 {
         if (mmc_card_sd(card))
-                mmc_set_sd_erase_timeout(card, cmd, arg, qty);
+                return mmc_sd_erase_timeout(card, arg, qty);
         else
-                mmc_set_mmc_erase_timeout(card, cmd, arg, qty);
+                return mmc_mmc_erase_timeout(card, arg, qty);
 }
 
 static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                         unsigned int to, unsigned int arg)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         unsigned int qty = 0;
         int err;
 
@@ -1229,7 +1349,6 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                 to <<= 9;
         }
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
         if (mmc_card_sd(card))
                 cmd.opcode = SD_ERASE_WR_BLK_START;
         else
@@ -1263,7 +1382,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
         cmd.opcode = MMC_ERASE;
         cmd.arg = arg;
         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-        mmc_set_erase_timeout(card, &cmd, arg, qty);
+        cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
                 printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
@@ -1397,33 +1516,77 @@ int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
 }
 EXPORT_SYMBOL(mmc_erase_group_aligned);
 
+int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
+{
+        struct mmc_command cmd = {0};
+
+        if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card))
+                return 0;
+
+        cmd.opcode = MMC_SET_BLOCKLEN;
+        cmd.arg = blocklen;
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+        return mmc_wait_for_cmd(card->host, &cmd, 5);
+}
+EXPORT_SYMBOL(mmc_set_blocklen);
+
+static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
+{
+        host->f_init = freq;
+
+#ifdef CONFIG_MMC_DEBUG
+        pr_info("%s: %s: trying to init card at %u Hz\n",
+                mmc_hostname(host), __func__, host->f_init);
+#endif
+        mmc_power_up(host);
+
+        /*
+         * sdio_reset sends CMD52 to reset card.  Since we do not know
+         * if the card is being re-initialized, just send it.  CMD52
+         * should be ignored by SD/eMMC cards.
+         */
+        sdio_reset(host);
+        mmc_go_idle(host);
+
+        mmc_send_if_cond(host, host->ocr_avail);
+
+        /* Order's important: probe SDIO, then SD, then MMC */
+        if (!mmc_attach_sdio(host))
+                return 0;
+        if (!mmc_attach_sd(host))
+                return 0;
+        if (!mmc_attach_mmc(host))
+                return 0;
+
+        mmc_power_off(host);
+        return -EIO;
+}
+
 void mmc_rescan(struct work_struct *work)
 {
+        static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
         struct mmc_host *host =
                 container_of(work, struct mmc_host, detect.work);
-        u32 ocr;
-        int err;
-        unsigned long flags;
-
-        spin_lock_irqsave(&host->lock, flags);
+        int i;
 
-        if (host->rescan_disable) {
-                spin_unlock_irqrestore(&host->lock, flags);
+        if (host->rescan_disable)
                 return;
-        }
-
-        spin_unlock_irqrestore(&host->lock, flags);
-
 
         mmc_bus_get(host);
 
-        /* if there is a card registered, check whether it is still present */
-        if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)
+        /*
+         * if there is a _removable_ card registered, check whether it is
+         * still present
+         */
+        if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
+            && !(host->caps & MMC_CAP_NONREMOVABLE))
                 host->bus_ops->detect(host);
 
+        /*
+         * Let mmc_bus_put() free the bus/bus_ops if we've found that
+         * the card is no longer present.
+         */
         mmc_bus_put(host);
-
-
         mmc_bus_get(host);
 
         /* if there still is a card present, stop here */
@@ -1432,8 +1595,6 @@ void mmc_rescan(struct work_struct *work)
                 goto out;
         }
 
-        /* detect a newly inserted card */
-
         /*
          * Only we can add a new handler, so it's safe to
          * release the lock here.
@@ -1444,55 +1605,15 @@ void mmc_rescan(struct work_struct *work)
                 goto out;
 
         mmc_claim_host(host);
-
-        mmc_power_up(host);
-        sdio_reset(host);
-        mmc_go_idle(host);
-
-        mmc_send_if_cond(host, host->ocr_avail);
-
-        /*
-         * First we search for SDIO...
-         */
-        err = mmc_send_io_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_sdio(host, ocr)) {
-                        mmc_claim_host(host);
-                        /* try SDMEM (but not MMC) even if SDIO is broken */
-                        if (mmc_send_app_op_cond(host, 0, &ocr))
-                                goto out_fail;
-
-                        if (mmc_attach_sd(host, ocr))
-                                mmc_power_off(host);
-                }
-                goto out;
-        }
-
-        /*
-         * ...then normal SD...
-         */
-        err = mmc_send_app_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_sd(host, ocr))
-                        mmc_power_off(host);
-                goto out;
-        }
-
-        /*
-         * ...and finally MMC.
-         */
-        err = mmc_send_op_cond(host, 0, &ocr);
-        if (!err) {
-                if (mmc_attach_mmc(host, ocr))
-                        mmc_power_off(host);
-                goto out;
+        for (i = 0; i < ARRAY_SIZE(freqs); i++) {
+                if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
+                        break;
+                if (freqs[i] <= host->f_min)
+                        break;
         }
-
-out_fail:
         mmc_release_host(host);
-        mmc_power_off(host);
 
-out:
+ out:
         if (host->caps & MMC_CAP_NEEDS_POLL)
                 mmc_schedule_delayed_work(&host->detect, HZ);
 }
@@ -1514,7 +1635,7 @@ void mmc_stop_host(struct mmc_host *host)
 
         if (host->caps & MMC_CAP_DISABLE)
                 cancel_delayed_work(&host->disable);
-        cancel_delayed_work(&host->detect);
+        cancel_delayed_work_sync(&host->detect);
         mmc_flush_scheduled_work();
 
         /* clear pm flags now and let card drivers set them as needed */
@@ -1538,37 +1659,45 @@ void mmc_stop_host(struct mmc_host *host)
         mmc_power_off(host);
 }
 
-void mmc_power_save_host(struct mmc_host *host)
+int mmc_power_save_host(struct mmc_host *host)
 {
+        int ret = 0;
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
                 mmc_bus_put(host);
-                return;
+                return -EINVAL;
         }
 
         if (host->bus_ops->power_save)
-                host->bus_ops->power_save(host);
+                ret = host->bus_ops->power_save(host);
 
         mmc_bus_put(host);
 
         mmc_power_off(host);
+
+        return ret;
 }
 EXPORT_SYMBOL(mmc_power_save_host);
 
-void mmc_power_restore_host(struct mmc_host *host)
+int mmc_power_restore_host(struct mmc_host *host)
 {
+        int ret;
+
         mmc_bus_get(host);
 
         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
                 mmc_bus_put(host);
-                return;
+                return -EINVAL;
         }
 
         mmc_power_up(host);
-        host->bus_ops->power_restore(host);
+        ret = host->bus_ops->power_restore(host);
 
         mmc_bus_put(host);
+
+        return ret;
 }
 EXPORT_SYMBOL(mmc_power_restore_host);
 
@@ -1647,7 +1776,7 @@ int mmc_suspend_host(struct mmc_host *host)
         }
         mmc_bus_put(host);
 
-        if (!err && !(host->pm_flags & MMC_PM_KEEP_POWER))
+        if (!err && !mmc_card_keep_power(host))
                 mmc_power_off(host);
 
         return err;
@@ -1665,9 +1794,21 @@ int mmc_resume_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-                if (!(host->pm_flags & MMC_PM_KEEP_POWER)) {
+                if (!mmc_card_keep_power(host)) {
                         mmc_power_up(host);
                         mmc_select_voltage(host, host->ocr);
+                        /*
+                         * Tell runtime PM core we just powered up the card,
+                         * since it still believes the card is powered off.
+                         * Note that currently runtime PM is only enabled
+                         * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
+                         */
+                        if (mmc_card_sdio(host->card) &&
+                            (host->caps & MMC_CAP_POWER_OFF_CARD)) {
+                                pm_runtime_disable(&host->card->dev);
+                                pm_runtime_set_active(&host->card->dev);
+                                pm_runtime_enable(&host->card->dev);
+                        }
                 }
                 BUG_ON(!host->bus_ops->resume);
                 err = host->bus_ops->resume(host);
@@ -1678,6 +1819,7 @@ int mmc_resume_host(struct mmc_host *host)
                         err = 0;
                 }
         }
+        host->pm_flags &= ~MMC_PM_KEEP_POWER;
         mmc_bus_put(host);
 
         return err;
@@ -1720,6 +1862,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 
         case PM_POST_SUSPEND:
         case PM_POST_HIBERNATION:
+        case PM_POST_RESTORE:
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 0;
@@ -1736,7 +1879,7 @@ static int __init mmc_init(void)
 {
         int ret;
 
-        workqueue = create_singlethread_workqueue("kmmcd");
+        workqueue = alloc_ordered_workqueue("kmmcd", 0);
         if (!workqueue)
                 return -ENOMEM;
 
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index 9d9eef50e5d1..d9411ed2a39b 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -22,8 +22,8 @@ struct mmc_bus_ops {
         void (*detect)(struct mmc_host *);
         int (*suspend)(struct mmc_host *);
         int (*resume)(struct mmc_host *);
-        void (*power_save)(struct mmc_host *);
-        void (*power_restore)(struct mmc_host *);
+        int (*power_save)(struct mmc_host *);
+        int (*power_restore)(struct mmc_host *);
 };
 
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
@@ -33,10 +33,16 @@ void mmc_init_erase(struct mmc_card *card);
 
 void mmc_set_chip_select(struct mmc_host *host, int mode);
 void mmc_set_clock(struct mmc_host *host, unsigned int hz);
+void mmc_gate_clock(struct mmc_host *host);
+void mmc_ungate_clock(struct mmc_host *host);
+void mmc_set_ungated(struct mmc_host *host);
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width);
 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr);
+int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage,
+                           bool cmd11);
 void mmc_set_timing(struct mmc_host *host, unsigned int timing);
+void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type);
 
 static inline void mmc_delay(unsigned int ms)
 {
@@ -52,13 +58,12 @@ void mmc_rescan(struct work_struct *work);
 void mmc_start_host(struct mmc_host *host);
 void mmc_stop_host(struct mmc_host *host);
 
-int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
-int mmc_attach_sd(struct mmc_host *host, u32 ocr);
-int mmc_attach_sdio(struct mmc_host *host, u32 ocr);
+int mmc_attach_mmc(struct mmc_host *host);
+int mmc_attach_sd(struct mmc_host *host);
+int mmc_attach_sdio(struct mmc_host *host);
 
 /* Module parameters */
 extern int use_spi_crc;
-extern int mmc_assume_removable;
 
 /* Debugfs information for hosts and cards */
 void mmc_add_host_debugfs(struct mmc_host *host);
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 53cb380c0987..998797ed67a6 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -134,6 +134,33 @@ static const struct file_operations mmc_ios_fops = {
         .release        = single_release,
 };
 
+static int mmc_clock_opt_get(void *data, u64 *val)
+{
+        struct mmc_host *host = data;
+
+        *val = host->ios.clock;
+
+        return 0;
+}
+
+static int mmc_clock_opt_set(void *data, u64 val)
+{
+        struct mmc_host *host = data;
+
+        /* We need this check due to input value is u64 */
+        if (val > host->f_max)
+                return -EINVAL;
+
+        mmc_claim_host(host);
+        mmc_set_clock(host, (unsigned int) val);
+        mmc_release_host(host);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set,
+        "%llu\n");
+
 void mmc_add_host_debugfs(struct mmc_host *host)
 {
         struct dentry *root;
@@ -150,11 +177,20 @@ void mmc_add_host_debugfs(struct mmc_host *host)
         host->debugfs_root = root;
 
         if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops))
-                goto err_ios;
+                goto err_node;
+
+        if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host,
+                        &mmc_clock_fops))
+                goto err_node;
 
+#ifdef CONFIG_MMC_CLKGATE
+        if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR),
+                                root, &host->clk_delay))
+                goto err_node;
+#endif
         return;
 
-err_ios:
+err_node:
         debugfs_remove_recursive(root);
         host->debugfs_root = NULL;
 err_root:
@@ -245,6 +281,7 @@ static const struct file_operations mmc_dbg_ext_csd_fops = {
         .open           = mmc_ext_csd_open,
         .read           = mmc_ext_csd_read,
         .release        = mmc_ext_csd_release,
+        .llseek         = default_llseek,
 };
 
 void mmc_add_card_debugfs(struct mmc_card *card)
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index d80cfdc8edd2..b29d3e8fd3a2 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2003 Russell King, All Rights Reserved.
  *  Copyright (C) 2007-2008 Pierre Ossman
+ *  Copyright (C) 2010 Linus Walleij
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -20,6 +21,7 @@
 #include <linux/suspend.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 
 #include "core.h"
 #include "host.h"
@@ -50,6 +52,202 @@ void mmc_unregister_host_class(void)
 static DEFINE_IDR(mmc_host_idr);
 static DEFINE_SPINLOCK(mmc_host_lock);
 
+#ifdef CONFIG_MMC_CLKGATE
+
+/*
+ * Enabling clock gating will make the core call out to the host
+ * once up and once down when it performs a request or card operation
+ * intermingled in any fashion. The driver will see this through
+ * set_ios() operations with ios.clock field set to 0 to gate (disable)
+ * the block clock, and to the old frequency to enable it again.
+ */
+static void mmc_host_clk_gate_delayed(struct mmc_host *host)
+{
+        unsigned long tick_ns;
+        unsigned long freq = host->ios.clock;
+        unsigned long flags;
+
+        if (!freq) {
+                pr_debug("%s: frequency set to 0 in disable function, "
+                         "this means the clock is already disabled.\n",
+                         mmc_hostname(host));
+                return;
+        }
+        /*
+         * New requests may have appeared while we were scheduling,
+         * then there is no reason to delay the check before
+         * clk_disable().
+         */
+        spin_lock_irqsave(&host->clk_lock, flags);
+
+        /*
+         * Delay n bus cycles (at least 8 from MMC spec) before attempting
+         * to disable the MCI block clock. The reference count may have
+         * gone up again after this delay due to rescheduling!
+         */
+        if (!host->clk_requests) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                tick_ns = DIV_ROUND_UP(1000000000, freq);
+                ndelay(host->clk_delay * tick_ns);
+        } else {
+                /* New users appeared while waiting for this work */
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                return;
+        }
+        mutex_lock(&host->clk_gate_mutex);
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (!host->clk_requests) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                /* This will set host->ios.clock to 0 */
+                mmc_gate_clock(host);
+                spin_lock_irqsave(&host->clk_lock, flags);
+                pr_debug("%s: gated MCI clock\n", mmc_hostname(host));
+        }
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mutex_unlock(&host->clk_gate_mutex);
+}
+
+/*
+ * Internal work. Work to disable the clock at some later point.
+ */
+static void mmc_host_clk_gate_work(struct work_struct *work)
+{
+        struct mmc_host *host = container_of(work, struct mmc_host,
+                                              clk_gate_work);
+
+        mmc_host_clk_gate_delayed(host);
+}
+
+/**
+ *      mmc_host_clk_ungate - ungate hardware MCI clocks
+ *      @host: host to ungate.
+ *
+ *      Makes sure the host ios.clock is restored to a non-zero value
+ *      past this call. Increase clock reference count and ungate clock
+ *      if we're the first user.
+ */
+void mmc_host_clk_ungate(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        mutex_lock(&host->clk_gate_mutex);
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (host->clk_gated) {
+                spin_unlock_irqrestore(&host->clk_lock, flags);
+                mmc_ungate_clock(host);
+                spin_lock_irqsave(&host->clk_lock, flags);
+                pr_debug("%s: ungated MCI clock\n", mmc_hostname(host));
+        }
+        host->clk_requests++;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        mutex_unlock(&host->clk_gate_mutex);
+}
+
+/**
+ *      mmc_host_may_gate_card - check if this card may be gated
+ *      @card: card to check.
+ */
+static bool mmc_host_may_gate_card(struct mmc_card *card)
+{
+        /* If there is no card we may gate it */
+        if (!card)
+                return true;
+        /*
+         * Don't gate SDIO cards! These need to be clocked at all times
+         * since they may be independent systems generating interrupts
+         * and other events. The clock requests counter from the core will
+         * go down to zero since the core does not need it, but we will not
+         * gate the clock, because there is somebody out there that may still
+         * be using it.
+         */
+        return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING);
+}
+
+/**
+ *      mmc_host_clk_gate - gate off hardware MCI clocks
+ *      @host: host to gate.
+ *
+ *      Calls the host driver with ios.clock set to zero as often as possible
+ *      in order to gate off hardware MCI clocks. Decrease clock reference
+ *      count and schedule disabling of clock.
+ */
+void mmc_host_clk_gate(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clk_requests--;
+        if (mmc_host_may_gate_card(host->card) &&
+            !host->clk_requests)
+                schedule_work(&host->clk_gate_work);
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+}
+
+/**
+ *      mmc_host_clk_rate - get current clock frequency setting
+ *      @host: host to get the clock frequency for.
+ *
+ *      Returns current clock frequency regardless of gating.
+ */
+unsigned int mmc_host_clk_rate(struct mmc_host *host)
+{
+        unsigned long freq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        if (host->clk_gated)
+                freq = host->clk_old;
+        else
+                freq = host->ios.clock;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        return freq;
+}
+
+/**
+ *      mmc_host_clk_init - set up clock gating code
+ *      @host: host with potential clock to control
+ */
+static inline void mmc_host_clk_init(struct mmc_host *host)
+{
+        host->clk_requests = 0;
+        /* Hold MCI clock for 8 cycles by default */
+        host->clk_delay = 8;
+        host->clk_gated = false;
+        INIT_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
+        spin_lock_init(&host->clk_lock);
+        mutex_init(&host->clk_gate_mutex);
+}
+
+/**
+ *      mmc_host_clk_exit - shut down clock gating code
+ *      @host: host with potential clock to control
+ */
+static inline void mmc_host_clk_exit(struct mmc_host *host)
+{
+        /*
+         * Wait for any outstanding gate and then make sure we're
+         * ungated before exiting.
+         */
+        if (cancel_work_sync(&host->clk_gate_work))
+                mmc_host_clk_gate_delayed(host);
+        if (host->clk_gated)
+                mmc_host_clk_ungate(host);
+        /* There should be only one user now */
+        WARN_ON(host->clk_requests > 1);
+}
+
+#else
+
+static inline void mmc_host_clk_init(struct mmc_host *host)
+{
+}
+
+static inline void mmc_host_clk_exit(struct mmc_host *host)
+{
+}
+
+#endif
+
 /**
  *      mmc_alloc_host - initialise the per-host structure.
  *      @extra: sizeof private data structure
@@ -82,6 +280,8 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
         host->class_dev.class = &mmc_host_class;
         device_initialize(&host->class_dev);
 
+        mmc_host_clk_init(host);
+
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
@@ -94,8 +294,7 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
          * By default, hosts do not support SGIO or large requests.
          * They have to set these according to their abilities.
          */
-        host->max_hw_segs = 1;
-        host->max_phys_segs = 1;
+        host->max_segs = 1;
         host->max_seg_size = PAGE_CACHE_SIZE;
 
         host->max_req_size = PAGE_CACHE_SIZE;
@@ -126,12 +325,12 @@ int mmc_add_host(struct mmc_host *host)
         WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
                 !host->ops->enable_sdio_irq);
 
-        led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
-
         err = device_add(&host->class_dev);
         if (err)
                 return err;
 
+        led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
+
 #ifdef CONFIG_DEBUG_FS
         mmc_add_host_debugfs(host);
 #endif
@@ -164,6 +363,8 @@ void mmc_remove_host(struct mmc_host *host)
         device_del(&host->class_dev);
 
         led_trigger_unregister_simple(host->led);
+
+        mmc_host_clk_exit(host);
 }
 
 EXPORT_SYMBOL(mmc_remove_host);
@@ -184,4 +385,3 @@ void mmc_free_host(struct mmc_host *host)
 }
 
 EXPORT_SYMBOL(mmc_free_host);
-
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index 8c87e1109a34..de199f911928 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -10,10 +10,31 @@
  */
 #ifndef _MMC_CORE_HOST_H
 #define _MMC_CORE_HOST_H
+#include <linux/mmc/host.h>
 
 int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
 
+#ifdef CONFIG_MMC_CLKGATE
+void mmc_host_clk_ungate(struct mmc_host *host);
+void mmc_host_clk_gate(struct mmc_host *host);
+unsigned int mmc_host_clk_rate(struct mmc_host *host);
+
+#else
+static inline void mmc_host_clk_ungate(struct mmc_host *host)
+{
+}
+
+static inline void mmc_host_clk_gate(struct mmc_host *host)
+{
+}
+
+static inline unsigned int mmc_host_clk_rate(struct mmc_host *host)
+{
+        return host->ios.clock;
+}
+#endif
+
 void mmc_host_deeper_disable(struct work_struct *work);
 
 #endif
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 6909a54c39be..aa7d1d79b8c5 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -20,6 +20,7 @@
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
+#include "sd_ops.h"
 
 static const unsigned int tran_exp[] = {
         10000,          100000,         1000000,        10000000,
@@ -173,14 +174,17 @@ static int mmc_decode_csd(struct mmc_card *card)
 }
 
 /*
- * Read and decode extended CSD.
+ * Read extended CSD.
  */
-static int mmc_read_ext_csd(struct mmc_card *card)
+static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
 {
         int err;
         u8 *ext_csd;
 
         BUG_ON(!card);
+        BUG_ON(!new_ext_csd);
+
+        *new_ext_csd = NULL;
 
         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
                 return 0;
@@ -198,12 +202,15 @@ static int mmc_read_ext_csd(struct mmc_card *card)
 
         err = mmc_send_ext_csd(card, ext_csd);
         if (err) {
+                kfree(ext_csd);
+                *new_ext_csd = NULL;
+
                 /* If the host or the card can't do the switch,
                  * fail more gracefully. */
                 if ((err != -EINVAL)
                  && (err != -ENOSYS)
                  && (err != -EFAULT))
-                        goto out;
+                        return err;
 
                 /*
                  * High capacity cards should have this "magic" size
@@ -221,17 +228,31 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                                 mmc_hostname(card->host));
                         err = 0;
                 }
+        } else
+                *new_ext_csd = ext_csd;
 
-                goto out;
-        }
+        return err;
+}
+
+/*
+ * Decode extended CSD.
+ */
+static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
+{
+        int err = 0;
+
+        BUG_ON(!card);
+
+        if (!ext_csd)
+                return 0;
 
         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
+        card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
         if (card->csd.structure == 3) {
-                int ext_csd_struct = ext_csd[EXT_CSD_STRUCTURE];
-                if (ext_csd_struct > 2) {
+                if (card->ext_csd.raw_ext_csd_structure > 2) {
                         printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
                                 "version %d\n", mmc_hostname(card->host),
-                                        ext_csd_struct);
+                                        card->ext_csd.raw_ext_csd_structure);
                         err = -EINVAL;
                         goto out;
                 }
@@ -245,6 +266,10 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 goto out;
         }
 
+        card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
+        card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
+        card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
+        card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
         if (card->ext_csd.rev >= 2) {
                 card->ext_csd.sectors =
                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
@@ -256,8 +281,23 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
                         mmc_card_set_blockaddr(card);
         }
-
+        card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
         switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
+        case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52;
+                break;
+        case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V;
+                break;
+        case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 |
+             EXT_CSD_CARD_TYPE_26:
+                card->ext_csd.hs_max_dtr = 52000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V;
+                break;
         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
                 card->ext_csd.hs_max_dtr = 52000000;
                 break;
@@ -271,8 +311,17 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         mmc_hostname(card->host));
         }
 
+        card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
+        card->ext_csd.raw_erase_timeout_mult =
+                ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
+        card->ext_csd.raw_hc_erase_grp_size =
+                ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
         if (card->ext_csd.rev >= 3) {
                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
+                card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
+
+                /* EXT_CSD value is in units of 10ms, but we store in ms */
+                card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 
                 /* Sleep / awake timeout in 100ns units */
                 if (sa_shift > 0 && sa_shift <= 0x17)
@@ -284,9 +333,65 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
                 card->ext_csd.hc_erase_size =
                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
+
+                card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
+
+                /*
+                 * There are two boot regions of equal size, defined in
+                 * multiples of 128K.
+                 */
+                card->ext_csd.boot_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
         }
 
+        card->ext_csd.raw_hc_erase_gap_size =
+                ext_csd[EXT_CSD_PARTITION_ATTRIBUTE];
+        card->ext_csd.raw_sec_trim_mult =
+                ext_csd[EXT_CSD_SEC_TRIM_MULT];
+        card->ext_csd.raw_sec_erase_mult =
+                ext_csd[EXT_CSD_SEC_ERASE_MULT];
+        card->ext_csd.raw_sec_feature_support =
+                ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
+        card->ext_csd.raw_trim_mult =
+                ext_csd[EXT_CSD_TRIM_MULT];
         if (card->ext_csd.rev >= 4) {
+                /*
+                 * Enhanced area feature support -- check whether the eMMC
+                 * card has the Enhanced area enabled.  If so, export enhanced
+                 * area offset and size to user by adding sysfs interface.
+                 */
+                if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
+                    (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
+                        u8 hc_erase_grp_sz =
+                                ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
+                        u8 hc_wp_grp_sz =
+                                ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
+
+                        card->ext_csd.enhanced_area_en = 1;
+                        /*
+                         * calculate the enhanced data area offset, in bytes
+                         */
+                        card->ext_csd.enhanced_area_offset =
+                                (ext_csd[139] << 24) + (ext_csd[138] << 16) +
+                                (ext_csd[137] << 8) + ext_csd[136];
+                        if (mmc_card_blockaddr(card))
+                                card->ext_csd.enhanced_area_offset <<= 9;
+                        /*
+                         * calculate the enhanced data area size, in kilobytes
+                         */
+                        card->ext_csd.enhanced_area_size =
+                                (ext_csd[142] << 16) + (ext_csd[141] << 8) +
+                                ext_csd[140];
+                        card->ext_csd.enhanced_area_size *=
+                                (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
+                        card->ext_csd.enhanced_area_size <<= 9;
+                } else {
+                        /*
+                         * If the enhanced area is not enabled, disable these
+                         * device attributes.
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                }
                 card->ext_csd.sec_trim_mult =
                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
                 card->ext_csd.sec_erase_mult =
@@ -297,14 +402,83 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         ext_csd[EXT_CSD_TRIM_MULT];
         }
 
+        if (card->ext_csd.rev >= 5)
+                card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
+
         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
                 card->erased_byte = 0xFF;
         else
                 card->erased_byte = 0x0;
 
 out:
+        return err;
+}
+
+static inline void mmc_free_ext_csd(u8 *ext_csd)
+{
         kfree(ext_csd);
+}
+
+
+static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
+{
+        u8 *bw_ext_csd;
+        int err;
 
+        if (bus_width == MMC_BUS_WIDTH_1)
+                return 0;
+
+        err = mmc_get_ext_csd(card, &bw_ext_csd);
+
+        if (err || bw_ext_csd == NULL) {
+                if (bus_width != MMC_BUS_WIDTH_1)
+                        err = -EINVAL;
+                goto out;
+        }
+
+        if (bus_width == MMC_BUS_WIDTH_1)
+                goto out;
+
+        /* only compare read only fields */
+        err = (!(card->ext_csd.raw_partition_support ==
+                        bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
+                (card->ext_csd.raw_erased_mem_count ==
+                        bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
+                (card->ext_csd.rev ==
+                        bw_ext_csd[EXT_CSD_REV]) &&
+                (card->ext_csd.raw_ext_csd_structure ==
+                        bw_ext_csd[EXT_CSD_STRUCTURE]) &&
+                (card->ext_csd.raw_card_type ==
+                        bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
+                (card->ext_csd.raw_s_a_timeout ==
+                        bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
+                (card->ext_csd.raw_hc_erase_gap_size ==
+                        bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
+                (card->ext_csd.raw_erase_timeout_mult ==
+                        bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
+                (card->ext_csd.raw_hc_erase_grp_size ==
+                        bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
+                (card->ext_csd.raw_sec_trim_mult ==
+                        bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
+                (card->ext_csd.raw_sec_erase_mult ==
+                        bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
+                (card->ext_csd.raw_sec_feature_support ==
+                        bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
+                (card->ext_csd.raw_trim_mult ==
+                        bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
+                (card->ext_csd.raw_sectors[0] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
+                (card->ext_csd.raw_sectors[1] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
+                (card->ext_csd.raw_sectors[2] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
+                (card->ext_csd.raw_sectors[3] ==
+                        bw_ext_csd[EXT_CSD_SEC_CNT + 3]));
+        if (err)
+                err = -EINVAL;
+
+out:
+        mmc_free_ext_csd(bw_ext_csd);
         return err;
 }
 
@@ -321,6 +495,9 @@ MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
+MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
+                card->ext_csd.enhanced_area_offset);
+MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 
 static struct attribute *mmc_std_attrs[] = {
         &dev_attr_cid.attr,
@@ -334,6 +511,8 @@ static struct attribute *mmc_std_attrs[] = {
         &dev_attr_name.attr,
         &dev_attr_oemid.attr,
         &dev_attr_serial.attr,
+        &dev_attr_enhanced_area_offset.attr,
+        &dev_attr_enhanced_area_size.attr,
         NULL,
 };
 
@@ -360,9 +539,11 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         struct mmc_card *oldcard)
 {
         struct mmc_card *card;
-        int err;
+        int err, ddr = 0;
         u32 cid[4];
         unsigned int max_dtr;
+        u32 rocr;
+        u8 *ext_csd = NULL;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -376,7 +557,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         mmc_go_idle(host);
 
         /* The extra bit indicates that we support high capacity */
-        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
+        err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
         if (err)
                 goto err;
 
@@ -461,20 +642,76 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 /*
                  * Fetch and process extended CSD.
                  */
-                err = mmc_read_ext_csd(card);
+
+                err = mmc_get_ext_csd(card, &ext_csd);
+                if (err)
+                        goto free_card;
+                err = mmc_read_ext_csd(card, ext_csd);
                 if (err)
                         goto free_card;
+
+                /* If doing byte addressing, check if required to do sector
+                 * addressing.  Handle the case of <2GB cards needing sector
+                 * addressing.  See section 8.1 JEDEC Standard JED84-A441;
+                 * ocr register has bit 30 set for sector addressing.
+                 */
+                if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
+                        mmc_card_set_blockaddr(card);
+
                 /* Erase size depends on CSD and Extended CSD */
                 mmc_set_erase_size(card);
         }
 
         /*
+         * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
+         * bit.  This bit will be lost every time after a reset or power off.
+         */
+        if (card->ext_csd.enhanced_area_en) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_ERASE_GROUP_DEF, 1, 0);
+
+                if (err && err != -EBADMSG)
+                        goto free_card;
+
+                if (err) {
+                        err = 0;
+                        /*
+                         * Just disable enhanced area off & sz
+                         * will try to enable ERASE_GROUP_DEF
+                         * during next time reinit
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                } else {
+                        card->ext_csd.erase_group_def = 1;
+                        /*
+                         * enable ERASE_GRP_DEF successfully.
+                         * This will affect the erase size, so
+                         * here need to reset erase size
+                         */
+                        mmc_set_erase_size(card);
+                }
+        }
+
+        /*
+         * Ensure eMMC user default partition is enabled
+         */
+        if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
+                card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
+                                 card->ext_csd.part_config,
+                                 card->ext_csd.part_time);
+                if (err && err != -EBADMSG)
+                        goto free_card;
+        }
+
+        /*
          * Activate high speed (if supported)
          */
         if ((card->ext_csd.hs_max_dtr != 0) &&
                 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_HS_TIMING, 1);
+                                 EXT_CSD_HS_TIMING, 1, 0);
                 if (err && err != -EBADMSG)
                         goto free_card;
 
@@ -503,32 +740,102 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         mmc_set_clock(host, max_dtr);
 
         /*
-         * Activate wide bus (if supported).
+         * Indicate DDR mode (if supported).
+         */
+        if (mmc_card_highspeed(card)) {
+                if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
+                        && ((host->caps & (MMC_CAP_1_8V_DDR |
+                             MMC_CAP_UHS_DDR50))
+                                == (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
+                                ddr = MMC_1_8V_DDR_MODE;
+                else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
+                        && ((host->caps & (MMC_CAP_1_2V_DDR |
+                             MMC_CAP_UHS_DDR50))
+                                == (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
+                                ddr = MMC_1_2V_DDR_MODE;
+        }
+
+        /*
+         * Activate wide bus and DDR (if supported).
          */
         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
-                unsigned ext_csd_bit, bus_width;
-
-                if (host->caps & MMC_CAP_8_BIT_DATA) {
-                        ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
-                        bus_width = MMC_BUS_WIDTH_8;
-                } else {
-                        ext_csd_bit = EXT_CSD_BUS_WIDTH_4;
-                        bus_width = MMC_BUS_WIDTH_4;
+                static unsigned ext_csd_bits[][2] = {
+                        { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
+                        { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
+                        { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
+                };
+                static unsigned bus_widths[] = {
+                        MMC_BUS_WIDTH_8,
+                        MMC_BUS_WIDTH_4,
+                        MMC_BUS_WIDTH_1
+                };
+                unsigned idx, bus_width = 0;
+
+                if (host->caps & MMC_CAP_8_BIT_DATA)
+                        idx = 0;
+                else
+                        idx = 1;
+                for (; idx < ARRAY_SIZE(bus_widths); idx++) {
+                        bus_width = bus_widths[idx];
+                        if (bus_width == MMC_BUS_WIDTH_1)
+                                ddr = 0; /* no DDR for 1-bit width */
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         EXT_CSD_BUS_WIDTH,
+                                         ext_csd_bits[idx][0],
+                                         0);
+                        if (!err) {
+                                mmc_set_bus_width(card->host, bus_width);
+
+                                /*
+                                 * If controller can't handle bus width test,
+                                 * compare ext_csd previously read in 1 bit mode
+                                 * against ext_csd at new bus width
+                                 */
+                                if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
+                                        err = mmc_compare_ext_csds(card,
+                                                bus_width);
+                                else
+                                        err = mmc_bus_test(card, bus_width);
+                                if (!err)
+                                        break;
+                        }
                 }
 
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                 EXT_CSD_BUS_WIDTH, ext_csd_bit);
-
-                if (err && err != -EBADMSG)
-                        goto free_card;
-
+                if (!err && ddr) {
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         EXT_CSD_BUS_WIDTH,
+                                         ext_csd_bits[idx][1],
+                                         0);
+                }
                 if (err) {
-                        printk(KERN_WARNING "%s: switch to bus width %d "
-                               "failed\n", mmc_hostname(card->host),
-                               1 << bus_width);
-                        err = 0;
-                } else {
+                        printk(KERN_WARNING "%s: switch to bus width %d ddr %d "
+                                "failed\n", mmc_hostname(card->host),
+                                1 << bus_width, ddr);
+                        goto free_card;
+                } else if (ddr) {
+                        /*
+                         * eMMC cards can support 3.3V to 1.2V i/o (vccq)
+                         * signaling.
+                         *
+                         * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
+                         *
+                         * 1.8V vccq at 3.3V core voltage (vcc) is not required
+                         * in the JEDEC spec for DDR.
+                         *
+                         * Do not force change in vccq since we are obviously
+                         * working and no change to vccq is needed.
+                         *
+                         * WARNING: eMMC rules are NOT the same as SD DDR
+                         */
+                        if (ddr == EXT_CSD_CARD_TYPE_DDR_1_2V) {
+                                err = mmc_set_signal_voltage(host,
+                                        MMC_SIGNAL_VOLTAGE_120, 0);
+                                if (err)
+                                        goto err;
+                        }
+                        mmc_card_set_ddr_mode(card);
+                        mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
                         mmc_set_bus_width(card->host, bus_width);
                 }
         }
@@ -536,12 +843,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (!oldcard)
                 host->card = card;
 
+        mmc_free_ext_csd(ext_csd);
         return 0;
 
 free_card:
         if (!oldcard)
                 mmc_remove_card(card);
 err:
+        mmc_free_ext_csd(ext_csd);
 
         return err;
 }
@@ -623,12 +932,16 @@ static int mmc_resume(struct mmc_host *host)
         return err;
 }
 
-static void mmc_power_restore(struct mmc_host *host)
+static int mmc_power_restore(struct mmc_host *host)
 {
+        int ret;
+
         host->card->state &= ~MMC_STATE_HIGHSPEED;
         mmc_claim_host(host);
-        mmc_init_card(host, host->ocr, host->card);
+        ret = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
+
+        return ret;
 }
 
 static int mmc_sleep(struct mmc_host *host)
@@ -685,7 +998,7 @@ static void mmc_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
+        if (!mmc_card_is_removable(host))
                 bus_ops = &mmc_ops_unsafe;
         else
                 bus_ops = &mmc_ops;
@@ -695,14 +1008,21 @@ static void mmc_attach_bus_ops(struct mmc_host *host)
 /*
  * Starting point for MMC card init.
  */
-int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
+int mmc_attach_mmc(struct mmc_host *host)
 {
         int err;
+        u32 ocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        err = mmc_send_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_attach_bus_ops(host);
+        if (host->ocr_avail_mmc)
+                host->ocr_avail = host->ocr_avail_mmc;
 
         /*
          * We need to get OCR a different way for SPI.
@@ -742,20 +1062,20 @@ int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
                 goto err;
 
         mmc_release_host(host);
-
         err = mmc_add_card(host->card);
+        mmc_claim_host(host);
         if (err)
                 goto remove_card;
 
         return 0;
 
 remove_card:
+        mmc_release_host(host);
         mmc_remove_card(host->card);
-        host->card = NULL;
         mmc_claim_host(host);
+        host->card = NULL;
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 326447c9ede8..845ce7c533b9 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -23,12 +23,10 @@
 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SELECT_CARD;
 
         if (card) {
@@ -60,15 +58,13 @@ int mmc_deselect_cards(struct mmc_host *host)
 
 int mmc_card_sleepawake(struct mmc_host *host, int sleep)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         struct mmc_card *card = host->card;
         int err;
 
         if (sleep)
                 mmc_deselect_cards(host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SLEEP_AWAKE;
         cmd.arg = card->rca << 16;
         if (sleep)
@@ -97,7 +93,7 @@ int mmc_card_sleepawake(struct mmc_host *host, int sleep)
 int mmc_go_idle(struct mmc_host *host)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         /*
          * Non-SPI hosts need to prevent chipselect going active during
@@ -105,7 +101,7 @@ int mmc_go_idle(struct mmc_host *host)
          * that in case of hardware that won't pull up DAT3/nCS otherwise.
          *
          * SPI hosts ignore ios.chip_select; it's managed according to
-         * rules that must accomodate non-MMC slaves which this layer
+         * rules that must accommodate non-MMC slaves which this layer
          * won't even know about.
          */
         if (!mmc_host_is_spi(host)) {
@@ -113,8 +109,6 @@ int mmc_go_idle(struct mmc_host *host)
                 mmc_delay(1);
         }
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_GO_IDLE_STATE;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
@@ -135,13 +129,11 @@ int mmc_go_idle(struct mmc_host *host)
 
 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SEND_OP_COND;
         cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
@@ -178,13 +170,11 @@ int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!cid);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_ALL_SEND_CID;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
@@ -201,13 +191,11 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 int mmc_set_relative_addr(struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SET_RELATIVE_ADDR;
         cmd.arg = card->rca << 16;
         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
@@ -223,13 +211,11 @@ static int
 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!cxd);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = opcode;
         cmd.arg = arg;
         cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
@@ -247,9 +233,9 @@ static int
 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
                 u32 opcode, void *buf, unsigned len)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
         void *data_buf;
 
@@ -260,10 +246,6 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         if (data_buf == NULL)
                 return -ENOMEM;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
@@ -355,11 +337,9 @@ int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
 
 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SPI_READ_OCR;
         cmd.arg = highcap ? (1 << 30) : 0;
         cmd.flags = MMC_RSP_SPI_R3;
@@ -372,11 +352,9 @@ int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
 
 int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SPI_CRC_ON_OFF;
         cmd.flags = MMC_RSP_SPI_R1;
         cmd.arg = use_crc;
@@ -387,23 +365,34 @@ int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
         return err;
 }
 
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
+/**
+ *      mmc_switch - modify EXT_CSD register
+ *      @card: the MMC card associated with the data transfer
+ *      @set: cmd set values
+ *      @index: EXT_CSD register index
+ *      @value: value to program into EXT_CSD register
+ *      @timeout_ms: timeout (ms) for operation performed by register write,
+ *                   timeout of zero implies maximum possible timeout
+ *
+ *      Modifies the EXT_CSD register for selected card.
+ */
+int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+               unsigned int timeout_ms)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         u32 status;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SWITCH;
         cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
                   (index << 16) |
                   (value << 8) |
                   set;
         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        cmd.cmd_timeout_ms = timeout_ms;
 
         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
         if (err)
@@ -433,17 +422,16 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(mmc_switch);
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = MMC_SEND_STATUS;
         if (!mmc_host_is_spi(card->host))
                 cmd.arg = card->rca << 16;
@@ -462,3 +450,100 @@ int mmc_send_status(struct mmc_card *card, u32 *status)
         return 0;
 }
 
+static int
+mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
+                  u8 len)
+{
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
+        struct scatterlist sg;
+        u8 *data_buf;
+        u8 *test_buf;
+        int i, err;
+        static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
+        static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
+
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(len, GFP_KERNEL);
+        if (!data_buf)
+                return -ENOMEM;
+
+        if (len == 8)
+                test_buf = testdata_8bit;
+        else if (len == 4)
+                test_buf = testdata_4bit;
+        else {
+                printk(KERN_ERR "%s: Invalid bus_width %d\n",
+                       mmc_hostname(host), len);
+                kfree(data_buf);
+                return -EINVAL;
+        }
+
+        if (opcode == MMC_BUS_TEST_W)
+                memcpy(data_buf, test_buf, len);
+
+        mrq.cmd = &cmd;
+        mrq.data = &data;
+        cmd.opcode = opcode;
+        cmd.arg = 0;
+
+        /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
+         * rely on callers to never use this with "native" calls for reading
+         * CSD or CID.  Native versions of those commands use the R2 type,
+         * not R1 plus a data block.
+         */
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+
+        data.blksz = len;
+        data.blocks = 1;
+        if (opcode == MMC_BUS_TEST_R)
+                data.flags = MMC_DATA_READ;
+        else
+                data.flags = MMC_DATA_WRITE;
+
+        data.sg = &sg;
+        data.sg_len = 1;
+        sg_init_one(&sg, data_buf, len);
+        mmc_wait_for_req(host, &mrq);
+        err = 0;
+        if (opcode == MMC_BUS_TEST_R) {
+                for (i = 0; i < len / 4; i++)
+                        if ((test_buf[i] ^ data_buf[i]) != 0xff) {
+                                err = -EIO;
+                                break;
+                        }
+        }
+        kfree(data_buf);
+
+        if (cmd.error)
+                return cmd.error;
+        if (data.error)
+                return data.error;
+
+        return err;
+}
+
+int mmc_bus_test(struct mmc_card *card, u8 bus_width)
+{
+        int err, width;
+
+        if (bus_width == MMC_BUS_WIDTH_8)
+                width = 8;
+        else if (bus_width == MMC_BUS_WIDTH_4)
+                width = 4;
+        else if (bus_width == MMC_BUS_WIDTH_1)
+                return 0; /* no need for test */
+        else
+                return -EINVAL;
+
+        /*
+         * Ignore errors from BUS_TEST_W.  BUS_TEST_R will fail if there
+         * is a problem.  This improves chances that the test will work.
+         */
+        mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
+        err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
+        return err;
+}
diff --git a/drivers/mmc/core/mmc_ops.h b/drivers/mmc/core/mmc_ops.h
index 653eb8e84178..9276946fa5b7 100644
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -20,12 +20,12 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid);
 int mmc_set_relative_addr(struct mmc_card *card);
 int mmc_send_csd(struct mmc_card *card, u32 *csd);
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value);
 int mmc_send_status(struct mmc_card *card, u32 *status);
 int mmc_send_cid(struct mmc_host *host, u32 *cid);
 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp);
 int mmc_spi_set_crc(struct mmc_host *host, int use_crc);
 int mmc_card_sleepawake(struct mmc_host *host, int sleep);
+int mmc_bus_test(struct mmc_card *card, u8 bus_width);
 
 #endif
 
diff --git a/drivers/mmc/core/quirks.c b/drivers/mmc/core/quirks.c
new file mode 100644
index 000000000000..3a596217029e
--- /dev/null
+++ b/drivers/mmc/core/quirks.c
@@ -0,0 +1,79 @@
+/*
+ *  This file contains work-arounds for many known SD/MMC
+ *  and SDIO hardware bugs.
+ *
+ *  Copyright (c) 2011 Andrei Warkentin <andreiw@motorola.com>
+ *  Copyright (c) 2011 Pierre Tardy <tardyp@gmail.com>
+ *  Inspired from pci fixup code:
+ *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/mmc/card.h>
+
+#ifndef SDIO_VENDOR_ID_TI
+#define SDIO_VENDOR_ID_TI               0x0097
+#endif
+
+#ifndef SDIO_DEVICE_ID_TI_WL1271
+#define SDIO_DEVICE_ID_TI_WL1271        0x4076
+#endif
+
+/*
+ * This hook just adds a quirk for all sdio devices
+ */
+static void add_quirk_for_sdio_devices(struct mmc_card *card, int data)
+{
+        if (mmc_card_sdio(card))
+                card->quirks |= data;
+}
+
+static const struct mmc_fixup mmc_fixup_methods[] = {
+        /* by default sdio devices are considered CLK_GATING broken */
+        /* good cards will be whitelisted as they are tested */
+        SDIO_FIXUP(SDIO_ANY_ID, SDIO_ANY_ID,
+                   add_quirk_for_sdio_devices,
+                   MMC_QUIRK_BROKEN_CLK_GATING),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   remove_quirk, MMC_QUIRK_BROKEN_CLK_GATING),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   add_quirk, MMC_QUIRK_NONSTD_FUNC_IF),
+
+        SDIO_FIXUP(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                   add_quirk, MMC_QUIRK_DISABLE_CD),
+
+        END_FIXUP
+};
+
+void mmc_fixup_device(struct mmc_card *card, const struct mmc_fixup *table)
+{
+        const struct mmc_fixup *f;
+        u64 rev = cid_rev_card(card);
+
+        /* Non-core specific workarounds. */
+        if (!table)
+                table = mmc_fixup_methods;
+
+        for (f = table; f->vendor_fixup; f++) {
+                if ((f->manfid == CID_MANFID_ANY ||
+                     f->manfid == card->cid.manfid) &&
+                    (f->oemid == CID_OEMID_ANY ||
+                     f->oemid == card->cid.oemid) &&
+                    (f->name == CID_NAME_ANY ||
+                     !strncmp(f->name, card->cid.prod_name,
+                              sizeof(card->cid.prod_name))) &&
+                    (f->cis_vendor == card->cis.vendor ||
+                     f->cis_vendor == (u16) SDIO_ANY_ID) &&
+                    (f->cis_device == card->cis.device ||
+                     f->cis_device == (u16) SDIO_ANY_ID) &&
+                    rev >= f->rev_start && rev <= f->rev_end) {
+                        dev_dbg(&card->dev, "calling %pF\n", f->vendor_fixup);
+                        f->vendor_fixup(card, f->data);
+                }
+        }
+}
+EXPORT_SYMBOL(mmc_fixup_device);
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 0f5241085557..ff2774128aa9 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -21,6 +21,7 @@
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
+#include "sd.h"
 #include "sd_ops.h"
 
 static const unsigned int tran_exp[] = {
@@ -129,7 +130,7 @@ static int mmc_decode_csd(struct mmc_card *card)
                 break;
         case 1:
                 /*
-                 * This is a block-addressed SDHC card. Most
+                 * This is a block-addressed SDHC or SDXC card. Most
                  * interesting fields are unused and have fixed
                  * values. To avoid getting tripped by buggy cards,
                  * we assume those fixed values ourselves.
@@ -143,6 +144,11 @@ static int mmc_decode_csd(struct mmc_card *card)
                 e = UNSTUFF_BITS(resp, 96, 3);
                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+                csd->c_size       = UNSTUFF_BITS(resp, 48, 22);
+
+                /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
+                if (csd->c_size >= 0xFFFF)
+                        mmc_card_set_ext_capacity(card);
 
                 m = UNSTUFF_BITS(resp, 48, 22);
                 csd->capacity     = (1 + m) << 10;
@@ -188,12 +194,17 @@ static int mmc_decode_scr(struct mmc_card *card)
 
         scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
         scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
+        if (scr->sda_vsn == SCR_SPEC_VER_2)
+                /* Check if Physical Layer Spec v3.0 is supported */
+                scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 
         if (UNSTUFF_BITS(resp, 55, 1))
                 card->erased_byte = 0xFF;
         else
                 card->erased_byte = 0x0;
 
+        if (scr->sda_spec3)
+                scr->cmds = UNSTUFF_BITS(resp, 32, 2);
         return 0;
 }
 
@@ -273,29 +284,74 @@ static int mmc_read_switch(struct mmc_card *card)
         status = kmalloc(64, GFP_KERNEL);
         if (!status) {
                 printk(KERN_ERR "%s: could not allocate a buffer for "
-                        "switch capabilities.\n", mmc_hostname(card->host));
+                        "switch capabilities.\n",
+                        mmc_hostname(card->host));
                 return -ENOMEM;
         }
 
+        /* Find out the supported Bus Speed Modes. */
         err = mmc_sd_switch(card, 0, 0, 1, status);
         if (err) {
-                /* If the host or the card can't do the switch,
-                 * fail more gracefully. */
-                if ((err != -EINVAL)
-                 && (err != -ENOSYS)
-                 && (err != -EFAULT))
+                /*
+                 * If the host or the card can't do the switch,
+                 * fail more gracefully.
+                 */
+                if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
                         goto out;
 
-                printk(KERN_WARNING "%s: problem reading switch "
-                        "capabilities, performance might suffer.\n",
+                printk(KERN_WARNING "%s: problem reading Bus Speed modes.\n",
                         mmc_hostname(card->host));
                 err = 0;
 
                 goto out;
         }
 
-        if (status[13] & 0x02)
-                card->sw_caps.hs_max_dtr = 50000000;
+        if (card->scr.sda_spec3) {
+                card->sw_caps.sd3_bus_mode = status[13];
+
+                /* Find out Driver Strengths supported by the card */
+                err = mmc_sd_switch(card, 0, 2, 1, status);
+                if (err) {
+                        /*
+                         * If the host or the card can't do the switch,
+                         * fail more gracefully.
+                         */
+                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
+                                goto out;
+
+                        printk(KERN_WARNING "%s: problem reading "
+                                "Driver Strength.\n",
+                                mmc_hostname(card->host));
+                        err = 0;
+
+                        goto out;
+                }
+
+                card->sw_caps.sd3_drv_type = status[9];
+
+                /* Find out Current Limits supported by the card */
+                err = mmc_sd_switch(card, 0, 3, 1, status);
+                if (err) {
+                        /*
+                         * If the host or the card can't do the switch,
+                         * fail more gracefully.
+                         */
+                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
+                                goto out;
+
+                        printk(KERN_WARNING "%s: problem reading "
+                                "Current Limit.\n",
+                                mmc_hostname(card->host));
+                        err = 0;
+
+                        goto out;
+                }
+
+                card->sw_caps.sd3_curr_limit = status[7];
+        } else {
+                if (status[13] & 0x02)
+                        card->sw_caps.hs_max_dtr = 50000000;
+        }
 
 out:
         kfree(status);
@@ -351,6 +407,232 @@ out:
         return err;
 }
 
+static int sd_select_driver_type(struct mmc_card *card, u8 *status)
+{
+        int host_drv_type = 0, card_drv_type = 0;
+        int err;
+
+        /*
+         * If the host doesn't support any of the Driver Types A,C or D,
+         * default Driver Type B is used.
+         */
+        if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
+            | MMC_CAP_DRIVER_TYPE_D)))
+                return 0;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_A) {
+                host_drv_type = MMC_SET_DRIVER_TYPE_A;
+                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_A;
+                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_B)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_B;
+                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
+        } else if (card->host->caps & MMC_CAP_DRIVER_TYPE_C) {
+                host_drv_type = MMC_SET_DRIVER_TYPE_C;
+                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
+        } else if (!(card->host->caps & MMC_CAP_DRIVER_TYPE_D)) {
+                /*
+                 * If we are here, that means only the default driver type
+                 * B is supported by the host.
+                 */
+                host_drv_type = MMC_SET_DRIVER_TYPE_B;
+                if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_B)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_B;
+                else if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                        card_drv_type = MMC_SET_DRIVER_TYPE_C;
+        }
+
+        err = mmc_sd_switch(card, 1, 2, card_drv_type, status);
+        if (err)
+                return err;
+
+        if ((status[15] & 0xF) != card_drv_type) {
+                printk(KERN_WARNING "%s: Problem setting driver strength!\n",
+                        mmc_hostname(card->host));
+                return 0;
+        }
+
+        mmc_set_driver_type(card->host, host_drv_type);
+
+        return 0;
+}
+
+static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+{
+        unsigned int bus_speed = 0, timing = 0;
+        int err;
+
+        /*
+         * If the host doesn't support any of the UHS-I modes, fallback on
+         * default speed.
+         */
+        if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
+                return 0;
+
+        if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
+            (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
+                        bus_speed = UHS_SDR104_BUS_SPEED;
+                        timing = MMC_TIMING_UHS_SDR104;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+        } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
+                        bus_speed = UHS_DDR50_BUS_SPEED;
+                        timing = MMC_TIMING_UHS_DDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR50)) {
+                        bus_speed = UHS_SDR50_BUS_SPEED;
+                        timing = MMC_TIMING_UHS_SDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
+                        bus_speed = UHS_SDR25_BUS_SPEED;
+                        timing = MMC_TIMING_UHS_SDR25;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
+                    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR12)) {
+                        bus_speed = UHS_SDR12_BUS_SPEED;
+                        timing = MMC_TIMING_UHS_SDR12;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+        }
+
+        card->sd_bus_speed = bus_speed;
+        err = mmc_sd_switch(card, 1, 0, bus_speed, status);
+        if (err)
+                return err;
+
+        if ((status[16] & 0xF) != bus_speed)
+                printk(KERN_WARNING "%s: Problem setting bus speed mode!\n",
+                        mmc_hostname(card->host));
+        else {
+                mmc_set_timing(card->host, timing);
+                mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
+        }
+
+        return 0;
+}
+
+static int sd_set_current_limit(struct mmc_card *card, u8 *status)
+{
+        int current_limit = 0;
+        int err;
+
+        /*
+         * Current limit switch is only defined for SDR50, SDR104, and DDR50
+         * bus speed modes. For other bus speed modes, we set the default
+         * current limit of 200mA.
+         */
+        if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) ||
+            (card->sd_bus_speed == UHS_SDR104_BUS_SPEED) ||
+            (card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) {
+                if (card->host->caps & MMC_CAP_MAX_CURRENT_800) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
+                                current_limit = SD_SET_CURRENT_LIMIT_800;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_600)
+                                current_limit = SD_SET_CURRENT_LIMIT_600;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
+                                current_limit = SD_SET_CURRENT_LIMIT_600;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
+                                current_limit = SD_SET_CURRENT_LIMIT_400;
+                        else if (card->sw_caps.sd3_curr_limit &
+                                        SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) {
+                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
+                                current_limit = SD_SET_CURRENT_LIMIT_200;
+                }
+        } else
+                current_limit = SD_SET_CURRENT_LIMIT_200;
+
+        err = mmc_sd_switch(card, 1, 3, current_limit, status);
+        if (err)
+                return err;
+
+        if (((status[15] >> 4) & 0x0F) != current_limit)
+                printk(KERN_WARNING "%s: Problem setting current limit!\n",
+                        mmc_hostname(card->host));
+
+        return 0;
+}
+
+/*
+ * UHS-I specific initialization procedure
+ */
+static int mmc_sd_init_uhs_card(struct mmc_card *card)
+{
+        int err;
+        u8 *status;
+
+        if (!card->scr.sda_spec3)
+                return 0;
+
+        if (!(card->csd.cmdclass & CCC_SWITCH))
+                return 0;
+
+        status = kmalloc(64, GFP_KERNEL);
+        if (!status) {
+                printk(KERN_ERR "%s: could not allocate a buffer for "
+                        "switch capabilities.\n", mmc_hostname(card->host));
+                return -ENOMEM;
+        }
+
+        /* Set 4-bit bus width */
+        if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
+            (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
+                if (err)
+                        goto out;
+
+                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+        }
+
+        /* Set the driver strength for the card */
+        err = sd_select_driver_type(card, status);
+        if (err)
+                goto out;
+
+        /* Set bus speed mode of the card */
+        err = sd_set_bus_speed_mode(card, status);
+        if (err)
+                goto out;
+
+        /* Set current limit for the card */
+        err = sd_set_current_limit(card, status);
+        if (err)
+                goto out;
+
+        /* SPI mode doesn't define CMD19 */
+        if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
+                err = card->host->ops->execute_tuning(card->host);
+
+out:
+        kfree(status);
+
+        return err;
+}
+
 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
         card->raw_cid[2], card->raw_cid[3]);
 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
@@ -399,7 +681,7 @@ struct device_type sd_type = {
 /*
  * Fetch CID from card.
  */
-int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid)
+int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 {
         int err;
 
@@ -419,12 +701,39 @@ int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid)
          */
         err = mmc_send_if_cond(host, ocr);
         if (!err)
-                ocr |= 1 << 30;
+                ocr |= SD_OCR_CCS;
+
+        /*
+         * If the host supports one of UHS-I modes, request the card
+         * to switch to 1.8V signaling level.
+         */
+        if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))
+                ocr |= SD_OCR_S18R;
+
+        /* If the host can supply more than 150mA, XPC should be set to 1. */
+        if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 |
+            MMC_CAP_SET_XPC_180))
+                ocr |= SD_OCR_XPC;
 
-        err = mmc_send_app_op_cond(host, ocr, NULL);
+try_again:
+        err = mmc_send_app_op_cond(host, ocr, rocr);
         if (err)
                 return err;
 
+        /*
+         * In case CCS and S18A in the response is set, start Signal Voltage
+         * Switch procedure. SPI mode doesn't support CMD11.
+         */
+        if (!mmc_host_is_spi(host) && rocr &&
+           ((*rocr & 0x41000000) == 0x41000000)) {
+                err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true);
+                if (err) {
+                        ocr &= ~SD_OCR_S18R;
+                        goto try_again;
+                }
+        }
+
         if (mmc_host_is_spi(host))
                 err = mmc_send_cid(host, cid);
         else
@@ -552,11 +861,12 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         struct mmc_card *card;
         int err;
         u32 cid[4];
+        u32 rocr = 0;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
-        err = mmc_sd_get_cid(host, ocr, cid);
+        err = mmc_sd_get_cid(host, ocr, cid, &rocr);
         if (err)
                 return err;
 
@@ -609,30 +919,47 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         if (err)
                 goto free_card;
 
-        /*
-         * Attempt to change to high-speed (if supported)
-         */
-        err = mmc_sd_switch_hs(card);
-        if (err > 0)
-                mmc_sd_go_highspeed(card);
-        else if (err)
-                goto free_card;
+        /* Initialization sequence for UHS-I cards */
+        if (rocr & SD_ROCR_S18A) {
+                err = mmc_sd_init_uhs_card(card);
+                if (err)
+                        goto free_card;
 
-        /*
-         * Set bus speed.
-         */
-        mmc_set_clock(host, mmc_sd_get_max_clock(card));
+                /* Card is an ultra-high-speed card */
+                mmc_sd_card_set_uhs(card);
 
-        /*
-         * Switch to wider bus (if supported).
-         */
-        if ((host->caps & MMC_CAP_4_BIT_DATA) &&
-                (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
-                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
-                if (err)
+                /*
+                 * Since initialization is now complete, enable preset
+                 * value registers for UHS-I cards.
+                 */
+                if (host->ops->enable_preset_value)
+                        host->ops->enable_preset_value(host, true);
+        } else {
+                /*
+                 * Attempt to change to high-speed (if supported)
+                 */
+                err = mmc_sd_switch_hs(card);
+                if (err > 0)
+                        mmc_sd_go_highspeed(card);
+                else if (err)
                         goto free_card;
 
-                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+                /*
+                 * Set bus speed.
+                 */
+                mmc_set_clock(host, mmc_sd_get_max_clock(card));
+
+                /*
+                 * Switch to wider bus (if supported).
+                 */
+                if ((host->caps & MMC_CAP_4_BIT_DATA) &&
+                        (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                        err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
+                        if (err)
+                                goto free_card;
+
+                        mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+                }
         }
 
         host->card = card;
@@ -722,12 +1049,16 @@ static int mmc_sd_resume(struct mmc_host *host)
         return err;
 }
 
-static void mmc_sd_power_restore(struct mmc_host *host)
+static int mmc_sd_power_restore(struct mmc_host *host)
 {
+        int ret;
+
         host->card->state &= ~MMC_STATE_HIGHSPEED;
         mmc_claim_host(host);
-        mmc_sd_init_card(host, host->ocr, host->card);
+        ret = mmc_sd_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
+
+        return ret;
 }
 
 static const struct mmc_bus_ops mmc_sd_ops = {
@@ -750,7 +1081,7 @@ static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
+        if (!mmc_card_is_removable(host))
                 bus_ops = &mmc_sd_ops_unsafe;
         else
                 bus_ops = &mmc_sd_ops;
@@ -760,14 +1091,30 @@ static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 /*
  * Starting point for SD card init.
  */
-int mmc_attach_sd(struct mmc_host *host, u32 ocr)
+int mmc_attach_sd(struct mmc_host *host)
 {
         int err;
+        u32 ocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        /* Make sure we are at 3.3V signalling voltage */
+        err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
+        if (err)
+                return err;
+
+        /* Disable preset value enable if already set since last time */
+        if (host->ops->enable_preset_value)
+                host->ops->enable_preset_value(host, false);
+
+        err = mmc_send_app_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_sd_attach_bus_ops(host);
+        if (host->ocr_avail_sd)
+                host->ocr_avail = host->ocr_avail_sd;
 
         /*
          * We need to get OCR a different way for SPI.
@@ -791,7 +1138,8 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
                 ocr &= ~0x7F;
         }
 
-        if (ocr & MMC_VDD_165_195) {
+        if ((ocr & MMC_VDD_165_195) &&
+            !(host->ocr_avail_sd & MMC_VDD_165_195)) {
                 printk(KERN_WARNING "%s: SD card claims to support the "
                        "incompletely defined 'low voltage range'. This "
                        "will be ignored.\n", mmc_hostname(host));
@@ -816,20 +1164,20 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
                 goto err;
 
         mmc_release_host(host);
-
         err = mmc_add_card(host->card);
+        mmc_claim_host(host);
         if (err)
                 goto remove_card;
 
         return 0;
 
 remove_card:
+        mmc_release_host(host);
         mmc_remove_card(host->card);
         host->card = NULL;
         mmc_claim_host(host);
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising SD card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/sd.h b/drivers/mmc/core/sd.h
index 3d8800fa7600..4b34b24f3f76 100644
--- a/drivers/mmc/core/sd.h
+++ b/drivers/mmc/core/sd.h
@@ -5,7 +5,7 @@
 
 extern struct device_type sd_type;
 
-int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid);
+int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr);
 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card);
 void mmc_decode_cid(struct mmc_card *card);
 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 797cdb5887fd..021fed153804 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -9,6 +9,7 @@
  * your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 
@@ -20,10 +21,10 @@
 #include "core.h"
 #include "sd_ops.h"
 
-static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
+int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(card && (card->host != host));
@@ -48,6 +49,7 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(mmc_app_cmd);
 
 /**
  *      mmc_wait_for_app_cmd - start an application command and wait for
@@ -65,7 +67,7 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
         struct mmc_command *cmd, int retries)
 {
-        struct mmc_request mrq;
+        struct mmc_request mrq = {0};
 
         int i, err;
 
@@ -118,13 +120,11 @@ EXPORT_SYMBOL(mmc_wait_for_app_cmd);
 int mmc_app_set_bus_width(struct mmc_card *card, int width)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!card);
         BUG_ON(!card->host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_APP_SET_BUS_WIDTH;
         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
@@ -148,13 +148,11 @@ int mmc_app_set_bus_width(struct mmc_card *card, int width)
 
 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_APP_OP_COND;
         if (mmc_host_is_spi(host))
                 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
@@ -193,7 +191,7 @@ int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
         static const u8 test_pattern = 0xAA;
         u8 result_pattern;
@@ -225,13 +223,11 @@ int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
 {
         int err;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         BUG_ON(!host);
         BUG_ON(!rca);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_SEND_RELATIVE_ADDR;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
@@ -248,10 +244,11 @@ int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
 {
         int err;
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
+        void *data_buf;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
@@ -263,9 +260,12 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         if (err)
                 return err;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
+        if (data_buf == NULL)
+                return -ENOMEM;
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -280,12 +280,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, scr, 8);
+        sg_init_one(&sg, data_buf, 8);
 
         mmc_set_data_timeout(&data, card);
 
         mmc_wait_for_req(card->host, &mrq);
 
+        memcpy(scr, data_buf, sizeof(card->raw_scr));
+        kfree(data_buf);
+
         if (cmd.error)
                 return cmd.error;
         if (data.error)
@@ -300,9 +303,9 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         u8 value, u8 *resp)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -313,10 +316,6 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         mode = !!mode;
         value &= 0xF;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
@@ -349,9 +348,9 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
 int mmc_app_sd_status(struct mmc_card *card, void *ssr)
 {
         int err;
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -364,10 +363,6 @@ int mmc_app_sd_status(struct mmc_card *card, void *ssr)
         if (err)
                 return err;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
 
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index f332c52968b7..262fff019177 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -10,11 +10,13 @@
  */
 
 #include <linux/err.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
 
 #include "core.h"
 #include "bus.h"
@@ -30,6 +32,11 @@ static int sdio_read_fbr(struct sdio_func *func)
         int ret;
         unsigned char data;
 
+        if (mmc_card_nonstd_func_interface(func->card)) {
+                func->class = SDIO_CLASS_NONE;
+                return 0;
+        }
+
         ret = mmc_io_rw_direct(func->card, 0, 0,
                 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
         if (ret)
@@ -180,7 +187,7 @@ static int sdio_disable_cd(struct mmc_card *card)
         int ret;
         u8 ctrl;
 
-        if (!card->cccr.disable_cd)
+        if (!mmc_card_disable_cd(card))
                 return 0;
 
         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
@@ -362,8 +369,8 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 goto err;
         }
 
-        if (ocr & R4_MEMORY_PRESENT
-            && mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid) == 0) {
+        if ((ocr & R4_MEMORY_PRESENT) &&
+            mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid, NULL) == 0) {
                 card->type = MMC_TYPE_SD_COMBO;
 
                 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
@@ -394,6 +401,14 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 if (err)
                         goto remove;
 
+                /*
+                 * Update oldcard with the new RCA received from the SDIO
+                 * device -- we're doing this so that it's updated in the
+                 * "card" struct when oldcard overwrites that later.
+                 */
+                if (oldcard)
+                        oldcard->rca = card->rca;
+
                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
         }
 
@@ -456,8 +471,8 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                         return -ENOENT;
 
                 card = oldcard;
-                return 0;
         }
+        mmc_fixup_device(card, NULL);
 
         if (card->type == MMC_TYPE_SD_COMBO) {
                 err = mmc_sd_setup_card(host, card, oldcard != NULL);
@@ -546,6 +561,13 @@ static void mmc_sdio_detect(struct mmc_host *host)
         BUG_ON(!host);
         BUG_ON(!host->card);
 
+        /* Make sure card is powered before detecting it */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD) {
+                err = pm_runtime_get_sync(&host->card->dev);
+                if (err < 0)
+                        goto out;
+        }
+
         mmc_claim_host(host);
 
         /*
@@ -555,6 +577,21 @@ static void mmc_sdio_detect(struct mmc_host *host)
 
         mmc_release_host(host);
 
+        /*
+         * Tell PM core it's OK to power off the card now.
+         *
+         * The _sync variant is used in order to ensure that the card
+         * is left powered off in case an error occurred, and the card
+         * is going to be removed.
+         *
+         * Since there is no specific reason to believe a new user
+         * is about to show up at this point, the _sync variant is
+         * desirable anyway.
+         */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_sync(&host->card->dev);
+
+out:
         if (err) {
                 mmc_sdio_remove(host);
 
@@ -594,7 +631,7 @@ static int mmc_sdio_suspend(struct mmc_host *host)
                 }
         }
 
-        if (!err && host->pm_flags & MMC_PM_KEEP_POWER) {
+        if (!err && mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
                 mmc_claim_host(host);
                 sdio_disable_wide(host->card);
                 mmc_release_host(host);
@@ -605,23 +642,27 @@ static int mmc_sdio_suspend(struct mmc_host *host)
 
 static int mmc_sdio_resume(struct mmc_host *host)
 {
-        int i, err;
+        int i, err = 0;
 
         BUG_ON(!host);
         BUG_ON(!host->card);
 
         /* Basic card reinitialization. */
         mmc_claim_host(host);
-        err = mmc_sdio_init_card(host, host->ocr, host->card,
-                                 (host->pm_flags & MMC_PM_KEEP_POWER));
-        if (!err) {
-                /* We may have switched to 1-bit mode during suspend. */
+
+        /* No need to reinitialize powered-resumed nonremovable cards */
+        if (mmc_card_is_removable(host) || !mmc_card_keep_power(host))
+                err = mmc_sdio_init_card(host, host->ocr, host->card,
+                                        mmc_card_keep_power(host));
+        else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
+                /* We may have switched to 1-bit mode during suspend */
                 err = sdio_enable_4bit_bus(host->card);
                 if (err > 0) {
                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
                         err = 0;
                 }
         }
+
         if (!err && host->sdio_irqs)
                 mmc_signal_sdio_irq(host);
         mmc_release_host(host);
@@ -647,27 +688,90 @@ static int mmc_sdio_resume(struct mmc_host *host)
         return err;
 }
 
+static int mmc_sdio_power_restore(struct mmc_host *host)
+{
+        int ret;
+        u32 ocr;
+
+        BUG_ON(!host);
+        BUG_ON(!host->card);
+
+        mmc_claim_host(host);
+
+        /*
+         * Reset the card by performing the same steps that are taken by
+         * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
+         *
+         * sdio_reset() is technically not needed. Having just powered up the
+         * hardware, it should already be in reset state. However, some
+         * platforms (such as SD8686 on OLPC) do not instantly cut power,
+         * meaning that a reset is required when restoring power soon after
+         * powering off. It is harmless in other cases.
+         *
+         * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
+         * is not necessary for non-removable cards. However, it is required
+         * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
+         * harmless in other situations.
+         *
+         * With these steps taken, mmc_select_voltage() is also required to
+         * restore the correct voltage setting of the card.
+         */
+        sdio_reset(host);
+        mmc_go_idle(host);
+        mmc_send_if_cond(host, host->ocr_avail);
+
+        ret = mmc_send_io_op_cond(host, 0, &ocr);
+        if (ret)
+                goto out;
+
+        if (host->ocr_avail_sdio)
+                host->ocr_avail = host->ocr_avail_sdio;
+
+        host->ocr = mmc_select_voltage(host, ocr & ~0x7F);
+        if (!host->ocr) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = mmc_sdio_init_card(host, host->ocr, host->card,
+                                mmc_card_keep_power(host));
+        if (!ret && host->sdio_irqs)
+                mmc_signal_sdio_irq(host);
+
+out:
+        mmc_release_host(host);
+
+        return ret;
+}
+
 static const struct mmc_bus_ops mmc_sdio_ops = {
         .remove = mmc_sdio_remove,
         .detect = mmc_sdio_detect,
         .suspend = mmc_sdio_suspend,
         .resume = mmc_sdio_resume,
+        .power_restore = mmc_sdio_power_restore,
 };
 
 
 /*
  * Starting point for SDIO card init.
  */
-int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
+int mmc_attach_sdio(struct mmc_host *host)
 {
-        int err;
-        int i, funcs;
+        int err, i, funcs;
+        u32 ocr;
         struct mmc_card *card;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
+        err = mmc_send_io_op_cond(host, 0, &ocr);
+        if (err)
+                return err;
+
         mmc_attach_bus(host, &mmc_sdio_ops);
+        if (host->ocr_avail_sdio)
+                host->ocr_avail = host->ocr_avail_sdio;
 
         /*
          * Sanity check the voltages that the card claims to
@@ -699,6 +803,23 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
         card = host->card;
 
         /*
+         * Enable runtime PM only if supported by host+card+board
+         */
+        if (host->caps & MMC_CAP_POWER_OFF_CARD) {
+                /*
+                 * Let runtime PM core know our card is active
+                 */
+                err = pm_runtime_set_active(&card->dev);
+                if (err)
+                        goto remove;
+
+                /*
+                 * Enable runtime PM for this card
+                 */
+                pm_runtime_enable(&card->dev);
+        }
+
+        /*
          * The number of functions on the card is encoded inside
          * the ocr.
          */
@@ -712,13 +833,18 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                 err = sdio_init_func(host->card, i + 1);
                 if (err)
                         goto remove;
-        }
 
-        mmc_release_host(host);
+                /*
+                 * Enable Runtime PM for this func (if supported)
+                 */
+                if (host->caps & MMC_CAP_POWER_OFF_CARD)
+                        pm_runtime_enable(&card->sdio_func[i]->dev);
+        }
 
         /*
          * First add the card to the driver model...
          */
+        mmc_release_host(host);
         err = mmc_add_card(host->card);
         if (err)
                 goto remove_added;
@@ -732,6 +858,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
                         goto remove_added;
         }
 
+        mmc_claim_host(host);
         return 0;
 
 
@@ -741,11 +868,12 @@ remove_added:
         mmc_claim_host(host);
 remove:
         /* And with lock if it hasn't been added. */
+        mmc_release_host(host);
         if (host->card)
                 mmc_sdio_remove(host);
+        mmc_claim_host(host);
 err:
         mmc_detach_bus(host);
-        mmc_release_host(host);
 
         printk(KERN_ERR "%s: error %d whilst initialising SDIO card\n",
                 mmc_hostname(host), err);
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 4a890dcb95ab..d2565df8a7fb 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -14,8 +14,10 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
 #include <linux/mmc/sdio_func.h>
 
 #include "sdio_cis.h"
@@ -125,21 +127,51 @@ static int sdio_bus_probe(struct device *dev)
         if (!id)
                 return -ENODEV;
 
+        /* Unbound SDIO functions are always suspended.
+         * During probe, the function is set active and the usage count
+         * is incremented.  If the driver supports runtime PM,
+         * it should call pm_runtime_put_noidle() in its probe routine and
+         * pm_runtime_get_noresume() in its remove routine.
+         */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
+                ret = pm_runtime_get_sync(dev);
+                if (ret < 0)
+                        goto out;
+        }
+
         /* Set the default block size so the driver is sure it's something
          * sensible. */
         sdio_claim_host(func);
         ret = sdio_set_block_size(func, 0);
         sdio_release_host(func);
         if (ret)
-                return ret;
+                goto disable_runtimepm;
+
+        ret = drv->probe(func, id);
+        if (ret)
+                goto disable_runtimepm;
+
+        return 0;
 
-        return drv->probe(func, id);
+disable_runtimepm:
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_noidle(dev);
+out:
+        return ret;
 }
 
 static int sdio_bus_remove(struct device *dev)
 {
         struct sdio_driver *drv = to_sdio_driver(dev->driver);
         struct sdio_func *func = dev_to_sdio_func(dev);
+        int ret = 0;
+
+        /* Make sure card is powered before invoking ->remove() */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
+                ret = pm_runtime_get_sync(dev);
+                if (ret < 0)
+                        goto out;
+        }
 
         drv->remove(func);
 
@@ -151,9 +183,36 @@ static int sdio_bus_remove(struct device *dev)
                 sdio_release_host(func);
         }
 
-        return 0;
+        /* First, undo the increment made directly above */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_noidle(dev);
+
+        /* Then undo the runtime PM settings in sdio_bus_probe() */
+        if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+                pm_runtime_put_sync(dev);
+
+out:
+        return ret;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static const struct dev_pm_ops sdio_bus_pm_ops = {
+        SET_RUNTIME_PM_OPS(
+                pm_generic_runtime_suspend,
+                pm_generic_runtime_resume,
+                pm_generic_runtime_idle
+        )
+};
+
+#define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
+
+#else /* !CONFIG_PM_RUNTIME */
+
+#define SDIO_PM_OPS_PTR NULL
+
+#endif /* !CONFIG_PM_RUNTIME */
+
 static struct bus_type sdio_bus_type = {
         .name           = "sdio",
         .dev_attrs      = sdio_dev_attrs,
@@ -161,6 +220,7 @@ static struct bus_type sdio_bus_type = {
         .uevent         = sdio_bus_uevent,
         .probe          = sdio_bus_probe,
         .remove         = sdio_bus_remove,
+        .pm             = SDIO_PM_OPS_PTR,
 };
 
 int sdio_register_bus(void)
diff --git a/drivers/mmc/core/sdio_irq.c b/drivers/mmc/core/sdio_irq.c
index bb192f90e8e9..03ead028d2ce 100644
--- a/drivers/mmc/core/sdio_irq.c
+++ b/drivers/mmc/core/sdio_irq.c
@@ -31,6 +31,17 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
 {
         int i, ret, count;
         unsigned char pending;
+        struct sdio_func *func;
+
+        /*
+         * Optimization, if there is only 1 function interrupt registered
+         * call irq handler directly
+         */
+        func = card->sdio_single_irq;
+        if (func) {
+                func->irq_handler(func);
+                return 1;
+        }
 
         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending);
         if (ret) {
@@ -42,10 +53,10 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
         count = 0;
         for (i = 1; i <= 7; i++) {
                 if (pending & (1 << i)) {
-                        struct sdio_func *func = card->sdio_func[i - 1];
+                        func = card->sdio_func[i - 1];
                         if (!func) {
                                 printk(KERN_WARNING "%s: pending IRQ for "
-                                        "non-existant function\n",
+                                        "non-existent function\n",
                                         mmc_card_id(card));
                                 ret = -EINVAL;
                         } else if (func->irq_handler) {
@@ -186,6 +197,24 @@ static int sdio_card_irq_put(struct mmc_card *card)
         return 0;
 }
 
+/* If there is only 1 function registered set sdio_single_irq */
+static void sdio_single_irq_set(struct mmc_card *card)
+{
+        struct sdio_func *func;
+        int i;
+
+        card->sdio_single_irq = NULL;
+        if ((card->host->caps & MMC_CAP_SDIO_IRQ) &&
+            card->host->sdio_irqs == 1)
+                for (i = 0; i < card->sdio_funcs; i++) {
+                       func = card->sdio_func[i];
+                       if (func && func->irq_handler) {
+                               card->sdio_single_irq = func;
+                               break;
+                       }
+               }
+}
+
 /**
  *      sdio_claim_irq - claim the IRQ for a SDIO function
  *      @func: SDIO function
@@ -227,6 +256,7 @@ int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
         ret = sdio_card_irq_get(func->card);
         if (ret)
                 func->irq_handler = NULL;
+        sdio_single_irq_set(func->card);
 
         return ret;
 }
@@ -251,6 +281,7 @@ int sdio_release_irq(struct sdio_func *func)
         if (func->irq_handler) {
                 func->irq_handler = NULL;
                 sdio_card_irq_put(func->card);
+                sdio_single_irq_set(func->card);
         }
 
         ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index dea36d9c22e6..f087d876c573 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -21,13 +21,11 @@
 
 int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int i, err = 0;
 
         BUG_ON(!host);
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_IO_SEND_OP_COND;
         cmd.arg = ocr;
         cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
@@ -70,7 +68,7 @@ int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
         unsigned addr, u8 in, u8 *out)
 {
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
         int err;
 
         BUG_ON(!host);
@@ -80,8 +78,6 @@ static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
         if (addr & ~0x1FFFF)
                 return -EINVAL;
 
-        memset(&cmd, 0, sizeof(struct mmc_command));
-
         cmd.opcode = SD_IO_RW_DIRECT;
         cmd.arg = write ? 0x80000000 : 0x00000000;
         cmd.arg |= fn << 28;
@@ -125,9 +121,9 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
         struct scatterlist sg;
 
         BUG_ON(!card);
@@ -140,10 +136,6 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         if (addr & ~0x1FFFF)
                 return -EINVAL;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-
         mrq.cmd = &cmd;
         mrq.data = &data;