4 files changed, 315 insertions, 162 deletions

diff --git a/drivers/gpu/drm/imx/Makefile b/drivers/gpu/drm/imx/Makefile
index 582c438d8cbd..63cf56ad5c61 100644
--- a/drivers/gpu/drm/imx/Makefile
+++ b/drivers/gpu/drm/imx/Makefile
@@ -9,4 +9,4 @@ obj-$(CONFIG_DRM_IMX_LDB) += imx-ldb.o
 
 imx-ipuv3-crtc-objs  := ipuv3-crtc.o ipuv3-plane.o
 obj-$(CONFIG_DRM_IMX_IPUV3)     += imx-ipuv3-crtc.o
-obj-$(CONFIG_DRM_IMX_HDMI) += imx-hdmi.o
+obj-$(CONFIG_DRM_IMX_HDMI) += imx-hdmi.o imx-hdmi_pltfm.o
diff --git a/drivers/gpu/drm/imx/imx-hdmi.c b/drivers/gpu/drm/imx/imx-hdmi.c
index 3118dde3ea62..9f2f0feb7b75 100644
--- a/drivers/gpu/drm/imx/imx-hdmi.c
+++ b/drivers/gpu/drm/imx/imx-hdmi.c
@@ -12,25 +12,20 @@
  * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
  */
 
-#include <linux/component.h>
 #include <linux/irq.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/hdmi.h>
-#include <linux/regmap.h>
-#include <linux/mfd/syscon.h>
-#include <linux/mfd/syscon/imx6q-iomuxc-gpr.h>
 #include <linux/of_device.h>
 
+#include <drm/drm_of.h>
 #include <drm/drmP.h>
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_edid.h>
 #include <drm/drm_encoder_slave.h>
-#include <video/imx-ipu-v3.h>
 
 #include "imx-hdmi.h"
-#include "imx-drm.h"
 
 #define HDMI_EDID_LEN           512
 
@@ -54,11 +49,6 @@ enum hdmi_datamap {
         YCbCr422_12B = 0x12,
 };
 
-enum imx_hdmi_devtype {
-        IMX6Q_HDMI,
-        IMX6DL_HDMI,
-};
-
 static const u16 csc_coeff_default[3][4] = {
         { 0x2000, 0x0000, 0x0000, 0x0000 },
         { 0x0000, 0x2000, 0x0000, 0x0000 },
@@ -113,7 +103,8 @@ struct hdmi_data_info {
 
 struct imx_hdmi {
         struct drm_connector connector;
-        struct drm_encoder encoder;
+        struct drm_encoder *encoder;
+        struct drm_bridge *bridge;
 
         enum imx_hdmi_devtype dev_type;
         struct device *dev;
@@ -121,6 +112,7 @@ struct imx_hdmi {
         struct clk *iahb_clk;
 
         struct hdmi_data_info hdmi_data;
+        const struct imx_hdmi_plat_data *plat_data;
         int vic;
 
         u8 edid[HDMI_EDID_LEN];
@@ -137,13 +129,6 @@ struct imx_hdmi {
         int ratio;
 };
 
-static void imx_hdmi_set_ipu_di_mux(struct imx_hdmi *hdmi, int ipu_di)
-{
-        regmap_update_bits(hdmi->regmap, IOMUXC_GPR3,
-                           IMX6Q_GPR3_HDMI_MUX_CTL_MASK,
-                           ipu_di << IMX6Q_GPR3_HDMI_MUX_CTL_SHIFT);
-}
-
 static inline void hdmi_writeb(struct imx_hdmi *hdmi, u8 val, int offset)
 {
         writeb(val, hdmi->regs + offset);
@@ -1371,6 +1356,50 @@ static void imx_hdmi_poweroff(struct imx_hdmi *hdmi)
         imx_hdmi_phy_disable(hdmi);
 }
 
+static void imx_hdmi_bridge_mode_set(struct drm_bridge *bridge,
+                                     struct drm_display_mode *mode,
+                                     struct drm_display_mode *adjusted_mode)
+{
+        struct imx_hdmi *hdmi = bridge->driver_private;
+
+        imx_hdmi_setup(hdmi, mode);
+
+        /* Store the display mode for plugin/DKMS poweron events */
+        memcpy(&hdmi->previous_mode, mode, sizeof(hdmi->previous_mode));
+}
+
+static bool imx_hdmi_bridge_mode_fixup(struct drm_bridge *bridge,
+                                       const struct drm_display_mode *mode,
+                                       struct drm_display_mode *adjusted_mode)
+{
+        return true;
+}
+
+static void imx_hdmi_bridge_disable(struct drm_bridge *bridge)
+{
+        struct imx_hdmi *hdmi = bridge->driver_private;
+
+        imx_hdmi_poweroff(hdmi);
+}
+
+static void imx_hdmi_bridge_enable(struct drm_bridge *bridge)
+{
+        struct imx_hdmi *hdmi = bridge->driver_private;
+
+        imx_hdmi_poweron(hdmi);
+}
+
+static void imx_hdmi_bridge_destroy(struct drm_bridge *bridge)
+{
+        drm_bridge_cleanup(bridge);
+        kfree(bridge);
+}
+
+static void imx_hdmi_bridge_nop(struct drm_bridge *bridge)
+{
+        /* do nothing */
+}
+
 static enum drm_connector_status imx_hdmi_connector_detect(struct drm_connector
                                                         *connector, bool force)
 {
@@ -1412,78 +1441,20 @@ static struct drm_encoder *imx_hdmi_connector_best_encoder(struct drm_connector
         struct imx_hdmi *hdmi = container_of(connector, struct imx_hdmi,
                                              connector);
 
-        return &hdmi->encoder;
+        return hdmi->encoder;
 }
 
-static void imx_hdmi_encoder_mode_set(struct drm_encoder *encoder,
-                        struct drm_display_mode *mode,
-                        struct drm_display_mode *adjusted_mode)
+static void imx_hdmi_connector_destroy(struct drm_connector *connector)
 {
-        struct imx_hdmi *hdmi = container_of(encoder, struct imx_hdmi, encoder);
-
-        imx_hdmi_setup(hdmi, mode);
-
-        /* Store the display mode for plugin/DKMS poweron events */
-        memcpy(&hdmi->previous_mode, mode, sizeof(hdmi->previous_mode));
+        drm_connector_unregister(connector);
+        drm_connector_cleanup(connector);
 }
 
-static bool imx_hdmi_encoder_mode_fixup(struct drm_encoder *encoder,
-                        const struct drm_display_mode *mode,
-                        struct drm_display_mode *adjusted_mode)
-{
-        return true;
-}
-
-static void imx_hdmi_encoder_disable(struct drm_encoder *encoder)
-{
-}
-
-static void imx_hdmi_encoder_dpms(struct drm_encoder *encoder, int mode)
-{
-        struct imx_hdmi *hdmi = container_of(encoder, struct imx_hdmi, encoder);
-
-        if (mode)
-                imx_hdmi_poweroff(hdmi);
-        else
-                imx_hdmi_poweron(hdmi);
-}
-
-static void imx_hdmi_encoder_prepare(struct drm_encoder *encoder)
-{
-        struct imx_hdmi *hdmi = container_of(encoder, struct imx_hdmi, encoder);
-
-        imx_hdmi_poweroff(hdmi);
-        imx_drm_panel_format(encoder, V4L2_PIX_FMT_RGB24);
-}
-
-static void imx_hdmi_encoder_commit(struct drm_encoder *encoder)
-{
-        struct imx_hdmi *hdmi = container_of(encoder, struct imx_hdmi, encoder);
-        int mux = imx_drm_encoder_get_mux_id(hdmi->dev->of_node, encoder);
-
-        imx_hdmi_set_ipu_di_mux(hdmi, mux);
-
-        imx_hdmi_poweron(hdmi);
-}
-
-static struct drm_encoder_funcs imx_hdmi_encoder_funcs = {
-        .destroy = imx_drm_encoder_destroy,
-};
-
-static struct drm_encoder_helper_funcs imx_hdmi_encoder_helper_funcs = {
-        .dpms = imx_hdmi_encoder_dpms,
-        .prepare = imx_hdmi_encoder_prepare,
-        .commit = imx_hdmi_encoder_commit,
-        .mode_set = imx_hdmi_encoder_mode_set,
-        .mode_fixup = imx_hdmi_encoder_mode_fixup,
-        .disable = imx_hdmi_encoder_disable,
-};
-
 static struct drm_connector_funcs imx_hdmi_connector_funcs = {
         .dpms = drm_helper_connector_dpms,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .detect = imx_hdmi_connector_detect,
-        .destroy = imx_drm_connector_destroy,
+        .destroy = imx_hdmi_connector_destroy,
 };
 
 static struct drm_connector_helper_funcs imx_hdmi_connector_helper_funcs = {
@@ -1491,6 +1462,16 @@ static struct drm_connector_helper_funcs imx_hdmi_connector_helper_funcs = {
         .best_encoder = imx_hdmi_connector_best_encoder,
 };
 
+struct drm_bridge_funcs imx_hdmi_bridge_funcs = {
+        .enable = imx_hdmi_bridge_enable,
+        .disable = imx_hdmi_bridge_disable,
+        .pre_enable = imx_hdmi_bridge_nop,
+        .post_disable = imx_hdmi_bridge_nop,
+        .mode_set = imx_hdmi_bridge_mode_set,
+        .mode_fixup = imx_hdmi_bridge_mode_fixup,
+        .destroy = imx_hdmi_bridge_destroy,
+};
+
 static irqreturn_t imx_hdmi_hardirq(int irq, void *dev_id)
 {
         struct imx_hdmi *hdmi = dev_id;
@@ -1539,74 +1520,61 @@ static irqreturn_t imx_hdmi_irq(int irq, void *dev_id)
 
 static int imx_hdmi_register(struct drm_device *drm, struct imx_hdmi *hdmi)
 {
+        struct drm_encoder *encoder = hdmi->encoder;
+        struct drm_bridge *bridge;
         int ret;
 
-        ret = imx_drm_encoder_parse_of(drm, &hdmi->encoder,
-                                       hdmi->dev->of_node);
-        if (ret)
-                return ret;
+        bridge = devm_kzalloc(drm->dev, sizeof(*bridge), GFP_KERNEL);
+        if (!bridge) {
+                DRM_ERROR("Failed to allocate drm bridge\n");
+                return -ENOMEM;
+        }
 
-        hdmi->connector.polled = DRM_CONNECTOR_POLL_HPD;
+        hdmi->bridge = bridge;
+        bridge->driver_private = hdmi;
+
+        ret = drm_bridge_init(drm, bridge, &imx_hdmi_bridge_funcs);
+        if (ret) {
+                DRM_ERROR("Failed to initialize bridge with drm\n");
+                return -EINVAL;
+        }
 
-        drm_encoder_helper_add(&hdmi->encoder, &imx_hdmi_encoder_helper_funcs);
-        drm_encoder_init(drm, &hdmi->encoder, &imx_hdmi_encoder_funcs,
-                         DRM_MODE_ENCODER_TMDS);
+        encoder->bridge = bridge;
+        hdmi->connector.polled = DRM_CONNECTOR_POLL_HPD;
 
         drm_connector_helper_add(&hdmi->connector,
                                  &imx_hdmi_connector_helper_funcs);
         drm_connector_init(drm, &hdmi->connector, &imx_hdmi_connector_funcs,
                            DRM_MODE_CONNECTOR_HDMIA);
 
-        hdmi->connector.encoder = &hdmi->encoder;
+        hdmi->connector.encoder = encoder;
 
-        drm_mode_connector_attach_encoder(&hdmi->connector, &hdmi->encoder);
+        drm_mode_connector_attach_encoder(&hdmi->connector, encoder);
 
         return 0;
 }
 
-static struct platform_device_id imx_hdmi_devtype[] = {
-        {
-                .name = "imx6q-hdmi",
-                .driver_data = IMX6Q_HDMI,
-        }, {
-                .name = "imx6dl-hdmi",
-                .driver_data = IMX6DL_HDMI,
-        }, { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(platform, imx_hdmi_devtype);
-
-static const struct of_device_id imx_hdmi_dt_ids[] = {
-{ .compatible = "fsl,imx6q-hdmi", .data = &imx_hdmi_devtype[IMX6Q_HDMI], },
-{ .compatible = "fsl,imx6dl-hdmi", .data = &imx_hdmi_devtype[IMX6DL_HDMI], },
-{ /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, imx_hdmi_dt_ids);
-
-static int imx_hdmi_bind(struct device *dev, struct device *master, void *data)
+int imx_hdmi_bind(struct device *dev, struct device *master,
+                 void *data, struct drm_encoder *encoder,
+                 struct resource *iores, int irq,
+                 const struct dw_hdmi_plat_data *plat_data)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct of_device_id *of_id =
-                                of_match_device(imx_hdmi_dt_ids, dev);
         struct drm_device *drm = data;
         struct device_node *np = dev->of_node;
         struct device_node *ddc_node;
         struct imx_hdmi *hdmi;
-        struct resource *iores;
-        int ret, irq;
+        int ret;
 
         hdmi = devm_kzalloc(dev, sizeof(*hdmi), GFP_KERNEL);
         if (!hdmi)
                 return -ENOMEM;
 
+        hdmi->plat_data = plat_data;
         hdmi->dev = dev;
+        hdmi->dev_type = plat_data->dev_type;
         hdmi->sample_rate = 48000;
         hdmi->ratio = 100;
-
-        if (of_id) {
-                const struct platform_device_id *device_id = of_id->data;
-
-                hdmi->dev_type = device_id->driver_data;
-        }
+        hdmi->encoder = encoder;
 
         ddc_node = of_parse_phandle(np, "ddc-i2c-bus", 0);
         if (ddc_node) {
@@ -1621,25 +1589,16 @@ static int imx_hdmi_bind(struct device *dev, struct device *master, void *data)
                 dev_dbg(hdmi->dev, "no ddc property found\n");
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0)
-                return irq;
-
         ret = devm_request_threaded_irq(dev, irq, imx_hdmi_hardirq,
                                         imx_hdmi_irq, IRQF_SHARED,
                                         dev_name(dev), hdmi);
         if (ret)
                 return ret;
 
-        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         hdmi->regs = devm_ioremap_resource(dev, iores);
         if (IS_ERR(hdmi->regs))
                 return PTR_ERR(hdmi->regs);
 
-        hdmi->regmap = syscon_regmap_lookup_by_phandle(np, "gpr");
-        if (IS_ERR(hdmi->regmap))
-                return PTR_ERR(hdmi->regmap);
-
         hdmi->isfr_clk = devm_clk_get(hdmi->dev, "isfr");
         if (IS_ERR(hdmi->isfr_clk)) {
                 ret = PTR_ERR(hdmi->isfr_clk);
@@ -1713,9 +1672,9 @@ err_isfr:
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(imx_hdmi_bind);
 
-static void imx_hdmi_unbind(struct device *dev, struct device *master,
-        void *data)
+void imx_hdmi_unbind(struct device *dev, struct device *master, void *data)
 {
         struct imx_hdmi *hdmi = dev_get_drvdata(dev);
 
@@ -1723,41 +1682,17 @@ static void imx_hdmi_unbind(struct device *dev, struct device *master,
         hdmi_writeb(hdmi, ~0, HDMI_IH_MUTE_PHY_STAT0);
 
         hdmi->connector.funcs->destroy(&hdmi->connector);
-        hdmi->encoder.funcs->destroy(&hdmi->encoder);
+        hdmi->encoder->funcs->destroy(hdmi->encoder);
 
         clk_disable_unprepare(hdmi->iahb_clk);
         clk_disable_unprepare(hdmi->isfr_clk);
         i2c_put_adapter(hdmi->ddc);
 }
-
-static const struct component_ops hdmi_ops = {
-        .bind   = imx_hdmi_bind,
-        .unbind = imx_hdmi_unbind,
-};
-
-static int imx_hdmi_platform_probe(struct platform_device *pdev)
-{
-        return component_add(&pdev->dev, &hdmi_ops);
-}
-
-static int imx_hdmi_platform_remove(struct platform_device *pdev)
-{
-        component_del(&pdev->dev, &hdmi_ops);
-        return 0;
-}
-
-static struct platform_driver imx_hdmi_driver = {
-        .probe  = imx_hdmi_platform_probe,
-        .remove = imx_hdmi_platform_remove,
-        .driver = {
-                .name = "imx-hdmi",
-                .of_match_table = imx_hdmi_dt_ids,
-        },
-};
-
-module_platform_driver(imx_hdmi_driver);
+EXPORT_SYMBOL_GPL(imx_hdmi_unbind);
 
 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
+MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
+MODULE_AUTHOR("Yakir Yang <ykk@rock-chips.com>");
 MODULE_DESCRIPTION("i.MX6 HDMI transmitter driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:imx-hdmi");
diff --git a/drivers/gpu/drm/imx/imx-hdmi.h b/drivers/gpu/drm/imx/imx-hdmi.h
index 39b677689db6..86c6c5bbc950 100644
--- a/drivers/gpu/drm/imx/imx-hdmi.h
+++ b/drivers/gpu/drm/imx/imx-hdmi.h
@@ -1029,4 +1029,19 @@ enum {
         HDMI_A_VIDPOLCFG_HSYNCPOL_ACTIVE_HIGH = 0x2,
         HDMI_A_VIDPOLCFG_HSYNCPOL_ACTIVE_LOW = 0x0,
 };
+
+enum imx_hdmi_devtype {
+        IMX6Q_HDMI,
+        IMX6DL_HDMI,
+};
+
+struct imx_hdmi_plat_data {
+        enum imx_hdmi_devtype dev_type;
+};
+
+int imx_hdmi_bind(struct device *dev, struct device *master,
+                  void *data, struct drm_encoder *encoder,
+                  struct resource *iores, int irq,
+                  const struct imx_hdmi_plat_data *plat_data);
+void imx_hdmi_unbind(struct device *dev, struct device *master, void *data);
 #endif /* __IMX_HDMI_H__ */
diff --git a/drivers/gpu/drm/imx/imx-hdmi_pltfm.c b/drivers/gpu/drm/imx/imx-hdmi_pltfm.c
new file mode 100644
index 000000000000..690181df71eb
--- /dev/null
+++ b/drivers/gpu/drm/imx/imx-hdmi_pltfm.c
@@ -0,0 +1,203 @@
+/* Copyright (C) 2011-2013 Freescale Semiconductor, Inc.
+ *
+ * derived from imx-hdmi.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/component.h>
+#include <linux/mfd/syscon.h>
+#include <linux/mfd/syscon/imx6q-iomuxc-gpr.h>
+#include <video/imx-ipu-v3.h>
+#include <linux/regmap.h>
+#include <drm/drm_of.h>
+#include <drm/drmP.h>
+#include <drm/drm_crtc_helper.h>
+#include <drm/drm_edid.h>
+#include <drm/drm_encoder_slave.h>
+
+#include "imx-drm.h"
+#include "imx-hdmi.h"
+
+struct imx_hdmi_priv {
+        struct device *dev;
+        struct drm_encoder encoder;
+        struct regmap *regmap;
+};
+
+static int imx_hdmi_parse_dt(struct imx_hdmi_priv *hdmi)
+{
+        struct device_node *np = hdmi->dev->of_node;
+
+        hdmi->regmap = syscon_regmap_lookup_by_phandle(np, "gpr");
+        if (IS_ERR(hdmi->regmap)) {
+                dev_err(hdmi->dev, "Unable to get gpr\n");
+                return PTR_ERR(hdmi->regmap);
+        }
+
+        return 0;
+}
+
+static void imx_hdmi_encoder_disable(struct drm_encoder *encoder)
+{
+}
+
+static bool imx_hdmi_encoder_mode_fixup(struct drm_encoder *encoder,
+                                        const struct drm_display_mode *mode,
+                                        struct drm_display_mode *adj_mode)
+{
+        return true;
+}
+
+static void imx_hdmi_encoder_mode_set(struct drm_encoder *encoder,
+                                      struct drm_display_mode *mode,
+                                      struct drm_display_mode *adj_mode)
+{
+}
+
+static void imx_hdmi_encoder_commit(struct drm_encoder *encoder)
+{
+        struct imx_hdmi_priv *hdmi = container_of(encoder,
+                                                  struct imx_hdmi_priv,
+                                                  encoder);
+        int mux = imx_drm_encoder_get_mux_id(hdmi->dev->of_node, encoder);
+
+        regmap_update_bits(hdmi->regmap, IOMUXC_GPR3,
+                           IMX6Q_GPR3_HDMI_MUX_CTL_MASK,
+                           mux << IMX6Q_GPR3_HDMI_MUX_CTL_SHIFT);
+}
+
+static void imx_hdmi_encoder_prepare(struct drm_encoder *encoder)
+{
+        imx_drm_panel_format(encoder, V4L2_PIX_FMT_RGB24);
+}
+
+static struct drm_encoder_helper_funcs imx_hdmi_encoder_helper_funcs = {
+        .mode_fixup = imx_hdmi_encoder_mode_fixup,
+        .mode_set   = imx_hdmi_encoder_mode_set,
+        .prepare    = imx_hdmi_encoder_prepare,
+        .commit     = imx_hdmi_encoder_commit,
+        .disable    = imx_hdmi_encoder_disable,
+};
+
+static struct drm_encoder_funcs imx_hdmi_encoder_funcs = {
+        .destroy = drm_encoder_cleanup,
+};
+
+static struct imx_hdmi_plat_data imx6q_hdmi_drv_data = {
+        .dev_type = IMX6Q_HDMI,
+};
+
+static struct imx_hdmi_plat_data imx6dl_hdmi_drv_data = {
+        .dev_type = IMX6DL_HDMI,
+};
+
+static const struct of_device_id imx_hdmi_dt_ids[] = {
+        { .compatible = "fsl,imx6q-hdmi",
+          .data = &imx6q_hdmi_drv_data
+        }, {
+          .compatible = "fsl,imx6dl-hdmi",
+          .data = &imx6dl_hdmi_drv_data
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, imx_hdmi_dt_ids);
+
+static int imx_hdmi_pltfm_bind(struct device *dev, struct device *master,
+                               void *data)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        const struct imx_hdmi_plat_data *plat_data;
+        const struct of_device_id *match;
+        struct drm_device *drm = data;
+        struct drm_encoder *encoder;
+        struct imx_hdmi_priv *hdmi;
+        struct resource *iores;
+        int irq;
+        int ret;
+
+        if (!pdev->dev.of_node)
+                return -ENODEV;
+
+        hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL);
+        if (!hdmi)
+                return -ENOMEM;
+
+        match = of_match_node(imx_hdmi_dt_ids, pdev->dev.of_node);
+        plat_data = match->data;
+        hdmi->dev = &pdev->dev;
+        encoder = &hdmi->encoder;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!iores)
+                return -ENXIO;
+
+        platform_set_drvdata(pdev, hdmi);
+
+        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
+        /*
+         * If we failed to find the CRTC(s) which this encoder is
+         * supposed to be connected to, it's because the CRTC has
+         * not been registered yet.  Defer probing, and hope that
+         * the required CRTC is added later.
+         */
+        if (encoder->possible_crtcs == 0)
+                return -EPROBE_DEFER;
+
+        ret = imx_hdmi_parse_dt(hdmi);
+        if (ret < 0)
+                return ret;
+
+        drm_encoder_helper_add(encoder, &imx_hdmi_encoder_helper_funcs);
+        drm_encoder_init(drm, encoder, &imx_hdmi_encoder_funcs,
+                         DRM_MODE_ENCODER_TMDS);
+
+        return imx_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
+}
+
+static void imx_hdmi_pltfm_unbind(struct device *dev, struct device *master,
+                                  void *data)
+{
+        return imx_hdmi_unbind(dev, master, data);
+}
+
+static const struct component_ops imx_hdmi_ops = {
+        .bind   = imx_hdmi_pltfm_bind,
+        .unbind = imx_hdmi_pltfm_unbind,
+};
+
+static int imx_hdmi_probe(struct platform_device *pdev)
+{
+        return component_add(&pdev->dev, &imx_hdmi_ops);
+}
+
+static int imx_hdmi_remove(struct platform_device *pdev)
+{
+        component_del(&pdev->dev, &imx_hdmi_ops);
+
+        return 0;
+}
+
+static struct platform_driver imx_hdmi_pltfm_driver = {
+        .probe  = imx_hdmi_probe,
+        .remove = imx_hdmi_remove,
+        .driver = {
+                .name = "hdmi-imx",
+                .of_match_table = imx_hdmi_dt_ids,
+        },
+};
+
+module_platform_driver(imx_hdmi_pltfm_driver);
+
+MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
+MODULE_AUTHOR("Yakir Yang <ykk@rock-chips.com>");
+MODULE_DESCRIPTION("IMX6 Specific DW-HDMI Driver Extension");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:hdmi-imx");