Merge tag 'mmc-updates-for-3.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc

Pull MMC updates from Chris Ball:
 "MMC highlights for 3.12:

  Core:
   - Support Allocation Units 8MB-64MB in SD3.0, previous max was 4MB.
   - The slot-gpio helper can now handle GPIO debouncing card-detect.
   - Read supported voltages from DT "voltage-ranges" property.

  Drivers:
   - dw_mmc: Add support for ARC architecture, and support exynos5420.
   - mmc_spi: Support CD/RO GPIOs.
   - sh_mobile_sdhi: Add compatibility for more Renesas SoCs.
   - sh_mmcif: Add DT support for DMA channels"

* tag 'mmc-updates-for-3.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc: (50 commits)
  Revert "mmc: tmio-mmc: Remove .set_pwr() callback from platform data"
  mmc: dw_mmc: Add support for ARC
  mmc: sdhci-s3c: initialize host->quirks2 for using quirks2
  mmc: sdhci-s3c: fix the wrong register value, when clock is disabled
  mmc: esdhc: add support to get voltage from device-tree
  mmc: sdhci: get voltage from sdhc host
  mmc: core: parse voltage from device-tree
  mmc: omap_hsmmc: use the generic config for omap2plus devices
  mmc: omap_hsmmc: clear status flags before starting a new command
  mmc: dw_mmc: exynos: Add a new compatible string for exynos5420
  mmc: sh_mmcif: revision-specific CLK_CTRL2 handling
  mmc: sh_mmcif: revision-specific Command Completion Signal handling
  mmc: sh_mmcif: add support for Device Tree DMA bindings
  mmc: sh_mmcif: move header include from header into .c
  mmc: SDHI: add DT compatibility strings for further SoCs
  mmc: dw_mmc-pci: enable bus-mastering mode
  mmc: dw_mmc-pci: get resources from a proper BAR
  mmc: tmio-mmc: Remove .set_pwr() callback from platform data
  mmc: tmio-mmc: Remove .get_cd() callback from platform data
  mmc: sh_mobile_sdhi: Remove .set_pwr() callback from platform data
  ...

5 files changed, 67 insertions, 7 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 5d088551196b..bf18b6bfce48 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -27,6 +27,7 @@
 #include <linux/fault-inject.h>
 #include <linux/random.h>
 #include <linux/slab.h>
+#include <linux/of.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -1196,6 +1197,49 @@ u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
 }
 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
 
+#ifdef CONFIG_OF
+
+/**
+ * mmc_of_parse_voltage - return mask of supported voltages
+ * @np: The device node need to be parsed.
+ * @mask: mask of voltages available for MMC/SD/SDIO
+ *
+ * 1. Return zero on success.
+ * 2. Return negative errno: voltage-range is invalid.
+ */
+int mmc_of_parse_voltage(struct device_node *np, u32 *mask)
+{
+        const u32 *voltage_ranges;
+        int num_ranges, i;
+
+        voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges);
+        num_ranges = num_ranges / sizeof(*voltage_ranges) / 2;
+        if (!voltage_ranges || !num_ranges) {
+                pr_info("%s: voltage-ranges unspecified\n", np->full_name);
+                return -EINVAL;
+        }
+
+        for (i = 0; i < num_ranges; i++) {
+                const int j = i * 2;
+                u32 ocr_mask;
+
+                ocr_mask = mmc_vddrange_to_ocrmask(
+                                be32_to_cpu(voltage_ranges[j]),
+                                be32_to_cpu(voltage_ranges[j + 1]));
+                if (!ocr_mask) {
+                        pr_err("%s: voltage-range #%d is invalid\n",
+                                np->full_name, i);
+                        return -EINVAL;
+                }
+                *mask |= ocr_mask;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(mmc_of_parse_voltage);
+
+#endif /* CONFIG_OF */
+
 #ifdef CONFIG_REGULATOR
 
 /**
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 6fb6f77450cb..49bc403e31f0 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -374,7 +374,7 @@ int mmc_of_parse(struct mmc_host *host)
                         if (!(flags & OF_GPIO_ACTIVE_LOW))
                                 gpio_inv_cd = true;
 
-                        ret = mmc_gpio_request_cd(host, gpio);
+                        ret = mmc_gpio_request_cd(host, gpio, 0);
                         if (ret < 0) {
                                 dev_err(host->parent,
                                         "Failed to request CD GPIO #%d: %d!\n",
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 837fc7386e23..ef183483d5b6 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -531,6 +531,7 @@ mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
 
         data.sg = &sg;
         data.sg_len = 1;
+        mmc_set_data_timeout(&data, card);
         sg_init_one(&sg, data_buf, len);
         mmc_wait_for_req(host, &mrq);
         err = 0;
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 176d125f5b57..5e8823dc3ef6 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -215,7 +215,7 @@ static int mmc_decode_scr(struct mmc_card *card)
 static int mmc_read_ssr(struct mmc_card *card)
 {
         unsigned int au, es, et, eo;
-        int err, i;
+        int err, i, max_au;
         u32 *ssr;
 
         if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
@@ -239,12 +239,15 @@ static int mmc_read_ssr(struct mmc_card *card)
         for (i = 0; i < 16; i++)
                 ssr[i] = be32_to_cpu(ssr[i]);
 
+        /* SD3.0 increases max AU size to 64MB (0xF) from 4MB (0x9) */
+        max_au = card->scr.sda_spec3 ? 0xF : 0x9;
+
         /*
          * UNSTUFF_BITS only works with four u32s so we have to offset the
          * bitfield positions accordingly.
          */
         au = UNSTUFF_BITS(ssr, 428 - 384, 4);
-        if (au > 0 && au <= 9) {
+        if (au > 0 && au <= max_au) {
                 card->ssr.au = 1 << (au + 4);
                 es = UNSTUFF_BITS(ssr, 408 - 384, 16);
                 et = UNSTUFF_BITS(ssr, 402 - 384, 6);
@@ -942,13 +945,13 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         if (!mmc_host_is_spi(host)) {
                 err = mmc_send_relative_addr(host, &card->rca);
                 if (err)
-                        return err;
+                        goto free_card;
         }
 
         if (!oldcard) {
                 err = mmc_sd_get_csd(host, card);
                 if (err)
-                        return err;
+                        goto free_card;
 
                 mmc_decode_cid(card);
         }
@@ -959,7 +962,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         if (!mmc_host_is_spi(host)) {
                 err = mmc_select_card(card);
                 if (err)
-                        return err;
+                        goto free_card;
         }
 
         err = mmc_sd_setup_card(host, card, oldcard != NULL);
diff --git a/drivers/mmc/core/slot-gpio.c b/drivers/mmc/core/slot-gpio.c
index 324235105519..46596b71a32f 100644
--- a/drivers/mmc/core/slot-gpio.c
+++ b/drivers/mmc/core/slot-gpio.c
@@ -135,6 +135,7 @@ EXPORT_SYMBOL(mmc_gpio_request_ro);
  * mmc_gpio_request_cd - request a gpio for card-detection
  * @host: mmc host
  * @gpio: gpio number requested
+ * @debounce: debounce time in microseconds
  *
  * As devm_* managed functions are used in mmc_gpio_request_cd(), client
  * drivers do not need to explicitly call mmc_gpio_free_cd() for freeing up,
@@ -143,9 +144,14 @@ EXPORT_SYMBOL(mmc_gpio_request_ro);
  * switching for card-detection, they are responsible for calling
  * mmc_gpio_request_cd() and mmc_gpio_free_cd() as a pair on their own.
  *
+ * If GPIO debouncing is desired, set the debounce parameter to a non-zero
+ * value. The caller is responsible for ensuring that the GPIO driver associated
+ * with the GPIO supports debouncing, otherwise an error will be returned.
+ *
  * Returns zero on success, else an error.
  */
-int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio)
+int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio,
+                        unsigned int debounce)
 {
         struct mmc_gpio *ctx;
         int irq = gpio_to_irq(gpio);
@@ -167,6 +173,12 @@ int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio)
                  */
                 return ret;
 
+        if (debounce) {
+                ret = gpio_set_debounce(gpio, debounce);
+                if (ret < 0)
+                        return ret;
+        }
+
         /*
          * Even if gpio_to_irq() returns a valid IRQ number, the platform might
          * still prefer to poll, e.g., because that IRQ number is already used