Merge tag 'dt2' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull arm-soc device tree conversions (part 2) from Olof Johansson:
 "These continue the device tree work from part 1, this set is for the
  tegra, mxs and imx platforms, all of which have dependencies on clock
  or pinctrl changes submitted earlier."

Fix up trivial conflicts due to nearby changes in
drivers/{gpio/gpio,i2c/busses/i2c}-mxs.c

* tag 'dt2' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (73 commits)
  ARM: dt: tegra: invert status=disable vs status=okay
  ARM: dt: tegra: consistent basic property ordering
  ARM: dt: tegra: sort nodes based on bus order
  ARM: dt: tegra: remove duplicate device_type property
  ARM: dt: tegra: consistenly use lower-case for hex constants
  ARM: dt: tegra: format regs properties consistently
  ARM: dt: tegra: gpio comment cleanup
  ARM: dt: tegra: remove unnecessary unit addresses
  ARM: dt: tegra: whitespace cleanup
  ARM: dt: tegra cardhu: fix typo in SDHCI node name
  ARM: dt: tegra: cardhu: register core regulator tps62361
  ARM: dt: tegra30.dtsi: Add SMMU node
  ARM: dt: tegra20.dtsi: Add GART node
  ARM: dt: tegra30.dtsi: Add Memory Controller(MC) nodes
  ARM: dt: tegra20.dtsi: Add Memory Controller(MC) nodes
  ARM: dt: tegra: Add device tree support for AHB
  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
  ...

7 files changed, 358 insertions, 219 deletions

diff --git a/drivers/clk/mxs/clk-imx23.c b/drivers/clk/mxs/clk-imx23.c
index dcae11285716..f7be225f544c 100644
--- a/drivers/clk/mxs/clk-imx23.c
+++ b/drivers/clk/mxs/clk-imx23.c
@@ -81,19 +81,20 @@ static struct clk_lookup uart_lookups[] __initdata = {
 };
 
 static struct clk_lookup hbus_lookups[] __initdata = {
-        { .dev_id = "mxs-dma-apbh", },
+        { .dev_id = "imx23-dma-apbh", },
         { .dev_id = "80004000.dma-apbh", },
 };
 
 static struct clk_lookup xbus_lookups[] __initdata = {
         { .dev_id = "duart", .con_id = "apb_pclk"},
-        { .dev_id = "mxs-dma-apbx", },
+        { .dev_id = "80070000.serial", .con_id = "apb_pclk"},
+        { .dev_id = "imx23-dma-apbx", },
         { .dev_id = "80024000.dma-apbx", },
 };
 
 static struct clk_lookup ssp_lookups[] __initdata = {
-        { .dev_id = "mxs-mmc.0", },
-        { .dev_id = "mxs-mmc.1", },
+        { .dev_id = "imx23-mmc.0", },
+        { .dev_id = "imx23-mmc.1", },
         { .dev_id = "80010000.ssp", },
         { .dev_id = "80034000.ssp", },
 };
diff --git a/drivers/clk/mxs/clk-imx28.c b/drivers/clk/mxs/clk-imx28.c
index b2a3257d4f66..2826a2606a29 100644
--- a/drivers/clk/mxs/clk-imx28.c
+++ b/drivers/clk/mxs/clk-imx28.c
@@ -136,33 +136,34 @@ static struct clk_lookup uart_lookups[] __initdata = {
 };
 
 static struct clk_lookup hbus_lookups[] __initdata = {
-        { .dev_id = "mxs-dma-apbh", },
+        { .dev_id = "imx28-dma-apbh", },
         { .dev_id = "80004000.dma-apbh", },
 };
 
 static struct clk_lookup xbus_lookups[] __initdata = {
         { .dev_id = "duart", .con_id = "apb_pclk"},
-        { .dev_id = "mxs-dma-apbx", },
+        { .dev_id = "80074000.serial", .con_id = "apb_pclk"},
+        { .dev_id = "imx28-dma-apbx", },
         { .dev_id = "80024000.dma-apbx", },
 };
 
 static struct clk_lookup ssp0_lookups[] __initdata = {
-        { .dev_id = "mxs-mmc.0", },
+        { .dev_id = "imx28-mmc.0", },
         { .dev_id = "80010000.ssp", },
 };
 
 static struct clk_lookup ssp1_lookups[] __initdata = {
-        { .dev_id = "mxs-mmc.1", },
+        { .dev_id = "imx28-mmc.1", },
         { .dev_id = "80012000.ssp", },
 };
 
 static struct clk_lookup ssp2_lookups[] __initdata = {
-        { .dev_id = "mxs-mmc.2", },
+        { .dev_id = "imx28-mmc.2", },
         { .dev_id = "80014000.ssp", },
 };
 
 static struct clk_lookup ssp3_lookups[] __initdata = {
-        { .dev_id = "mxs-mmc.3", },
+        { .dev_id = "imx28-mmc.3", },
         { .dev_id = "80016000.ssp", },
 };
 
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index ef378b5b17e4..aadeb5be9dba 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -238,6 +238,7 @@ config IMX_DMA
 config MXS_DMA
         bool "MXS DMA support"
         depends on SOC_IMX23 || SOC_IMX28
+        select STMP_DEVICE
         select DMA_ENGINE
         help
           Support the MXS DMA engine. This engine including APBH-DMA
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index 3db3a48d3f01..c96ab15319f2 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -22,11 +22,14 @@
 #include <linux/platform_device.h>
 #include <linux/dmaengine.h>
 #include <linux/delay.h>
+#include <linux/module.h>
 #include <linux/fsl/mxs-dma.h>
+#include <linux/stmp_device.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <asm/irq.h>
 #include <mach/mxs.h>
-#include <mach/common.h>
 
 #include "dmaengine.h"
 
@@ -36,12 +39,8 @@
  * dma can program the controller registers of peripheral devices.
  */
 
-#define MXS_DMA_APBH            0
-#define MXS_DMA_APBX            1
-#define dma_is_apbh()           (mxs_dma->dev_id == MXS_DMA_APBH)
-
-#define APBH_VERSION_LATEST     3
-#define apbh_is_old()           (mxs_dma->version < APBH_VERSION_LATEST)
+#define dma_is_apbh(mxs_dma)    ((mxs_dma)->type == MXS_DMA_APBH)
+#define apbh_is_old(mxs_dma)    ((mxs_dma)->dev_id == IMX23_DMA)
 
 #define HW_APBHX_CTRL0                          0x000
 #define BM_APBH_CTRL0_APB_BURST8_EN             (1 << 29)
@@ -51,13 +50,14 @@
 #define HW_APBHX_CTRL2                          0x020
 #define HW_APBHX_CHANNEL_CTRL                   0x030
 #define BP_APBHX_CHANNEL_CTRL_RESET_CHANNEL     16
-#define HW_APBH_VERSION                         (cpu_is_mx23() ? 0x3f0 : 0x800)
-#define HW_APBX_VERSION                         0x800
-#define BP_APBHX_VERSION_MAJOR                  24
-#define HW_APBHX_CHn_NXTCMDAR(n) \
-        (((dma_is_apbh() && apbh_is_old()) ? 0x050 : 0x110) + (n) * 0x70)
-#define HW_APBHX_CHn_SEMA(n) \
-        (((dma_is_apbh() && apbh_is_old()) ? 0x080 : 0x140) + (n) * 0x70)
+/*
+ * The offset of NXTCMDAR register is different per both dma type and version,
+ * while stride for each channel is all the same 0x70.
+ */
+#define HW_APBHX_CHn_NXTCMDAR(d, n) \
+        (((dma_is_apbh(d) && apbh_is_old(d)) ? 0x050 : 0x110) + (n) * 0x70)
+#define HW_APBHX_CHn_SEMA(d, n) \
+        (((dma_is_apbh(d) && apbh_is_old(d)) ? 0x080 : 0x140) + (n) * 0x70)
 
 /*
  * ccw bits definitions
@@ -121,9 +121,19 @@ struct mxs_dma_chan {
 #define MXS_DMA_CHANNELS                16
 #define MXS_DMA_CHANNELS_MASK           0xffff
 
+enum mxs_dma_devtype {
+        MXS_DMA_APBH,
+        MXS_DMA_APBX,
+};
+
+enum mxs_dma_id {
+        IMX23_DMA,
+        IMX28_DMA,
+};
+
 struct mxs_dma_engine {
-        int                             dev_id;
-        unsigned int                    version;
+        enum mxs_dma_id                 dev_id;
+        enum mxs_dma_devtype            type;
         void __iomem                    *base;
         struct clk                      *clk;
         struct dma_device               dma_device;
@@ -131,17 +141,86 @@ struct mxs_dma_engine {
         struct mxs_dma_chan             mxs_chans[MXS_DMA_CHANNELS];
 };
 
+struct mxs_dma_type {
+        enum mxs_dma_id id;
+        enum mxs_dma_devtype type;
+};
+
+static struct mxs_dma_type mxs_dma_types[] = {
+        {
+                .id = IMX23_DMA,
+                .type = MXS_DMA_APBH,
+        }, {
+                .id = IMX23_DMA,
+                .type = MXS_DMA_APBX,
+        }, {
+                .id = IMX28_DMA,
+                .type = MXS_DMA_APBH,
+        }, {
+                .id = IMX28_DMA,
+                .type = MXS_DMA_APBX,
+        }
+};
+
+static struct platform_device_id mxs_dma_ids[] = {
+        {
+                .name = "imx23-dma-apbh",
+                .driver_data = (kernel_ulong_t) &mxs_dma_types[0],
+        }, {
+                .name = "imx23-dma-apbx",
+                .driver_data = (kernel_ulong_t) &mxs_dma_types[1],
+        }, {
+                .name = "imx28-dma-apbh",
+                .driver_data = (kernel_ulong_t) &mxs_dma_types[2],
+        }, {
+                .name = "imx28-dma-apbx",
+                .driver_data = (kernel_ulong_t) &mxs_dma_types[3],
+        }, {
+                /* end of list */
+        }
+};
+
+static const struct of_device_id mxs_dma_dt_ids[] = {
+        { .compatible = "fsl,imx23-dma-apbh", .data = &mxs_dma_ids[0], },
+        { .compatible = "fsl,imx23-dma-apbx", .data = &mxs_dma_ids[1], },
+        { .compatible = "fsl,imx28-dma-apbh", .data = &mxs_dma_ids[2], },
+        { .compatible = "fsl,imx28-dma-apbx", .data = &mxs_dma_ids[3], },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxs_dma_dt_ids);
+
+static struct mxs_dma_chan *to_mxs_dma_chan(struct dma_chan *chan)
+{
+        return container_of(chan, struct mxs_dma_chan, chan);
+}
+
+int mxs_dma_is_apbh(struct dma_chan *chan)
+{
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
+        struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
+
+        return dma_is_apbh(mxs_dma);
+}
+
+int mxs_dma_is_apbx(struct dma_chan *chan)
+{
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
+        struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
+
+        return !dma_is_apbh(mxs_dma);
+}
+
 static void mxs_dma_reset_chan(struct mxs_dma_chan *mxs_chan)
 {
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int chan_id = mxs_chan->chan.chan_id;
 
-        if (dma_is_apbh() && apbh_is_old())
+        if (dma_is_apbh(mxs_dma) && apbh_is_old(mxs_dma))
                 writel(1 << (chan_id + BP_APBH_CTRL0_RESET_CHANNEL),
-                        mxs_dma->base + HW_APBHX_CTRL0 + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CTRL0 + STMP_OFFSET_REG_SET);
         else
                 writel(1 << (chan_id + BP_APBHX_CHANNEL_CTRL_RESET_CHANNEL),
-                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + STMP_OFFSET_REG_SET);
 }
 
 static void mxs_dma_enable_chan(struct mxs_dma_chan *mxs_chan)
@@ -151,10 +230,10 @@ static void mxs_dma_enable_chan(struct mxs_dma_chan *mxs_chan)
 
         /* set cmd_addr up */
         writel(mxs_chan->ccw_phys,
-                mxs_dma->base + HW_APBHX_CHn_NXTCMDAR(chan_id));
+                mxs_dma->base + HW_APBHX_CHn_NXTCMDAR(mxs_dma, chan_id));
 
         /* write 1 to SEMA to kick off the channel */
-        writel(1, mxs_dma->base + HW_APBHX_CHn_SEMA(chan_id));
+        writel(1, mxs_dma->base + HW_APBHX_CHn_SEMA(mxs_dma, chan_id));
 }
 
 static void mxs_dma_disable_chan(struct mxs_dma_chan *mxs_chan)
@@ -168,12 +247,12 @@ static void mxs_dma_pause_chan(struct mxs_dma_chan *mxs_chan)
         int chan_id = mxs_chan->chan.chan_id;
 
         /* freeze the channel */
-        if (dma_is_apbh() && apbh_is_old())
+        if (dma_is_apbh(mxs_dma) && apbh_is_old(mxs_dma))
                 writel(1 << chan_id,
-                        mxs_dma->base + HW_APBHX_CTRL0 + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CTRL0 + STMP_OFFSET_REG_SET);
         else
                 writel(1 << chan_id,
-                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + STMP_OFFSET_REG_SET);
 
         mxs_chan->status = DMA_PAUSED;
 }
@@ -184,21 +263,16 @@ static void mxs_dma_resume_chan(struct mxs_dma_chan *mxs_chan)
         int chan_id = mxs_chan->chan.chan_id;
 
         /* unfreeze the channel */
-        if (dma_is_apbh() && apbh_is_old())
+        if (dma_is_apbh(mxs_dma) && apbh_is_old(mxs_dma))
                 writel(1 << chan_id,
-                        mxs_dma->base + HW_APBHX_CTRL0 + MXS_CLR_ADDR);
+                        mxs_dma->base + HW_APBHX_CTRL0 + STMP_OFFSET_REG_CLR);
         else
                 writel(1 << chan_id,
-                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + MXS_CLR_ADDR);
+                        mxs_dma->base + HW_APBHX_CHANNEL_CTRL + STMP_OFFSET_REG_CLR);
 
         mxs_chan->status = DMA_IN_PROGRESS;
 }
 
-static struct mxs_dma_chan *to_mxs_dma_chan(struct dma_chan *chan)
-{
-        return container_of(chan, struct mxs_dma_chan, chan);
-}
-
 static dma_cookie_t mxs_dma_tx_submit(struct dma_async_tx_descriptor *tx)
 {
         return dma_cookie_assign(tx);
@@ -220,11 +294,11 @@ static irqreturn_t mxs_dma_int_handler(int irq, void *dev_id)
         /* completion status */
         stat1 = readl(mxs_dma->base + HW_APBHX_CTRL1);
         stat1 &= MXS_DMA_CHANNELS_MASK;
-        writel(stat1, mxs_dma->base + HW_APBHX_CTRL1 + MXS_CLR_ADDR);
+        writel(stat1, mxs_dma->base + HW_APBHX_CTRL1 + STMP_OFFSET_REG_CLR);
 
         /* error status */
         stat2 = readl(mxs_dma->base + HW_APBHX_CTRL2);
-        writel(stat2, mxs_dma->base + HW_APBHX_CTRL2 + MXS_CLR_ADDR);
+        writel(stat2, mxs_dma->base + HW_APBHX_CTRL2 + STMP_OFFSET_REG_CLR);
 
         /*
          * When both completion and error of termination bits set at the
@@ -567,27 +641,21 @@ static int __init mxs_dma_init(struct mxs_dma_engine *mxs_dma)
         if (ret)
                 return ret;
 
-        ret = mxs_reset_block(mxs_dma->base);
+        ret = stmp_reset_block(mxs_dma->base);
         if (ret)
                 goto err_out;
 
-        /* only major version matters */
-        mxs_dma->version = readl(mxs_dma->base +
-                                ((mxs_dma->dev_id == MXS_DMA_APBX) ?
-                                HW_APBX_VERSION : HW_APBH_VERSION)) >>
-                                BP_APBHX_VERSION_MAJOR;
-
         /* enable apbh burst */
-        if (dma_is_apbh()) {
+        if (dma_is_apbh(mxs_dma)) {
                 writel(BM_APBH_CTRL0_APB_BURST_EN,
-                        mxs_dma->base + HW_APBHX_CTRL0 + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CTRL0 + STMP_OFFSET_REG_SET);
                 writel(BM_APBH_CTRL0_APB_BURST8_EN,
-                        mxs_dma->base + HW_APBHX_CTRL0 + MXS_SET_ADDR);
+                        mxs_dma->base + HW_APBHX_CTRL0 + STMP_OFFSET_REG_SET);
         }
 
         /* enable irq for all the channels */
         writel(MXS_DMA_CHANNELS_MASK << MXS_DMA_CHANNELS,
-                mxs_dma->base + HW_APBHX_CTRL1 + MXS_SET_ADDR);
+                mxs_dma->base + HW_APBHX_CTRL1 + STMP_OFFSET_REG_SET);
 
 err_out:
         clk_disable_unprepare(mxs_dma->clk);
@@ -596,8 +664,9 @@ err_out:
 
 static int __init mxs_dma_probe(struct platform_device *pdev)
 {
-        const struct platform_device_id *id_entry =
-                                platform_get_device_id(pdev);
+        const struct platform_device_id *id_entry;
+        const struct of_device_id *of_id;
+        const struct mxs_dma_type *dma_type;
         struct mxs_dma_engine *mxs_dma;
         struct resource *iores;
         int ret, i;
@@ -606,7 +675,15 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
         if (!mxs_dma)
                 return -ENOMEM;
 
-        mxs_dma->dev_id = id_entry->driver_data;
+        of_id = of_match_device(mxs_dma_dt_ids, &pdev->dev);
+        if (of_id)
+                id_entry = of_id->data;
+        else
+                id_entry = platform_get_device_id(pdev);
+
+        dma_type = (struct mxs_dma_type *)id_entry->driver_data;
+        mxs_dma->type = dma_type->type;
+        mxs_dma->dev_id = dma_type->id;
 
         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
@@ -689,23 +766,12 @@ err_request_region:
         return ret;
 }
 
-static struct platform_device_id mxs_dma_type[] = {
-        {
-                .name = "mxs-dma-apbh",
-                .driver_data = MXS_DMA_APBH,
-        }, {
-                .name = "mxs-dma-apbx",
-                .driver_data = MXS_DMA_APBX,
-        }, {
-                /* end of list */
-        }
-};
-
 static struct platform_driver mxs_dma_driver = {
         .driver         = {
                 .name   = "mxs-dma",
+                .of_match_table = mxs_dma_dt_ids,
         },
-        .id_table       = mxs_dma_type,
+        .id_table       = mxs_dma_ids,
 };
 
 static int __init mxs_dma_module_init(void)
diff --git a/drivers/gpio/gpio-mxs.c b/drivers/gpio/gpio-mxs.c
index b4136501abd8..39e495669961 100644
--- a/drivers/gpio/gpio-mxs.c
+++ b/drivers/gpio/gpio-mxs.c
@@ -25,23 +25,25 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/gpio.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/basic_mmio_gpio.h>
 #include <linux/module.h>
-#include <mach/mxs.h>
 
 #define MXS_SET         0x4
 #define MXS_CLR         0x8
 
-#define PINCTRL_DOUT(n)         ((cpu_is_mx23() ? 0x0500 : 0x0700) + (n) * 0x10)
-#define PINCTRL_DIN(n)          ((cpu_is_mx23() ? 0x0600 : 0x0900) + (n) * 0x10)
-#define PINCTRL_DOE(n)          ((cpu_is_mx23() ? 0x0700 : 0x0b00) + (n) * 0x10)
-#define PINCTRL_PIN2IRQ(n)      ((cpu_is_mx23() ? 0x0800 : 0x1000) + (n) * 0x10)
-#define PINCTRL_IRQEN(n)        ((cpu_is_mx23() ? 0x0900 : 0x1100) + (n) * 0x10)
-#define PINCTRL_IRQLEV(n)       ((cpu_is_mx23() ? 0x0a00 : 0x1200) + (n) * 0x10)
-#define PINCTRL_IRQPOL(n)       ((cpu_is_mx23() ? 0x0b00 : 0x1300) + (n) * 0x10)
-#define PINCTRL_IRQSTAT(n)      ((cpu_is_mx23() ? 0x0c00 : 0x1400) + (n) * 0x10)
+#define PINCTRL_DOUT(p)         ((is_imx23_gpio(p) ? 0x0500 : 0x0700) + (p->id) * 0x10)
+#define PINCTRL_DIN(p)          ((is_imx23_gpio(p) ? 0x0600 : 0x0900) + (p->id) * 0x10)
+#define PINCTRL_DOE(p)          ((is_imx23_gpio(p) ? 0x0700 : 0x0b00) + (p->id) * 0x10)
+#define PINCTRL_PIN2IRQ(p)      ((is_imx23_gpio(p) ? 0x0800 : 0x1000) + (p->id) * 0x10)
+#define PINCTRL_IRQEN(p)        ((is_imx23_gpio(p) ? 0x0900 : 0x1100) + (p->id) * 0x10)
+#define PINCTRL_IRQLEV(p)       ((is_imx23_gpio(p) ? 0x0a00 : 0x1200) + (p->id) * 0x10)
+#define PINCTRL_IRQPOL(p)       ((is_imx23_gpio(p) ? 0x0b00 : 0x1300) + (p->id) * 0x10)
+#define PINCTRL_IRQSTAT(p)      ((is_imx23_gpio(p) ? 0x0c00 : 0x1400) + (p->id) * 0x10)
 
 #define GPIO_INT_FALL_EDGE      0x0
 #define GPIO_INT_LOW_LEV        0x1
@@ -52,14 +54,30 @@
 
 #define irq_to_gpio(irq)        ((irq) - MXS_GPIO_IRQ_START)
 
+enum mxs_gpio_id {
+        IMX23_GPIO,
+        IMX28_GPIO,
+};
+
 struct mxs_gpio_port {
         void __iomem *base;
         int id;
         int irq;
         int virtual_irq_start;
         struct bgpio_chip bgc;
+        enum mxs_gpio_id devid;
 };
 
+static inline int is_imx23_gpio(struct mxs_gpio_port *port)
+{
+        return port->devid == IMX23_GPIO;
+}
+
+static inline int is_imx28_gpio(struct mxs_gpio_port *port)
+{
+        return port->devid == IMX28_GPIO;
+}
+
 /* Note: This driver assumes 32 GPIOs are handled in one register */
 
 static int mxs_gpio_set_irq_type(struct irq_data *d, unsigned int type)
@@ -89,21 +107,21 @@ static int mxs_gpio_set_irq_type(struct irq_data *d, unsigned int type)
         }
 
         /* set level or edge */
-        pin_addr = port->base + PINCTRL_IRQLEV(port->id);
+        pin_addr = port->base + PINCTRL_IRQLEV(port);
         if (edge & GPIO_INT_LEV_MASK)
                 writel(pin_mask, pin_addr + MXS_SET);
         else
                 writel(pin_mask, pin_addr + MXS_CLR);
 
         /* set polarity */
-        pin_addr = port->base + PINCTRL_IRQPOL(port->id);
+        pin_addr = port->base + PINCTRL_IRQPOL(port);
         if (edge & GPIO_INT_POL_MASK)
                 writel(pin_mask, pin_addr + MXS_SET);
         else
                 writel(pin_mask, pin_addr + MXS_CLR);
 
         writel(1 << (gpio & 0x1f),
-               port->base + PINCTRL_IRQSTAT(port->id) + MXS_CLR);
+               port->base + PINCTRL_IRQSTAT(port) + MXS_CLR);
 
         return 0;
 }
@@ -117,8 +135,8 @@ static void mxs_gpio_irq_handler(u32 irq, struct irq_desc *desc)
 
         desc->irq_data.chip->irq_ack(&desc->irq_data);
 
-        irq_stat = readl(port->base + PINCTRL_IRQSTAT(port->id)) &
-                        readl(port->base + PINCTRL_IRQEN(port->id));
+        irq_stat = readl(port->base + PINCTRL_IRQSTAT(port)) &
+                        readl(port->base + PINCTRL_IRQEN(port));
 
         while (irq_stat != 0) {
                 int irqoffset = fls(irq_stat) - 1;
@@ -164,8 +182,8 @@ static void __init mxs_gpio_init_gc(struct mxs_gpio_port *port)
         ct->chip.irq_unmask = irq_gc_mask_set_bit;
         ct->chip.irq_set_type = mxs_gpio_set_irq_type;
         ct->chip.irq_set_wake = mxs_gpio_set_wake_irq;
-        ct->regs.ack = PINCTRL_IRQSTAT(port->id) + MXS_CLR;
-        ct->regs.mask = PINCTRL_IRQEN(port->id);
+        ct->regs.ack = PINCTRL_IRQSTAT(port) + MXS_CLR;
+        ct->regs.mask = PINCTRL_IRQEN(port);
 
         irq_setup_generic_chip(gc, IRQ_MSK(32), 0, IRQ_NOREQUEST, 0);
 }
@@ -179,60 +197,83 @@ static int mxs_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
         return port->virtual_irq_start + offset;
 }
 
+static struct platform_device_id mxs_gpio_ids[] = {
+        {
+                .name = "imx23-gpio",
+                .driver_data = IMX23_GPIO,
+        }, {
+                .name = "imx28-gpio",
+                .driver_data = IMX28_GPIO,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(platform, mxs_gpio_ids);
+
+static const struct of_device_id mxs_gpio_dt_ids[] = {
+        { .compatible = "fsl,imx23-gpio", .data = (void *) IMX23_GPIO, },
+        { .compatible = "fsl,imx28-gpio", .data = (void *) IMX28_GPIO, },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxs_gpio_dt_ids);
+
 static int __devinit mxs_gpio_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                        of_match_device(mxs_gpio_dt_ids, &pdev->dev);
+        struct device_node *np = pdev->dev.of_node;
+        struct device_node *parent;
         static void __iomem *base;
         struct mxs_gpio_port *port;
         struct resource *iores = NULL;
         int err;
 
-        port = kzalloc(sizeof(struct mxs_gpio_port), GFP_KERNEL);
+        port = devm_kzalloc(&pdev->dev, sizeof(*port), GFP_KERNEL);
         if (!port)
                 return -ENOMEM;
 
-        port->id = pdev->id;
+        if (np) {
+                port->id = of_alias_get_id(np, "gpio");
+                if (port->id < 0)
+                        return port->id;
+                port->devid = (enum mxs_gpio_id) of_id->data;
+        } else {
+                port->id = pdev->id;
+                port->devid = pdev->id_entry->driver_data;
+        }
         port->virtual_irq_start = MXS_GPIO_IRQ_START + port->id * 32;
 
+        port->irq = platform_get_irq(pdev, 0);
+        if (port->irq < 0)
+                return port->irq;
+
         /*
          * map memory region only once, as all the gpio ports
          * share the same one
          */
         if (!base) {
-                iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-                if (!iores) {
-                        err = -ENODEV;
-                        goto out_kfree;
-                }
-
-                if (!request_mem_region(iores->start, resource_size(iores),
-                                        pdev->name)) {
-                        err = -EBUSY;
-                        goto out_kfree;
-                }
-
-                base = ioremap(iores->start, resource_size(iores));
-                if (!base) {
-                        err = -ENOMEM;
-                        goto out_release_mem;
+                if (np) {
+                        parent = of_get_parent(np);
+                        base = of_iomap(parent, 0);
+                        of_node_put(parent);
+                } else {
+                        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                        base = devm_request_and_ioremap(&pdev->dev, iores);
                 }
+                if (!base)
+                        return -EADDRNOTAVAIL;
         }
         port->base = base;
 
-        port->irq = platform_get_irq(pdev, 0);
-        if (port->irq < 0) {
-                err = -EINVAL;
-                goto out_iounmap;
-        }
-
         /*
          * select the pin interrupt functionality but initially
          * disable the interrupts
          */
-        writel(~0U, port->base + PINCTRL_PIN2IRQ(port->id));
-        writel(0, port->base + PINCTRL_IRQEN(port->id));
+        writel(~0U, port->base + PINCTRL_PIN2IRQ(port));
+        writel(0, port->base + PINCTRL_IRQEN(port));
 
         /* clear address has to be used to clear IRQSTAT bits */
-        writel(~0U, port->base + PINCTRL_IRQSTAT(port->id) + MXS_CLR);
+        writel(~0U, port->base + PINCTRL_IRQSTAT(port) + MXS_CLR);
 
         /* gpio-mxs can be a generic irq chip */
         mxs_gpio_init_gc(port);
@@ -242,41 +283,32 @@ static int __devinit mxs_gpio_probe(struct platform_device *pdev)
         irq_set_handler_data(port->irq, port);
 
         err = bgpio_init(&port->bgc, &pdev->dev, 4,
-                         port->base + PINCTRL_DIN(port->id),
-                         port->base + PINCTRL_DOUT(port->id), NULL,
-                         port->base + PINCTRL_DOE(port->id), NULL, 0);
+                         port->base + PINCTRL_DIN(port),
+                         port->base + PINCTRL_DOUT(port), NULL,
+                         port->base + PINCTRL_DOE(port), NULL, 0);
         if (err)
-                goto out_iounmap;
+                return err;
 
         port->bgc.gc.to_irq = mxs_gpio_to_irq;
         port->bgc.gc.base = port->id * 32;
 
         err = gpiochip_add(&port->bgc.gc);
-        if (err)
-                goto out_bgpio_remove;
+        if (err) {
+                bgpio_remove(&port->bgc);
+                return err;
+        }
 
         return 0;
-
-out_bgpio_remove:
-        bgpio_remove(&port->bgc);
-out_iounmap:
-        if (iores)
-                iounmap(port->base);
-out_release_mem:
-        if (iores)
-                release_mem_region(iores->start, resource_size(iores));
-out_kfree:
-        kfree(port);
-        dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
-        return err;
 }
 
 static struct platform_driver mxs_gpio_driver = {
         .driver         = {
                 .name   = "gpio-mxs",
                 .owner  = THIS_MODULE,
+                .of_match_table = mxs_gpio_dt_ids,
         },
         .probe          = mxs_gpio_probe,
+        .id_table       = mxs_gpio_ids,
 };
 
 static int __init mxs_gpio_init(void)
diff --git a/drivers/i2c/busses/i2c-mxs.c b/drivers/i2c/busses/i2c-mxs.c
index 58a338846f06..04eb441b6ce1 100644
--- a/drivers/i2c/busses/i2c-mxs.c
+++ b/drivers/i2c/busses/i2c-mxs.c
@@ -28,6 +28,9 @@
 #include <linux/io.h>
 #include <linux/pinctrl/consumer.h>
 #include <linux/stmp_device.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_i2c.h>
 
 #define DRIVER_NAME "mxs-i2c"
 
@@ -366,6 +369,7 @@ static int __devinit mxs_i2c_probe(struct platform_device *pdev)
         adap->algo = &mxs_i2c_algo;
         adap->dev.parent = dev;
         adap->nr = pdev->id;
+        adap->dev.of_node = pdev->dev.of_node;
         i2c_set_adapdata(adap, i2c);
         err = i2c_add_numbered_adapter(adap);
         if (err) {
@@ -375,6 +379,8 @@ static int __devinit mxs_i2c_probe(struct platform_device *pdev)
                 return err;
         }
 
+        of_i2c_register_devices(adap);
+
         return 0;
 }
 
@@ -394,10 +400,17 @@ static int __devexit mxs_i2c_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id mxs_i2c_dt_ids[] = {
+        { .compatible = "fsl,imx28-i2c", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxs_i2c_dt_ids);
+
 static struct platform_driver mxs_i2c_driver = {
         .driver = {
                    .name = DRIVER_NAME,
                    .owner = THIS_MODULE,
+                   .of_match_table = mxs_i2c_dt_ids,
                    },
         .remove = __devexit_p(mxs_i2c_remove),
 };
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index bb03ddda481d..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>
@@ -40,18 +43,15 @@
 #include <linux/module.h>
 #include <linux/fsl/mxs-dma.h>
 #include <linux/pinctrl/consumer.h>
-
-#include <mach/mxs.h>
-#include <mach/common.h>
-#include <mach/mmc.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
@@ -86,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)
@@ -116,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)
 
@@ -139,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;
@@ -146,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;
 
@@ -158,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);
 }
 
@@ -191,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) |
@@ -207,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;
@@ -215,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,
@@ -229,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));
                 }
         }
 
@@ -277,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);
@@ -485,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);
@@ -509,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;
@@ -598,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;
 
@@ -637,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);
@@ -669,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;
@@ -677,11 +675,34 @@ 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;
@@ -691,46 +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_iounmap;
+                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);
 
@@ -752,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;
@@ -765,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;
 
@@ -779,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;
 }
 
@@ -806,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)
@@ -820,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;
 }
 
@@ -865,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
         },
 };