Merge branch 'mxs/dt/for-3.5' of git://git.linaro.org/people/shawnguo/linux-2.6 into next/dt2

* 'mxs/dt/for-3.5' of git://git.linaro.org/people/shawnguo/linux-2.6: (51 commits)
  ARM: dts: enable audio support for imx28-evk
  ARM: dts: enable i2c device for imx28-evk
  i2c: mxs: add device tree probe support
  ARM: dts: enable mmc for imx28-evk
  ARM: dts: enable mmc for imx23-evk
  mmc: mxs-mmc: add device tree support
  mmc: mxs-mmc: copy wp_gpio in struct mxs_mmc_host
  mmc: mxs-mmc: have dma_channel than dma_res in mxs_mmc_host
  mmc: mxs-mmc: use devm_* helper to make cleanup simpler
  mmc: mxs-mmc: move header from mach into linux folder
  mmc: mxs-mmc: get rid of the use of cpu_is_xxx
  mmc: mxs-mmc: let ssp_is_old take host as parameter
  mmc: mxs-mmc: use global stmp_device functionality
  ARM: mxs: add gpio support for device tree boot
  gpio/mxs: add device tree probe
  gpio/mxs: get rid of the use of cpu_is_xxx
  gpio/mxs: use devm_* helpers to make error handling simple
  ARM: mxs: add mxs-dma dt support
  ARM: mxs: do not add dma device by default
  dma: mxs-dma: add device tree probe support
  ...

2 files changed, 127 insertions, 85 deletions

diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index e3f5af96ab87..34a90266ab11 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -23,6 +23,9 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -39,18 +42,16 @@
 #include <linux/regulator/consumer.h>
 #include <linux/module.h>
 #include <linux/fsl/mxs-dma.h>
-
-#include <mach/mxs.h>
-#include <mach/common.h>
-#include <mach/mmc.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/stmp_device.h>
+#include <linux/mmc/mxs-mmc.h>
 
 #define DRIVER_NAME     "mxs-mmc"
 
 /* card detect polling timeout */
 #define MXS_MMC_DETECT_TIMEOUT                  (HZ/2)
 
-#define SSP_VERSION_LATEST      4
-#define ssp_is_old()            (host->version < SSP_VERSION_LATEST)
+#define ssp_is_old(host)        ((host)->devid == IMX23_MMC)
 
 /* SSP registers */
 #define HW_SSP_CTRL0                            0x000
@@ -85,14 +86,14 @@
 #define  BM_SSP_BLOCK_SIZE_BLOCK_COUNT          (0xffffff << 4)
 #define  BP_SSP_BLOCK_SIZE_BLOCK_SIZE           (0)
 #define  BM_SSP_BLOCK_SIZE_BLOCK_SIZE           (0xf)
-#define HW_SSP_TIMING                           (ssp_is_old() ? 0x050 : 0x070)
+#define HW_SSP_TIMING(h)                        (ssp_is_old(h) ? 0x050 : 0x070)
 #define  BP_SSP_TIMING_TIMEOUT                  (16)
 #define  BM_SSP_TIMING_TIMEOUT                  (0xffff << 16)
 #define  BP_SSP_TIMING_CLOCK_DIVIDE             (8)
 #define  BM_SSP_TIMING_CLOCK_DIVIDE             (0xff << 8)
 #define  BP_SSP_TIMING_CLOCK_RATE               (0)
 #define  BM_SSP_TIMING_CLOCK_RATE               (0xff)
-#define HW_SSP_CTRL1                            (ssp_is_old() ? 0x060 : 0x080)
+#define HW_SSP_CTRL1(h)                         (ssp_is_old(h) ? 0x060 : 0x080)
 #define  BM_SSP_CTRL1_SDIO_IRQ                  (1 << 31)
 #define  BM_SSP_CTRL1_SDIO_IRQ_EN               (1 << 30)
 #define  BM_SSP_CTRL1_RESP_ERR_IRQ              (1 << 29)
@@ -115,15 +116,13 @@
 #define  BM_SSP_CTRL1_WORD_LENGTH               (0xf << 4)
 #define  BP_SSP_CTRL1_SSP_MODE                  (0)
 #define  BM_SSP_CTRL1_SSP_MODE                  (0xf)
-#define HW_SSP_SDRESP0                          (ssp_is_old() ? 0x080 : 0x0a0)
-#define HW_SSP_SDRESP1                          (ssp_is_old() ? 0x090 : 0x0b0)
-#define HW_SSP_SDRESP2                          (ssp_is_old() ? 0x0a0 : 0x0c0)
-#define HW_SSP_SDRESP3                          (ssp_is_old() ? 0x0b0 : 0x0d0)
-#define HW_SSP_STATUS                           (ssp_is_old() ? 0x0c0 : 0x100)
+#define HW_SSP_SDRESP0(h)                       (ssp_is_old(h) ? 0x080 : 0x0a0)
+#define HW_SSP_SDRESP1(h)                       (ssp_is_old(h) ? 0x090 : 0x0b0)
+#define HW_SSP_SDRESP2(h)                       (ssp_is_old(h) ? 0x0a0 : 0x0c0)
+#define HW_SSP_SDRESP3(h)                       (ssp_is_old(h) ? 0x0b0 : 0x0d0)
+#define HW_SSP_STATUS(h)                        (ssp_is_old(h) ? 0x0c0 : 0x100)
 #define  BM_SSP_STATUS_CARD_DETECT              (1 << 28)
 #define  BM_SSP_STATUS_SDIO_IRQ                 (1 << 17)
-#define HW_SSP_VERSION                          (cpu_is_mx23() ? 0x110 : 0x130)
-#define  BP_SSP_VERSION_MAJOR                   (24)
 
 #define BF_SSP(value, field)    (((value) << BP_SSP_##field) & BM_SSP_##field)
 
@@ -138,6 +137,11 @@
 
 #define SSP_PIO_NUM     3
 
+enum mxs_mmc_id {
+        IMX23_MMC,
+        IMX28_MMC,
+};
+
 struct mxs_mmc_host {
         struct mmc_host                 *mmc;
         struct mmc_request              *mrq;
@@ -145,9 +149,7 @@ struct mxs_mmc_host {
         struct mmc_data                 *data;
 
         void __iomem                    *base;
-        int                             irq;
-        struct resource                 *res;
-        struct resource                 *dma_res;
+        int                             dma_channel;
         struct clk                      *clk;
         unsigned int                    clk_rate;
 
@@ -157,32 +159,28 @@ struct mxs_mmc_host {
         enum dma_transfer_direction     slave_dirn;
         u32                             ssp_pio_words[SSP_PIO_NUM];
 
-        unsigned int                    version;
+        enum mxs_mmc_id                 devid;
         unsigned char                   bus_width;
         spinlock_t                      lock;
         int                             sdio_irq_en;
+        int                             wp_gpio;
 };
 
 static int mxs_mmc_get_ro(struct mmc_host *mmc)
 {
         struct mxs_mmc_host *host = mmc_priv(mmc);
-        struct mxs_mmc_platform_data *pdata =
-                mmc_dev(host->mmc)->platform_data;
-
-        if (!pdata)
-                return -EFAULT;
 
-        if (!gpio_is_valid(pdata->wp_gpio))
+        if (!gpio_is_valid(host->wp_gpio))
                 return -EINVAL;
 
-        return gpio_get_value(pdata->wp_gpio);
+        return gpio_get_value(host->wp_gpio);
 }
 
 static int mxs_mmc_get_cd(struct mmc_host *mmc)
 {
         struct mxs_mmc_host *host = mmc_priv(mmc);
 
-        return !(readl(host->base + HW_SSP_STATUS) &
+        return !(readl(host->base + HW_SSP_STATUS(host)) &
                  BM_SSP_STATUS_CARD_DETECT);
 }
 
@@ -190,7 +188,7 @@ static void mxs_mmc_reset(struct mxs_mmc_host *host)
 {
         u32 ctrl0, ctrl1;
 
-        mxs_reset_block(host->base);
+        stmp_reset_block(host->base);
 
         ctrl0 = BM_SSP_CTRL0_IGNORE_CRC;
         ctrl1 = BF_SSP(0x3, CTRL1_SSP_MODE) |
@@ -206,7 +204,7 @@ static void mxs_mmc_reset(struct mxs_mmc_host *host)
         writel(BF_SSP(0xffff, TIMING_TIMEOUT) |
                BF_SSP(2, TIMING_CLOCK_DIVIDE) |
                BF_SSP(0, TIMING_CLOCK_RATE),
-               host->base + HW_SSP_TIMING);
+               host->base + HW_SSP_TIMING(host));
 
         if (host->sdio_irq_en) {
                 ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
@@ -214,7 +212,7 @@ static void mxs_mmc_reset(struct mxs_mmc_host *host)
         }
 
         writel(ctrl0, host->base + HW_SSP_CTRL0);
-        writel(ctrl1, host->base + HW_SSP_CTRL1);
+        writel(ctrl1, host->base + HW_SSP_CTRL1(host));
 }
 
 static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
@@ -228,12 +226,12 @@ static void mxs_mmc_request_done(struct mxs_mmc_host *host)
 
         if (mmc_resp_type(cmd) & MMC_RSP_PRESENT) {
                 if (mmc_resp_type(cmd) & MMC_RSP_136) {
-                        cmd->resp[3] = readl(host->base + HW_SSP_SDRESP0);
-                        cmd->resp[2] = readl(host->base + HW_SSP_SDRESP1);
-                        cmd->resp[1] = readl(host->base + HW_SSP_SDRESP2);
-                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP3);
+                        cmd->resp[3] = readl(host->base + HW_SSP_SDRESP0(host));
+                        cmd->resp[2] = readl(host->base + HW_SSP_SDRESP1(host));
+                        cmd->resp[1] = readl(host->base + HW_SSP_SDRESP2(host));
+                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP3(host));
                 } else {
-                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP0);
+                        cmd->resp[0] = readl(host->base + HW_SSP_SDRESP0(host));
                 }
         }
 
@@ -276,9 +274,9 @@ static irqreturn_t mxs_mmc_irq_handler(int irq, void *dev_id)
 
         spin_lock(&host->lock);
 
-        stat = readl(host->base + HW_SSP_CTRL1);
+        stat = readl(host->base + HW_SSP_CTRL1(host));
         writel(stat & MXS_MMC_IRQ_BITS,
-               host->base + HW_SSP_CTRL1 + MXS_CLR_ADDR);
+               host->base + HW_SSP_CTRL1(host) + STMP_OFFSET_REG_CLR);
 
         if ((stat & BM_SSP_CTRL1_SDIO_IRQ) && (stat & BM_SSP_CTRL1_SDIO_IRQ_EN))
                 mmc_signal_sdio_irq(host->mmc);
@@ -484,7 +482,7 @@ static void mxs_mmc_adtc(struct mxs_mmc_host *host)
                 blocks = 1;
 
         /* xfer count, block size and count need to be set differently */
-        if (ssp_is_old()) {
+        if (ssp_is_old(host)) {
                 ctrl0 |= BF_SSP(data_size, CTRL0_XFER_COUNT);
                 cmd0 |= BF_SSP(log2_blksz, CMD0_BLOCK_SIZE) |
                         BF_SSP(blocks - 1, CMD0_BLOCK_COUNT);
@@ -508,10 +506,10 @@ static void mxs_mmc_adtc(struct mxs_mmc_host *host)
 
         /* set the timeout count */
         timeout = mxs_ns_to_ssp_ticks(host->clk_rate, data->timeout_ns);
-        val = readl(host->base + HW_SSP_TIMING);
+        val = readl(host->base + HW_SSP_TIMING(host));
         val &= ~(BM_SSP_TIMING_TIMEOUT);
         val |= BF_SSP(timeout, TIMING_TIMEOUT);
-        writel(val, host->base + HW_SSP_TIMING);
+        writel(val, host->base + HW_SSP_TIMING(host));
 
         /* pio */
         host->ssp_pio_words[0] = ctrl0;
@@ -597,11 +595,11 @@ static void mxs_mmc_set_clk_rate(struct mxs_mmc_host *host, unsigned int rate)
 
         ssp_sck = ssp_clk / clock_divide / (1 + clock_rate);
 
-        val = readl(host->base + HW_SSP_TIMING);
+        val = readl(host->base + HW_SSP_TIMING(host));
         val &= ~(BM_SSP_TIMING_CLOCK_DIVIDE | BM_SSP_TIMING_CLOCK_RATE);
         val |= BF_SSP(clock_divide, TIMING_CLOCK_DIVIDE);
         val |= BF_SSP(clock_rate, TIMING_CLOCK_RATE);
-        writel(val, host->base + HW_SSP_TIMING);
+        writel(val, host->base + HW_SSP_TIMING(host));
 
         host->clk_rate = ssp_sck;
 
@@ -636,18 +634,19 @@ static void mxs_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
 
         if (enable) {
                 writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
-                       host->base + HW_SSP_CTRL0 + MXS_SET_ADDR);
+                       host->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
                 writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
-                       host->base + HW_SSP_CTRL1 + MXS_SET_ADDR);
+                       host->base + HW_SSP_CTRL1(host) + STMP_OFFSET_REG_SET);
 
-                if (readl(host->base + HW_SSP_STATUS) & BM_SSP_STATUS_SDIO_IRQ)
+                if (readl(host->base + HW_SSP_STATUS(host)) &
+                                BM_SSP_STATUS_SDIO_IRQ)
                         mmc_signal_sdio_irq(host->mmc);
 
         } else {
                 writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
-                       host->base + HW_SSP_CTRL0 + MXS_CLR_ADDR);
+                       host->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
                 writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
-                       host->base + HW_SSP_CTRL1 + MXS_CLR_ADDR);
+                       host->base + HW_SSP_CTRL1(host) + STMP_OFFSET_REG_CLR);
         }
 
         spin_unlock_irqrestore(&host->lock, flags);
@@ -668,7 +667,7 @@ static bool mxs_mmc_dma_filter(struct dma_chan *chan, void *param)
         if (!mxs_dma_is_apbh(chan))
                 return false;
 
-        if (chan->chan_id != host->dma_res->start)
+        if (chan->chan_id != host->dma_channel)
                 return false;
 
         chan->private = &host->dma_data;
@@ -676,12 +675,36 @@ static bool mxs_mmc_dma_filter(struct dma_chan *chan, void *param)
         return true;
 }
 
+static struct platform_device_id mxs_mmc_ids[] = {
+        {
+                .name = "imx23-mmc",
+                .driver_data = IMX23_MMC,
+        }, {
+                .name = "imx28-mmc",
+                .driver_data = IMX28_MMC,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(platform, mxs_mmc_ids);
+
+static const struct of_device_id mxs_mmc_dt_ids[] = {
+        { .compatible = "fsl,imx23-mmc", .data = (void *) IMX23_MMC, },
+        { .compatible = "fsl,imx28-mmc", .data = (void *) IMX28_MMC, },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxs_mmc_dt_ids);
+
 static int mxs_mmc_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                        of_match_device(mxs_mmc_dt_ids, &pdev->dev);
+        struct device_node *np = pdev->dev.of_node;
         struct mxs_mmc_host *host;
         struct mmc_host *mmc;
-        struct resource *iores, *dmares, *r;
+        struct resource *iores, *dmares;
         struct mxs_mmc_platform_data *pdata;
+        struct pinctrl *pinctrl;
         int ret = 0, irq_err, irq_dma;
         dma_cap_mask_t mask;
 
@@ -689,40 +712,51 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
         irq_err = platform_get_irq(pdev, 0);
         irq_dma = platform_get_irq(pdev, 1);
-        if (!iores || !dmares || irq_err < 0 || irq_dma < 0)
+        if (!iores || irq_err < 0 || irq_dma < 0)
                 return -EINVAL;
 
-        r = request_mem_region(iores->start, resource_size(iores), pdev->name);
-        if (!r)
-                return -EBUSY;
-
         mmc = mmc_alloc_host(sizeof(struct mxs_mmc_host), &pdev->dev);
-        if (!mmc) {
-                ret = -ENOMEM;
-                goto out_release_mem;
-        }
+        if (!mmc)
+                return -ENOMEM;
 
         host = mmc_priv(mmc);
-        host->base = ioremap(r->start, resource_size(r));
+        host->base = devm_request_and_ioremap(&pdev->dev, iores);
         if (!host->base) {
-                ret = -ENOMEM;
+                ret = -EADDRNOTAVAIL;
                 goto out_mmc_free;
         }
 
-        /* only major verion does matter */
-        host->version = readl(host->base + HW_SSP_VERSION) >>
-                        BP_SSP_VERSION_MAJOR;
+        if (np) {
+                host->devid = (enum mxs_mmc_id) of_id->data;
+                /*
+                 * TODO: This is a temporary solution and should be changed
+                 * to use generic DMA binding later when the helpers get in.
+                 */
+                ret = of_property_read_u32(np, "fsl,ssp-dma-channel",
+                                           &host->dma_channel);
+                if (ret) {
+                        dev_err(mmc_dev(host->mmc),
+                                "failed to get dma channel\n");
+                        goto out_mmc_free;
+                }
+        } else {
+                host->devid = pdev->id_entry->driver_data;
+                host->dma_channel = dmares->start;
+        }
 
         host->mmc = mmc;
-        host->res = r;
-        host->dma_res = dmares;
-        host->irq = irq_err;
         host->sdio_irq_en = 0;
 
+        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(pinctrl)) {
+                ret = PTR_ERR(pinctrl);
+                goto out_mmc_free;
+        }
+
         host->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(host->clk)) {
                 ret = PTR_ERR(host->clk);
-                goto out_iounmap;
+                goto out_mmc_free;
         }
         clk_prepare_enable(host->clk);
 
@@ -744,11 +778,20 @@ static int mxs_mmc_probe(struct platform_device *pdev)
                     MMC_CAP_SDIO_IRQ | MMC_CAP_NEEDS_POLL;
 
         pdata = mmc_dev(host->mmc)->platform_data;
-        if (pdata) {
+        if (!pdata) {
+                u32 bus_width = 0;
+                of_property_read_u32(np, "bus-width", &bus_width);
+                if (bus_width == 4)
+                        mmc->caps |= MMC_CAP_4_BIT_DATA;
+                else if (bus_width == 8)
+                        mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
+                host->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+        } else {
                 if (pdata->flags & SLOTF_8_BIT_CAPABLE)
                         mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
                 if (pdata->flags & SLOTF_4_BIT_CAPABLE)
                         mmc->caps |= MMC_CAP_4_BIT_DATA;
+                host->wp_gpio = pdata->wp_gpio;
         }
 
         mmc->f_min = 400000;
@@ -757,13 +800,14 @@ static int mxs_mmc_probe(struct platform_device *pdev)
 
         mmc->max_segs = 52;
         mmc->max_blk_size = 1 << 0xf;
-        mmc->max_blk_count = (ssp_is_old()) ? 0xff : 0xffffff;
-        mmc->max_req_size = (ssp_is_old()) ? 0xffff : 0xffffffff;
+        mmc->max_blk_count = (ssp_is_old(host)) ? 0xff : 0xffffff;
+        mmc->max_req_size = (ssp_is_old(host)) ? 0xffff : 0xffffffff;
         mmc->max_seg_size = dma_get_max_seg_size(host->dmach->device->dev);
 
         platform_set_drvdata(pdev, mmc);
 
-        ret = request_irq(host->irq, mxs_mmc_irq_handler, 0, DRIVER_NAME, host);
+        ret = devm_request_irq(&pdev->dev, irq_err, mxs_mmc_irq_handler, 0,
+                               DRIVER_NAME, host);
         if (ret)
                 goto out_free_dma;
 
@@ -771,26 +815,20 @@ static int mxs_mmc_probe(struct platform_device *pdev)
 
         ret = mmc_add_host(mmc);
         if (ret)
-                goto out_free_irq;
+                goto out_free_dma;
 
         dev_info(mmc_dev(host->mmc), "initialized\n");
 
         return 0;
 
-out_free_irq:
-        free_irq(host->irq, host);
 out_free_dma:
         if (host->dmach)
                 dma_release_channel(host->dmach);
 out_clk_put:
         clk_disable_unprepare(host->clk);
         clk_put(host->clk);
-out_iounmap:
-        iounmap(host->base);
 out_mmc_free:
         mmc_free_host(mmc);
-out_release_mem:
-        release_mem_region(iores->start, resource_size(iores));
         return ret;
 }
 
@@ -798,12 +836,9 @@ static int mxs_mmc_remove(struct platform_device *pdev)
 {
         struct mmc_host *mmc = platform_get_drvdata(pdev);
         struct mxs_mmc_host *host = mmc_priv(mmc);
-        struct resource *res = host->res;
 
         mmc_remove_host(mmc);
 
-        free_irq(host->irq, host);
-
         platform_set_drvdata(pdev, NULL);
 
         if (host->dmach)
@@ -812,12 +847,8 @@ static int mxs_mmc_remove(struct platform_device *pdev)
         clk_disable_unprepare(host->clk);
         clk_put(host->clk);
 
-        iounmap(host->base);
-
         mmc_free_host(mmc);
 
-        release_mem_region(res->start, resource_size(res));
-
         return 0;
 }
 
@@ -857,11 +888,13 @@ static const struct dev_pm_ops mxs_mmc_pm_ops = {
 static struct platform_driver mxs_mmc_driver = {
         .probe          = mxs_mmc_probe,
         .remove         = mxs_mmc_remove,
+        .id_table       = mxs_mmc_ids,
         .driver         = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
 #ifdef CONFIG_PM
                 .pm     = &mxs_mmc_pm_ops,
+                .of_match_table = mxs_mmc_dt_ids,
 #endif
         },
 };
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 8abdaf6697a8..d190d04636a7 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -24,6 +24,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
+#include <linux/pinctrl/consumer.h>
 #include <mach/esdhc.h>
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
@@ -68,6 +69,7 @@ struct pltfm_imx_data {
         int flags;
         u32 scratchpad;
         enum imx_esdhc_type devtype;
+        struct pinctrl *pinctrl;
         struct esdhc_platform_data boarddata;
 };
 
@@ -467,6 +469,12 @@ static int __devinit sdhci_esdhc_imx_probe(struct platform_device *pdev)
         clk_prepare_enable(clk);
         pltfm_host->clk = clk;
 
+        imx_data->pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(imx_data->pinctrl)) {
+                err = PTR_ERR(imx_data->pinctrl);
+                goto pin_err;
+        }
+
         host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
         if (is_imx25_esdhc(imx_data) || is_imx35_esdhc(imx_data))
@@ -558,6 +566,7 @@ no_card_detect_irq:
                 gpio_free(boarddata->wp_gpio);
 no_card_detect_pin:
 no_board_data:
+pin_err:
         clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
 err_clk_get: