1 files changed, 122 insertions, 12 deletions

diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 9b82910b9dbb..3b5248567973 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -15,9 +15,11 @@
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/clk.h>
+#include <linux/gpio.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/sdhci-pltfm.h>
 #include <mach/hardware.h>
+#include <mach/esdhc.h>
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
@@ -30,6 +32,39 @@ static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, i
         writel(((readl(base) & ~(mask << shift)) | (val << shift)), base);
 }
 
+static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
+{
+        /* fake CARD_PRESENT flag on mx25/35 */
+        u32 val = readl(host->ioaddr + reg);
+
+        if (unlikely(reg == SDHCI_PRESENT_STATE)) {
+                struct esdhc_platform_data *boarddata =
+                                host->mmc->parent->platform_data;
+
+                if (boarddata && gpio_is_valid(boarddata->cd_gpio)
+                                && gpio_get_value(boarddata->cd_gpio))
+                        /* no card, if a valid gpio says so... */
+                        val &= SDHCI_CARD_PRESENT;
+                else
+                        /* ... in all other cases assume card is present */
+                        val |= SDHCI_CARD_PRESENT;
+        }
+
+        return val;
+}
+
+static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
+{
+        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE))
+                /*
+                 * these interrupts won't work with a custom card_detect gpio
+                 * (only applied to mx25/35)
+                 */
+                val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+
+        writel(val, host->ioaddr + reg);
+}
+
 static u16 esdhc_readw_le(struct sdhci_host *host, int reg)
 {
         if (unlikely(reg == SDHCI_HOST_VERSION))
@@ -100,10 +135,39 @@ static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
         return clk_get_rate(pltfm_host->clk) / 256 / 16;
 }
 
+static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
+{
+        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+
+        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+                return gpio_get_value(boarddata->wp_gpio);
+        else
+                return -ENOSYS;
+}
+
+static struct sdhci_ops sdhci_esdhc_ops = {
+        .read_w = esdhc_readw_le,
+        .write_w = esdhc_writew_le,
+        .write_b = esdhc_writeb_le,
+        .set_clock = esdhc_set_clock,
+        .get_max_clock = esdhc_pltfm_get_max_clock,
+        .get_min_clock = esdhc_pltfm_get_min_clock,
+};
+
+static irqreturn_t cd_irq(int irq, void *data)
+{
+        struct sdhci_host *sdhost = (struct sdhci_host *)data;
+
+        tasklet_schedule(&sdhost->card_tasklet);
+        return IRQ_HANDLED;
+};
+
 static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pdata)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
         struct clk *clk;
+        int err;
 
         clk = clk_get(mmc_dev(host->mmc), NULL);
         if (IS_ERR(clk)) {
@@ -116,32 +180,78 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
         if (cpu_is_mx35() || cpu_is_mx51())
                 host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
-        /* Fix errata ENGcm07207 which is present on i.MX25 and i.MX35 */
-        if (cpu_is_mx25() || cpu_is_mx35())
+        if (cpu_is_mx25() || cpu_is_mx35()) {
+                /* Fix errata ENGcm07207 present on i.MX25 and i.MX35 */
                 host->quirks |= SDHCI_QUIRK_NO_MULTIBLOCK;
+                /* write_protect can't be routed to controller, use gpio */
+                sdhci_esdhc_ops.get_ro = esdhc_pltfm_get_ro;
+        }
+
+        if (boarddata) {
+                err = gpio_request_one(boarddata->wp_gpio, GPIOF_IN, "ESDHC_WP");
+                if (err) {
+                        dev_warn(mmc_dev(host->mmc),
+                                "no write-protect pin available!\n");
+                        boarddata->wp_gpio = err;
+                }
+
+                err = gpio_request_one(boarddata->cd_gpio, GPIOF_IN, "ESDHC_CD");
+                if (err) {
+                        dev_warn(mmc_dev(host->mmc),
+                                "no card-detect pin available!\n");
+                        goto no_card_detect_pin;
+                }
+
+                /* i.MX5x has issues to be researched */
+                if (!cpu_is_mx25() && !cpu_is_mx35())
+                        goto not_supported;
+
+                err = request_irq(gpio_to_irq(boarddata->cd_gpio), cd_irq,
+                                 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                                 mmc_hostname(host->mmc), host);
+                if (err) {
+                        dev_warn(mmc_dev(host->mmc), "request irq error\n");
+                        goto no_card_detect_irq;
+                }
+
+                sdhci_esdhc_ops.write_l = esdhc_writel_le;
+                sdhci_esdhc_ops.read_l = esdhc_readl_le;
+                /* Now we have a working card_detect again */
+                host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+        }
+
+        return 0;
 
+ no_card_detect_irq:
+        gpio_free(boarddata->cd_gpio);
+ no_card_detect_pin:
+        boarddata->cd_gpio = err;
+ not_supported:
         return 0;
 }
 
 static void esdhc_pltfm_exit(struct sdhci_host *host)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+
+        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+                gpio_free(boarddata->wp_gpio);
+
+        if (boarddata && gpio_is_valid(boarddata->cd_gpio)) {
+                gpio_free(boarddata->cd_gpio);
+
+                if (!(host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION))
+                        free_irq(gpio_to_irq(boarddata->cd_gpio), host);
+        }
 
         clk_disable(pltfm_host->clk);
         clk_put(pltfm_host->clk);
 }
 
-static struct sdhci_ops sdhci_esdhc_ops = {
-        .read_w = esdhc_readw_le,
-        .write_w = esdhc_writew_le,
-        .write_b = esdhc_writeb_le,
-        .set_clock = esdhc_set_clock,
-        .get_max_clock = esdhc_pltfm_get_max_clock,
-        .get_min_clock = esdhc_pltfm_get_min_clock,
-};
-
 struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
-        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA,
+        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
+                        | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
         /* ADMA has issues. Might be fixable */
         .ops = &sdhci_esdhc_ops,
         .init = esdhc_pltfm_init,