7 files changed, 176 insertions, 30 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 5005a6323165..61c6c0b8f0e0 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -984,6 +984,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,
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index 7745dea430b8..93f33973de39 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -43,6 +43,7 @@ void mmc_set_bus_width_ddr(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);
 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)
 {
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 8285842f19e9..5b7c99855635 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -400,6 +400,98 @@ 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;
+}
+
+/*
+ * 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);
+
+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],
@@ -448,10 +540,9 @@ 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;
-        u32 rocr;
 
         /*
          * Since we're changing the OCR value, we seem to
@@ -485,7 +576,7 @@ int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid)
                 ocr |= SD_OCR_XPC;
 
 try_again:
-        err = mmc_send_app_op_cond(host, ocr, &rocr);
+        err = mmc_send_app_op_cond(host, ocr, rocr);
         if (err)
                 return err;
 
@@ -493,7 +584,8 @@ try_again:
          * 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 & 0x41000000) == 0x41000000)) {
+        if (!mmc_host_is_spi(host) && rocr &&
+           ((*rocr & 0x41000000) == 0x41000000)) {
                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
                 if (err) {
                         ocr &= ~SD_OCR_S18R;
@@ -628,11 +720,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;
 
@@ -685,30 +778,37 @@ 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;
-
-        /*
-         * 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);
+        /* Initialization sequence for UHS-I cards */
+        if (rocr & SD_ROCR_S18A) {
+                err = mmc_sd_init_uhs_card(card);
                 if (err)
                         goto free_card;
+        } 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;
+
+                /*
+                 * Set bus speed.
+                 */
+                mmc_set_clock(host, mmc_sd_get_max_clock(card));
 
-                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
+                /*
+                 * 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;
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/sdio.c b/drivers/mmc/core/sdio.c
index 1e6095961500..4d0c15bfa514 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -369,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 ||
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 4e2031449a23..8072e16d6d46 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1245,6 +1245,25 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 
+        if (host->version >= SDHCI_SPEC_300) {
+                u16 ctrl_2;
+
+                ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+                if (!(ctrl_2 & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
+                        /*
+                         * We only need to set Driver Strength if the
+                         * preset value enable is not set.
+                         */
+                        ctrl_2 &= ~SDHCI_CTRL_DRV_TYPE_MASK;
+                        if (ios->drv_type == MMC_SET_DRIVER_TYPE_A)
+                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_A;
+                        else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C)
+                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_C;
+
+                        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
+                }
+        }
+
         /*
          * Some (ENE) controllers go apeshit on some ios operation,
          * signalling timeout and CRC errors even on CMD0. Resetting
@@ -2086,6 +2105,14 @@ int sdhci_add_host(struct sdhci_host *host)
         if (caps[1] & SDHCI_SUPPORT_DDR50)
                 mmc->caps |= MMC_CAP_UHS_DDR50;
 
+        /* Driver Type(s) (A, C, D) supported by the host */
+        if (caps[1] & SDHCI_DRIVER_TYPE_A)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
+        if (caps[1] & SDHCI_DRIVER_TYPE_C)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_C;
+        if (caps[1] & SDHCI_DRIVER_TYPE_D)
+                mmc->caps |= MMC_CAP_DRIVER_TYPE_D;
+
         ocr_avail = 0;
         /*
          * According to SD Host Controller spec v3.00, if the Host System
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 5cba2fea46e0..667bf8874be7 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -71,7 +71,7 @@
 #define  SDHCI_DATA_LVL_MASK    0x00F00000
 #define   SDHCI_DATA_LVL_SHIFT  20
 
-#define SDHCI_HOST_CONTROL      0x28
+#define SDHCI_HOST_CONTROL      0x28
 #define  SDHCI_CTRL_LED         0x01
 #define  SDHCI_CTRL_4BITBUS     0x02
 #define  SDHCI_CTRL_HISPD       0x04
@@ -150,6 +150,12 @@
 
 #define SDHCI_HOST_CONTROL2             0x3E
 #define  SDHCI_CTRL_VDD_180             0x0008
+#define  SDHCI_CTRL_DRV_TYPE_MASK       0x0030
+#define   SDHCI_CTRL_DRV_TYPE_B         0x0000
+#define   SDHCI_CTRL_DRV_TYPE_A         0x0010
+#define   SDHCI_CTRL_DRV_TYPE_C         0x0020
+#define   SDHCI_CTRL_DRV_TYPE_D         0x0030
+#define  SDHCI_CTRL_PRESET_VAL_ENABLE   0x8000
 
 #define SDHCI_CAPABILITIES      0x40
 #define  SDHCI_TIMEOUT_CLK_MASK 0x0000003F
@@ -173,6 +179,9 @@
 #define  SDHCI_SUPPORT_SDR50    0x00000001
 #define  SDHCI_SUPPORT_SDR104   0x00000002
 #define  SDHCI_SUPPORT_DDR50    0x00000004
+#define  SDHCI_DRIVER_TYPE_A    0x00000010
+#define  SDHCI_DRIVER_TYPE_C    0x00000020
+#define  SDHCI_DRIVER_TYPE_D    0x00000040
 
 #define SDHCI_CAPABILITIES_1    0x44