1 files changed, 79 insertions, 154 deletions

diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index e07df812ff1..4dc0028086a 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -24,8 +24,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
-#include <linux/pinctrl/consumer.h>
-#include <linux/platform_data/mmc-esdhc-imx.h>
+#include <mach/esdhc.h>
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
@@ -33,16 +32,6 @@
 /* VENDOR SPEC register */
 #define SDHCI_VENDOR_SPEC               0xC0
 #define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
-#define SDHCI_WTMK_LVL                  0x44
-#define SDHCI_MIX_CTRL                  0x48
-
-/*
- * There is an INT DMA ERR mis-match between eSDHC and STD SDHC SPEC:
- * Bit25 is used in STD SPEC, and is reserved in fsl eSDHC design,
- * but bit28 is used as the INT DMA ERR in fsl eSDHC design.
- * Define this macro DMA error INT for fsl eSDHC
- */
-#define SDHCI_INT_VENDOR_SPEC_DMA_ERR   0x10000000
 
 /*
  * The CMDTYPE of the CMD register (offset 0xE) should be set to
@@ -62,18 +51,13 @@ enum imx_esdhc_type {
         IMX35_ESDHC,
         IMX51_ESDHC,
         IMX53_ESDHC,
-        IMX6Q_USDHC,
 };
 
 struct pltfm_imx_data {
         int flags;
         u32 scratchpad;
         enum imx_esdhc_type devtype;
-        struct pinctrl *pinctrl;
         struct esdhc_platform_data boarddata;
-        struct clk *clk_ipg;
-        struct clk *clk_ahb;
-        struct clk *clk_per;
 };
 
 static struct platform_device_id imx_esdhc_devtype[] = {
@@ -90,9 +74,6 @@ static struct platform_device_id imx_esdhc_devtype[] = {
                 .name = "sdhci-esdhc-imx53",
                 .driver_data = IMX53_ESDHC,
         }, {
-                .name = "sdhci-usdhc-imx6q",
-                .driver_data = IMX6Q_USDHC,
-        }, {
                 /* sentinel */
         }
 };
@@ -103,7 +84,6 @@ static const struct of_device_id imx_esdhc_dt_ids[] = {
         { .compatible = "fsl,imx35-esdhc", .data = &imx_esdhc_devtype[IMX35_ESDHC], },
         { .compatible = "fsl,imx51-esdhc", .data = &imx_esdhc_devtype[IMX51_ESDHC], },
         { .compatible = "fsl,imx53-esdhc", .data = &imx_esdhc_devtype[IMX53_ESDHC], },
-        { .compatible = "fsl,imx6q-usdhc", .data = &imx_esdhc_devtype[IMX6Q_USDHC], },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, imx_esdhc_dt_ids);
@@ -128,11 +108,6 @@ static inline int is_imx53_esdhc(struct pltfm_imx_data *data)
         return data->devtype == IMX53_ESDHC;
 }
 
-static inline int is_imx6q_usdhc(struct pltfm_imx_data *data)
-{
-        return data->devtype == IMX6Q_USDHC;
-}
-
 static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, int reg)
 {
         void __iomem *base = host->ioaddr + (reg & ~0x3);
@@ -160,27 +135,6 @@ static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
                         val |= SDHCI_CARD_PRESENT;
         }
 
-        if (unlikely(reg == SDHCI_CAPABILITIES)) {
-                /* In FSL esdhc IC module, only bit20 is used to indicate the
-                 * ADMA2 capability of esdhc, but this bit is messed up on
-                 * some SOCs (e.g. on MX25, MX35 this bit is set, but they
-                 * don't actually support ADMA2). So set the BROKEN_ADMA
-                 * uirk on MX25/35 platforms.
-                 */
-
-                if (val & SDHCI_CAN_DO_ADMA1) {
-                        val &= ~SDHCI_CAN_DO_ADMA1;
-                        val |= SDHCI_CAN_DO_ADMA2;
-                }
-        }
-
-        if (unlikely(reg == SDHCI_INT_STATUS)) {
-                if (val & SDHCI_INT_VENDOR_SPEC_DMA_ERR) {
-                        val &= ~SDHCI_INT_VENDOR_SPEC_DMA_ERR;
-                        val |= SDHCI_INT_ADMA_ERROR;
-                }
-        }
-
         return val;
 }
 
@@ -225,28 +179,13 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
                         writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
         }
 
-        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
-                if (val & SDHCI_INT_ADMA_ERROR) {
-                        val &= ~SDHCI_INT_ADMA_ERROR;
-                        val |= SDHCI_INT_VENDOR_SPEC_DMA_ERR;
-                }
-        }
-
         writel(val, host->ioaddr + reg);
 }
 
 static u16 esdhc_readw_le(struct sdhci_host *host, int reg)
 {
-        if (unlikely(reg == SDHCI_HOST_VERSION)) {
-                u16 val = readw(host->ioaddr + (reg ^ 2));
-                /*
-                 * uSDHC supports SDHCI v3.0, but it's encoded as value
-                 * 0x3 in host controller version register, which violates
-                 * SDHCI_SPEC_300 definition.  Work it around here.
-                 */
-                if ((val & SDHCI_SPEC_VER_MASK) == 3)
-                        return --val;
-        }
+        if (unlikely(reg == SDHCI_HOST_VERSION))
+                reg ^= 2;
 
         return readw(host->ioaddr + reg);
 }
@@ -274,21 +213,11 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
                 imx_data->scratchpad = val;
                 return;
         case SDHCI_COMMAND:
-                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION ||
-                     host->cmd->opcode == MMC_SET_BLOCK_COUNT) &&
-                    (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
+                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION)
+                        && (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
                         val |= SDHCI_CMD_ABORTCMD;
-
-                if (is_imx6q_usdhc(imx_data)) {
-                        u32 m = readl(host->ioaddr + SDHCI_MIX_CTRL);
-                        m = imx_data->scratchpad | (m & 0xffff0000);
-                        writel(m, host->ioaddr + SDHCI_MIX_CTRL);
-                        writel(val << 16,
-                               host->ioaddr + SDHCI_TRANSFER_MODE);
-                } else {
-                        writel(val << 16 | imx_data->scratchpad,
-                               host->ioaddr + SDHCI_TRANSFER_MODE);
-                }
+                writel(val << 16 | imx_data->scratchpad,
+                        host->ioaddr + SDHCI_TRANSFER_MODE);
                 return;
         case SDHCI_BLOCK_SIZE:
                 val &= ~SDHCI_MAKE_BLKSZ(0x7, 0);
@@ -299,8 +228,6 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
 
 static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
 {
-        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct pltfm_imx_data *imx_data = pltfm_host->priv;
         u32 new_val;
 
         switch (reg) {
@@ -315,13 +242,10 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                 new_val = val & (SDHCI_CTRL_LED | \
                                 SDHCI_CTRL_4BITBUS | \
                                 SDHCI_CTRL_D3CD);
-                /* ensure the endianness */
+                /* ensure the endianess */
                 new_val |= ESDHC_HOST_CONTROL_LE;
-                /* bits 8&9 are reserved on mx25 */
-                if (!is_imx25_esdhc(imx_data)) {
-                        /* DMA mode bits are shifted */
-                        new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
-                }
+                /* DMA mode bits are shifted */
+                new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
 
                 esdhc_clrset_le(host, 0xffff, new_val, reg);
                 return;
@@ -387,10 +311,9 @@ static struct sdhci_ops sdhci_esdhc_ops = {
 };
 
 static struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
-        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_NO_HISPD_BIT
-                        | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
-                        | SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC
+        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
                         | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+        /* ADMA has issues. Might be fixable */
         .ops = &sdhci_esdhc_ops,
 };
 
@@ -403,7 +326,7 @@ static irqreturn_t cd_irq(int irq, void *data)
 };
 
 #ifdef CONFIG_OF
-static int
+static int __devinit
 sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
                          struct esdhc_platform_data *boarddata)
 {
@@ -412,7 +335,7 @@ sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
         if (!np)
                 return -ENODEV;
 
-        if (of_get_property(np, "non-removable", NULL))
+        if (of_get_property(np, "fsl,card-wired", NULL))
                 boarddata->cd_type = ESDHC_CD_PERMANENT;
 
         if (of_get_property(np, "fsl,cd-controller", NULL))
@@ -440,13 +363,14 @@ sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
 }
 #endif
 
-static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
+static int __devinit sdhci_esdhc_imx_probe(struct platform_device *pdev)
 {
         const struct of_device_id *of_id =
                         of_match_device(imx_esdhc_dt_ids, &pdev->dev);
         struct sdhci_pltfm_host *pltfm_host;
         struct sdhci_host *host;
         struct esdhc_platform_data *boarddata;
+        struct clk *clk;
         int err;
         struct pltfm_imx_data *imx_data;
 
@@ -456,10 +380,10 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         pltfm_host = sdhci_priv(host);
 
-        imx_data = devm_kzalloc(&pdev->dev, sizeof(*imx_data), GFP_KERNEL);
+        imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
         if (!imx_data) {
                 err = -ENOMEM;
-                goto free_sdhci;
+                goto err_imx_data;
         }
 
         if (of_id)
@@ -467,59 +391,31 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
         imx_data->devtype = pdev->id_entry->driver_data;
         pltfm_host->priv = imx_data;
 
-        imx_data->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
-        if (IS_ERR(imx_data->clk_ipg)) {
-                err = PTR_ERR(imx_data->clk_ipg);
-                goto free_sdhci;
-        }
-
-        imx_data->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
-        if (IS_ERR(imx_data->clk_ahb)) {
-                err = PTR_ERR(imx_data->clk_ahb);
-                goto free_sdhci;
+        clk = clk_get(mmc_dev(host->mmc), NULL);
+        if (IS_ERR(clk)) {
+                dev_err(mmc_dev(host->mmc), "clk err\n");
+                err = PTR_ERR(clk);
+                goto err_clk_get;
         }
+        clk_enable(clk);
+        pltfm_host->clk = clk;
 
-        imx_data->clk_per = devm_clk_get(&pdev->dev, "per");
-        if (IS_ERR(imx_data->clk_per)) {
-                err = PTR_ERR(imx_data->clk_per);
-                goto free_sdhci;
-        }
-
-        pltfm_host->clk = imx_data->clk_per;
-
-        clk_prepare_enable(imx_data->clk_per);
-        clk_prepare_enable(imx_data->clk_ipg);
-        clk_prepare_enable(imx_data->clk_ahb);
-
-        imx_data->pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(imx_data->pinctrl)) {
-                err = PTR_ERR(imx_data->pinctrl);
-                goto disable_clk;
-        }
-
-        host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
+        if (!is_imx25_esdhc(imx_data))
+                host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
         if (is_imx25_esdhc(imx_data) || is_imx35_esdhc(imx_data))
                 /* Fix errata ENGcm07207 present on i.MX25 and i.MX35 */
-                host->quirks |= SDHCI_QUIRK_NO_MULTIBLOCK
-                        | SDHCI_QUIRK_BROKEN_ADMA;
+                host->quirks |= SDHCI_QUIRK_NO_MULTIBLOCK;
 
         if (is_imx53_esdhc(imx_data))
                 imx_data->flags |= ESDHC_FLAG_MULTIBLK_NO_INT;
 
-        /*
-         * The imx6q ROM code will change the default watermark level setting
-         * to something insane.  Change it back here.
-         */
-        if (is_imx6q_usdhc(imx_data))
-                writel(0x08100810, host->ioaddr + SDHCI_WTMK_LVL);
-
         boarddata = &imx_data->boarddata;
         if (sdhci_esdhc_imx_probe_dt(pdev, boarddata) < 0) {
                 if (!host->mmc->parent->platform_data) {
                         dev_err(mmc_dev(host->mmc), "no board data!\n");
                         err = -EINVAL;
-                        goto disable_clk;
+                        goto no_board_data;
                 }
                 imx_data->boarddata = *((struct esdhc_platform_data *)
                                         host->mmc->parent->platform_data);
@@ -527,8 +423,7 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         /* write_protect */
         if (boarddata->wp_type == ESDHC_WP_GPIO) {
-                err = devm_gpio_request_one(&pdev->dev, boarddata->wp_gpio,
-                                            GPIOF_IN, "ESDHC_WP");
+                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");
@@ -544,21 +439,19 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         switch (boarddata->cd_type) {
         case ESDHC_CD_GPIO:
-                err = devm_gpio_request_one(&pdev->dev, boarddata->cd_gpio,
-                                            GPIOF_IN, "ESDHC_CD");
+                err = gpio_request_one(boarddata->cd_gpio, GPIOF_IN, "ESDHC_CD");
                 if (err) {
                         dev_err(mmc_dev(host->mmc),
                                 "no card-detect pin available!\n");
-                        goto disable_clk;
+                        goto no_card_detect_pin;
                 }
 
-                err = devm_request_irq(&pdev->dev,
-                                 gpio_to_irq(boarddata->cd_gpio), cd_irq,
+                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_err(mmc_dev(host->mmc), "request irq error\n");
-                        goto disable_clk;
+                        goto no_card_detect_irq;
                 }
                 /* fall through */
 
@@ -577,31 +470,50 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         err = sdhci_add_host(host);
         if (err)
-                goto disable_clk;
+                goto err_add_host;
 
         return 0;
 
-disable_clk:
-        clk_disable_unprepare(imx_data->clk_per);
-        clk_disable_unprepare(imx_data->clk_ipg);
-        clk_disable_unprepare(imx_data->clk_ahb);
-free_sdhci:
+err_add_host:
+        if (gpio_is_valid(boarddata->cd_gpio))
+                free_irq(gpio_to_irq(boarddata->cd_gpio), host);
+no_card_detect_irq:
+        if (gpio_is_valid(boarddata->cd_gpio))
+                gpio_free(boarddata->cd_gpio);
+        if (gpio_is_valid(boarddata->wp_gpio))
+                gpio_free(boarddata->wp_gpio);
+no_card_detect_pin:
+no_board_data:
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+err_clk_get:
+        kfree(imx_data);
+err_imx_data:
         sdhci_pltfm_free(pdev);
         return err;
 }
 
-static int sdhci_esdhc_imx_remove(struct platform_device *pdev)
+static int __devexit sdhci_esdhc_imx_remove(struct platform_device *pdev)
 {
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
+        struct esdhc_platform_data *boarddata = &imx_data->boarddata;
         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
 
         sdhci_remove_host(host, dead);
 
-        clk_disable_unprepare(imx_data->clk_per);
-        clk_disable_unprepare(imx_data->clk_ipg);
-        clk_disable_unprepare(imx_data->clk_ahb);
+        if (gpio_is_valid(boarddata->wp_gpio))
+                gpio_free(boarddata->wp_gpio);
+
+        if (gpio_is_valid(boarddata->cd_gpio)) {
+                free_irq(gpio_to_irq(boarddata->cd_gpio), host);
+                gpio_free(boarddata->cd_gpio);
+        }
+
+        clk_disable(pltfm_host->clk);
+        clk_put(pltfm_host->clk);
+        kfree(imx_data);
 
         sdhci_pltfm_free(pdev);
 
@@ -613,14 +525,27 @@ static struct platform_driver sdhci_esdhc_imx_driver = {
                 .name   = "sdhci-esdhc-imx",
                 .owner  = THIS_MODULE,
                 .of_match_table = imx_esdhc_dt_ids,
-                .pm     = SDHCI_PLTFM_PMOPS,
         },
         .id_table       = imx_esdhc_devtype,
         .probe          = sdhci_esdhc_imx_probe,
-        .remove         = sdhci_esdhc_imx_remove,
+        .remove         = __devexit_p(sdhci_esdhc_imx_remove),
+#ifdef CONFIG_PM
+        .suspend        = sdhci_pltfm_suspend,
+        .resume         = sdhci_pltfm_resume,
+#endif
 };
 
-module_platform_driver(sdhci_esdhc_imx_driver);
+static int __init sdhci_esdhc_imx_init(void)
+{
+        return platform_driver_register(&sdhci_esdhc_imx_driver);
+}
+module_init(sdhci_esdhc_imx_init);
+
+static void __exit sdhci_esdhc_imx_exit(void)
+{
+        platform_driver_unregister(&sdhci_esdhc_imx_driver);
+}
+module_exit(sdhci_esdhc_imx_exit);
 
 MODULE_DESCRIPTION("SDHCI driver for Freescale i.MX eSDHC");
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");