15 files changed, 688 insertions, 568 deletions

diff --git a/arch/arm/mach-omap2/display.c b/arch/arm/mach-omap2/display.c
index 60cded4738a0..54d49ddb9b81 100644
--- a/arch/arm/mach-omap2/display.c
+++ b/arch/arm/mach-omap2/display.c
@@ -185,16 +185,128 @@ static int omap_dss_set_min_bus_tput(struct device *dev, unsigned long tput)
         return omap_pm_set_min_bus_tput(dev, OCP_INITIATOR_AGENT, tput);
 }
 
+static struct platform_device *create_dss_pdev(const char *pdev_name,
+                int pdev_id, const char *oh_name, void *pdata, int pdata_len,
+                struct platform_device *parent)
+{
+        struct platform_device *pdev;
+        struct omap_device *od;
+        struct omap_hwmod *ohs[1];
+        struct omap_hwmod *oh;
+        int r;
+
+        oh = omap_hwmod_lookup(oh_name);
+        if (!oh) {
+                pr_err("Could not look up %s\n", oh_name);
+                r = -ENODEV;
+                goto err;
+        }
+
+        pdev = platform_device_alloc(pdev_name, pdev_id);
+        if (!pdev) {
+                pr_err("Could not create pdev for %s\n", pdev_name);
+                r = -ENOMEM;
+                goto err;
+        }
+
+        if (parent != NULL)
+                pdev->dev.parent = &parent->dev;
+
+        if (pdev->id != -1)
+                dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
+        else
+                dev_set_name(&pdev->dev, "%s", pdev->name);
+
+        ohs[0] = oh;
+        od = omap_device_alloc(pdev, ohs, 1, NULL, 0);
+        if (!od) {
+                pr_err("Could not alloc omap_device for %s\n", pdev_name);
+                r = -ENOMEM;
+                goto err;
+        }
+
+        r = platform_device_add_data(pdev, pdata, pdata_len);
+        if (r) {
+                pr_err("Could not set pdata for %s\n", pdev_name);
+                goto err;
+        }
+
+        r = omap_device_register(pdev);
+        if (r) {
+                pr_err("Could not register omap_device for %s\n", pdev_name);
+                goto err;
+        }
+
+        return pdev;
+
+err:
+        return ERR_PTR(r);
+}
+
+static struct platform_device *create_simple_dss_pdev(const char *pdev_name,
+                int pdev_id, void *pdata, int pdata_len,
+                struct platform_device *parent)
+{
+        struct platform_device *pdev;
+        int r;
+
+        pdev = platform_device_alloc(pdev_name, pdev_id);
+        if (!pdev) {
+                pr_err("Could not create pdev for %s\n", pdev_name);
+                r = -ENOMEM;
+                goto err;
+        }
+
+        if (parent != NULL)
+                pdev->dev.parent = &parent->dev;
+
+        if (pdev->id != -1)
+                dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
+        else
+                dev_set_name(&pdev->dev, "%s", pdev->name);
+
+        r = platform_device_add_data(pdev, pdata, pdata_len);
+        if (r) {
+                pr_err("Could not set pdata for %s\n", pdev_name);
+                goto err;
+        }
+
+        r = omap_device_register(pdev);
+        if (r) {
+                pr_err("Could not register omap_device for %s\n", pdev_name);
+                goto err;
+        }
+
+        return pdev;
+
+err:
+        return ERR_PTR(r);
+}
+
 int __init omap_display_init(struct omap_dss_board_info *board_data)
 {
         int r = 0;
-        struct omap_hwmod *oh;
         struct platform_device *pdev;
         int i, oh_count;
-        struct omap_display_platform_data pdata;
         const struct omap_dss_hwmod_data *curr_dss_hwmod;
+        struct platform_device *dss_pdev;
+
+        /* create omapdss device */
 
-        memset(&pdata, 0, sizeof(pdata));
+        board_data->dsi_enable_pads = omap_dsi_enable_pads;
+        board_data->dsi_disable_pads = omap_dsi_disable_pads;
+        board_data->get_context_loss_count = omap_pm_get_dev_context_loss_count;
+        board_data->set_min_bus_tput = omap_dss_set_min_bus_tput;
+
+        omap_display_device.dev.platform_data = board_data;
+
+        r = platform_device_register(&omap_display_device);
+        if (r < 0) {
+                pr_err("Unable to register omapdss device\n");
+                return r;
+        }
+
+        /* create devices for dss hwmods */
 
         if (cpu_is_omap24xx()) {
                 curr_dss_hwmod = omap2_dss_hwmod_data;
@@ -207,40 +319,58 @@ int __init omap_display_init(struct omap_dss_board_info *board_data)
                 oh_count = ARRAY_SIZE(omap4_dss_hwmod_data);
         }
 
-        if (board_data->dsi_enable_pads == NULL)
-                board_data->dsi_enable_pads = omap_dsi_enable_pads;
-        if (board_data->dsi_disable_pads == NULL)
-                board_data->dsi_disable_pads = omap_dsi_disable_pads;
-
-        pdata.board_data = board_data;
-        pdata.board_data->get_context_loss_count =
-                omap_pm_get_dev_context_loss_count;
-        pdata.board_data->set_min_bus_tput = omap_dss_set_min_bus_tput;
-
-        for (i = 0; i < oh_count; i++) {
-                oh = omap_hwmod_lookup(curr_dss_hwmod[i].oh_name);
-                if (!oh) {
-                        pr_err("Could not look up %s\n",
-                                curr_dss_hwmod[i].oh_name);
-                        return -ENODEV;
+        /*
+         * First create the pdev for dss_core, which is used as a parent device
+         * by the other dss pdevs. Note: dss_core has to be the first item in
+         * the hwmod list.
+         */
+        dss_pdev = create_dss_pdev(curr_dss_hwmod[0].dev_name,
+                        curr_dss_hwmod[0].id,
+                        curr_dss_hwmod[0].oh_name,
+                        board_data, sizeof(*board_data),
+                        NULL);
+
+        if (IS_ERR(dss_pdev)) {
+                pr_err("Could not build omap_device for %s\n",
+                                curr_dss_hwmod[0].oh_name);
+
+                return PTR_ERR(dss_pdev);
+        }
+
+        for (i = 1; i < oh_count; i++) {
+                pdev = create_dss_pdev(curr_dss_hwmod[i].dev_name,
+                                curr_dss_hwmod[i].id,
+                                curr_dss_hwmod[i].oh_name,
+                                board_data, sizeof(*board_data),
+                                dss_pdev);
+
+                if (IS_ERR(pdev)) {
+                        pr_err("Could not build omap_device for %s\n",
+                                        curr_dss_hwmod[i].oh_name);
+
+                        return PTR_ERR(pdev);
                 }
+        }
 
-                pdev = omap_device_build(curr_dss_hwmod[i].dev_name,
-                                curr_dss_hwmod[i].id, oh, &pdata,
-                                sizeof(struct omap_display_platform_data),
-                                NULL, 0, 0);
+        /* Create devices for DPI and SDI */
 
-                if (WARN((IS_ERR(pdev)), "Could not build omap_device for %s\n",
-                                curr_dss_hwmod[i].oh_name))
-                        return -ENODEV;
+        pdev = create_simple_dss_pdev("omapdss_dpi", -1,
+                        board_data, sizeof(*board_data), dss_pdev);
+        if (IS_ERR(pdev)) {
+                pr_err("Could not build platform_device for omapdss_dpi\n");
+                return PTR_ERR(pdev);
         }
-        omap_display_device.dev.platform_data = board_data;
 
-        r = platform_device_register(&omap_display_device);
-        if (r < 0)
-                printk(KERN_ERR "Unable to register OMAP-Display device\n");
+        if (cpu_is_omap34xx()) {
+                pdev = create_simple_dss_pdev("omapdss_sdi", -1,
+                                board_data, sizeof(*board_data), dss_pdev);
+                if (IS_ERR(pdev)) {
+                        pr_err("Could not build platform_device for omapdss_sdi\n");
+                        return PTR_ERR(pdev);
+                }
+        }
 
-        return r;
+        return 0;
 }
 
 static void dispc_disable_outputs(void)
diff --git a/drivers/video/omap2/displays/panel-tfp410.c b/drivers/video/omap2/displays/panel-tfp410.c
index 52637fa8fda8..bff306e041ca 100644
--- a/drivers/video/omap2/displays/panel-tfp410.c
+++ b/drivers/video/omap2/displays/panel-tfp410.c
@@ -47,13 +47,9 @@ struct panel_drv_data {
         struct mutex lock;
 
         int pd_gpio;
-};
 
-static inline struct tfp410_platform_data
-*get_pdata(const struct omap_dss_device *dssdev)
-{
-        return dssdev->data;
-}
+        struct i2c_adapter *i2c_adapter;
+};
 
 static int tfp410_power_on(struct omap_dss_device *dssdev)
 {
@@ -68,7 +64,7 @@ static int tfp410_power_on(struct omap_dss_device *dssdev)
                 goto err0;
 
         if (gpio_is_valid(ddata->pd_gpio))
-                gpio_set_value(ddata->pd_gpio, 1);
+                gpio_set_value_cansleep(ddata->pd_gpio, 1);
 
         return 0;
 err0:
@@ -83,18 +79,18 @@ static void tfp410_power_off(struct omap_dss_device *dssdev)
                 return;
 
         if (gpio_is_valid(ddata->pd_gpio))
-                gpio_set_value(ddata->pd_gpio, 0);
+                gpio_set_value_cansleep(ddata->pd_gpio, 0);
 
         omapdss_dpi_display_disable(dssdev);
 }
 
 static int tfp410_probe(struct omap_dss_device *dssdev)
 {
-        struct tfp410_platform_data *pdata = get_pdata(dssdev);
         struct panel_drv_data *ddata;
         int r;
+        int i2c_bus_num;
 
-        ddata = kzalloc(sizeof(*ddata), GFP_KERNEL);
+        ddata = devm_kzalloc(&dssdev->dev, sizeof(*ddata), GFP_KERNEL);
         if (!ddata)
                 return -ENOMEM;
 
@@ -104,10 +100,15 @@ static int tfp410_probe(struct omap_dss_device *dssdev)
         ddata->dssdev = dssdev;
         mutex_init(&ddata->lock);
 
-        if (pdata)
+        if (dssdev->data) {
+                struct tfp410_platform_data *pdata = dssdev->data;
+
                 ddata->pd_gpio = pdata->power_down_gpio;
-        else
+                i2c_bus_num = pdata->i2c_bus_num;
+        } else {
                 ddata->pd_gpio = -1;
+                i2c_bus_num = -1;
+        }
 
         if (gpio_is_valid(ddata->pd_gpio)) {
                 r = gpio_request_one(ddata->pd_gpio, GPIOF_OUT_INIT_LOW,
@@ -115,13 +116,31 @@ static int tfp410_probe(struct omap_dss_device *dssdev)
                 if (r) {
                         dev_err(&dssdev->dev, "Failed to request PD GPIO %d\n",
                                         ddata->pd_gpio);
-                        ddata->pd_gpio = -1;
+                        return r;
                 }
         }
 
+        if (i2c_bus_num != -1) {
+                struct i2c_adapter *adapter;
+
+                adapter = i2c_get_adapter(i2c_bus_num);
+                if (!adapter) {
+                        dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
+                                        i2c_bus_num);
+                        r = -EINVAL;
+                        goto err_i2c;
+                }
+
+                ddata->i2c_adapter = adapter;
+        }
+
         dev_set_drvdata(&dssdev->dev, ddata);
 
         return 0;
+err_i2c:
+        if (gpio_is_valid(ddata->pd_gpio))
+                gpio_free(ddata->pd_gpio);
+        return r;
 }
 
 static void __exit tfp410_remove(struct omap_dss_device *dssdev)
@@ -130,14 +149,15 @@ static void __exit tfp410_remove(struct omap_dss_device *dssdev)
 
         mutex_lock(&ddata->lock);
 
+        if (ddata->i2c_adapter)
+                i2c_put_adapter(ddata->i2c_adapter);
+
         if (gpio_is_valid(ddata->pd_gpio))
                 gpio_free(ddata->pd_gpio);
 
         dev_set_drvdata(&dssdev->dev, NULL);
 
         mutex_unlock(&ddata->lock);
-
-        kfree(ddata);
 }
 
 static int tfp410_enable(struct omap_dss_device *dssdev)
@@ -269,27 +289,17 @@ static int tfp410_read_edid(struct omap_dss_device *dssdev,
                 u8 *edid, int len)
 {
         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
-        struct tfp410_platform_data *pdata = get_pdata(dssdev);
-        struct i2c_adapter *adapter;
         int r, l, bytes_read;
 
         mutex_lock(&ddata->lock);
 
-        if (pdata->i2c_bus_num == 0) {
+        if (!ddata->i2c_adapter) {
                 r = -ENODEV;
                 goto err;
         }
 
-        adapter = i2c_get_adapter(pdata->i2c_bus_num);
-        if (!adapter) {
-                dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
-                                pdata->i2c_bus_num);
-                r = -EINVAL;
-                goto err;
-        }
-
         l = min(EDID_LENGTH, len);
-        r = tfp410_ddc_read(adapter, edid, l, 0);
+        r = tfp410_ddc_read(ddata->i2c_adapter, edid, l, 0);
         if (r)
                 goto err;
 
@@ -299,7 +309,7 @@ static int tfp410_read_edid(struct omap_dss_device *dssdev,
         if (len > EDID_LENGTH && edid[0x7e] > 0) {
                 l = min(EDID_LENGTH, len - EDID_LENGTH);
 
-                r = tfp410_ddc_read(adapter, edid + EDID_LENGTH,
+                r = tfp410_ddc_read(ddata->i2c_adapter, edid + EDID_LENGTH,
                                 l, EDID_LENGTH);
                 if (r)
                         goto err;
@@ -319,21 +329,15 @@ err:
 static bool tfp410_detect(struct omap_dss_device *dssdev)
 {
         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
-        struct tfp410_platform_data *pdata = get_pdata(dssdev);
-        struct i2c_adapter *adapter;
         unsigned char out;
         int r;
 
         mutex_lock(&ddata->lock);
 
-        if (pdata->i2c_bus_num == 0)
-                goto out;
-
-        adapter = i2c_get_adapter(pdata->i2c_bus_num);
-        if (!adapter)
+        if (!ddata->i2c_adapter)
                 goto out;
 
-        r = tfp410_ddc_read(adapter, &out, 1, 0);
+        r = tfp410_ddc_read(ddata->i2c_adapter, &out, 1, 0);
 
         mutex_unlock(&ddata->lock);
 
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index 64cb8aa49b26..72ded9cd2cb0 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -43,6 +43,8 @@ static struct {
 
         struct regulator *vdds_dsi_reg;
         struct regulator *vdds_sdi_reg;
+
+        const char *default_display_name;
 } core;
 
 static char *def_disp_name;
@@ -54,9 +56,6 @@ bool dss_debug;
 module_param_named(debug, dss_debug, bool, 0644);
 #endif
 
-static int omap_dss_register_device(struct omap_dss_device *);
-static void omap_dss_unregister_device(struct omap_dss_device *);
-
 /* REGULATORS */
 
 struct regulator *dss_get_vdds_dsi(void)
@@ -87,6 +86,41 @@ struct regulator *dss_get_vdds_sdi(void)
         return reg;
 }
 
+int dss_get_ctx_loss_count(struct device *dev)
+{
+        struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
+        int cnt;
+
+        if (!board_data->get_context_loss_count)
+                return -ENOENT;
+
+        cnt = board_data->get_context_loss_count(dev);
+
+        WARN_ONCE(cnt < 0, "get_context_loss_count failed: %d\n", cnt);
+
+        return cnt;
+}
+
+int dss_dsi_enable_pads(int dsi_id, unsigned lane_mask)
+{
+        struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
+
+        if (!board_data->dsi_enable_pads)
+                return -ENOENT;
+
+        return board_data->dsi_enable_pads(dsi_id, lane_mask);
+}
+
+void dss_dsi_disable_pads(int dsi_id, unsigned lane_mask)
+{
+        struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
+
+        if (!board_data->dsi_enable_pads)
+                return;
+
+        return board_data->dsi_disable_pads(dsi_id, lane_mask);
+}
+
 int dss_set_min_bus_tput(struct device *dev, unsigned long tput)
 {
         struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
@@ -131,34 +165,6 @@ static int dss_initialize_debugfs(void)
         debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,
                         &dss_debug_dump_clocks, &dss_debug_fops);
 
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
-        debugfs_create_file("dispc_irq", S_IRUGO, dss_debugfs_dir,
-                        &dispc_dump_irqs, &dss_debug_fops);
-#endif
-
-#if defined(CONFIG_OMAP2_DSS_DSI) && defined(CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS)
-        dsi_create_debugfs_files_irq(dss_debugfs_dir, &dss_debug_fops);
-#endif
-
-        debugfs_create_file("dss", S_IRUGO, dss_debugfs_dir,
-                        &dss_dump_regs, &dss_debug_fops);
-        debugfs_create_file("dispc", S_IRUGO, dss_debugfs_dir,
-                        &dispc_dump_regs, &dss_debug_fops);
-#ifdef CONFIG_OMAP2_DSS_RFBI
-        debugfs_create_file("rfbi", S_IRUGO, dss_debugfs_dir,
-                        &rfbi_dump_regs, &dss_debug_fops);
-#endif
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_create_debugfs_files_reg(dss_debugfs_dir, &dss_debug_fops);
-#endif
-#ifdef CONFIG_OMAP2_DSS_VENC
-        debugfs_create_file("venc", S_IRUGO, dss_debugfs_dir,
-                        &venc_dump_regs, &dss_debug_fops);
-#endif
-#ifdef CONFIG_OMAP4_DSS_HDMI
-        debugfs_create_file("hdmi", S_IRUGO, dss_debugfs_dir,
-                        &hdmi_dump_regs, &dss_debug_fops);
-#endif
         return 0;
 }
 
@@ -167,6 +173,19 @@ static void dss_uninitialize_debugfs(void)
         if (dss_debugfs_dir)
                 debugfs_remove_recursive(dss_debugfs_dir);
 }
+
+int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
+{
+        struct dentry *d;
+
+        d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir,
+                        write, &dss_debug_fops);
+
+        if (IS_ERR(d))
+                return PTR_ERR(d);
+
+        return 0;
+}
 #else /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */
 static inline int dss_initialize_debugfs(void)
 {
@@ -175,14 +194,18 @@ static inline int dss_initialize_debugfs(void)
 static inline void dss_uninitialize_debugfs(void)
 {
 }
+static inline int dss_debugfs_create_file(const char *name,
+                void (*write)(struct seq_file *))
+{
+        return 0;
+}
 #endif /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */
 
 /* PLATFORM DEVICE */
-static int omap_dss_probe(struct platform_device *pdev)
+static int __init omap_dss_probe(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         int r;
-        int i;
 
         core.pdev = pdev;
 
@@ -197,28 +220,13 @@ static int omap_dss_probe(struct platform_device *pdev)
         if (r)
                 goto err_debugfs;
 
-        for (i = 0; i < pdata->num_devices; ++i) {
-                struct omap_dss_device *dssdev = pdata->devices[i];
-
-                r = omap_dss_register_device(dssdev);
-                if (r) {
-                        DSSERR("device %d %s register failed %d\n", i,
-                                dssdev->name ?: "unnamed", r);
-
-                        while (--i >= 0)
-                                omap_dss_unregister_device(pdata->devices[i]);
-
-                        goto err_register;
-                }
-
-                if (def_disp_name && strcmp(def_disp_name, dssdev->name) == 0)
-                        pdata->default_device = dssdev;
-        }
+        if (def_disp_name)
+                core.default_display_name = def_disp_name;
+        else if (pdata->default_device)
+                core.default_display_name = pdata->default_device->name;
 
         return 0;
 
-err_register:
-        dss_uninitialize_debugfs();
 err_debugfs:
 
         return r;
@@ -226,17 +234,11 @@ err_debugfs:
 
 static int omap_dss_remove(struct platform_device *pdev)
 {
-        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
-        int i;
-
         dss_uninitialize_debugfs();
 
         dss_uninit_overlays(pdev);
         dss_uninit_overlay_managers(pdev);
 
-        for (i = 0; i < pdata->num_devices; ++i)
-                omap_dss_unregister_device(pdata->devices[i]);
-
         return 0;
 }
 
@@ -261,7 +263,6 @@ static int omap_dss_resume(struct platform_device *pdev)
 }
 
 static struct platform_driver omap_dss_driver = {
-        .probe          = omap_dss_probe,
         .remove         = omap_dss_remove,
         .shutdown       = omap_dss_shutdown,
         .suspend        = omap_dss_suspend,
@@ -336,7 +337,6 @@ static int dss_driver_probe(struct device *dev)
         int r;
         struct omap_dss_driver *dssdrv = to_dss_driver(dev->driver);
         struct omap_dss_device *dssdev = to_dss_device(dev);
-        struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
         bool force;
 
         DSSDBG("driver_probe: dev %s/%s, drv %s\n",
@@ -345,7 +345,8 @@ static int dss_driver_probe(struct device *dev)
 
         dss_init_device(core.pdev, dssdev);
 
-        force = pdata->default_device == dssdev;
+        force = core.default_display_name &&
+                strcmp(core.default_display_name, dssdev->name) == 0;
         dss_recheck_connections(dssdev, force);
 
         r = dssdrv->probe(dssdev);
@@ -439,27 +440,38 @@ static void omap_dss_dev_release(struct device *dev)
         reset_device(dev, 0);
 }
 
-static int omap_dss_register_device(struct omap_dss_device *dssdev)
+int omap_dss_register_device(struct omap_dss_device *dssdev,
+                struct device *parent, int disp_num)
 {
-        static int dev_num;
-
         WARN_ON(!dssdev->driver_name);
 
         reset_device(&dssdev->dev, 1);
         dssdev->dev.bus = &dss_bus_type;
-        dssdev->dev.parent = &dss_bus;
+        dssdev->dev.parent = parent;
         dssdev->dev.release = omap_dss_dev_release;
-        dev_set_name(&dssdev->dev, "display%d", dev_num++);
+        dev_set_name(&dssdev->dev, "display%d", disp_num);
         return device_register(&dssdev->dev);
 }
 
-static void omap_dss_unregister_device(struct omap_dss_device *dssdev)
+void omap_dss_unregister_device(struct omap_dss_device *dssdev)
 {
         device_unregister(&dssdev->dev);
 }
 
+static int dss_unregister_dss_dev(struct device *dev, void *data)
+{
+        struct omap_dss_device *dssdev = to_dss_device(dev);
+        omap_dss_unregister_device(dssdev);
+        return 0;
+}
+
+void omap_dss_unregister_child_devices(struct device *parent)
+{
+        device_for_each_child(parent, NULL, dss_unregister_dss_dev);
+}
+
 /* BUS */
-static int omap_dss_bus_register(void)
+static int __init omap_dss_bus_register(void)
 {
         int r;
 
@@ -481,12 +493,56 @@ static int omap_dss_bus_register(void)
 }
 
 /* INIT */
+static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
+#ifdef CONFIG_OMAP2_DSS_DPI
+        dpi_init_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_SDI
+        sdi_init_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_RFBI
+        rfbi_init_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_VENC
+        venc_init_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_DSI
+        dsi_init_platform_driver,
+#endif
+#ifdef CONFIG_OMAP4_DSS_HDMI
+        hdmi_init_platform_driver,
+#endif
+};
+
+static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
+#ifdef CONFIG_OMAP2_DSS_DPI
+        dpi_uninit_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_SDI
+        sdi_uninit_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_RFBI
+        rfbi_uninit_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_VENC
+        venc_uninit_platform_driver,
+#endif
+#ifdef CONFIG_OMAP2_DSS_DSI
+        dsi_uninit_platform_driver,
+#endif
+#ifdef CONFIG_OMAP4_DSS_HDMI
+        hdmi_uninit_platform_driver,
+#endif
+};
+
+static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];
 
 static int __init omap_dss_register_drivers(void)
 {
         int r;
+        int i;
 
-        r = platform_driver_register(&omap_dss_driver);
+        r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
         if (r)
                 return r;
 
@@ -502,40 +558,18 @@ static int __init omap_dss_register_drivers(void)
                 goto err_dispc;
         }
 
-        r = rfbi_init_platform_driver();
-        if (r) {
-                DSSERR("Failed to initialize rfbi platform driver\n");
-                goto err_rfbi;
-        }
-
-        r = venc_init_platform_driver();
-        if (r) {
-                DSSERR("Failed to initialize venc platform driver\n");
-                goto err_venc;
-        }
-
-        r = dsi_init_platform_driver();
-        if (r) {
-                DSSERR("Failed to initialize DSI platform driver\n");
-                goto err_dsi;
-        }
-
-        r = hdmi_init_platform_driver();
-        if (r) {
-                DSSERR("Failed to initialize hdmi\n");
-                goto err_hdmi;
+        /*
+         * It's ok if the output-driver register fails. It happens, for example,
+         * when there is no output-device (e.g. SDI for OMAP4).
+         */
+        for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
+                r = dss_output_drv_reg_funcs[i]();
+                if (r == 0)
+                        dss_output_drv_loaded[i] = true;
         }
 
         return 0;
 
-err_hdmi:
-        dsi_uninit_platform_driver();
-err_dsi:
-        venc_uninit_platform_driver();
-err_venc:
-        rfbi_uninit_platform_driver();
-err_rfbi:
-        dispc_uninit_platform_driver();
 err_dispc:
         dss_uninit_platform_driver();
 err_dss:
@@ -546,10 +580,13 @@ err_dss:
 
 static void __exit omap_dss_unregister_drivers(void)
 {
-        hdmi_uninit_platform_driver();
-        dsi_uninit_platform_driver();
-        venc_uninit_platform_driver();
-        rfbi_uninit_platform_driver();
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
+                if (dss_output_drv_loaded[i])
+                        dss_output_drv_unreg_funcs[i]();
+        }
+
         dispc_uninit_platform_driver();
         dss_uninit_platform_driver();
 
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 727e15b29a14..b509ca661e35 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -131,23 +131,6 @@ static inline u32 dispc_read_reg(const u16 idx)
         return __raw_readl(dispc.base + idx);
 }
 
-static int dispc_get_ctx_loss_count(void)
-{
-        struct device *dev = &dispc.pdev->dev;
-        struct omap_display_platform_data *pdata = dev->platform_data;
-        struct omap_dss_board_info *board_data = pdata->board_data;
-        int cnt;
-
-        if (!board_data->get_context_loss_count)
-                return -ENOENT;
-
-        cnt = board_data->get_context_loss_count(dev);
-
-        WARN_ONCE(cnt < 0, "get_context_loss_count failed: %d\n", cnt);
-
-        return cnt;
-}
-
 #define SR(reg) \
         dispc.ctx[DISPC_##reg / sizeof(u32)] = dispc_read_reg(DISPC_##reg)
 #define RR(reg) \
@@ -251,7 +234,7 @@ static void dispc_save_context(void)
         if (dss_has_feature(FEAT_CORE_CLK_DIV))
                 SR(DIVISOR);
 
-        dispc.ctx_loss_cnt = dispc_get_ctx_loss_count();
+        dispc.ctx_loss_cnt = dss_get_ctx_loss_count(&dispc.pdev->dev);
         dispc.ctx_valid = true;
 
         DSSDBG("context saved, ctx_loss_count %d\n", dispc.ctx_loss_cnt);
@@ -266,7 +249,7 @@ static void dispc_restore_context(void)
         if (!dispc.ctx_valid)
                 return;
 
-        ctx = dispc_get_ctx_loss_count();
+        ctx = dss_get_ctx_loss_count(&dispc.pdev->dev);
 
         if (ctx >= 0 && ctx == dispc.ctx_loss_cnt)
                 return;
@@ -2778,7 +2761,7 @@ void dispc_dump_irqs(struct seq_file *s)
 }
 #endif
 
-void dispc_dump_regs(struct seq_file *s)
+static void dispc_dump_regs(struct seq_file *s)
 {
         int i, j;
         const char *mgr_names[] = {
@@ -3499,7 +3482,7 @@ static void _omap_dispc_initial_config(void)
 }
 
 /* DISPC HW IP initialisation */
-static int omap_dispchw_probe(struct platform_device *pdev)
+static int __init omap_dispchw_probe(struct platform_device *pdev)
 {
         u32 rev;
         int r = 0;
@@ -3568,6 +3551,11 @@ static int omap_dispchw_probe(struct platform_device *pdev)
 
         dispc_runtime_put();
 
+        dss_debugfs_create_file("dispc", dispc_dump_regs);
+
+#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
+        dss_debugfs_create_file("dispc_irq", dispc_dump_irqs);
+#endif
         return 0;
 
 err_runtime_get:
@@ -3576,7 +3564,7 @@ err_runtime_get:
         return r;
 }
 
-static int omap_dispchw_remove(struct platform_device *pdev)
+static int __exit omap_dispchw_remove(struct platform_device *pdev)
 {
         pm_runtime_disable(&pdev->dev);
 
@@ -3588,19 +3576,12 @@ static int omap_dispchw_remove(struct platform_device *pdev)
 static int dispc_runtime_suspend(struct device *dev)
 {
         dispc_save_context();
-        dss_runtime_put();
 
         return 0;
 }
 
 static int dispc_runtime_resume(struct device *dev)
 {
-        int r;
-
-        r = dss_runtime_get();
-        if (r < 0)
-                return r;
-
         dispc_restore_context();
 
         return 0;
@@ -3612,8 +3593,7 @@ static const struct dev_pm_ops dispc_pm_ops = {
 };
 
 static struct platform_driver omap_dispchw_driver = {
-        .probe          = omap_dispchw_probe,
-        .remove         = omap_dispchw_remove,
+        .remove         = __exit_p(omap_dispchw_remove),
         .driver         = {
                 .name   = "omapdss_dispc",
                 .owner  = THIS_MODULE,
@@ -3621,12 +3601,12 @@ static struct platform_driver omap_dispchw_driver = {
         },
 };
 
-int dispc_init_platform_driver(void)
+int __init dispc_init_platform_driver(void)
 {
-        return platform_driver_register(&omap_dispchw_driver);
+        return platform_driver_probe(&omap_dispchw_driver, omap_dispchw_probe);
 }
 
-void dispc_uninit_platform_driver(void)
+void __exit dispc_uninit_platform_driver(void)
 {
-        return platform_driver_unregister(&omap_dispchw_driver);
+        platform_driver_unregister(&omap_dispchw_driver);
 }
diff --git a/drivers/video/omap2/dss/display.c b/drivers/video/omap2/dss/display.c
index e688d10f061a..faf7d91c4a84 100644
--- a/drivers/video/omap2/dss/display.c
+++ b/drivers/video/omap2/dss/display.c
@@ -359,46 +359,6 @@ void dss_init_device(struct platform_device *pdev,
         int i;
         int r;
 
-        switch (dssdev->type) {
-#ifdef CONFIG_OMAP2_DSS_DPI
-        case OMAP_DISPLAY_TYPE_DPI:
-                r = dpi_init_display(dssdev);
-                break;
-#endif
-#ifdef CONFIG_OMAP2_DSS_RFBI
-        case OMAP_DISPLAY_TYPE_DBI:
-                r = rfbi_init_display(dssdev);
-                break;
-#endif
-#ifdef CONFIG_OMAP2_DSS_VENC
-        case OMAP_DISPLAY_TYPE_VENC:
-                r = venc_init_display(dssdev);
-                break;
-#endif
-#ifdef CONFIG_OMAP2_DSS_SDI
-        case OMAP_DISPLAY_TYPE_SDI:
-                r = sdi_init_display(dssdev);
-                break;
-#endif
-#ifdef CONFIG_OMAP2_DSS_DSI
-        case OMAP_DISPLAY_TYPE_DSI:
-                r = dsi_init_display(dssdev);
-                break;
-#endif
-        case OMAP_DISPLAY_TYPE_HDMI:
-                r = hdmi_init_display(dssdev);
-                break;
-        default:
-                DSSERR("Support for display '%s' not compiled in.\n",
-                                dssdev->name);
-                return;
-        }
-
-        if (r) {
-                DSSERR("failed to init display %s\n", dssdev->name);
-                return;
-        }
-
         /* create device sysfs files */
         i = 0;
         while ((attr = display_sysfs_attrs[i++]) != NULL) {
diff --git a/drivers/video/omap2/dss/dpi.c b/drivers/video/omap2/dss/dpi.c
index d6e8fe776152..8c2056c9537b 100644
--- a/drivers/video/omap2/dss/dpi.c
+++ b/drivers/video/omap2/dss/dpi.c
@@ -202,10 +202,6 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
                         goto err_reg_enable;
         }
 
-        r = dss_runtime_get();
-        if (r)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r)
                 goto err_get_dispc;
@@ -244,8 +240,6 @@ err_dsi_pll_init:
 err_get_dsi:
         dispc_runtime_put();
 err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
 err_reg_enable:
@@ -266,7 +260,6 @@ void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
         }
 
         dispc_runtime_put();
-        dss_runtime_put();
 
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
@@ -283,20 +276,13 @@ void dpi_set_timings(struct omap_dss_device *dssdev,
         DSSDBG("dpi_set_timings\n");
         dssdev->panel.timings = *timings;
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
-                r = dss_runtime_get();
-                if (r)
-                        return;
-
                 r = dispc_runtime_get();
-                if (r) {
-                        dss_runtime_put();
+                if (r)
                         return;
-                }
 
                 dpi_set_mode(dssdev);
 
                 dispc_runtime_put();
-                dss_runtime_put();
         } else {
                 dss_mgr_set_timings(dssdev->manager, timings);
         }
@@ -353,7 +339,7 @@ int dpi_check_timings(struct omap_dss_device *dssdev,
 }
 EXPORT_SYMBOL(dpi_check_timings);
 
-int dpi_init_display(struct omap_dss_device *dssdev)
+static int __init dpi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
 
@@ -379,12 +365,58 @@ int dpi_init_display(struct omap_dss_device *dssdev)
         return 0;
 }
 
-int dpi_init(void)
+static void __init dpi_probe_pdata(struct platform_device *pdev)
+{
+        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
+        int i, r;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_DPI)
+                        continue;
+
+                r = dpi_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &pdev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                        dssdev->name, r);
+        }
+}
+
+static int __init omap_dpi_probe(struct platform_device *pdev)
+{
+        dpi_probe_pdata(pdev);
+
+        return 0;
+}
+
+static int __exit omap_dpi_remove(struct platform_device *pdev)
 {
+        omap_dss_unregister_child_devices(&pdev->dev);
+
         return 0;
 }
 
-void dpi_exit(void)
+static struct platform_driver omap_dpi_driver = {
+        .remove         = __exit_p(omap_dpi_remove),
+        .driver         = {
+                .name   = "omapdss_dpi",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int __init dpi_init_platform_driver(void)
 {
+        return platform_driver_probe(&omap_dpi_driver, omap_dpi_probe);
 }
 
+void __exit dpi_uninit_platform_driver(void)
+{
+        platform_driver_unregister(&omap_dpi_driver);
+}
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index 446e13667471..e2aaf5a167fa 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -256,14 +256,13 @@ struct dsi_data {
         struct platform_device *pdev;
         void __iomem    *base;
 
+        int module_id;
+
         int irq;
 
         struct clk *dss_clk;
         struct clk *sys_clk;
 
-        int (*enable_pads)(int dsi_id, unsigned lane_mask);
-        void (*disable_pads)(int dsi_id, unsigned lane_mask);
-
         struct dsi_clock_info current_cinfo;
 
         bool vdds_dsi_enabled;
@@ -361,11 +360,6 @@ struct platform_device *dsi_get_dsidev_from_id(int module)
         return dsi_pdev_map[module];
 }
 
-static inline int dsi_get_dsidev_id(struct platform_device *dsidev)
-{
-        return dsidev->id;
-}
-
 static inline void dsi_write_reg(struct platform_device *dsidev,
                 const struct dsi_reg idx, u32 val)
 {
@@ -1184,10 +1178,9 @@ static unsigned long dsi_get_txbyteclkhs(struct platform_device *dsidev)
 static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
 {
         unsigned long r;
-        int dsi_module = dsi_get_dsidev_id(dsidev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        if (dss_get_dsi_clk_source(dsi_module) == OMAP_DSS_CLK_SRC_FCK) {
+        if (dss_get_dsi_clk_source(dsi->module_id) == OMAP_DSS_CLK_SRC_FCK) {
                 /* DSI FCLK source is DSS_CLK_FCK */
                 r = clk_get_rate(dsi->dss_clk);
         } else {
@@ -1686,7 +1679,7 @@ static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         struct dsi_clock_info *cinfo = &dsi->current_cinfo;
         enum omap_dss_clk_source dispc_clk_src, dsi_clk_src;
-        int dsi_module = dsi_get_dsidev_id(dsidev);
+        int dsi_module = dsi->module_id;
 
         dispc_clk_src = dss_get_dispc_clk_source();
         dsi_clk_src = dss_get_dsi_clk_source(dsi_module);
@@ -1758,7 +1751,6 @@ static void dsi_dump_dsidev_irqs(struct platform_device *dsidev,
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         unsigned long flags;
         struct dsi_irq_stats stats;
-        int dsi_module = dsi_get_dsidev_id(dsidev);
 
         spin_lock_irqsave(&dsi->irq_stats_lock, flags);
 
@@ -1775,7 +1767,7 @@ static void dsi_dump_dsidev_irqs(struct platform_device *dsidev,
 #define PIS(x) \
         seq_printf(s, "%-20s %10d\n", #x, stats.dsi_irqs[ffs(DSI_IRQ_##x)-1]);
 
-        seq_printf(s, "-- DSI%d interrupts --\n", dsi_module + 1);
+        seq_printf(s, "-- DSI%d interrupts --\n", dsi->module_id + 1);
         PIS(VC0);
         PIS(VC1);
         PIS(VC2);
@@ -1855,22 +1847,6 @@ static void dsi2_dump_irqs(struct seq_file *s)
 
         dsi_dump_dsidev_irqs(dsidev, s);
 }
-
-void dsi_create_debugfs_files_irq(struct dentry *debugfs_dir,
-                const struct file_operations *debug_fops)
-{
-        struct platform_device *dsidev;
-
-        dsidev = dsi_get_dsidev_from_id(0);
-        if (dsidev)
-                debugfs_create_file("dsi1_irqs", S_IRUGO, debugfs_dir,
-                        &dsi1_dump_irqs, debug_fops);
-
-        dsidev = dsi_get_dsidev_from_id(1);
-        if (dsidev)
-                debugfs_create_file("dsi2_irqs", S_IRUGO, debugfs_dir,
-                        &dsi2_dump_irqs, debug_fops);
-}
 #endif
 
 static void dsi_dump_dsidev_regs(struct platform_device *dsidev,
@@ -1971,21 +1947,6 @@ static void dsi2_dump_regs(struct seq_file *s)
         dsi_dump_dsidev_regs(dsidev, s);
 }
 
-void dsi_create_debugfs_files_reg(struct dentry *debugfs_dir,
-                const struct file_operations *debug_fops)
-{
-        struct platform_device *dsidev;
-
-        dsidev = dsi_get_dsidev_from_id(0);
-        if (dsidev)
-                debugfs_create_file("dsi1_regs", S_IRUGO, debugfs_dir,
-                        &dsi1_dump_regs, debug_fops);
-
-        dsidev = dsi_get_dsidev_from_id(1);
-        if (dsidev)
-                debugfs_create_file("dsi2_regs", S_IRUGO, debugfs_dir,
-                        &dsi2_dump_regs, debug_fops);
-}
 enum dsi_cio_power_state {
         DSI_COMPLEXIO_POWER_OFF         = 0x0,
         DSI_COMPLEXIO_POWER_ON          = 0x1,
@@ -2306,7 +2267,7 @@ static int dsi_cio_init(struct omap_dss_device *dssdev)
 
         DSSDBGF();
 
-        r = dsi->enable_pads(dsidev->id, dsi_get_lane_mask(dssdev));
+        r = dss_dsi_enable_pads(dsi->module_id, dsi_get_lane_mask(dssdev));
         if (r)
                 return r;
 
@@ -2416,7 +2377,7 @@ err_cio_pwr:
                 dsi_cio_disable_lane_override(dsidev);
 err_scp_clk_dom:
         dsi_disable_scp_clk(dsidev);
-        dsi->disable_pads(dsidev->id, dsi_get_lane_mask(dssdev));
+        dss_dsi_disable_pads(dsi->module_id, dsi_get_lane_mask(dssdev));
         return r;
 }
 
@@ -2430,7 +2391,7 @@ static void dsi_cio_uninit(struct omap_dss_device *dssdev)
 
         dsi_cio_power(dsidev, DSI_COMPLEXIO_POWER_OFF);
         dsi_disable_scp_clk(dsidev);
-        dsi->disable_pads(dsidev->id, dsi_get_lane_mask(dssdev));
+        dss_dsi_disable_pads(dsi->module_id, dsi_get_lane_mask(dssdev));
 }
 
 static void dsi_config_tx_fifo(struct platform_device *dsidev,
@@ -4307,7 +4268,7 @@ static int dsi_configure_dispc_clocks(struct omap_dss_device *dssdev)
 static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        int dsi_module = dsi_get_dsidev_id(dsidev);
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         int r;
 
         r = dsi_pll_init(dsidev, true, true);
@@ -4319,7 +4280,7 @@ static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
                 goto err1;
 
         dss_select_dispc_clk_source(dssdev->clocks.dispc.dispc_fclk_src);
-        dss_select_dsi_clk_source(dsi_module, dssdev->clocks.dsi.dsi_fclk_src);
+        dss_select_dsi_clk_source(dsi->module_id, dssdev->clocks.dsi.dsi_fclk_src);
         dss_select_lcd_clk_source(dssdev->manager->id,
                         dssdev->clocks.dispc.channel.lcd_clk_src);
 
@@ -4358,7 +4319,7 @@ err3:
         dsi_cio_uninit(dssdev);
 err2:
         dss_select_dispc_clk_source(OMAP_DSS_CLK_SRC_FCK);
-        dss_select_dsi_clk_source(dsi_module, OMAP_DSS_CLK_SRC_FCK);
+        dss_select_dsi_clk_source(dsi->module_id, OMAP_DSS_CLK_SRC_FCK);
         dss_select_lcd_clk_source(dssdev->manager->id, OMAP_DSS_CLK_SRC_FCK);
 
 err1:
@@ -4372,7 +4333,6 @@ static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev,
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        int dsi_module = dsi_get_dsidev_id(dsidev);
 
         if (enter_ulps && !dsi->ulps_enabled)
                 dsi_enter_ulps(dsidev);
@@ -4385,7 +4345,7 @@ static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev,
         dsi_vc_enable(dsidev, 3, 0);
 
         dss_select_dispc_clk_source(OMAP_DSS_CLK_SRC_FCK);
-        dss_select_dsi_clk_source(dsi_module, OMAP_DSS_CLK_SRC_FCK);
+        dss_select_dsi_clk_source(dsi->module_id, OMAP_DSS_CLK_SRC_FCK);
         dss_select_lcd_clk_source(dssdev->manager->id, OMAP_DSS_CLK_SRC_FCK);
         dsi_cio_uninit(dssdev);
         dsi_pll_uninit(dsidev, disconnect_lanes);
@@ -4489,7 +4449,7 @@ int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable)
 }
 EXPORT_SYMBOL(omapdss_dsi_enable_te);
 
-int dsi_init_display(struct omap_dss_device *dssdev)
+static int __init dsi_init_display(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
@@ -4642,13 +4602,39 @@ static void dsi_put_clocks(struct platform_device *dsidev)
                 clk_put(dsi->sys_clk);
 }
 
+static void __init dsi_probe_pdata(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct omap_dss_board_info *pdata = dsidev->dev.platform_data;
+        int i, r;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_DSI)
+                        continue;
+
+                if (dssdev->phy.dsi.module != dsi->module_id)
+                        continue;
+
+                r = dsi_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &dsidev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                        dssdev->name, r);
+        }
+}
+
 /* DSI1 HW IP initialisation */
-static int omap_dsihw_probe(struct platform_device *dsidev)
+static int __init omap_dsihw_probe(struct platform_device *dsidev)
 {
-        struct omap_display_platform_data *dss_plat_data;
-        struct omap_dss_board_info *board_info;
         u32 rev;
-        int r, i, dsi_module = dsi_get_dsidev_id(dsidev);
+        int r, i;
         struct resource *dsi_mem;
         struct dsi_data *dsi;
 
@@ -4656,15 +4642,11 @@ static int omap_dsihw_probe(struct platform_device *dsidev)
         if (!dsi)
                 return -ENOMEM;
 
+        dsi->module_id = dsidev->id;
         dsi->pdev = dsidev;
-        dsi_pdev_map[dsi_module] = dsidev;
+        dsi_pdev_map[dsi->module_id] = dsidev;
         dev_set_drvdata(&dsidev->dev, dsi);
 
-        dss_plat_data = dsidev->dev.platform_data;
-        board_info = dss_plat_data->board_data;
-        dsi->enable_pads = board_info->dsi_enable_pads;
-        dsi->disable_pads = board_info->dsi_disable_pads;
-
         spin_lock_init(&dsi->irq_lock);
         spin_lock_init(&dsi->errors_lock);
         dsi->errors = 0;
@@ -4742,8 +4724,21 @@ static int omap_dsihw_probe(struct platform_device *dsidev)
         else
                 dsi->num_lanes_supported = 3;
 
+        dsi_probe_pdata(dsidev);
+
         dsi_runtime_put(dsidev);
 
+        if (dsi->module_id == 0)
+                dss_debugfs_create_file("dsi1_regs", dsi1_dump_regs);
+        else if (dsi->module_id == 1)
+                dss_debugfs_create_file("dsi2_regs", dsi2_dump_regs);
+
+#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
+        if (dsi->module_id == 0)
+                dss_debugfs_create_file("dsi1_irqs", dsi1_dump_irqs);
+        else if (dsi->module_id == 1)
+                dss_debugfs_create_file("dsi2_irqs", dsi2_dump_irqs);
+#endif
         return 0;
 
 err_runtime_get:
@@ -4752,12 +4747,14 @@ err_runtime_get:
         return r;
 }
 
-static int omap_dsihw_remove(struct platform_device *dsidev)
+static int __exit omap_dsihw_remove(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
         WARN_ON(dsi->scp_clk_refcount > 0);
 
+        omap_dss_unregister_child_devices(&dsidev->dev);
+
         pm_runtime_disable(&dsidev->dev);
 
         dsi_put_clocks(dsidev);
@@ -4778,7 +4775,6 @@ static int omap_dsihw_remove(struct platform_device *dsidev)
 static int dsi_runtime_suspend(struct device *dev)
 {
         dispc_runtime_put();
-        dss_runtime_put();
 
         return 0;
 }
@@ -4787,20 +4783,11 @@ static int dsi_runtime_resume(struct device *dev)
 {
         int r;
 
-        r = dss_runtime_get();
-        if (r)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r)
-                goto err_get_dispc;
+                return r;
 
         return 0;
-
-err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
-        return r;
 }
 
 static const struct dev_pm_ops dsi_pm_ops = {
@@ -4809,8 +4796,7 @@ static const struct dev_pm_ops dsi_pm_ops = {
 };
 
 static struct platform_driver omap_dsihw_driver = {
-        .probe          = omap_dsihw_probe,
-        .remove         = omap_dsihw_remove,
+        .remove         = __exit_p(omap_dsihw_remove),
         .driver         = {
                 .name   = "omapdss_dsi",
                 .owner  = THIS_MODULE,
@@ -4818,12 +4804,12 @@ static struct platform_driver omap_dsihw_driver = {
         },
 };
 
-int dsi_init_platform_driver(void)
+int __init dsi_init_platform_driver(void)
 {
-        return platform_driver_register(&omap_dsihw_driver);
+        return platform_driver_probe(&omap_dsihw_driver, omap_dsihw_probe);
 }
 
-void dsi_uninit_platform_driver(void)
+void __exit dsi_uninit_platform_driver(void)
 {
-        return platform_driver_unregister(&omap_dsihw_driver);
+        platform_driver_unregister(&omap_dsihw_driver);
 }
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index e212acb1e7d5..2183f840a7ac 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -62,6 +62,9 @@ struct dss_reg {
 #define REG_FLD_MOD(idx, val, start, end) \
         dss_write_reg(idx, FLD_MOD(dss_read_reg(idx), val, start, end))
 
+static int dss_runtime_get(void);
+static void dss_runtime_put(void);
+
 static struct {
         struct platform_device *pdev;
         void __iomem    *base;
@@ -277,7 +280,7 @@ void dss_dump_clocks(struct seq_file *s)
         dss_runtime_put();
 }
 
-void dss_dump_regs(struct seq_file *s)
+static void dss_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dss_read_reg(r))
 
@@ -707,7 +710,7 @@ static void dss_put_clocks(void)
         clk_put(dss.dss_clk);
 }
 
-int dss_runtime_get(void)
+static int dss_runtime_get(void)
 {
         int r;
 
@@ -718,7 +721,7 @@ int dss_runtime_get(void)
         return r < 0 ? r : 0;
 }
 
-void dss_runtime_put(void)
+static void dss_runtime_put(void)
 {
         int r;
 
@@ -741,7 +744,7 @@ void dss_debug_dump_clocks(struct seq_file *s)
 #endif
 
 /* DSS HW IP initialisation */
-static int omap_dsshw_probe(struct platform_device *pdev)
+static int __init omap_dsshw_probe(struct platform_device *pdev)
 {
         struct resource *dss_mem;
         u32 rev;
@@ -786,40 +789,24 @@ static int omap_dsshw_probe(struct platform_device *pdev)
         dss.lcd_clk_source[0] = OMAP_DSS_CLK_SRC_FCK;
         dss.lcd_clk_source[1] = OMAP_DSS_CLK_SRC_FCK;
 
-        r = dpi_init();
-        if (r) {
-                DSSERR("Failed to initialize DPI\n");
-                goto err_dpi;
-        }
-
-        r = sdi_init();
-        if (r) {
-                DSSERR("Failed to initialize SDI\n");
-                goto err_sdi;
-        }
-
         rev = dss_read_reg(DSS_REVISION);
         printk(KERN_INFO "OMAP DSS rev %d.%d\n",
                         FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
 
         dss_runtime_put();
 
+        dss_debugfs_create_file("dss", dss_dump_regs);
+
         return 0;
-err_sdi:
-        dpi_exit();
-err_dpi:
-        dss_runtime_put();
+
 err_runtime_get:
         pm_runtime_disable(&pdev->dev);
         dss_put_clocks();
         return r;
 }
 
-static int omap_dsshw_remove(struct platform_device *pdev)
+static int __exit omap_dsshw_remove(struct platform_device *pdev)
 {
-        dpi_exit();
-        sdi_exit();
-
         pm_runtime_disable(&pdev->dev);
 
         dss_put_clocks();
@@ -858,8 +845,7 @@ static const struct dev_pm_ops dss_pm_ops = {
 };
 
 static struct platform_driver omap_dsshw_driver = {
-        .probe          = omap_dsshw_probe,
-        .remove         = omap_dsshw_remove,
+        .remove         = __exit_p(omap_dsshw_remove),
         .driver         = {
                 .name   = "omapdss_dss",
                 .owner  = THIS_MODULE,
@@ -867,12 +853,12 @@ static struct platform_driver omap_dsshw_driver = {
         },
 };
 
-int dss_init_platform_driver(void)
+int __init dss_init_platform_driver(void)
 {
-        return platform_driver_register(&omap_dsshw_driver);
+        return platform_driver_probe(&omap_dsshw_driver, omap_dsshw_probe);
 }
 
 void dss_uninit_platform_driver(void)
 {
-        return platform_driver_unregister(&omap_dsshw_driver);
+        platform_driver_unregister(&omap_dsshw_driver);
 }
diff --git a/drivers/video/omap2/dss/dss.h b/drivers/video/omap2/dss/dss.h
index 8e9e9a5765fa..d5cb19fe7e8b 100644
--- a/drivers/video/omap2/dss/dss.h
+++ b/drivers/video/omap2/dss/dss.h
@@ -159,7 +159,16 @@ struct platform_device;
 struct bus_type *dss_get_bus(void);
 struct regulator *dss_get_vdds_dsi(void);
 struct regulator *dss_get_vdds_sdi(void);
+int dss_get_ctx_loss_count(struct device *dev);
+int dss_dsi_enable_pads(int dsi_id, unsigned lane_mask);
+void dss_dsi_disable_pads(int dsi_id, unsigned lane_mask);
 int dss_set_min_bus_tput(struct device *dev, unsigned long tput);
+int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *));
+
+int omap_dss_register_device(struct omap_dss_device *dssdev,
+                struct device *parent, int disp_num);
+void omap_dss_unregister_device(struct omap_dss_device *dssdev);
+void omap_dss_unregister_child_devices(struct device *parent);
 
 /* apply */
 void dss_apply_init(void);
@@ -227,18 +236,14 @@ int dss_ovl_check(struct omap_overlay *ovl, struct omap_overlay_info *info,
                 const struct omap_video_timings *mgr_timings);
 
 /* DSS */
-int dss_init_platform_driver(void);
+int dss_init_platform_driver(void) __init;
 void dss_uninit_platform_driver(void);
 
-int dss_runtime_get(void);
-void dss_runtime_put(void);
-
 void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select);
 enum dss_hdmi_venc_clk_source_select dss_get_hdmi_venc_clk_source(void);
 const char *dss_get_generic_clk_source_name(enum omap_dss_clk_source clk_src);
 void dss_dump_clocks(struct seq_file *s);
 
-void dss_dump_regs(struct seq_file *s);
 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
 void dss_debug_dump_clocks(struct seq_file *s);
 #endif
@@ -268,19 +273,8 @@ int dss_calc_clock_div(bool is_tft, unsigned long req_pck,
                 struct dispc_clock_info *dispc_cinfo);
 
 /* SDI */
-#ifdef CONFIG_OMAP2_DSS_SDI
-int sdi_init(void);
-void sdi_exit(void);
-int sdi_init_display(struct omap_dss_device *display);
-#else
-static inline int sdi_init(void)
-{
-        return 0;
-}
-static inline void sdi_exit(void)
-{
-}
-#endif
+int sdi_init_platform_driver(void) __init;
+void sdi_uninit_platform_driver(void) __exit;
 
 /* DSI */
 #ifdef CONFIG_OMAP2_DSS_DSI
@@ -288,19 +282,14 @@ static inline void sdi_exit(void)
 struct dentry;
 struct file_operations;
 
-int dsi_init_platform_driver(void);
-void dsi_uninit_platform_driver(void);
+int dsi_init_platform_driver(void) __init;
+void dsi_uninit_platform_driver(void) __exit;
 
 int dsi_runtime_get(struct platform_device *dsidev);
 void dsi_runtime_put(struct platform_device *dsidev);
 
 void dsi_dump_clocks(struct seq_file *s);
-void dsi_create_debugfs_files_irq(struct dentry *debugfs_dir,
-                const struct file_operations *debug_fops);
-void dsi_create_debugfs_files_reg(struct dentry *debugfs_dir,
-                const struct file_operations *debug_fops);
 
-int dsi_init_display(struct omap_dss_device *display);
 void dsi_irq_handler(void);
 u8 dsi_get_pixel_size(enum omap_dss_dsi_pixel_format fmt);
 
@@ -317,13 +306,6 @@ void dsi_wait_pll_hsdiv_dispc_active(struct platform_device *dsidev);
 void dsi_wait_pll_hsdiv_dsi_active(struct platform_device *dsidev);
 struct platform_device *dsi_get_dsidev_from_id(int module);
 #else
-static inline int dsi_init_platform_driver(void)
-{
-        return 0;
-}
-static inline void dsi_uninit_platform_driver(void)
-{
-}
 static inline int dsi_runtime_get(struct platform_device *dsidev)
 {
         return 0;
@@ -380,26 +362,13 @@ static inline struct platform_device *dsi_get_dsidev_from_id(int module)
 #endif
 
 /* DPI */
-#ifdef CONFIG_OMAP2_DSS_DPI
-int dpi_init(void);
-void dpi_exit(void);
-int dpi_init_display(struct omap_dss_device *dssdev);
-#else
-static inline int dpi_init(void)
-{
-        return 0;
-}
-static inline void dpi_exit(void)
-{
-}
-#endif
+int dpi_init_platform_driver(void) __init;
+void dpi_uninit_platform_driver(void) __exit;
 
 /* DISPC */
-int dispc_init_platform_driver(void);
-void dispc_uninit_platform_driver(void);
+int dispc_init_platform_driver(void) __init;
+void dispc_uninit_platform_driver(void) __exit;
 void dispc_dump_clocks(struct seq_file *s);
-void dispc_dump_irqs(struct seq_file *s);
-void dispc_dump_regs(struct seq_file *s);
 void dispc_irq_handler(void);
 
 int dispc_runtime_get(void);
@@ -463,19 +432,10 @@ void dispc_mgr_setup(enum omap_channel channel,
 
 /* VENC */
 #ifdef CONFIG_OMAP2_DSS_VENC
-int venc_init_platform_driver(void);
-void venc_uninit_platform_driver(void);
-void venc_dump_regs(struct seq_file *s);
-int venc_init_display(struct omap_dss_device *display);
+int venc_init_platform_driver(void) __init;
+void venc_uninit_platform_driver(void) __exit;
 unsigned long venc_get_pixel_clock(void);
 #else
-static inline int venc_init_platform_driver(void)
-{
-        return 0;
-}
-static inline void venc_uninit_platform_driver(void)
-{
-}
 static inline unsigned long venc_get_pixel_clock(void)
 {
         WARN("%s: VENC not compiled in, returning pclk as 0\n", __func__);
@@ -485,23 +445,10 @@ static inline unsigned long venc_get_pixel_clock(void)
 
 /* HDMI */
 #ifdef CONFIG_OMAP4_DSS_HDMI
-int hdmi_init_platform_driver(void);
-void hdmi_uninit_platform_driver(void);
-int hdmi_init_display(struct omap_dss_device *dssdev);
+int hdmi_init_platform_driver(void) __init;
+void hdmi_uninit_platform_driver(void) __exit;
 unsigned long hdmi_get_pixel_clock(void);
-void hdmi_dump_regs(struct seq_file *s);
 #else
-static inline int hdmi_init_display(struct omap_dss_device *dssdev)
-{
-        return 0;
-}
-static inline int hdmi_init_platform_driver(void)
-{
-        return 0;
-}
-static inline void hdmi_uninit_platform_driver(void)
-{
-}
 static inline unsigned long hdmi_get_pixel_clock(void)
 {
         WARN("%s: HDMI not compiled in, returning pclk as 0\n", __func__);
@@ -519,20 +466,8 @@ int hdmi_panel_init(void);
 void hdmi_panel_exit(void);
 
 /* RFBI */
-#ifdef CONFIG_OMAP2_DSS_RFBI
-int rfbi_init_platform_driver(void);
-void rfbi_uninit_platform_driver(void);
-void rfbi_dump_regs(struct seq_file *s);
-int rfbi_init_display(struct omap_dss_device *display);
-#else
-static inline int rfbi_init_platform_driver(void)
-{
-        return 0;
-}
-static inline void rfbi_uninit_platform_driver(void)
-{
-}
-#endif
+int rfbi_init_platform_driver(void) __init;
+void rfbi_uninit_platform_driver(void) __exit;
 
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index 32ad7124a952..5f2e2f677bef 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -63,7 +63,6 @@
 
 static struct {
         struct mutex lock;
-        struct omap_display_platform_data *pdata;
         struct platform_device *pdev;
         struct hdmi_ip_data ip_data;
 
@@ -130,25 +129,12 @@ static int hdmi_runtime_get(void)
 
         DSSDBG("hdmi_runtime_get\n");
 
-        /*
-         * HACK: Add dss_runtime_get() to ensure DSS clock domain is enabled.
-         * This should be removed later.
-         */
-        r = dss_runtime_get();
-        if (r < 0)
-                goto err_get_dss;
-
         r = pm_runtime_get_sync(&hdmi.pdev->dev);
         WARN_ON(r < 0);
         if (r < 0)
-                goto err_get_hdmi;
+                return r;
 
         return 0;
-
-err_get_hdmi:
-        dss_runtime_put();
-err_get_dss:
-        return r;
 }
 
 static void hdmi_runtime_put(void)
@@ -159,15 +145,9 @@ static void hdmi_runtime_put(void)
 
         r = pm_runtime_put_sync(&hdmi.pdev->dev);
         WARN_ON(r < 0);
-
-        /*
-         * HACK: This is added to complement the dss_runtime_get() call in
-         * hdmi_runtime_get(). This should be removed later.
-         */
-        dss_runtime_put();
 }
 
-int hdmi_init_display(struct omap_dss_device *dssdev)
+static int __init hdmi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
 
@@ -440,7 +420,7 @@ void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev)
         }
 }
 
-void hdmi_dump_regs(struct seq_file *s)
+static void hdmi_dump_regs(struct seq_file *s)
 {
         mutex_lock(&hdmi.lock);
 
@@ -791,13 +771,36 @@ static void hdmi_put_clocks(void)
                 clk_put(hdmi.sys_clk);
 }
 
+static void __init hdmi_probe_pdata(struct platform_device *pdev)
+{
+        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
+        int r, i;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_HDMI)
+                        continue;
+
+                r = hdmi_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &pdev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                        dssdev->name, r);
+        }
+}
+
 /* HDMI HW IP initialisation */
-static int omapdss_hdmihw_probe(struct platform_device *pdev)
+static int __init omapdss_hdmihw_probe(struct platform_device *pdev)
 {
         struct resource *hdmi_mem;
         int r;
 
-        hdmi.pdata = pdev->dev.platform_data;
         hdmi.pdev = pdev;
 
         mutex_init(&hdmi.lock);
@@ -831,6 +834,10 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
 
         hdmi_panel_init();
 
+        dss_debugfs_create_file("hdmi", hdmi_dump_regs);
+
+        hdmi_probe_pdata(pdev);
+
 #if defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI) || \
         defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI_MODULE)
 
@@ -845,8 +852,10 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int omapdss_hdmihw_remove(struct platform_device *pdev)
+static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 {
+        omap_dss_unregister_child_devices(&pdev->dev);
+
         hdmi_panel_exit();
 
 #if defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI) || \
@@ -868,7 +877,6 @@ static int hdmi_runtime_suspend(struct device *dev)
         clk_disable(hdmi.sys_clk);
 
         dispc_runtime_put();
-        dss_runtime_put();
 
         return 0;
 }
@@ -877,23 +885,13 @@ static int hdmi_runtime_resume(struct device *dev)
 {
         int r;
 
-        r = dss_runtime_get();
-        if (r < 0)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r < 0)
-                goto err_get_dispc;
-
+                return r;
 
         clk_enable(hdmi.sys_clk);
 
         return 0;
-
-err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
-        return r;
 }
 
 static const struct dev_pm_ops hdmi_pm_ops = {
@@ -902,8 +900,7 @@ static const struct dev_pm_ops hdmi_pm_ops = {
 };
 
 static struct platform_driver omapdss_hdmihw_driver = {
-        .probe          = omapdss_hdmihw_probe,
-        .remove         = omapdss_hdmihw_remove,
+        .remove         = __exit_p(omapdss_hdmihw_remove),
         .driver         = {
                 .name   = "omapdss_hdmi",
                 .owner  = THIS_MODULE,
@@ -911,12 +908,12 @@ static struct platform_driver omapdss_hdmihw_driver = {
         },
 };
 
-int hdmi_init_platform_driver(void)
+int __init hdmi_init_platform_driver(void)
 {
-        return platform_driver_register(&omapdss_hdmihw_driver);
+        return platform_driver_probe(&omapdss_hdmihw_driver, omapdss_hdmihw_probe);
 }
 
-void hdmi_uninit_platform_driver(void)
+void __exit hdmi_uninit_platform_driver(void)
 {
-        return platform_driver_unregister(&omapdss_hdmihw_driver);
+        platform_driver_unregister(&omapdss_hdmihw_driver);
 }
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index feadfab27ec2..3d8c206e90e5 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -819,7 +819,7 @@ int omap_rfbi_update(struct omap_dss_device *dssdev,
 }
 EXPORT_SYMBOL(omap_rfbi_update);
 
-void rfbi_dump_regs(struct seq_file *s)
+static void rfbi_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, rfbi_read_reg(r))
 
@@ -920,15 +920,39 @@ void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev)
 }
 EXPORT_SYMBOL(omapdss_rfbi_display_disable);
 
-int rfbi_init_display(struct omap_dss_device *dssdev)
+static int __init rfbi_init_display(struct omap_dss_device *dssdev)
 {
         rfbi.dssdev[dssdev->phy.rfbi.channel] = dssdev;
         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
         return 0;
 }
 
+static void __init rfbi_probe_pdata(struct platform_device *pdev)
+{
+        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
+        int i, r;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_DBI)
+                        continue;
+
+                r = rfbi_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &pdev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                dssdev->name, r);
+        }
+}
+
 /* RFBI HW IP initialisation */
-static int omap_rfbihw_probe(struct platform_device *pdev)
+static int __init omap_rfbihw_probe(struct platform_device *pdev)
 {
         u32 rev;
         struct resource *rfbi_mem;
@@ -976,6 +1000,10 @@ static int omap_rfbihw_probe(struct platform_device *pdev)
 
         rfbi_runtime_put();
 
+        dss_debugfs_create_file("rfbi", rfbi_dump_regs);
+
+        rfbi_probe_pdata(pdev);
+
         return 0;
 
 err_runtime_get:
@@ -983,8 +1011,9 @@ err_runtime_get:
         return r;
 }
 
-static int omap_rfbihw_remove(struct platform_device *pdev)
+static int __exit omap_rfbihw_remove(struct platform_device *pdev)
 {
+        omap_dss_unregister_child_devices(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
         return 0;
 }
@@ -992,7 +1021,6 @@ static int omap_rfbihw_remove(struct platform_device *pdev)
 static int rfbi_runtime_suspend(struct device *dev)
 {
         dispc_runtime_put();
-        dss_runtime_put();
 
         return 0;
 }
@@ -1001,20 +1029,11 @@ static int rfbi_runtime_resume(struct device *dev)
 {
         int r;
 
-        r = dss_runtime_get();
-        if (r < 0)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r < 0)
-                goto err_get_dispc;
+                return r;
 
         return 0;
-
-err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
-        return r;
 }
 
 static const struct dev_pm_ops rfbi_pm_ops = {
@@ -1023,8 +1042,7 @@ static const struct dev_pm_ops rfbi_pm_ops = {
 };
 
 static struct platform_driver omap_rfbihw_driver = {
-        .probe          = omap_rfbihw_probe,
-        .remove         = omap_rfbihw_remove,
+        .remove         = __exit_p(omap_rfbihw_remove),
         .driver         = {
                 .name   = "omapdss_rfbi",
                 .owner  = THIS_MODULE,
@@ -1032,12 +1050,12 @@ static struct platform_driver omap_rfbihw_driver = {
         },
 };
 
-int rfbi_init_platform_driver(void)
+int __init rfbi_init_platform_driver(void)
 {
-        return platform_driver_register(&omap_rfbihw_driver);
+        return platform_driver_probe(&omap_rfbihw_driver, omap_rfbihw_probe);
 }
 
-void rfbi_uninit_platform_driver(void)
+void __exit rfbi_uninit_platform_driver(void)
 {
-        return platform_driver_unregister(&omap_rfbihw_driver);
+        platform_driver_unregister(&omap_rfbihw_driver);
 }
diff --git a/drivers/video/omap2/dss/sdi.c b/drivers/video/omap2/dss/sdi.c
index 67fbe7cee412..3a43dc2a9b46 100644
--- a/drivers/video/omap2/dss/sdi.c
+++ b/drivers/video/omap2/dss/sdi.c
@@ -24,6 +24,7 @@
 #include <linux/err.h>
 #include <linux/regulator/consumer.h>
 #include <linux/export.h>
+#include <linux/platform_device.h>
 
 #include <video/omapdss.h>
 #include "dss.h"
@@ -71,10 +72,6 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err_reg_enable;
 
-        r = dss_runtime_get();
-        if (r)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r)
                 goto err_get_dispc;
@@ -137,8 +134,6 @@ err_set_dss_clock_div:
 err_calc_clock_div:
         dispc_runtime_put();
 err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
         regulator_disable(sdi.vdds_sdi_reg);
 err_reg_enable:
         omap_dss_stop_device(dssdev);
@@ -154,7 +149,6 @@ void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
         dss_sdi_disable();
 
         dispc_runtime_put();
-        dss_runtime_put();
 
         regulator_disable(sdi.vdds_sdi_reg);
 
@@ -162,7 +156,7 @@ void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
 }
 EXPORT_SYMBOL(omapdss_sdi_display_disable);
 
-int sdi_init_display(struct omap_dss_device *dssdev)
+static int __init sdi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("SDI init\n");
 
@@ -182,11 +176,58 @@ int sdi_init_display(struct omap_dss_device *dssdev)
         return 0;
 }
 
-int sdi_init(void)
+static void __init sdi_probe_pdata(struct platform_device *pdev)
+{
+        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
+        int i, r;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_SDI)
+                        continue;
+
+                r = sdi_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &pdev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                        dssdev->name, r);
+        }
+}
+
+static int __init omap_sdi_probe(struct platform_device *pdev)
 {
+        sdi_probe_pdata(pdev);
+
+        return 0;
+}
+
+static int __exit omap_sdi_remove(struct platform_device *pdev)
+{
+        omap_dss_unregister_child_devices(&pdev->dev);
+
         return 0;
 }
 
-void sdi_exit(void)
+static struct platform_driver omap_sdi_driver = {
+        .remove         = __exit_p(omap_sdi_remove),
+        .driver         = {
+                .name   = "omapdss_sdi",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int __init sdi_init_platform_driver(void)
+{
+        return platform_driver_probe(&omap_sdi_driver, omap_sdi_probe);
+}
+
+void __exit sdi_uninit_platform_driver(void)
 {
+        platform_driver_unregister(&omap_sdi_driver);
 }
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 9475e6edce68..178c40d3312e 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -725,7 +725,7 @@ static struct omap_dss_driver venc_driver = {
 };
 /* driver end */
 
-int venc_init_display(struct omap_dss_device *dssdev)
+static int __init venc_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
 
@@ -745,7 +745,7 @@ int venc_init_display(struct omap_dss_device *dssdev)
         return 0;
 }
 
-void venc_dump_regs(struct seq_file *s)
+static void venc_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, venc_read_reg(r))
 
@@ -829,8 +829,32 @@ static void venc_put_clocks(void)
                 clk_put(venc.tv_dac_clk);
 }
 
+static void __init venc_probe_pdata(struct platform_device *pdev)
+{
+        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
+        int r, i;
+
+        for (i = 0; i < pdata->num_devices; ++i) {
+                struct omap_dss_device *dssdev = pdata->devices[i];
+
+                if (dssdev->type != OMAP_DISPLAY_TYPE_VENC)
+                        continue;
+
+                r = venc_init_display(dssdev);
+                if (r) {
+                        DSSERR("device %s init failed: %d\n", dssdev->name, r);
+                        continue;
+                }
+
+                r = omap_dss_register_device(dssdev, &pdev->dev, i);
+                if (r)
+                        DSSERR("device %s register failed: %d\n",
+                                        dssdev->name, r);
+        }
+}
+
 /* VENC HW IP initialisation */
-static int omap_venchw_probe(struct platform_device *pdev)
+static int __init omap_venchw_probe(struct platform_device *pdev)
 {
         u8 rev_id;
         struct resource *venc_mem;
@@ -874,6 +898,10 @@ static int omap_venchw_probe(struct platform_device *pdev)
         if (r)
                 goto err_reg_panel_driver;
 
+        dss_debugfs_create_file("venc", venc_dump_regs);
+
+        venc_probe_pdata(pdev);
+
         return 0;
 
 err_reg_panel_driver:
@@ -883,12 +911,15 @@ err_runtime_get:
         return r;
 }
 
-static int omap_venchw_remove(struct platform_device *pdev)
+static int __exit omap_venchw_remove(struct platform_device *pdev)
 {
+        omap_dss_unregister_child_devices(&pdev->dev);
+
         if (venc.vdda_dac_reg != NULL) {
                 regulator_put(venc.vdda_dac_reg);
                 venc.vdda_dac_reg = NULL;
         }
+
         omap_dss_unregister_driver(&venc_driver);
 
         pm_runtime_disable(&pdev->dev);
@@ -903,7 +934,6 @@ static int venc_runtime_suspend(struct device *dev)
                 clk_disable(venc.tv_dac_clk);
 
         dispc_runtime_put();
-        dss_runtime_put();
 
         return 0;
 }
@@ -912,23 +942,14 @@ static int venc_runtime_resume(struct device *dev)
 {
         int r;
 
-        r = dss_runtime_get();
-        if (r < 0)
-                goto err_get_dss;
-
         r = dispc_runtime_get();
         if (r < 0)
-                goto err_get_dispc;
+                return r;
 
         if (venc.tv_dac_clk)
                 clk_enable(venc.tv_dac_clk);
 
         return 0;
-
-err_get_dispc:
-        dss_runtime_put();
-err_get_dss:
-        return r;
 }
 
 static const struct dev_pm_ops venc_pm_ops = {
@@ -937,8 +958,7 @@ static const struct dev_pm_ops venc_pm_ops = {
 };
 
 static struct platform_driver omap_venchw_driver = {
-        .probe          = omap_venchw_probe,
-        .remove         = omap_venchw_remove,
+        .remove         = __exit_p(omap_venchw_remove),
         .driver         = {
                 .name   = "omapdss_venc",
                 .owner  = THIS_MODULE,
@@ -946,18 +966,18 @@ static struct platform_driver omap_venchw_driver = {
         },
 };
 
-int venc_init_platform_driver(void)
+int __init venc_init_platform_driver(void)
 {
         if (cpu_is_omap44xx())
                 return 0;
 
-        return platform_driver_register(&omap_venchw_driver);
+        return platform_driver_probe(&omap_venchw_driver, omap_venchw_probe);
 }
 
-void venc_uninit_platform_driver(void)
+void __exit venc_uninit_platform_driver(void)
 {
         if (cpu_is_omap44xx())
                 return;
 
-        return platform_driver_unregister(&omap_venchw_driver);
+        platform_driver_unregister(&omap_venchw_driver);
 }
diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c
index 7f02e7f90d63..165a4be95025 100644
--- a/drivers/video/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/omap2/omapfb/omapfb-main.c
@@ -2307,7 +2307,7 @@ static int omapfb_init_display(struct omapfb2_device *fbdev,
         return 0;
 }
 
-static int omapfb_probe(struct platform_device *pdev)
+static int __init omapfb_probe(struct platform_device *pdev)
 {
         struct omapfb2_device *fbdev = NULL;
         int r = 0;
@@ -2448,7 +2448,7 @@ err0:
         return r;
 }
 
-static int omapfb_remove(struct platform_device *pdev)
+static int __exit omapfb_remove(struct platform_device *pdev)
 {
         struct omapfb2_device *fbdev = platform_get_drvdata(pdev);
 
@@ -2462,8 +2462,7 @@ static int omapfb_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver omapfb_driver = {
-        .probe          = omapfb_probe,
-        .remove         = omapfb_remove,
+        .remove         = __exit_p(omapfb_remove),
         .driver         = {
                 .name   = "omapfb",
                 .owner  = THIS_MODULE,
@@ -2474,7 +2473,7 @@ static int __init omapfb_init(void)
 {
         DBG("omapfb_init\n");
 
-        if (platform_driver_register(&omapfb_driver)) {
+        if (platform_driver_probe(&omapfb_driver, omapfb_probe)) {
                 printk(KERN_ERR "failed to register omapfb driver\n");
                 return -ENODEV;
         }
diff --git a/include/video/omapdss.h b/include/video/omapdss.h
index 1cbb2dd5fbba..1217df40cb7e 100644
--- a/include/video/omapdss.h
+++ b/include/video/omapdss.h
@@ -317,11 +317,6 @@ extern int omap_display_init(struct omap_dss_board_info *board_data);
 /* HDMI mux init*/
 extern int omap_hdmi_init(enum omap_hdmi_flags flags);
 
-struct omap_display_platform_data {
-        struct omap_dss_board_info *board_data;
-        /* TODO: Additional members to be added when PM is considered */
-};
-
 struct omap_video_timings {
         /* Unit: pixels */
         u16 x_res;