/* we can probably ignore these until we support command-mode panels: */
 static int omap_crtc_connect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        if (mgr->output)
                return -EINVAL;
 }
 
 static void omap_crtc_disconnect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        mgr->output->manager = NULL;
        mgr->output = NULL;
 
                struct drm_encoder *encoder = priv->encoders[i];
                struct omap_dss_device *dssdev =
                                        omap_encoder_get_dssdev(encoder);
-               struct omap_dss_output *output;
+               struct omap_dss_device *output;
 
                output = omapdss_find_output_from_display(dssdev);
 
 
 }
 
 static int dss_mgr_connect_compat(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        return mgr->set_output(mgr, dst);
 }
 
 static void dss_mgr_disconnect_compat(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        mgr->unset_output(mgr);
 }
 }
 
 static int dss_mgr_set_output(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *output)
+               struct omap_dss_device *output)
 {
        int r;
 
 
 
 static int omapdss_default_connect(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
        struct omap_overlay_manager *mgr;
        int r;
 
 
 static void omapdss_default_disconnect(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
        struct omap_overlay_manager *mgr;
 
        out = dssdev->output;
 
        struct dss_lcd_mgr_config mgr_config;
        int data_lines;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 } dpi;
 
 static struct platform_device *dpi_get_dsidev(enum omap_channel channel)
 
 int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &dpi.output;
+       struct omap_dss_device *out = &dpi.output;
        int r;
 
        mutex_lock(&dpi.lock);
 
 static void dpi_init_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &dpi.output;
+       struct omap_dss_device *out = &dpi.output;
 
-       out->pdev = pdev;
+       out->dev = &pdev->dev;
        out->id = OMAP_DSS_OUTPUT_DPI;
-       out->type = OMAP_DISPLAY_TYPE_DPI;
+       out->output_type = OMAP_DISPLAY_TYPE_DPI;
        out->name = "dpi.0";
        out->dispc_channel = dpi_get_channel();
 
 
 static void __exit dpi_uninit_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &dpi.output;
+       struct omap_dss_device *out = &dpi.output;
 
        dss_unregister_output(out);
 }
 
        enum omap_dss_dsi_mode mode;
        struct omap_dss_dsi_videomode_timings vm_timings;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 };
 
 struct dsi_packet_sent_handler_data {
 
 static inline struct platform_device *dsi_get_dsidev_from_dssdev(struct omap_dss_device *dssdev)
 {
-       return dssdev->output->pdev;
+       return to_platform_device(dssdev->output->dev);
 }
 
 struct platform_device *dsi_get_dsidev_from_id(int module)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
        enum omap_dss_output_id id;
 
        switch (module) {
 
        out = omap_dss_get_output(id);
 
-       return out ? out->pdev : NULL;
+       return out ? to_platform_device(out->dev) : NULL;
 }
 
 static inline void dsi_write_reg(struct platform_device *dsidev,
        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
        struct omap_overlay_manager *mgr = dsi->output.manager;
        int bpp = dsi_get_pixel_size(dsi->pix_fmt);
-       struct omap_dss_output *out = &dsi->output;
+       struct omap_dss_device *out = &dsi->output;
        u8 data_type;
        u16 word_count;
        int r;
 static void dsi_init_output(struct platform_device *dsidev)
 {
        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-       struct omap_dss_output *out = &dsi->output;
+       struct omap_dss_device *out = &dsi->output;
 
-       out->pdev = dsidev;
+       out->dev = &dsidev->dev;
        out->id = dsi->module_id == 0 ?
                        OMAP_DSS_OUTPUT_DSI1 : OMAP_DSS_OUTPUT_DSI2;
 
-       out->type = OMAP_DISPLAY_TYPE_DSI;
+       out->output_type = OMAP_DISPLAY_TYPE_DSI;
        out->name = dsi->module_id == 0 ? "dsi.0" : "dsi.1";
        out->dispc_channel = dsi_get_channel(dsi->module_id);
 
 static void dsi_uninit_output(struct platform_device *dsidev)
 {
        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-       struct omap_dss_output *out = &dsi->output;
+       struct omap_dss_device *out = &dsi->output;
 
        dss_unregister_output(out);
 }
 
                const struct omap_dss_device *src);
 
 /* output */
-void dss_register_output(struct omap_dss_output *out);
-void dss_unregister_output(struct omap_dss_output *out);
+void dss_register_output(struct omap_dss_device *out);
+void dss_unregister_output(struct omap_dss_device *out);
 
 /* display */
 int dss_suspend_all_devices(void);
 
        int ls_oe_gpio;
        int hpd_gpio;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 } hdmi;
 
 /*
 
 int omapdss_hdmi_display_enable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &hdmi.output;
+       struct omap_dss_device *out = &hdmi.output;
        int r = 0;
 
        DSSDBG("ENTER hdmi_display_enable\n");
 
 static void hdmi_init_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &hdmi.output;
+       struct omap_dss_device *out = &hdmi.output;
 
-       out->pdev = pdev;
+       out->dev = &pdev->dev;
        out->id = OMAP_DSS_OUTPUT_HDMI;
-       out->type = OMAP_DISPLAY_TYPE_HDMI;
+       out->output_type = OMAP_DISPLAY_TYPE_HDMI;
        out->name = "hdmi.0";
        out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
 
 
 static void __exit hdmi_uninit_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &hdmi.output;
+       struct omap_dss_device *out = &hdmi.output;
 
        dss_unregister_output(out);
 }
 
 static LIST_HEAD(output_list);
 static DEFINE_MUTEX(output_lock);
 
-int omapdss_output_set_device(struct omap_dss_output *out,
+int omapdss_output_set_device(struct omap_dss_device *out,
                struct omap_dss_device *dssdev)
 {
        int r;
                goto err;
        }
 
-       if (out->type != dssdev->type) {
+       if (out->output_type != dssdev->type) {
                DSSERR("output type and display type don't match\n");
                r = -EINVAL;
                goto err;
 }
 EXPORT_SYMBOL(omapdss_output_set_device);
 
-int omapdss_output_unset_device(struct omap_dss_output *out)
+int omapdss_output_unset_device(struct omap_dss_device *out)
 {
        int r;
 
 }
 EXPORT_SYMBOL(omapdss_output_unset_device);
 
-void dss_register_output(struct omap_dss_output *out)
+void dss_register_output(struct omap_dss_device *out)
 {
        list_add_tail(&out->list, &output_list);
 }
 
-void dss_unregister_output(struct omap_dss_output *out)
+void dss_unregister_output(struct omap_dss_device *out)
 {
        list_del(&out->list);
 }
 
-struct omap_dss_output *omap_dss_get_output(enum omap_dss_output_id id)
+struct omap_dss_device *omap_dss_get_output(enum omap_dss_output_id id)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
 
        list_for_each_entry(out, &output_list, list) {
                if (out->id == id)
 }
 EXPORT_SYMBOL(omap_dss_get_output);
 
-struct omap_dss_output *omap_dss_find_output(const char *name)
+struct omap_dss_device *omap_dss_find_output(const char *name)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
 
        list_for_each_entry(out, &output_list, list) {
                if (strcmp(out->name, name) == 0)
 }
 EXPORT_SYMBOL(omap_dss_find_output);
 
-struct omap_dss_output *omap_dss_find_output_by_node(struct device_node *node)
+struct omap_dss_device *omap_dss_find_output_by_node(struct device_node *node)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
 
        list_for_each_entry(out, &output_list, list) {
-               if (out->pdev->dev.of_node == node)
+               if (out->dev->of_node == node)
                        return out;
        }
 
 }
 EXPORT_SYMBOL(omap_dss_find_output_by_node);
 
-struct omap_dss_output *omapdss_find_output_from_display(struct omap_dss_device *dssdev)
+struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device *dssdev)
 {
        return dssdev->output;
 }
 
 struct omap_overlay_manager *omapdss_find_mgr_from_display(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out;
+       struct omap_dss_device *out;
 
        out = omapdss_find_output_from_display(dssdev);
 
 EXPORT_SYMBOL(dss_uninstall_mgr_ops);
 
 int dss_mgr_connect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        return dss_mgr_ops->connect(mgr, dst);
 }
 EXPORT_SYMBOL(dss_mgr_connect);
 
 void dss_mgr_disconnect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst)
+               struct omap_dss_device *dst)
 {
        dss_mgr_ops->disconnect(mgr, dst);
 }
 
        int data_lines;
        struct rfbi_timings intf_timings;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 } rfbi;
 
 static inline void rfbi_write_reg(const struct rfbi_reg idx, u32 val)
 
 int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &rfbi.output;
+       struct omap_dss_device *out = &rfbi.output;
        int r;
 
        if (out == NULL || out->manager == NULL) {
 
 void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &rfbi.output;
+       struct omap_dss_device *out = &rfbi.output;
 
        dss_mgr_unregister_framedone_handler(out->manager,
                        framedone_callback, NULL);
 
 static void rfbi_init_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &rfbi.output;
+       struct omap_dss_device *out = &rfbi.output;
 
-       out->pdev = pdev;
+       out->dev = &pdev->dev;
        out->id = OMAP_DSS_OUTPUT_DBI;
-       out->type = OMAP_DISPLAY_TYPE_DBI;
+       out->output_type = OMAP_DISPLAY_TYPE_DBI;
        out->name = "rfbi.0";
        out->dispc_channel = OMAP_DSS_CHANNEL_LCD;
 
 
 static void __exit rfbi_uninit_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &rfbi.output;
+       struct omap_dss_device *out = &rfbi.output;
 
        dss_unregister_output(out);
 }
 
        struct omap_video_timings timings;
        int datapairs;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 } sdi;
 
 struct sdi_clk_calc_ctx {
 
 int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &sdi.output;
+       struct omap_dss_device *out = &sdi.output;
        struct omap_video_timings *t = &sdi.timings;
        struct dss_clock_info dss_cinfo;
        struct dispc_clock_info dispc_cinfo;
 
 static void sdi_init_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &sdi.output;
+       struct omap_dss_device *out = &sdi.output;
 
-       out->pdev = pdev;
+       out->dev = &pdev->dev;
        out->id = OMAP_DSS_OUTPUT_SDI;
-       out->type = OMAP_DISPLAY_TYPE_SDI;
+       out->output_type = OMAP_DISPLAY_TYPE_SDI;
        out->name = "sdi.0";
        out->dispc_channel = OMAP_DSS_CHANNEL_LCD;
 
 
 static void __exit sdi_uninit_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &sdi.output;
+       struct omap_dss_device *out = &sdi.output;
 
        dss_unregister_output(out);
 }
 
        enum omap_dss_venc_type type;
        bool invert_polarity;
 
-       struct omap_dss_output output;
+       struct omap_dss_device output;
 } venc;
 
 static inline void venc_write_reg(int idx, u32 val)
 
 int omapdss_venc_display_enable(struct omap_dss_device *dssdev)
 {
-       struct omap_dss_output *out = &venc.output;
+       struct omap_dss_device *out = &venc.output;
        int r;
 
        DSSDBG("venc_display_enable\n");
 
 static void venc_init_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &venc.output;
+       struct omap_dss_device *out = &venc.output;
 
-       out->pdev = pdev;
+       out->dev = &pdev->dev;
        out->id = OMAP_DSS_OUTPUT_VENC;
-       out->type = OMAP_DISPLAY_TYPE_VENC;
+       out->output_type = OMAP_DISPLAY_TYPE_VENC;
        out->name = "venc.0";
        out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
 
 
 static void __exit venc_uninit_output(struct platform_device *pdev)
 {
-       struct omap_dss_output *out = &venc.output;
+       struct omap_dss_device *out = &venc.output;
 
        dss_unregister_output(out);
 }
 
        enum omap_dss_output_id supported_outputs;
 
        /* dynamic fields */
-       struct omap_dss_output *output;
+       struct omap_dss_device *output;
 
        /*
         * The following functions do not block:
         */
 
        int (*set_output)(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *output);
+               struct omap_dss_device *output);
        int (*unset_output)(struct omap_overlay_manager *mgr);
 
        int (*set_manager_info)(struct omap_overlay_manager *mgr,
        u8 pre_mult_alpha;
 };
 
-struct omap_dss_output {
-       struct list_head list;
-
-       const char *name;
-
-       /* display type supported by the output */
-       enum omap_display_type type;
-
-       /* DISPC channel for this output */
-       enum omap_channel dispc_channel;
-
-       /* output instance */
-       enum omap_dss_output_id id;
-
-       /* output's platform device pointer */
-       struct platform_device *pdev;
-
-       /* dynamic fields */
-       struct omap_overlay_manager *manager;
-
-       struct omap_dss_device *device;
-};
-
 struct omap_dss_device {
        /* old device, to be removed */
        struct device old_dev;
        char alias[16];
 
        enum omap_display_type type;
+       enum omap_display_type output_type;
 
        /* obsolete, to be removed */
        enum omap_channel channel;
 
        enum omap_display_caps caps;
 
-       struct omap_dss_output *output;
+       struct omap_dss_device *output;
 
        enum omap_dss_display_state state;
 
        void (*platform_disable)(struct omap_dss_device *dssdev);
        int (*set_backlight)(struct omap_dss_device *dssdev, int level);
        int (*get_backlight)(struct omap_dss_device *dssdev);
+
+
+       /* OMAP DSS output specific fields */
+
+       struct list_head list;
+
+       /* DISPC channel for this output */
+       enum omap_channel dispc_channel;
+
+       /* output instance */
+       enum omap_dss_output_id id;
+
+       /* dynamic fields */
+       struct omap_overlay_manager *manager;
+
+       struct omap_dss_device *device;
 };
 
 struct omap_dss_hdmi_data
 int omap_dss_get_num_overlays(void);
 struct omap_overlay *omap_dss_get_overlay(int num);
 
-struct omap_dss_output *omap_dss_get_output(enum omap_dss_output_id id);
-struct omap_dss_output *omap_dss_find_output(const char *name);
-struct omap_dss_output *omap_dss_find_output_by_node(struct device_node *node);
-int omapdss_output_set_device(struct omap_dss_output *out,
+struct omap_dss_device *omap_dss_get_output(enum omap_dss_output_id id);
+struct omap_dss_device *omap_dss_find_output(const char *name);
+struct omap_dss_device *omap_dss_find_output_by_node(struct device_node *node);
+int omapdss_output_set_device(struct omap_dss_device *out,
                struct omap_dss_device *dssdev);
-int omapdss_output_unset_device(struct omap_dss_output *out);
+int omapdss_output_unset_device(struct omap_dss_device *out);
 
-struct omap_dss_output *omapdss_find_output_from_display(struct omap_dss_device *dssdev);
+struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device *dssdev);
 struct omap_overlay_manager *omapdss_find_mgr_from_display(struct omap_dss_device *dssdev);
 
 void omapdss_default_get_resolution(struct omap_dss_device *dssdev,
 
 struct dss_mgr_ops {
        int (*connect)(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst);
+               struct omap_dss_device *dst);
        void (*disconnect)(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst);
+               struct omap_dss_device *dst);
 
        void (*start_update)(struct omap_overlay_manager *mgr);
        int (*enable)(struct omap_overlay_manager *mgr);
 void dss_uninstall_mgr_ops(void);
 
 int dss_mgr_connect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst);
+               struct omap_dss_device *dst);
 void dss_mgr_disconnect(struct omap_overlay_manager *mgr,
-               struct omap_dss_output *dst);
+               struct omap_dss_device *dst);
 void dss_mgr_set_timings(struct omap_overlay_manager *mgr,
                const struct omap_video_timings *timings);
 void dss_mgr_set_lcd_config(struct omap_overlay_manager *mgr,