111 files changed, 4403 insertions, 2974 deletions

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index e7718fdad1e1..c04ccdf60eaa 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -21,6 +21,8 @@ source "drivers/gpu/vga/Kconfig"
 
 source "drivers/gpu/drm/Kconfig"
 
+source "drivers/gpu/host1x/Kconfig"
+
 config VGASTATE
        tristate
        default n
@@ -31,26 +33,8 @@ config VIDEO_OUTPUT_CONTROL
           This framework adds support for low-level control of the video 
           output switch.
 
-config DISPLAY_TIMING
-       bool
-
-config VIDEOMODE
-       bool
-
-config OF_DISPLAY_TIMING
-        bool "Enable device tree display timing support"
-        depends on OF
-        select DISPLAY_TIMING
-        help
-          helper to parse display timings from the devicetree
-
-config OF_VIDEOMODE
-        bool "Enable device tree videomode support"
-        depends on OF
-        select VIDEOMODE
-        select OF_DISPLAY_TIMING
-        help
-          helper to get videomodes from the devicetree
+config VIDEOMODE_HELPERS
+        bool
 
 config HDMI
         bool
@@ -212,14 +196,6 @@ config FB_SYS_FOPS
        depends on FB
        default n
 
-config FB_WMT_GE_ROPS
-        tristate
-        depends on FB
-        default n
-        ---help---
-          Include functions for accelerated rectangle filling and area
-          copying using WonderMedia Graphics Engine operations.
-
 config FB_DEFERRED_IO
         bool
         depends on FB
@@ -1797,22 +1773,37 @@ config FB_AU1200
           option au1200fb:panel=<name>.
 
 config FB_VT8500
-        bool "VT8500 LCD Driver"
+        bool "VIA VT8500 framebuffer support"
         depends on (FB = y) && ARM && ARCH_VT8500
-        select FB_WMT_GE_ROPS
+        select FB_SYS_FILLRECT if (!FB_WMT_GE_ROPS)
+        select FB_SYS_COPYAREA if (!FB_WMT_GE_ROPS)
         select FB_SYS_IMAGEBLIT
+        select FB_MODE_HELPERS
+        select VIDEOMODE_HELPERS
         help
           This is the framebuffer driver for VIA VT8500 integrated LCD
           controller.
 
 config FB_WM8505
-        bool "WM8505 frame buffer support"
+        bool "Wondermedia WM8xxx-series frame buffer support"
         depends on (FB = y) && ARM && ARCH_VT8500
-        select FB_WMT_GE_ROPS
+        select FB_SYS_FILLRECT if (!FB_WMT_GE_ROPS)
+        select FB_SYS_COPYAREA if (!FB_WMT_GE_ROPS)
         select FB_SYS_IMAGEBLIT
+        select FB_MODE_HELPERS
+        select VIDEOMODE_HELPERS
         help
-          This is the framebuffer driver for WonderMedia WM8505/WM8650
-          integrated LCD controller.
+          This is the framebuffer driver for WonderMedia WM8xxx-series
+          integrated LCD controller. This driver covers the WM8505, WM8650
+          and WM8850 SoCs.
+
+config FB_WMT_GE_ROPS
+        bool "VT8500/WM8xxx accelerated raster ops support"
+        depends on (FB = y) && (FB_VT8500 || FB_WM8505)
+        default n
+        help
+          This adds support for accelerated raster operations on the
+          VIA VT8500 and Wondermedia 85xx series SoCs.
 
 source "drivers/video/geode/Kconfig"
 
@@ -2277,7 +2268,7 @@ config XEN_FBDEV_FRONTEND
         select FB_SYS_IMAGEBLIT
         select FB_SYS_FOPS
         select FB_DEFERRED_IO
-        select INPUT_XEN_KBDDEV_FRONTEND
+        select INPUT_XEN_KBDDEV_FRONTEND if INPUT_MISC
         select XEN_XENBUS_FRONTEND
         default y
         help
@@ -2453,6 +2444,15 @@ config FB_PUV3_UNIGFX
           Choose this option if you want to use the Unigfx device as a
           framebuffer device. Without the support of PCI & AGP.
 
+config FB_HYPERV
+        tristate "Microsoft Hyper-V Synthetic Video support"
+        depends on FB && HYPERV
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This framebuffer driver supports Microsoft Hyper-V Synthetic Video.
+
 source "drivers/video/omap/Kconfig"
 source "drivers/video/omap2/Kconfig"
 source "drivers/video/exynos/Kconfig"
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 9df387334cb7..7234e4a959e8 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -149,6 +149,7 @@ obj-$(CONFIG_FB_MSM)              += msm/
 obj-$(CONFIG_FB_NUC900)           += nuc900fb.o
 obj-$(CONFIG_FB_JZ4740)           += jz4740_fb.o
 obj-$(CONFIG_FB_PUV3_UNIGFX)      += fb-puv3.o
+obj-$(CONFIG_FB_HYPERV)           += hyperv_fb.o
 
 # Platform or fallback drivers go here
 obj-$(CONFIG_FB_UVESA)            += uvesafb.o
@@ -171,7 +172,7 @@ obj-$(CONFIG_FB_VIRTUAL)          += vfb.o
 
 #video output switch sysfs driver
 obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o
-obj-$(CONFIG_DISPLAY_TIMING) += display_timing.o
-obj-$(CONFIG_OF_DISPLAY_TIMING) += of_display_timing.o
-obj-$(CONFIG_VIDEOMODE) += videomode.o
-obj-$(CONFIG_OF_VIDEOMODE) += of_videomode.o
+obj-$(CONFIG_VIDEOMODE_HELPERS) += display_timing.o videomode.o
+ifeq ($(CONFIG_OF),y)
+obj-$(CONFIG_VIDEOMODE_HELPERS) += of_display_timing.o of_videomode.o
+endif
diff --git a/drivers/video/amifb.c b/drivers/video/amifb.c
index 7fa1bf823729..a6780eecff0e 100644
--- a/drivers/video/amifb.c
+++ b/drivers/video/amifb.c
@@ -1181,7 +1181,7 @@ static int ami_decode_var(struct fb_var_screeninfo *var, struct amifb_par *par,
         }
 
         /*
-         * FB_VMODE_SMOOTH_XPAN will be cleared, if one of the folloing
+         * FB_VMODE_SMOOTH_XPAN will be cleared, if one of the following
          * checks failed and smooth scrolling is not possible
          */
 
@@ -3788,19 +3788,7 @@ static struct platform_driver amifb_driver = {
         },
 };
 
-static int __init amifb_init(void)
-{
-        return platform_driver_probe(&amifb_driver, amifb_probe);
-}
-
-module_init(amifb_init);
-
-static void __exit amifb_exit(void)
-{
-        platform_driver_unregister(&amifb_driver);
-}
-
-module_exit(amifb_exit);
+module_platform_driver_probe(amifb_driver, amifb_probe);
 
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:amiga-video");
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 025428e04c33..540909de6247 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -34,6 +34,77 @@
 #define ATMEL_LCDC_DMA_BURST_LEN        8       /* words */
 #define ATMEL_LCDC_FIFO_SIZE            512     /* words */
 
+struct atmel_lcdfb_config {
+        bool have_alt_pixclock;
+        bool have_hozval;
+        bool have_intensity_bit;
+};
+
+static struct atmel_lcdfb_config at91sam9261_config = {
+        .have_hozval            = true,
+        .have_intensity_bit     = true,
+};
+
+static struct atmel_lcdfb_config at91sam9263_config = {
+        .have_intensity_bit     = true,
+};
+
+static struct atmel_lcdfb_config at91sam9g10_config = {
+        .have_hozval            = true,
+};
+
+static struct atmel_lcdfb_config at91sam9g45_config = {
+        .have_alt_pixclock      = true,
+};
+
+static struct atmel_lcdfb_config at91sam9g45es_config = {
+};
+
+static struct atmel_lcdfb_config at91sam9rl_config = {
+        .have_intensity_bit     = true,
+};
+
+static struct atmel_lcdfb_config at32ap_config = {
+        .have_hozval            = true,
+};
+
+static const struct platform_device_id atmel_lcdfb_devtypes[] = {
+        {
+                .name = "at91sam9261-lcdfb",
+                .driver_data = (unsigned long)&at91sam9261_config,
+        }, {
+                .name = "at91sam9263-lcdfb",
+                .driver_data = (unsigned long)&at91sam9263_config,
+        }, {
+                .name = "at91sam9g10-lcdfb",
+                .driver_data = (unsigned long)&at91sam9g10_config,
+        }, {
+                .name = "at91sam9g45-lcdfb",
+                .driver_data = (unsigned long)&at91sam9g45_config,
+        }, {
+                .name = "at91sam9g45es-lcdfb",
+                .driver_data = (unsigned long)&at91sam9g45es_config,
+        }, {
+                .name = "at91sam9rl-lcdfb",
+                .driver_data = (unsigned long)&at91sam9rl_config,
+        }, {
+                .name = "at32ap-lcdfb",
+                .driver_data = (unsigned long)&at32ap_config,
+        }, {
+                /* terminator */
+        }
+};
+
+static struct atmel_lcdfb_config *
+atmel_lcdfb_get_config(struct platform_device *pdev)
+{
+        unsigned long data;
+
+        data = platform_get_device_id(pdev)->driver_data;
+
+        return (struct atmel_lcdfb_config *)data;
+}
+
 #if defined(CONFIG_ARCH_AT91)
 #define ATMEL_LCDFB_FBINFO_DEFAULT      (FBINFO_DEFAULT \
                                          | FBINFO_PARTIAL_PAN_OK \
@@ -193,14 +264,16 @@ static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
         .accel          = FB_ACCEL_NONE,
 };
 
-static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
+static unsigned long compute_hozval(struct atmel_lcdfb_info *sinfo,
+                                                        unsigned long xres)
 {
+        unsigned long lcdcon2;
         unsigned long value;
 
-        if (!(cpu_is_at91sam9261() || cpu_is_at91sam9g10()
-                || cpu_is_at32ap7000()))
+        if (!sinfo->config->have_hozval)
                 return xres;
 
+        lcdcon2 = lcdc_readl(sinfo, ATMEL_LCDC_LCDCON2);
         value = xres;
         if ((lcdcon2 & ATMEL_LCDC_DISTYPE) != ATMEL_LCDC_DISTYPE_TFT) {
                 /* STN display */
@@ -423,7 +496,7 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
                 break;
         case 16:
                 /* Older SOCs use IBGR:555 rather than BGR:565. */
-                if (sinfo->have_intensity_bit)
+                if (sinfo->config->have_intensity_bit)
                         var->green.length = 5;
                 else
                         var->green.length = 6;
@@ -531,7 +604,7 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         /* Now, the LCDC core... */
 
         /* Set pixel clock */
-        if (cpu_is_at91sam9g45() && !cpu_is_at91sam9g45es())
+        if (sinfo->config->have_alt_pixclock)
                 pix_factor = 1;
 
         clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
@@ -591,8 +664,7 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         lcdc_writel(sinfo, ATMEL_LCDC_TIM2, value);
 
         /* Horizontal value (aka line size) */
-        hozval_linesz = compute_hozval(info->var.xres,
-                                        lcdc_readl(sinfo, ATMEL_LCDC_LCDCON2));
+        hozval_linesz = compute_hozval(sinfo, info->var.xres);
 
         /* Display size */
         value = (hozval_linesz - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
@@ -684,7 +756,7 @@ static int atmel_lcdfb_setcolreg(unsigned int regno, unsigned int red,
 
         case FB_VISUAL_PSEUDOCOLOR:
                 if (regno < 256) {
-                        if (sinfo->have_intensity_bit) {
+                        if (sinfo->config->have_intensity_bit) {
                                 /* old style I+BGR:555 */
                                 val  = ((red   >> 11) & 0x001f);
                                 val |= ((green >>  6) & 0x03e0);
@@ -821,15 +893,13 @@ static int __init atmel_lcdfb_init_fbinfo(struct atmel_lcdfb_info *sinfo)
 
 static void atmel_lcdfb_start_clock(struct atmel_lcdfb_info *sinfo)
 {
-        if (sinfo->bus_clk)
-                clk_enable(sinfo->bus_clk);
+        clk_enable(sinfo->bus_clk);
         clk_enable(sinfo->lcdc_clk);
 }
 
 static void atmel_lcdfb_stop_clock(struct atmel_lcdfb_info *sinfo)
 {
-        if (sinfo->bus_clk)
-                clk_disable(sinfo->bus_clk);
+        clk_disable(sinfo->bus_clk);
         clk_disable(sinfo->lcdc_clk);
 }
 
@@ -874,10 +944,9 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
         }
         sinfo->info = info;
         sinfo->pdev = pdev;
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9263() ||
-                                                        cpu_is_at91sam9rl()) {
-                sinfo->have_intensity_bit = true;
-        }
+        sinfo->config = atmel_lcdfb_get_config(pdev);
+        if (!sinfo->config)
+                goto free_info;
 
         strcpy(info->fix.id, sinfo->pdev->name);
         info->flags = ATMEL_LCDFB_FBINFO_DEFAULT;
@@ -888,13 +957,10 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
         info->fix = atmel_lcdfb_fix;
 
         /* Enable LCDC Clocks */
-        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()
-         || cpu_is_at32ap7000()) {
-                sinfo->bus_clk = clk_get(dev, "hck1");
-                if (IS_ERR(sinfo->bus_clk)) {
-                        ret = PTR_ERR(sinfo->bus_clk);
-                        goto free_info;
-                }
+        sinfo->bus_clk = clk_get(dev, "hclk");
+        if (IS_ERR(sinfo->bus_clk)) {
+                ret = PTR_ERR(sinfo->bus_clk);
+                goto free_info;
         }
         sinfo->lcdc_clk = clk_get(dev, "lcdc_clk");
         if (IS_ERR(sinfo->lcdc_clk)) {
@@ -1055,8 +1121,7 @@ stop_clk:
         atmel_lcdfb_stop_clock(sinfo);
         clk_put(sinfo->lcdc_clk);
 put_bus_clk:
-        if (sinfo->bus_clk)
-                clk_put(sinfo->bus_clk);
+        clk_put(sinfo->bus_clk);
 free_info:
         framebuffer_release(info);
 out:
@@ -1081,8 +1146,7 @@ static int __exit atmel_lcdfb_remove(struct platform_device *pdev)
         unregister_framebuffer(info);
         atmel_lcdfb_stop_clock(sinfo);
         clk_put(sinfo->lcdc_clk);
-        if (sinfo->bus_clk)
-                clk_put(sinfo->bus_clk);
+        clk_put(sinfo->bus_clk);
         fb_dealloc_cmap(&info->cmap);
         free_irq(sinfo->irq_base, info);
         iounmap(sinfo->mmio);
@@ -1151,25 +1215,14 @@ static struct platform_driver atmel_lcdfb_driver = {
         .remove         = __exit_p(atmel_lcdfb_remove),
         .suspend        = atmel_lcdfb_suspend,
         .resume         = atmel_lcdfb_resume,
-
+        .id_table       = atmel_lcdfb_devtypes,
         .driver         = {
                 .name   = "atmel_lcdfb",
                 .owner  = THIS_MODULE,
         },
 };
 
-static int __init atmel_lcdfb_init(void)
-{
-        return platform_driver_probe(&atmel_lcdfb_driver, atmel_lcdfb_probe);
-}
-
-static void __exit atmel_lcdfb_exit(void)
-{
-        platform_driver_unregister(&atmel_lcdfb_driver);
-}
-
-module_init(atmel_lcdfb_init);
-module_exit(atmel_lcdfb_exit);
+module_platform_driver_probe(atmel_lcdfb_driver, atmel_lcdfb_probe);
 
 MODULE_DESCRIPTION("AT91/AT32 LCD Controller framebuffer driver");
 MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@atmel.com>");
diff --git a/drivers/video/auo_k1900fb.c b/drivers/video/auo_k1900fb.c
index 1a9ac6e1f4b3..f5b668e77af3 100644
--- a/drivers/video/auo_k1900fb.c
+++ b/drivers/video/auo_k1900fb.c
@@ -60,9 +60,12 @@
 
 static void auok1900_init(struct auok190xfb_par *par)
 {
+        struct device *dev = par->info->device;
         struct auok190x_board *board = par->board;
         u16 init_param = 0;
 
+        pm_runtime_get_sync(dev);
+
         init_param |= AUOK1900_INIT_TEMP_AVERAGE;
         init_param |= AUOK1900_INIT_ROTATE(par->rotation);
         init_param |= AUOK190X_INIT_INVERSE_WHITE;
@@ -74,6 +77,9 @@ static void auok1900_init(struct auok190xfb_par *par)
 
         /* let the controller finish */
         board->wait_for_rdy(par);
+
+        pm_runtime_mark_last_busy(dev);
+        pm_runtime_put_autosuspend(dev);
 }
 
 static void auok1900_update_region(struct auok190xfb_par *par, int mode,
@@ -82,6 +88,7 @@ static void auok1900_update_region(struct auok190xfb_par *par, int mode,
         struct device *dev = par->info->device;
         unsigned char *buf = (unsigned char *)par->info->screen_base;
         int xres = par->info->var.xres;
+        int line_length = par->info->fix.line_length;
         u16 args[4];
 
         pm_runtime_get_sync(dev);
@@ -100,9 +107,9 @@ static void auok1900_update_region(struct auok190xfb_par *par, int mode,
         args[1] = y1 + 1;
         args[2] = xres;
         args[3] = y2 - y1;
-        buf += y1 * xres;
+        buf += y1 * line_length;
         auok190x_send_cmdargs_pixels(par, AUOK1900_CMD_PARTIALDISP, 4, args,
-                                     ((y2 - y1) * xres)/2, (u16 *) buf);
+                                     ((y2 - y1) * line_length)/2, (u16 *) buf);
         auok190x_send_command(par, AUOK190X_CMD_DATA_STOP);
 
         par->update_cnt++;
diff --git a/drivers/video/auo_k1901fb.c b/drivers/video/auo_k1901fb.c
index d1db1653cd88..12b9adcb75c5 100644
--- a/drivers/video/auo_k1901fb.c
+++ b/drivers/video/auo_k1901fb.c
@@ -101,9 +101,12 @@
 
 static void auok1901_init(struct auok190xfb_par *par)
 {
+        struct device *dev = par->info->device;
         struct auok190x_board *board = par->board;
         u16 init_param = 0;
 
+        pm_runtime_get_sync(dev);
+
         init_param |= AUOK190X_INIT_INVERSE_WHITE;
         init_param |= AUOK190X_INIT_FORMAT0;
         init_param |= AUOK1901_INIT_RESOLUTION(par->resolution);
@@ -113,6 +116,9 @@ static void auok1901_init(struct auok190xfb_par *par)
 
         /* let the controller finish */
         board->wait_for_rdy(par);
+
+        pm_runtime_mark_last_busy(dev);
+        pm_runtime_put_autosuspend(dev);
 }
 
 static void auok1901_update_region(struct auok190xfb_par *par, int mode,
@@ -121,6 +127,7 @@ static void auok1901_update_region(struct auok190xfb_par *par, int mode,
         struct device *dev = par->info->device;
         unsigned char *buf = (unsigned char *)par->info->screen_base;
         int xres = par->info->var.xres;
+        int line_length = par->info->fix.line_length;
         u16 args[5];
 
         pm_runtime_get_sync(dev);
@@ -139,9 +146,9 @@ static void auok1901_update_region(struct auok190xfb_par *par, int mode,
         args[1] = y1 + 1;
         args[2] = xres;
         args[3] = y2 - y1;
-        buf += y1 * xres;
+        buf += y1 * line_length;
         auok190x_send_cmdargs_pixels_nowait(par, AUOK1901_CMD_DMA_START, 4,
-                                            args, ((y2 - y1) * xres)/2,
+                                            args, ((y2 - y1) * line_length)/2,
                                             (u16 *) buf);
         auok190x_send_command_nowait(par, AUOK190X_CMD_DATA_STOP);
 
diff --git a/drivers/video/auo_k190x.c b/drivers/video/auo_k190x.c
index 53846cb534d4..8d2499d1cafb 100644
--- a/drivers/video/auo_k190x.c
+++ b/drivers/video/auo_k190x.c
@@ -40,6 +40,14 @@ static struct panel_info panel_table[] = {
                 .w = 1024,
                 .h = 768,
         },
+        [AUOK190X_RESOLUTION_600_800] = {
+                .w = 600,
+                .h = 800,
+        },
+        [AUOK190X_RESOLUTION_768_1024] = {
+                .w = 768,
+                .h = 1024,
+        },
 };
 
 /*
@@ -60,8 +68,48 @@ static void auok190x_issue_cmd(struct auok190xfb_par *par, u16 data)
         par->board->set_ctl(par, AUOK190X_I80_DC, 1);
 }
 
-static int auok190x_issue_pixels(struct auok190xfb_par *par, int size,
-                                 u16 *data)
+/**
+ * Conversion of 16bit color to 4bit grayscale
+ * does roughly (0.3 * R + 0.6 G + 0.1 B) / 2
+ */
+static inline int rgb565_to_gray4(u16 data, struct fb_var_screeninfo *var)
+{
+        return ((((data & 0xF800) >> var->red.offset) * 77 +
+                 ((data & 0x07E0) >> (var->green.offset + 1)) * 151 +
+                 ((data & 0x1F) >> var->blue.offset) * 28) >> 8 >> 1);
+}
+
+static int auok190x_issue_pixels_rgb565(struct auok190xfb_par *par, int size,
+                                        u16 *data)
+{
+        struct fb_var_screeninfo *var = &par->info->var;
+        struct device *dev = par->info->device;
+        int i;
+        u16 tmp;
+
+        if (size & 7) {
+                dev_err(dev, "issue_pixels: size %d must be a multiple of 8\n",
+                        size);
+                return -EINVAL;
+        }
+
+        for (i = 0; i < (size >> 2); i++) {
+                par->board->set_ctl(par, AUOK190X_I80_WR, 0);
+
+                tmp  = (rgb565_to_gray4(data[4*i], var) & 0x000F);
+                tmp |= (rgb565_to_gray4(data[4*i+1], var) << 4) & 0x00F0;
+                tmp |= (rgb565_to_gray4(data[4*i+2], var) << 8) & 0x0F00;
+                tmp |= (rgb565_to_gray4(data[4*i+3], var) << 12) & 0xF000;
+
+                par->board->set_hdb(par, tmp);
+                par->board->set_ctl(par, AUOK190X_I80_WR, 1);
+        }
+
+        return 0;
+}
+
+static int auok190x_issue_pixels_gray8(struct auok190xfb_par *par, int size,
+                                       u16 *data)
 {
         struct device *dev = par->info->device;
         int i;
@@ -91,6 +139,23 @@ static int auok190x_issue_pixels(struct auok190xfb_par *par, int size,
         return 0;
 }
 
+static int auok190x_issue_pixels(struct auok190xfb_par *par, int size,
+                                 u16 *data)
+{
+        struct fb_info *info = par->info;
+        struct device *dev = par->info->device;
+
+        if (info->var.bits_per_pixel == 8 && info->var.grayscale)
+                auok190x_issue_pixels_gray8(par, size, data);
+        else if (info->var.bits_per_pixel == 16)
+                auok190x_issue_pixels_rgb565(par, size, data);
+        else
+                dev_err(dev, "unsupported color mode (bits: %d, gray: %d)\n",
+                        info->var.bits_per_pixel, info->var.grayscale);
+
+        return 0;
+}
+
 static u16 auok190x_read_data(struct auok190xfb_par *par)
 {
         u16 data;
@@ -224,8 +289,8 @@ static void auok190xfb_dpy_deferred_io(struct fb_info *info,
 {
         struct fb_deferred_io *fbdefio = info->fbdefio;
         struct auok190xfb_par *par = info->par;
+        u16 line_length = info->fix.line_length;
         u16 yres = info->var.yres;
-        u16 xres = info->var.xres;
         u16 y1 = 0, h = 0;
         int prev_index = -1;
         struct page *cur;
@@ -254,7 +319,7 @@ static void auok190xfb_dpy_deferred_io(struct fb_info *info,
         }
 
         /* height increment is fixed per page */
-        h_inc = DIV_ROUND_UP(PAGE_SIZE , xres);
+        h_inc = DIV_ROUND_UP(PAGE_SIZE , line_length);
 
         /* calculate number of pages from pixel height */
         threshold = par->consecutive_threshold / h_inc;
@@ -265,7 +330,7 @@ static void auok190xfb_dpy_deferred_io(struct fb_info *info,
         list_for_each_entry(cur, &fbdefio->pagelist, lru) {
                 if (prev_index < 0) {
                         /* just starting so assign first page */
-                        y1 = (cur->index << PAGE_SHIFT) / xres;
+                        y1 = (cur->index << PAGE_SHIFT) / line_length;
                         h = h_inc;
                 } else if ((cur->index - prev_index) <= threshold) {
                         /* page is within our threshold for single updates */
@@ -275,7 +340,7 @@ static void auok190xfb_dpy_deferred_io(struct fb_info *info,
                         par->update_partial(par, y1, y1 + h);
 
                         /* start over with our non consecutive page */
-                        y1 = (cur->index << PAGE_SHIFT) / xres;
+                        y1 = (cur->index << PAGE_SHIFT) / line_length;
                         h = h_inc;
                 }
                 prev_index = cur->index;
@@ -376,27 +441,127 @@ static void auok190xfb_imageblit(struct fb_info *info,
 static int auok190xfb_check_var(struct fb_var_screeninfo *var,
                                    struct fb_info *info)
 {
-        if (info->var.xres != var->xres || info->var.yres != var->yres ||
-            info->var.xres_virtual != var->xres_virtual ||
-            info->var.yres_virtual != var->yres_virtual) {
-                pr_info("%s: Resolution not supported: X%u x Y%u\n",
-                         __func__, var->xres, var->yres);
+        struct device *dev = info->device;
+        struct auok190xfb_par *par = info->par;
+        struct panel_info *panel = &panel_table[par->resolution];
+        int size;
+
+        /*
+         * Color depth
+         */
+
+        if (var->bits_per_pixel == 8 && var->grayscale == 1) {
+                /*
+                 * For 8-bit grayscale, R, G, and B offset are equal.
+                 */
+                var->red.length = 8;
+                var->red.offset = 0;
+                var->red.msb_right = 0;
+
+                var->green.length = 8;
+                var->green.offset = 0;
+                var->green.msb_right = 0;
+
+                var->blue.length = 8;
+                var->blue.offset = 0;
+                var->blue.msb_right = 0;
+
+                var->transp.length = 0;
+                var->transp.offset = 0;
+                var->transp.msb_right = 0;
+        } else if (var->bits_per_pixel == 16) {
+                var->red.length = 5;
+                var->red.offset = 11;
+                var->red.msb_right = 0;
+
+                var->green.length = 6;
+                var->green.offset = 5;
+                var->green.msb_right = 0;
+
+                var->blue.length = 5;
+                var->blue.offset = 0;
+                var->blue.msb_right = 0;
+
+                var->transp.length = 0;
+                var->transp.offset = 0;
+                var->transp.msb_right = 0;
+        } else {
+                dev_warn(dev, "unsupported color mode (bits: %d, grayscale: %d)\n",
+                        info->var.bits_per_pixel, info->var.grayscale);
                 return -EINVAL;
         }
 
         /*
+         * Dimensions
+         */
+
+        switch (var->rotate) {
+        case FB_ROTATE_UR:
+        case FB_ROTATE_UD:
+                var->xres = panel->w;
+                var->yres = panel->h;
+                break;
+        case FB_ROTATE_CW:
+        case FB_ROTATE_CCW:
+                var->xres = panel->h;
+                var->yres = panel->w;
+                break;
+        default:
+                dev_dbg(dev, "Invalid rotation request\n");
+                return -EINVAL;
+        }
+
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        /*
          *  Memory limit
          */
 
-        if ((info->fix.line_length * var->yres_virtual) > info->fix.smem_len) {
-                pr_info("%s: Memory Limit requested yres_virtual = %u\n",
-                         __func__, var->yres_virtual);
+        size = var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8;
+        if (size > info->fix.smem_len) {
+                dev_err(dev, "Memory limit exceeded, requested %dK\n",
+                        size >> 10);
                 return -ENOMEM;
         }
 
         return 0;
 }
 
+static int auok190xfb_set_fix(struct fb_info *info)
+{
+        struct fb_fix_screeninfo *fix = &info->fix;
+        struct fb_var_screeninfo *var = &info->var;
+
+        fix->line_length = var->xres_virtual * var->bits_per_pixel / 8;
+
+        fix->type = FB_TYPE_PACKED_PIXELS;
+        fix->accel = FB_ACCEL_NONE;
+        fix->visual = (var->grayscale) ? FB_VISUAL_STATIC_PSEUDOCOLOR
+                                       : FB_VISUAL_TRUECOLOR;
+        fix->xpanstep = 0;
+        fix->ypanstep = 0;
+        fix->ywrapstep = 0;
+
+        return 0;
+}
+
+static int auok190xfb_set_par(struct fb_info *info)
+{
+        struct auok190xfb_par *par = info->par;
+
+        par->rotation = info->var.rotate;
+        auok190xfb_set_fix(info);
+
+        /* reinit the controller to honor the rotation */
+        par->init(par);
+
+        /* wait for init to complete */
+        par->board->wait_for_rdy(par);
+
+        return 0;
+}
+
 static struct fb_ops auok190xfb_ops = {
         .owner          = THIS_MODULE,
         .fb_read        = fb_sys_read,
@@ -405,6 +570,7 @@ static struct fb_ops auok190xfb_ops = {
         .fb_copyarea    = auok190xfb_copyarea,
         .fb_imageblit   = auok190xfb_imageblit,
         .fb_check_var   = auok190xfb_check_var,
+        .fb_set_par     = auok190xfb_set_par,
 };
 
 /*
@@ -588,10 +754,16 @@ static int auok190x_power(struct auok190xfb_par *par, bool on)
 
 static void auok190x_recover(struct auok190xfb_par *par)
 {
+        struct device *dev = par->info->device;
+
         auok190x_power(par, 0);
         msleep(100);
         auok190x_power(par, 1);
 
+        /* after powercycling the device, it's always active */
+        pm_runtime_set_active(dev);
+        par->standby = 0;
+
         par->init(par);
 
         /* wait for init to complete */
@@ -875,42 +1047,17 @@ int auok190x_common_probe(struct platform_device *pdev,
         /* initialise fix, var, resolution and rotation */
 
         strlcpy(info->fix.id, init->id, 16);
-        info->fix.type = FB_TYPE_PACKED_PIXELS;
-        info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
-        info->fix.xpanstep = 0;
-        info->fix.ypanstep = 0;
-        info->fix.ywrapstep = 0;
-        info->fix.accel = FB_ACCEL_NONE;
-
         info->var.bits_per_pixel = 8;
         info->var.grayscale = 1;
-        info->var.red.length = 8;
-        info->var.green.length = 8;
-        info->var.blue.length = 8;
 
         panel = &panel_table[board->resolution];
 
-        /* if 90 degree rotation, switch width and height */
-        if (board->rotation & 1) {
-                info->var.xres = panel->h;
-                info->var.yres = panel->w;
-                info->var.xres_virtual = panel->h;
-                info->var.yres_virtual = panel->w;
-                info->fix.line_length = panel->h;
-        } else {
-                info->var.xres = panel->w;
-                info->var.yres = panel->h;
-                info->var.xres_virtual = panel->w;
-                info->var.yres_virtual = panel->h;
-                info->fix.line_length = panel->w;
-        }
-
         par->resolution = board->resolution;
-        par->rotation = board->rotation;
+        par->rotation = 0;
 
         /* videomemory handling */
 
-        videomemorysize = roundup((panel->w * panel->h), PAGE_SIZE);
+        videomemorysize = roundup((panel->w * panel->h) * 2, PAGE_SIZE);
         videomemory = vmalloc(videomemorysize);
         if (!videomemory) {
                 ret = -ENOMEM;
@@ -924,6 +1071,12 @@ int auok190x_common_probe(struct platform_device *pdev,
         info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
         info->fbops = &auok190xfb_ops;
 
+        ret = auok190xfb_check_var(&info->var, info);
+        if (ret)
+                goto err_defio;
+
+        auok190xfb_set_fix(info);
+
         /* deferred io init */
 
         info->fbdefio = devm_kzalloc(info->device,
@@ -935,7 +1088,7 @@ int auok190x_common_probe(struct platform_device *pdev,
                 goto err_defio;
         }
 
-        dev_dbg(info->device, "targetting %d frames per second\n", board->fps);
+        dev_dbg(info->device, "targeting %d frames per second\n", board->fps);
         info->fbdefio->delay = HZ / board->fps;
         info->fbdefio->first_io = auok190xfb_dpy_first_io,
         info->fbdefio->deferred_io = auok190xfb_dpy_deferred_io,
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index db10d0120d2b..2e166c3fc4c3 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -59,6 +59,13 @@ config LCD_LTV350QV
 
           The LTV350QV panel is present on all ATSTK1000 boards.
 
+config LCD_ILI922X
+        tristate "ILI Technology ILI9221/ILI9222 support"
+        depends on SPI
+        help
+          If you have a panel based on the ILI9221/9222 controller
+          chip then say y to include a driver for it.
+
 config LCD_ILI9320
         tristate "ILI Technology ILI9320 controller support"
         depends on SPI
@@ -161,7 +168,7 @@ if BACKLIGHT_CLASS_DEVICE
 config BACKLIGHT_ATMEL_LCDC
         bool "Atmel LCDC Contrast-as-Backlight control"
         depends on FB_ATMEL
-        default y if MACH_SAM9261EK || MACH_SAM9G10EK || MACH_SAM9263EK
+        default y if MACH_AT91SAM9261EK || MACH_AT91SAM9G10EK || MACH_AT91SAM9263EK
         help
           This provides a backlight control internal to the Atmel LCDC
           driver.  If the LCD "contrast control" on your board is wired
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 96c4d620c5ce..92711fe60464 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -5,6 +5,7 @@ obj-$(CONFIG_LCD_CLASS_DEVICE)		+= lcd.o
 obj-$(CONFIG_LCD_CORGI)                 += corgi_lcd.o
 obj-$(CONFIG_LCD_HP700)                 += jornada720_lcd.o
 obj-$(CONFIG_LCD_HX8357)                += hx8357.o
+obj-$(CONFIG_LCD_ILI922X)               += ili922x.o
 obj-$(CONFIG_LCD_ILI9320)               += ili9320.o
 obj-$(CONFIG_LCD_L4F00242T03)           += l4f00242t03.o
 obj-$(CONFIG_LCD_LD9040)                += ld9040.o
diff --git a/drivers/video/backlight/adp5520_bl.c b/drivers/video/backlight/adp5520_bl.c
index a1e41d4faa71..c84701b7ca6e 100644
--- a/drivers/video/backlight/adp5520_bl.c
+++ b/drivers/video/backlight/adp5520_bl.c
@@ -143,13 +143,16 @@ static int adp5520_bl_setup(struct backlight_device *bl)
 static ssize_t adp5520_show(struct device *dev, char *buf, int reg)
 {
         struct adp5520_bl *data = dev_get_drvdata(dev);
-        int error;
+        int ret;
         uint8_t reg_val;
 
         mutex_lock(&data->lock);
-        error = adp5520_read(data->master, reg, &reg_val);
+        ret = adp5520_read(data->master, reg, &reg_val);
         mutex_unlock(&data->lock);
 
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%u\n", reg_val);
 }
 
@@ -349,35 +352,34 @@ static int adp5520_bl_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int adp5520_bl_suspend(struct platform_device *pdev,
-                                 pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int adp5520_bl_suspend(struct device *dev)
 {
-        struct backlight_device *bl = platform_get_drvdata(pdev);
+        struct backlight_device *bl = dev_get_drvdata(dev);
+
         return adp5520_bl_set(bl, 0);
 }
 
-static int adp5520_bl_resume(struct platform_device *pdev)
+static int adp5520_bl_resume(struct device *dev)
 {
-        struct backlight_device *bl = platform_get_drvdata(pdev);
+        struct backlight_device *bl = dev_get_drvdata(dev);
 
         backlight_update_status(bl);
         return 0;
 }
-#else
-#define adp5520_bl_suspend      NULL
-#define adp5520_bl_resume       NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(adp5520_bl_pm_ops, adp5520_bl_suspend,
+                        adp5520_bl_resume);
+
 static struct platform_driver adp5520_bl_driver = {
         .driver         = {
                 .name   = "adp5520-backlight",
                 .owner  = THIS_MODULE,
+                .pm     = &adp5520_bl_pm_ops,
         },
         .probe          = adp5520_bl_probe,
         .remove         = adp5520_bl_remove,
-        .suspend        = adp5520_bl_suspend,
-        .resume         = adp5520_bl_resume,
 };
 
 module_platform_driver(adp5520_bl_driver);
diff --git a/drivers/video/backlight/adp8860_bl.c b/drivers/video/backlight/adp8860_bl.c
index a77c9cad3320..75b10f876127 100644
--- a/drivers/video/backlight/adp8860_bl.c
+++ b/drivers/video/backlight/adp8860_bl.c
@@ -249,12 +249,14 @@ static int adp8860_led_probe(struct i2c_client *client)
                 if (led_dat->id > 7 || led_dat->id < 1) {
                         dev_err(&client->dev, "Invalid LED ID %d\n",
                                 led_dat->id);
+                        ret = -EINVAL;
                         goto err;
                 }
 
                 if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) {
                         dev_err(&client->dev, "LED %d used by Backlight\n",
                                 led_dat->id);
+                        ret = -EBUSY;
                         goto err;
                 }
 
@@ -773,25 +775,29 @@ static int adp8860_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int adp8860_i2c_suspend(struct i2c_client *client, pm_message_t message)
+#ifdef CONFIG_PM_SLEEP
+static int adp8860_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         adp8860_clr_bits(client, ADP8860_MDCR, NSTBY);
 
         return 0;
 }
 
-static int adp8860_i2c_resume(struct i2c_client *client)
+static int adp8860_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         adp8860_set_bits(client, ADP8860_MDCR, NSTBY | BLEN);
 
         return 0;
 }
-#else
-#define adp8860_i2c_suspend NULL
-#define adp8860_i2c_resume NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(adp8860_i2c_pm_ops, adp8860_i2c_suspend,
+                        adp8860_i2c_resume);
+
 static const struct i2c_device_id adp8860_id[] = {
         { "adp8860", adp8860 },
         { "adp8861", adp8861 },
@@ -802,12 +808,11 @@ MODULE_DEVICE_TABLE(i2c, adp8860_id);
 
 static struct i2c_driver adp8860_driver = {
         .driver = {
-                .name = KBUILD_MODNAME,
+                .name   = KBUILD_MODNAME,
+                .pm     = &adp8860_i2c_pm_ops,
         },
         .probe    = adp8860_probe,
         .remove   = adp8860_remove,
-        .suspend = adp8860_i2c_suspend,
-        .resume  = adp8860_i2c_resume,
         .id_table = adp8860_id,
 };
 
diff --git a/drivers/video/backlight/adp8870_bl.c b/drivers/video/backlight/adp8870_bl.c
index 712c25a0d8fe..90049d7b5c60 100644
--- a/drivers/video/backlight/adp8870_bl.c
+++ b/drivers/video/backlight/adp8870_bl.c
@@ -274,12 +274,14 @@ static int adp8870_led_probe(struct i2c_client *client)
                 if (led_dat->id > 7 || led_dat->id < 1) {
                         dev_err(&client->dev, "Invalid LED ID %d\n",
                                 led_dat->id);
+                        ret = -EINVAL;
                         goto err;
                 }
 
                 if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) {
                         dev_err(&client->dev, "LED %d used by Backlight\n",
                                 led_dat->id);
+                        ret = -EBUSY;
                         goto err;
                 }
 
@@ -895,13 +897,13 @@ static int adp8870_probe(struct i2c_client *client,
 
         data->bl = bl;
 
-        if (pdata->en_ambl_sens)
+        if (pdata->en_ambl_sens) {
                 ret = sysfs_create_group(&bl->dev.kobj,
                         &adp8870_bl_attr_group);
-
-        if (ret) {
-                dev_err(&client->dev, "failed to register sysfs\n");
-                goto out1;
+                if (ret) {
+                        dev_err(&client->dev, "failed to register sysfs\n");
+                        goto out1;
+                }
         }
 
         ret = adp8870_bl_setup(bl);
@@ -947,25 +949,29 @@ static int adp8870_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int adp8870_i2c_suspend(struct i2c_client *client, pm_message_t message)
+#ifdef CONFIG_PM_SLEEP
+static int adp8870_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         adp8870_clr_bits(client, ADP8870_MDCR, NSTBY);
 
         return 0;
 }
 
-static int adp8870_i2c_resume(struct i2c_client *client)
+static int adp8870_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         adp8870_set_bits(client, ADP8870_MDCR, NSTBY | BLEN);
 
         return 0;
 }
-#else
-#define adp8870_i2c_suspend NULL
-#define adp8870_i2c_resume NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(adp8870_i2c_pm_ops, adp8870_i2c_suspend,
+                        adp8870_i2c_resume);
+
 static const struct i2c_device_id adp8870_id[] = {
         { "adp8870", 0 },
         { }
@@ -974,12 +980,11 @@ MODULE_DEVICE_TABLE(i2c, adp8870_id);
 
 static struct i2c_driver adp8870_driver = {
         .driver = {
-                .name = KBUILD_MODNAME,
+                .name   = KBUILD_MODNAME,
+                .pm     = &adp8870_i2c_pm_ops,
         },
         .probe    = adp8870_probe,
         .remove   = adp8870_remove,
-        .suspend = adp8870_i2c_suspend,
-        .resume  = adp8870_i2c_resume,
         .id_table = adp8870_id,
 };
 
diff --git a/drivers/video/backlight/ams369fg06.c b/drivers/video/backlight/ams369fg06.c
index c02aa2c2575a..319fef6cb422 100644
--- a/drivers/video/backlight/ams369fg06.c
+++ b/drivers/video/backlight/ams369fg06.c
@@ -533,12 +533,12 @@ static int ams369fg06_remove(struct spi_device *spi)
         return 0;
 }
 
-#if defined(CONFIG_PM)
-static int ams369fg06_suspend(struct spi_device *spi, pm_message_t mesg)
+#ifdef CONFIG_PM_SLEEP
+static int ams369fg06_suspend(struct device *dev)
 {
-        struct ams369fg06 *lcd = spi_get_drvdata(spi);
+        struct ams369fg06 *lcd = dev_get_drvdata(dev);
 
-        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+        dev_dbg(dev, "lcd->power = %d\n", lcd->power);
 
         /*
          * when lcd panel is suspend, lcd panel becomes off
@@ -547,19 +547,19 @@ static int ams369fg06_suspend(struct spi_device *spi, pm_message_t mesg)
         return ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int ams369fg06_resume(struct spi_device *spi)
+static int ams369fg06_resume(struct device *dev)
 {
-        struct ams369fg06 *lcd = spi_get_drvdata(spi);
+        struct ams369fg06 *lcd = dev_get_drvdata(dev);
 
         lcd->power = FB_BLANK_POWERDOWN;
 
         return ams369fg06_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define ams369fg06_suspend      NULL
-#define ams369fg06_resume       NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ams369fg06_pm_ops, ams369fg06_suspend,
+                        ams369fg06_resume);
+
 static void ams369fg06_shutdown(struct spi_device *spi)
 {
         struct ams369fg06 *lcd = spi_get_drvdata(spi);
@@ -571,12 +571,11 @@ static struct spi_driver ams369fg06_driver = {
         .driver = {
                 .name   = "ams369fg06",
                 .owner  = THIS_MODULE,
+                .pm     = &ams369fg06_pm_ops,
         },
         .probe          = ams369fg06_probe,
         .remove         = ams369fg06_remove,
         .shutdown       = ams369fg06_shutdown,
-        .suspend        = ams369fg06_suspend,
-        .resume         = ams369fg06_resume,
 };
 
 module_spi_driver(ams369fg06_driver);
diff --git a/drivers/video/backlight/as3711_bl.c b/drivers/video/backlight/as3711_bl.c
index 41d52fe52543..123887cd76bd 100644
--- a/drivers/video/backlight/as3711_bl.c
+++ b/drivers/video/backlight/as3711_bl.c
@@ -258,6 +258,109 @@ static int as3711_bl_register(struct platform_device *pdev,
         return 0;
 }
 
+static int as3711_backlight_parse_dt(struct device *dev)
+{
+        struct as3711_bl_pdata *pdata = dev_get_platdata(dev);
+        struct device_node *bl =
+                of_find_node_by_name(dev->parent->of_node, "backlight"), *fb;
+        int ret;
+
+        if (!bl) {
+                dev_dbg(dev, "backlight node not found\n");
+                return -ENODEV;
+        }
+
+        fb = of_parse_phandle(bl, "su1-dev", 0);
+        if (fb) {
+                pdata->su1_fb = fb->full_name;
+
+                ret = of_property_read_u32(bl, "su1-max-uA", &pdata->su1_max_uA);
+                if (pdata->su1_max_uA <= 0)
+                        ret = -EINVAL;
+                if (ret < 0)
+                        return ret;
+        }
+
+        fb = of_parse_phandle(bl, "su2-dev", 0);
+        if (fb) {
+                int count = 0;
+
+                pdata->su2_fb = fb->full_name;
+
+                ret = of_property_read_u32(bl, "su2-max-uA", &pdata->su2_max_uA);
+                if (pdata->su2_max_uA <= 0)
+                        ret = -EINVAL;
+                if (ret < 0)
+                        return ret;
+
+                if (of_find_property(bl, "su2-feedback-voltage", NULL)) {
+                        pdata->su2_feedback = AS3711_SU2_VOLTAGE;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-feedback-curr1", NULL)) {
+                        pdata->su2_feedback = AS3711_SU2_CURR1;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-feedback-curr2", NULL)) {
+                        pdata->su2_feedback = AS3711_SU2_CURR2;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-feedback-curr3", NULL)) {
+                        pdata->su2_feedback = AS3711_SU2_CURR3;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-feedback-curr-auto", NULL)) {
+                        pdata->su2_feedback = AS3711_SU2_CURR_AUTO;
+                        count++;
+                }
+                if (count != 1)
+                        return -EINVAL;
+
+                count = 0;
+                if (of_find_property(bl, "su2-fbprot-lx-sd4", NULL)) {
+                        pdata->su2_fbprot = AS3711_SU2_LX_SD4;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-fbprot-gpio2", NULL)) {
+                        pdata->su2_fbprot = AS3711_SU2_GPIO2;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-fbprot-gpio3", NULL)) {
+                        pdata->su2_fbprot = AS3711_SU2_GPIO3;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-fbprot-gpio4", NULL)) {
+                        pdata->su2_fbprot = AS3711_SU2_GPIO4;
+                        count++;
+                }
+                if (count != 1)
+                        return -EINVAL;
+
+                count = 0;
+                if (of_find_property(bl, "su2-auto-curr1", NULL)) {
+                        pdata->su2_auto_curr1 = true;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-auto-curr2", NULL)) {
+                        pdata->su2_auto_curr2 = true;
+                        count++;
+                }
+                if (of_find_property(bl, "su2-auto-curr3", NULL)) {
+                        pdata->su2_auto_curr3 = true;
+                        count++;
+                }
+
+                /*
+                 * At least one su2-auto-curr* must be specified iff
+                 * AS3711_SU2_CURR_AUTO is used
+                 */
+                if (!count ^ (pdata->su2_feedback != AS3711_SU2_CURR_AUTO))
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int as3711_backlight_probe(struct platform_device *pdev)
 {
         struct as3711_bl_pdata *pdata = dev_get_platdata(&pdev->dev);
@@ -267,11 +370,24 @@ static int as3711_backlight_probe(struct platform_device *pdev)
         unsigned int max_brightness;
         int ret;
 
-        if (!pdata || (!pdata->su1_fb && !pdata->su2_fb)) {
+        if (!pdata) {
                 dev_err(&pdev->dev, "No platform data, exiting...\n");
                 return -ENODEV;
         }
 
+        if (pdev->dev.parent->of_node) {
+                ret = as3711_backlight_parse_dt(&pdev->dev);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "DT parsing failed: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        if (!pdata->su1_fb && !pdata->su2_fb) {
+                dev_err(&pdev->dev, "No framebuffer specified\n");
+                return -EINVAL;
+        }
+
         /*
          * Due to possible hardware damage I chose to block all modes,
          * unsupported on my hardware. Anyone, wishing to use any of those modes
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index de5e5e74e2a7..a60d6afca97c 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -118,7 +118,7 @@ static const struct backlight_ops atmel_pwm_bl_ops = {
         .update_status  = atmel_pwm_bl_set_intensity,
 };
 
-static int atmel_pwm_bl_probe(struct platform_device *pdev)
+static int __init atmel_pwm_bl_probe(struct platform_device *pdev)
 {
         struct backlight_properties props;
         const struct atmel_pwm_bl_platform_data *pdata;
@@ -225,17 +225,7 @@ static struct platform_driver atmel_pwm_bl_driver = {
         .remove = __exit_p(atmel_pwm_bl_remove),
 };
 
-static int __init atmel_pwm_bl_init(void)
-{
-        return platform_driver_probe(&atmel_pwm_bl_driver, atmel_pwm_bl_probe);
-}
-module_init(atmel_pwm_bl_init);
-
-static void __exit atmel_pwm_bl_exit(void)
-{
-        platform_driver_unregister(&atmel_pwm_bl_driver);
-}
-module_exit(atmel_pwm_bl_exit);
+module_platform_driver_probe(atmel_pwm_bl_driver, atmel_pwm_bl_probe);
 
 MODULE_AUTHOR("Hans-Christian egtvedt <hans-christian.egtvedt@atmel.com>");
 MODULE_DESCRIPTION("Atmel PWM backlight driver");
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index aa782f302983..c97867a717a7 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -457,10 +457,10 @@ static const struct backlight_ops corgi_bl_ops = {
         .update_status  = corgi_bl_update_status,
 };
 
-#ifdef CONFIG_PM
-static int corgi_lcd_suspend(struct spi_device *spi, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int corgi_lcd_suspend(struct device *dev)
 {
-        struct corgi_lcd *lcd = spi_get_drvdata(spi);
+        struct corgi_lcd *lcd = dev_get_drvdata(dev);
 
         corgibl_flags |= CORGIBL_SUSPENDED;
         corgi_bl_set_intensity(lcd, 0);
@@ -468,20 +468,19 @@ static int corgi_lcd_suspend(struct spi_device *spi, pm_message_t state)
         return 0;
 }
 
-static int corgi_lcd_resume(struct spi_device *spi)
+static int corgi_lcd_resume(struct device *dev)
 {
-        struct corgi_lcd *lcd = spi_get_drvdata(spi);
+        struct corgi_lcd *lcd = dev_get_drvdata(dev);
 
         corgibl_flags &= ~CORGIBL_SUSPENDED;
         corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);
         backlight_update_status(lcd->bl_dev);
         return 0;
 }
-#else
-#define corgi_lcd_suspend       NULL
-#define corgi_lcd_resume        NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(corgi_lcd_pm_ops, corgi_lcd_suspend, corgi_lcd_resume);
+
 static int setup_gpio_backlight(struct corgi_lcd *lcd,
                                 struct corgi_lcd_platform_data *pdata)
 {
@@ -611,11 +610,10 @@ static struct spi_driver corgi_lcd_driver = {
         .driver         = {
                 .name   = "corgi-lcd",
                 .owner  = THIS_MODULE,
+                .pm     = &corgi_lcd_pm_ops,
         },
         .probe          = corgi_lcd_probe,
         .remove         = corgi_lcd_remove,
-        .suspend        = corgi_lcd_suspend,
-        .resume         = corgi_lcd_resume,
 };
 
 module_spi_driver(corgi_lcd_driver);
diff --git a/drivers/video/backlight/da903x_bl.c b/drivers/video/backlight/da903x_bl.c
index 8179cef0730f..67cadd30e273 100644
--- a/drivers/video/backlight/da903x_bl.c
+++ b/drivers/video/backlight/da903x_bl.c
@@ -88,16 +88,21 @@ static int da903x_backlight_update_status(struct backlight_device *bl)
         if (bl->props.fb_blank != FB_BLANK_UNBLANK)
                 brightness = 0;
 
+        if (bl->props.state & BL_CORE_SUSPENDED)
+                brightness = 0;
+
         return da903x_backlight_set(bl, brightness);
 }
 
 static int da903x_backlight_get_brightness(struct backlight_device *bl)
 {
         struct da903x_backlight_data *data = bl_get_data(bl);
+
         return data->current_brightness;
 }
 
 static const struct backlight_ops da903x_backlight_ops = {
+        .options        = BL_CORE_SUSPENDRESUME,
         .update_status  = da903x_backlight_update_status,
         .get_brightness = da903x_backlight_get_brightness,
 };
@@ -161,35 +166,10 @@ static int da903x_backlight_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int da903x_backlight_suspend(struct device *dev)
-{
-        struct backlight_device *bl = dev_get_drvdata(dev);
-
-        return da903x_backlight_set(bl, 0);
-}
-
-static int da903x_backlight_resume(struct device *dev)
-{
-        struct backlight_device *bl = dev_get_drvdata(dev);
-
-        backlight_update_status(bl);
-        return 0;
-}
-
-static const struct dev_pm_ops da903x_backlight_pm_ops = {
-        .suspend        = da903x_backlight_suspend,
-        .resume         = da903x_backlight_resume,
-};
-#endif
-
 static struct platform_driver da903x_backlight_driver = {
         .driver         = {
                 .name   = "da903x-backlight",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
-                .pm     = &da903x_backlight_pm_ops,
-#endif
         },
         .probe          = da903x_backlight_probe,
         .remove         = da903x_backlight_remove,
diff --git a/drivers/video/backlight/ep93xx_bl.c b/drivers/video/backlight/ep93xx_bl.c
index ef3e21e8f825..33455821dd31 100644
--- a/drivers/video/backlight/ep93xx_bl.c
+++ b/drivers/video/backlight/ep93xx_bl.c
@@ -60,7 +60,7 @@ static const struct backlight_ops ep93xxbl_ops = {
         .get_brightness = ep93xxbl_get_brightness,
 };
 
-static int __init ep93xxbl_probe(struct platform_device *dev)
+static int ep93xxbl_probe(struct platform_device *dev)
 {
         struct ep93xxbl *ep93xxbl;
         struct backlight_device *bl;
@@ -115,35 +115,33 @@ static int ep93xxbl_remove(struct platform_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int ep93xxbl_suspend(struct platform_device *dev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int ep93xxbl_suspend(struct device *dev)
 {
-        struct backlight_device *bl = platform_get_drvdata(dev);
+        struct backlight_device *bl = dev_get_drvdata(dev);
 
         return ep93xxbl_set(bl, 0);
 }
 
-static int ep93xxbl_resume(struct platform_device *dev)
+static int ep93xxbl_resume(struct device *dev)
 {
-        struct backlight_device *bl = platform_get_drvdata(dev);
+        struct backlight_device *bl = dev_get_drvdata(dev);
 
         backlight_update_status(bl);
         return 0;
 }
-#else
-#define ep93xxbl_suspend        NULL
-#define ep93xxbl_resume         NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ep93xxbl_pm_ops, ep93xxbl_suspend, ep93xxbl_resume);
+
 static struct platform_driver ep93xxbl_driver = {
         .driver         = {
                 .name   = "ep93xx-bl",
                 .owner  = THIS_MODULE,
+                .pm     = &ep93xxbl_pm_ops,
         },
         .probe          = ep93xxbl_probe,
         .remove         = ep93xxbl_remove,
-        .suspend        = ep93xxbl_suspend,
-        .resume         = ep93xxbl_resume,
 };
 
 module_platform_driver(ep93xxbl_driver);
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
index 0ae155be9c89..19e393b41438 100644
--- a/drivers/video/backlight/generic_bl.c
+++ b/drivers/video/backlight/generic_bl.c
@@ -9,8 +9,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -108,7 +106,7 @@ static int genericbl_probe(struct platform_device *pdev)
 
         generic_backlight_device = bd;
 
-        pr_info("Generic Backlight Driver Initialized.\n");
+        dev_info(&pdev->dev, "Generic Backlight Driver Initialized.\n");
         return 0;
 }
 
@@ -122,7 +120,7 @@ static int genericbl_remove(struct platform_device *pdev)
 
         backlight_device_unregister(bd);
 
-        pr_info("Generic Backlight Driver Unloaded\n");
+        dev_info(&pdev->dev, "Generic Backlight Driver Unloaded\n");
         return 0;
 }
 
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index 5cefd73526f8..00076ecfe9b8 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -64,29 +64,28 @@ static void hp680bl_send_intensity(struct backlight_device *bd)
 }
 
 
-#ifdef CONFIG_PM
-static int hp680bl_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int hp680bl_suspend(struct device *dev)
 {
-        struct backlight_device *bd = platform_get_drvdata(pdev);
+        struct backlight_device *bd = dev_get_drvdata(dev);
 
         hp680bl_suspended = 1;
         hp680bl_send_intensity(bd);
         return 0;
 }
 
-static int hp680bl_resume(struct platform_device *pdev)
+static int hp680bl_resume(struct device *dev)
 {
-        struct backlight_device *bd = platform_get_drvdata(pdev);
+        struct backlight_device *bd = dev_get_drvdata(dev);
 
         hp680bl_suspended = 0;
         hp680bl_send_intensity(bd);
         return 0;
 }
-#else
-#define hp680bl_suspend NULL
-#define hp680bl_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(hp680bl_pm_ops, hp680bl_suspend, hp680bl_resume);
+
 static int hp680bl_set_intensity(struct backlight_device *bd)
 {
         hp680bl_send_intensity(bd);
@@ -140,10 +139,9 @@ static int hp680bl_remove(struct platform_device *pdev)
 static struct platform_driver hp680bl_driver = {
         .probe          = hp680bl_probe,
         .remove         = hp680bl_remove,
-        .suspend        = hp680bl_suspend,
-        .resume         = hp680bl_resume,
         .driver         = {
                 .name   = "hp680-bl",
+                .pm     = &hp680bl_pm_ops,
         },
 };
 
diff --git a/drivers/video/backlight/ili922x.c b/drivers/video/backlight/ili922x.c
new file mode 100644
index 000000000000..d9f65c2d9b01
--- /dev/null
+++ b/drivers/video/backlight/ili922x.c
@@ -0,0 +1,555 @@
+/*
+ * (C) Copyright 2008
+ * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This driver implements a lcd device for the ILITEK 922x display
+ * controller. The interface to the display is SPI and the display's
+ * memory is cyclically updated over the RGB interface.
+ */
+
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/lcd.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
+#include <linux/string.h>
+
+/* Register offset, see manual section 8.2 */
+#define REG_START_OSCILLATION                   0x00
+#define REG_DRIVER_CODE_READ                    0x00
+#define REG_DRIVER_OUTPUT_CONTROL               0x01
+#define REG_LCD_AC_DRIVEING_CONTROL             0x02
+#define REG_ENTRY_MODE                          0x03
+#define REG_COMPARE_1                           0x04
+#define REG_COMPARE_2                           0x05
+#define REG_DISPLAY_CONTROL_1                   0x07
+#define REG_DISPLAY_CONTROL_2                   0x08
+#define REG_DISPLAY_CONTROL_3                   0x09
+#define REG_FRAME_CYCLE_CONTROL                 0x0B
+#define REG_EXT_INTF_CONTROL                    0x0C
+#define REG_POWER_CONTROL_1                     0x10
+#define REG_POWER_CONTROL_2                     0x11
+#define REG_POWER_CONTROL_3                     0x12
+#define REG_POWER_CONTROL_4                     0x13
+#define REG_RAM_ADDRESS_SET                     0x21
+#define REG_WRITE_DATA_TO_GRAM                  0x22
+#define REG_RAM_WRITE_MASK1                     0x23
+#define REG_RAM_WRITE_MASK2                     0x24
+#define REG_GAMMA_CONTROL_1                     0x30
+#define REG_GAMMA_CONTROL_2                     0x31
+#define REG_GAMMA_CONTROL_3                     0x32
+#define REG_GAMMA_CONTROL_4                     0x33
+#define REG_GAMMA_CONTROL_5                     0x34
+#define REG_GAMMA_CONTROL_6                     0x35
+#define REG_GAMMA_CONTROL_7                     0x36
+#define REG_GAMMA_CONTROL_8                     0x37
+#define REG_GAMMA_CONTROL_9                     0x38
+#define REG_GAMMA_CONTROL_10                    0x39
+#define REG_GATE_SCAN_CONTROL                   0x40
+#define REG_VERT_SCROLL_CONTROL                 0x41
+#define REG_FIRST_SCREEN_DRIVE_POS              0x42
+#define REG_SECOND_SCREEN_DRIVE_POS             0x43
+#define REG_RAM_ADDR_POS_H                      0x44
+#define REG_RAM_ADDR_POS_V                      0x45
+#define REG_OSCILLATOR_CONTROL                  0x4F
+#define REG_GPIO                                0x60
+#define REG_OTP_VCM_PROGRAMMING                 0x61
+#define REG_OTP_VCM_STATUS_ENABLE               0x62
+#define REG_OTP_PROGRAMMING_ID_KEY              0x65
+
+/*
+ * maximum frequency for register access
+ * (not for the GRAM access)
+ */
+#define ILITEK_MAX_FREQ_REG     4000000
+
+/*
+ * Device ID as found in the datasheet (supports 9221 and 9222)
+ */
+#define ILITEK_DEVICE_ID        0x9220
+#define ILITEK_DEVICE_ID_MASK   0xFFF0
+
+/* Last two bits in the START BYTE */
+#define START_RS_INDEX          0
+#define START_RS_REG            1
+#define START_RW_WRITE          0
+#define START_RW_READ           1
+
+/**
+ * START_BYTE(id, rs, rw)
+ *
+ * Set the start byte according to the required operation.
+ * The start byte is defined as:
+ *   ----------------------------------
+ *  | 0 | 1 | 1 | 1 | 0 | ID | RS | RW |
+ *   ----------------------------------
+ * @id: display's id as set by the manufacturer
+ * @rs: operation type bit, one of:
+ *        - START_RS_INDEX      set the index register
+ *        - START_RS_REG        write/read registers/GRAM
+ * @rw: read/write operation
+ *       - START_RW_WRITE       write
+ *       - START_RW_READ        read
+ */
+#define START_BYTE(id, rs, rw)  \
+        (0x70 | (((id) & 0x01) << 2) | (((rs) & 0x01) << 1) | ((rw) & 0x01))
+
+/**
+ * CHECK_FREQ_REG(spi_device s, spi_transfer x) - Check the frequency
+ *      for the SPI transfer. According to the datasheet, the controller
+ *      accept higher frequency for the GRAM transfer, but it requires
+ *      lower frequency when the registers are read/written.
+ *      The macro sets the frequency in the spi_transfer structure if
+ *      the frequency exceeds the maximum value.
+ */
+#define CHECK_FREQ_REG(s, x)    \
+        do {                    \
+                if (s->max_speed_hz > ILITEK_MAX_FREQ_REG)      \
+                        ((struct spi_transfer *)x)->speed_hz =  \
+                                        ILITEK_MAX_FREQ_REG;    \
+        } while (0)
+
+#define CMD_BUFSIZE             16
+
+#define POWER_IS_ON(pwr)        ((pwr) <= FB_BLANK_NORMAL)
+
+#define set_tx_byte(b)          (tx_invert ? ~(b) : b)
+
+/**
+ * ili922x_id - id as set by manufacturer
+ */
+static int ili922x_id = 1;
+module_param(ili922x_id, int, 0);
+
+static int tx_invert;
+module_param(tx_invert, int, 0);
+
+/**
+ * driver's private structure
+ */
+struct ili922x {
+        struct spi_device *spi;
+        struct lcd_device *ld;
+        int power;
+};
+
+/**
+ * ili922x_read_status - read status register from display
+ * @spi: spi device
+ * @rs:  output value
+ */
+static int ili922x_read_status(struct spi_device *spi, u16 *rs)
+{
+        struct spi_message msg;
+        struct spi_transfer xfer;
+        unsigned char tbuf[CMD_BUFSIZE];
+        unsigned char rbuf[CMD_BUFSIZE];
+        int ret, i;
+
+        memset(&xfer, 0, sizeof(struct spi_transfer));
+        spi_message_init(&msg);
+        xfer.tx_buf = tbuf;
+        xfer.rx_buf = rbuf;
+        xfer.cs_change = 1;
+        CHECK_FREQ_REG(spi, &xfer);
+
+        tbuf[0] = set_tx_byte(START_BYTE(ili922x_id, START_RS_INDEX,
+                                         START_RW_READ));
+        /*
+         * we need 4-byte xfer here due to invalid dummy byte
+         * received after start byte
+         */
+        for (i = 1; i < 4; i++)
+                tbuf[i] = set_tx_byte(0);       /* dummy */
+
+        xfer.bits_per_word = 8;
+        xfer.len = 4;
+        spi_message_add_tail(&xfer, &msg);
+        ret = spi_sync(spi, &msg);
+        if (ret < 0) {
+                dev_dbg(&spi->dev, "Error sending SPI message 0x%x", ret);
+                return ret;
+        }
+
+        *rs = (rbuf[2] << 8) + rbuf[3];
+        return 0;
+}
+
+/**
+ * ili922x_read - read register from display
+ * @spi: spi device
+ * @reg: offset of the register to be read
+ * @rx:  output value
+ */
+static int ili922x_read(struct spi_device *spi, u8 reg, u16 *rx)
+{
+        struct spi_message msg;
+        struct spi_transfer xfer_regindex, xfer_regvalue;
+        unsigned char tbuf[CMD_BUFSIZE];
+        unsigned char rbuf[CMD_BUFSIZE];
+        int ret, len = 0, send_bytes;
+
+        memset(&xfer_regindex, 0, sizeof(struct spi_transfer));
+        memset(&xfer_regvalue, 0, sizeof(struct spi_transfer));
+        spi_message_init(&msg);
+        xfer_regindex.tx_buf = tbuf;
+        xfer_regindex.rx_buf = rbuf;
+        xfer_regindex.cs_change = 1;
+        CHECK_FREQ_REG(spi, &xfer_regindex);
+
+        tbuf[0] = set_tx_byte(START_BYTE(ili922x_id, START_RS_INDEX,
+                                         START_RW_WRITE));
+        tbuf[1] = set_tx_byte(0);
+        tbuf[2] = set_tx_byte(reg);
+        xfer_regindex.bits_per_word = 8;
+        len = xfer_regindex.len = 3;
+        spi_message_add_tail(&xfer_regindex, &msg);
+
+        send_bytes = len;
+
+        tbuf[len++] = set_tx_byte(START_BYTE(ili922x_id, START_RS_REG,
+                                             START_RW_READ));
+        tbuf[len++] = set_tx_byte(0);
+        tbuf[len] = set_tx_byte(0);
+
+        xfer_regvalue.cs_change = 1;
+        xfer_regvalue.len = 3;
+        xfer_regvalue.tx_buf = &tbuf[send_bytes];
+        xfer_regvalue.rx_buf = &rbuf[send_bytes];
+        CHECK_FREQ_REG(spi, &xfer_regvalue);
+
+        spi_message_add_tail(&xfer_regvalue, &msg);
+        ret = spi_sync(spi, &msg);
+        if (ret < 0) {
+                dev_dbg(&spi->dev, "Error sending SPI message 0x%x", ret);
+                return ret;
+        }
+
+        *rx = (rbuf[1 + send_bytes] << 8) + rbuf[2 + send_bytes];
+        return 0;
+}
+
+/**
+ * ili922x_write - write a controller register
+ * @spi: struct spi_device *
+ * @reg: offset of the register to be written
+ * @value: value to be written
+ */
+static int ili922x_write(struct spi_device *spi, u8 reg, u16 value)
+{
+        struct spi_message msg;
+        struct spi_transfer xfer_regindex, xfer_regvalue;
+        unsigned char tbuf[CMD_BUFSIZE];
+        unsigned char rbuf[CMD_BUFSIZE];
+        int ret, len = 0;
+
+        memset(&xfer_regindex, 0, sizeof(struct spi_transfer));
+        memset(&xfer_regvalue, 0, sizeof(struct spi_transfer));
+
+        spi_message_init(&msg);
+        xfer_regindex.tx_buf = tbuf;
+        xfer_regindex.rx_buf = rbuf;
+        xfer_regindex.cs_change = 1;
+        CHECK_FREQ_REG(spi, &xfer_regindex);
+
+        tbuf[0] = set_tx_byte(START_BYTE(ili922x_id, START_RS_INDEX,
+                                         START_RW_WRITE));
+        tbuf[1] = set_tx_byte(0);
+        tbuf[2] = set_tx_byte(reg);
+        xfer_regindex.bits_per_word = 8;
+        xfer_regindex.len = 3;
+        spi_message_add_tail(&xfer_regindex, &msg);
+
+        ret = spi_sync(spi, &msg);
+
+        spi_message_init(&msg);
+        len = 0;
+        tbuf[0] = set_tx_byte(START_BYTE(ili922x_id, START_RS_REG,
+                                         START_RW_WRITE));
+        tbuf[1] = set_tx_byte((value & 0xFF00) >> 8);
+        tbuf[2] = set_tx_byte(value & 0x00FF);
+
+        xfer_regvalue.cs_change = 1;
+        xfer_regvalue.len = 3;
+        xfer_regvalue.tx_buf = tbuf;
+        xfer_regvalue.rx_buf = rbuf;
+        CHECK_FREQ_REG(spi, &xfer_regvalue);
+
+        spi_message_add_tail(&xfer_regvalue, &msg);
+
+        ret = spi_sync(spi, &msg);
+        if (ret < 0) {
+                dev_err(&spi->dev, "Error sending SPI message 0x%x", ret);
+                return ret;
+        }
+        return 0;
+}
+
+#ifdef DEBUG
+/**
+ * ili922x_reg_dump - dump all registers
+ */
+static void ili922x_reg_dump(struct spi_device *spi)
+{
+        u8 reg;
+        u16 rx;
+
+        dev_dbg(&spi->dev, "ILI922x configuration registers:\n");
+        for (reg = REG_START_OSCILLATION;
+             reg <= REG_OTP_PROGRAMMING_ID_KEY; reg++) {
+                ili922x_read(spi, reg, &rx);
+                dev_dbg(&spi->dev, "reg @ 0x%02X: 0x%04X\n", reg, rx);
+        }
+}
+#else
+static inline void ili922x_reg_dump(struct spi_device *spi) {}
+#endif
+
+/**
+ * set_write_to_gram_reg - initialize the display to write the GRAM
+ * @spi: spi device
+ */
+static void set_write_to_gram_reg(struct spi_device *spi)
+{
+        struct spi_message msg;
+        struct spi_transfer xfer;
+        unsigned char tbuf[CMD_BUFSIZE];
+
+        memset(&xfer, 0, sizeof(struct spi_transfer));
+
+        spi_message_init(&msg);
+        xfer.tx_buf = tbuf;
+        xfer.rx_buf = NULL;
+        xfer.cs_change = 1;
+
+        tbuf[0] = START_BYTE(ili922x_id, START_RS_INDEX, START_RW_WRITE);
+        tbuf[1] = 0;
+        tbuf[2] = REG_WRITE_DATA_TO_GRAM;
+
+        xfer.bits_per_word = 8;
+        xfer.len = 3;
+        spi_message_add_tail(&xfer, &msg);
+        spi_sync(spi, &msg);
+}
+
+/**
+ * ili922x_poweron - turn the display on
+ * @spi: spi device
+ *
+ * The sequence to turn on the display is taken from
+ * the datasheet and/or the example code provided by the
+ * manufacturer.
+ */
+static int ili922x_poweron(struct spi_device *spi)
+{
+        int ret;
+
+        /* Power on */
+        ret = ili922x_write(spi, REG_POWER_CONTROL_1, 0x0000);
+        usleep_range(10000, 10500);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_2, 0x0000);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_3, 0x0000);
+        msleep(40);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_4, 0x0000);
+        msleep(40);
+        /* register 0x56 is not documented in the datasheet */
+        ret += ili922x_write(spi, 0x56, 0x080F);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_1, 0x4240);
+        usleep_range(10000, 10500);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_2, 0x0000);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_3, 0x0014);
+        msleep(40);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_4, 0x1319);
+        msleep(40);
+
+        return ret;
+}
+
+/**
+ * ili922x_poweroff - turn the display off
+ * @spi: spi device
+ */
+static int ili922x_poweroff(struct spi_device *spi)
+{
+        int ret;
+
+        /* Power off */
+        ret = ili922x_write(spi, REG_POWER_CONTROL_1, 0x0000);
+        usleep_range(10000, 10500);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_2, 0x0000);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_3, 0x0000);
+        msleep(40);
+        ret += ili922x_write(spi, REG_POWER_CONTROL_4, 0x0000);
+        msleep(40);
+
+        return ret;
+}
+
+/**
+ * ili922x_display_init - initialize the display by setting
+ *                        the configuration registers
+ * @spi: spi device
+ */
+static void ili922x_display_init(struct spi_device *spi)
+{
+        ili922x_write(spi, REG_START_OSCILLATION, 1);
+        usleep_range(10000, 10500);
+        ili922x_write(spi, REG_DRIVER_OUTPUT_CONTROL, 0x691B);
+        ili922x_write(spi, REG_LCD_AC_DRIVEING_CONTROL, 0x0700);
+        ili922x_write(spi, REG_ENTRY_MODE, 0x1030);
+        ili922x_write(spi, REG_COMPARE_1, 0x0000);
+        ili922x_write(spi, REG_COMPARE_2, 0x0000);
+        ili922x_write(spi, REG_DISPLAY_CONTROL_1, 0x0037);
+        ili922x_write(spi, REG_DISPLAY_CONTROL_2, 0x0202);
+        ili922x_write(spi, REG_DISPLAY_CONTROL_3, 0x0000);
+        ili922x_write(spi, REG_FRAME_CYCLE_CONTROL, 0x0000);
+
+        /* Set RGB interface */
+        ili922x_write(spi, REG_EXT_INTF_CONTROL, 0x0110);
+
+        ili922x_poweron(spi);
+
+        ili922x_write(spi, REG_GAMMA_CONTROL_1, 0x0302);
+        ili922x_write(spi, REG_GAMMA_CONTROL_2, 0x0407);
+        ili922x_write(spi, REG_GAMMA_CONTROL_3, 0x0304);
+        ili922x_write(spi, REG_GAMMA_CONTROL_4, 0x0203);
+        ili922x_write(spi, REG_GAMMA_CONTROL_5, 0x0706);
+        ili922x_write(spi, REG_GAMMA_CONTROL_6, 0x0407);
+        ili922x_write(spi, REG_GAMMA_CONTROL_7, 0x0706);
+        ili922x_write(spi, REG_GAMMA_CONTROL_8, 0x0000);
+        ili922x_write(spi, REG_GAMMA_CONTROL_9, 0x0C06);
+        ili922x_write(spi, REG_GAMMA_CONTROL_10, 0x0F00);
+        ili922x_write(spi, REG_RAM_ADDRESS_SET, 0x0000);
+        ili922x_write(spi, REG_GATE_SCAN_CONTROL, 0x0000);
+        ili922x_write(spi, REG_VERT_SCROLL_CONTROL, 0x0000);
+        ili922x_write(spi, REG_FIRST_SCREEN_DRIVE_POS, 0xDB00);
+        ili922x_write(spi, REG_SECOND_SCREEN_DRIVE_POS, 0xDB00);
+        ili922x_write(spi, REG_RAM_ADDR_POS_H, 0xAF00);
+        ili922x_write(spi, REG_RAM_ADDR_POS_V, 0xDB00);
+        ili922x_reg_dump(spi);
+        set_write_to_gram_reg(spi);
+}
+
+static int ili922x_lcd_power(struct ili922x *lcd, int power)
+{
+        int ret = 0;
+
+        if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
+                ret = ili922x_poweron(lcd->spi);
+        else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
+                ret = ili922x_poweroff(lcd->spi);
+
+        if (!ret)
+                lcd->power = power;
+
+        return ret;
+}
+
+static int ili922x_set_power(struct lcd_device *ld, int power)
+{
+        struct ili922x *ili = lcd_get_data(ld);
+
+        return ili922x_lcd_power(ili, power);
+}
+
+static int ili922x_get_power(struct lcd_device *ld)
+{
+        struct ili922x *ili = lcd_get_data(ld);
+
+        return ili->power;
+}
+
+static struct lcd_ops ili922x_ops = {
+        .get_power = ili922x_get_power,
+        .set_power = ili922x_set_power,
+};
+
+static int ili922x_probe(struct spi_device *spi)
+{
+        struct ili922x *ili;
+        struct lcd_device *lcd;
+        int ret;
+        u16 reg = 0;
+
+        ili = devm_kzalloc(&spi->dev, sizeof(*ili), GFP_KERNEL);
+        if (!ili) {
+                dev_err(&spi->dev, "cannot alloc priv data\n");
+                return -ENOMEM;
+        }
+
+        ili->spi = spi;
+        spi_set_drvdata(spi, ili);
+
+        /* check if the device is connected */
+        ret = ili922x_read(spi, REG_DRIVER_CODE_READ, &reg);
+        if (ret || ((reg & ILITEK_DEVICE_ID_MASK) != ILITEK_DEVICE_ID)) {
+                dev_err(&spi->dev,
+                        "no LCD found: Chip ID 0x%x, ret %d\n",
+                        reg, ret);
+                return -ENODEV;
+        } else {
+                dev_info(&spi->dev, "ILI%x found, SPI freq %d, mode %d\n",
+                         reg, spi->max_speed_hz, spi->mode);
+        }
+
+        ret = ili922x_read_status(spi, &reg);
+        if (ret) {
+                dev_err(&spi->dev, "reading RS failed...\n");
+                return ret;
+        } else
+                dev_dbg(&spi->dev, "status: 0x%x\n", reg);
+
+        ili922x_display_init(spi);
+
+        ili->power = FB_BLANK_POWERDOWN;
+
+        lcd = lcd_device_register("ili922xlcd", &spi->dev, ili,
+                                  &ili922x_ops);
+        if (IS_ERR(lcd)) {
+                dev_err(&spi->dev, "cannot register LCD\n");
+                return PTR_ERR(lcd);
+        }
+
+        ili->ld = lcd;
+        spi_set_drvdata(spi, ili);
+
+        ili922x_lcd_power(ili, FB_BLANK_UNBLANK);
+
+        return 0;
+}
+
+static int ili922x_remove(struct spi_device *spi)
+{
+        struct ili922x *ili = spi_get_drvdata(spi);
+
+        ili922x_poweroff(spi);
+        lcd_device_unregister(ili->ld);
+        return 0;
+}
+
+static struct spi_driver ili922x_driver = {
+        .driver = {
+                .name = "ili922x",
+                .owner = THIS_MODULE,
+        },
+        .probe = ili922x_probe,
+        .remove = ili922x_remove,
+};
+
+module_spi_driver(ili922x_driver);
+
+MODULE_AUTHOR("Stefano Babic <sbabic@denx.de>");
+MODULE_DESCRIPTION("ILI9221/9222 LCD driver");
+MODULE_LICENSE("GPL");
+MODULE_PARM_DESC(ili922x_id, "set controller identifier (default=1)");
+MODULE_PARM_DESC(tx_invert, "invert bytes before sending");
diff --git a/drivers/video/backlight/ili9320.c b/drivers/video/backlight/ili9320.c
index 1235bf9defc4..f8be90c5dedc 100644
--- a/drivers/video/backlight/ili9320.c
+++ b/drivers/video/backlight/ili9320.c
@@ -231,7 +231,7 @@ int ili9320_probe_spi(struct spi_device *spi,
         ili->power = FB_BLANK_POWERDOWN;
         ili->platdata = cfg;
 
-        dev_set_drvdata(&spi->dev, ili);
+        spi_set_drvdata(spi, ili);
 
         ili9320_setup_spi(ili, spi);
 
@@ -270,27 +270,21 @@ int ili9320_remove(struct ili9320 *ili)
 }
 EXPORT_SYMBOL_GPL(ili9320_remove);
 
-#ifdef CONFIG_PM
-int ili9320_suspend(struct ili9320 *lcd, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+int ili9320_suspend(struct ili9320 *lcd)
 {
         int ret;
 
-        dev_dbg(lcd->dev, "%s: event %d\n", __func__, state.event);
+        ret = ili9320_power(lcd, FB_BLANK_POWERDOWN);
 
-        if (state.event == PM_EVENT_SUSPEND) {
-                ret = ili9320_power(lcd, FB_BLANK_POWERDOWN);
-
-                if (lcd->platdata->suspend == ILI9320_SUSPEND_DEEP) {
-                        ili9320_write(lcd, ILI9320_POWER1, lcd->power1 |
-                                      ILI9320_POWER1_SLP |
-                                      ILI9320_POWER1_DSTB);
-                        lcd->initialised = 0;
-                }
-
-                return ret;
+        if (lcd->platdata->suspend == ILI9320_SUSPEND_DEEP) {
+                ili9320_write(lcd, ILI9320_POWER1, lcd->power1 |
+                              ILI9320_POWER1_SLP |
+                              ILI9320_POWER1_DSTB);
+                lcd->initialised = 0;
         }
 
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL_GPL(ili9320_suspend);
 
diff --git a/drivers/video/backlight/ili9320.h b/drivers/video/backlight/ili9320.h
index e0db738f7bb9..42329e7aa9a8 100644
--- a/drivers/video/backlight/ili9320.h
+++ b/drivers/video/backlight/ili9320.h
@@ -76,5 +76,5 @@ extern void ili9320_shutdown(struct ili9320 *lcd);
 
 /* PM */
 
-extern int ili9320_suspend(struct ili9320 *lcd, pm_message_t state);
+extern int ili9320_suspend(struct ili9320 *lcd);
 extern int ili9320_resume(struct ili9320 *lcd);
diff --git a/drivers/video/backlight/jornada720_bl.c b/drivers/video/backlight/jornada720_bl.c
index fef6ce4fad71..3ccb89340f22 100644
--- a/drivers/video/backlight/jornada720_bl.c
+++ b/drivers/video/backlight/jornada720_bl.c
@@ -9,8 +9,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/backlight.h>
 #include <linux/device.h>
 #include <linux/fb.h>
@@ -40,11 +38,13 @@ static int jornada_bl_get_brightness(struct backlight_device *bd)
         ret = jornada_ssp_byte(GETBRIGHTNESS);
 
         if (jornada_ssp_byte(GETBRIGHTNESS) != TXDUMMY) {
-                pr_err("get brightness timeout\n");
+                dev_err(&bd->dev, "get brightness timeout\n");
                 jornada_ssp_end();
                 return -ETIMEDOUT;
-        } else /* exchange txdummy for value */
+        } else {
+                /* exchange txdummy for value */
                 ret = jornada_ssp_byte(TXDUMMY);
+        }
 
         jornada_ssp_end();
 
@@ -61,7 +61,7 @@ static int jornada_bl_update_status(struct backlight_device *bd)
         if ((bd->props.power != FB_BLANK_UNBLANK) || (bd->props.fb_blank != FB_BLANK_UNBLANK)) {
                 ret = jornada_ssp_byte(BRIGHTNESSOFF);
                 if (ret != TXDUMMY) {
-                        pr_info("brightness off timeout\n");
+                        dev_info(&bd->dev, "brightness off timeout\n");
                         /* turn off backlight */
                         PPSR &= ~PPC_LDD1;
                         PPDR |= PPC_LDD1;
@@ -72,7 +72,7 @@ static int jornada_bl_update_status(struct backlight_device *bd)
 
                 /* send command to our mcu */
                 if (jornada_ssp_byte(SETBRIGHTNESS) != TXDUMMY) {
-                        pr_info("failed to set brightness\n");
+                        dev_info(&bd->dev, "failed to set brightness\n");
                         ret = -ETIMEDOUT;
                         goto out;
                 }
@@ -86,7 +86,7 @@ static int jornada_bl_update_status(struct backlight_device *bd)
                  */
                 if (jornada_ssp_byte(BL_MAX_BRIGHT - bd->props.brightness)
                         != TXDUMMY) {
-                        pr_err("set brightness failed\n");
+                        dev_err(&bd->dev, "set brightness failed\n");
                         ret = -ETIMEDOUT;
                 }
 
@@ -120,7 +120,7 @@ static int jornada_bl_probe(struct platform_device *pdev)
 
         if (IS_ERR(bd)) {
                 ret = PTR_ERR(bd);
-                pr_err("failed to register device, err=%x\n", ret);
+                dev_err(&pdev->dev, "failed to register device, err=%x\n", ret);
                 return ret;
         }
 
@@ -134,7 +134,7 @@ static int jornada_bl_probe(struct platform_device *pdev)
         jornada_bl_update_status(bd);
 
         platform_set_drvdata(pdev, bd);
-        pr_info("HP Jornada 700 series backlight driver\n");
+        dev_info(&pdev->dev, "HP Jornada 700 series backlight driver\n");
 
         return 0;
 }
diff --git a/drivers/video/backlight/jornada720_lcd.c b/drivers/video/backlight/jornada720_lcd.c
index 635b30523fd5..b061413f1a65 100644
--- a/drivers/video/backlight/jornada720_lcd.c
+++ b/drivers/video/backlight/jornada720_lcd.c
@@ -9,8 +9,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/device.h>
 #include <linux/fb.h>
 #include <linux/kernel.h>
@@ -27,7 +25,7 @@
 #define LCD_MAX_CONTRAST        0xff
 #define LCD_DEF_CONTRAST        0x80
 
-static int jornada_lcd_get_power(struct lcd_device *dev)
+static int jornada_lcd_get_power(struct lcd_device *ld)
 {
         /* LDD2 in PPC = LCD POWER */
         if (PPSR & PPC_LDD2)
@@ -36,17 +34,17 @@ static int jornada_lcd_get_power(struct lcd_device *dev)
                 return FB_BLANK_POWERDOWN;      /* PW OFF */
 }
 
-static int jornada_lcd_get_contrast(struct lcd_device *dev)
+static int jornada_lcd_get_contrast(struct lcd_device *ld)
 {
         int ret;
 
-        if (jornada_lcd_get_power(dev) != FB_BLANK_UNBLANK)
+        if (jornada_lcd_get_power(ld) != FB_BLANK_UNBLANK)
                 return 0;
 
         jornada_ssp_start();
 
         if (jornada_ssp_byte(GETCONTRAST) != TXDUMMY) {
-                pr_err("get contrast failed\n");
+                dev_err(&ld->dev, "get contrast failed\n");
                 jornada_ssp_end();
                 return -ETIMEDOUT;
         } else {
@@ -56,7 +54,7 @@ static int jornada_lcd_get_contrast(struct lcd_device *dev)
         }
 }
 
-static int jornada_lcd_set_contrast(struct lcd_device *dev, int value)
+static int jornada_lcd_set_contrast(struct lcd_device *ld, int value)
 {
         int ret;
 
@@ -67,7 +65,7 @@ static int jornada_lcd_set_contrast(struct lcd_device *dev, int value)
 
         /* push the new value */
         if (jornada_ssp_byte(value) != TXDUMMY) {
-                pr_err("set contrast failed\n");
+                dev_err(&ld->dev, "set contrast failed\n");
                 jornada_ssp_end();
                 return -ETIMEDOUT;
         }
@@ -78,13 +76,14 @@ static int jornada_lcd_set_contrast(struct lcd_device *dev, int value)
         return 0;
 }
 
-static int jornada_lcd_set_power(struct lcd_device *dev, int power)
+static int jornada_lcd_set_power(struct lcd_device *ld, int power)
 {
         if (power != FB_BLANK_UNBLANK) {
                 PPSR &= ~PPC_LDD2;
                 PPDR |= PPC_LDD2;
-        } else
+        } else {
                 PPSR |= PPC_LDD2;
+        }
 
         return 0;
 }
@@ -105,7 +104,7 @@ static int jornada_lcd_probe(struct platform_device *pdev)
 
         if (IS_ERR(lcd_device)) {
                 ret = PTR_ERR(lcd_device);
-                pr_err("failed to register device\n");
+                dev_err(&pdev->dev, "failed to register device\n");
                 return ret;
         }
 
diff --git a/drivers/video/backlight/kb3886_bl.c b/drivers/video/backlight/kb3886_bl.c
index 6c5ed6b242cc..bca6ccc74dfb 100644
--- a/drivers/video/backlight/kb3886_bl.c
+++ b/drivers/video/backlight/kb3886_bl.c
@@ -106,29 +106,28 @@ static int kb3886bl_send_intensity(struct backlight_device *bd)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int kb3886bl_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int kb3886bl_suspend(struct device *dev)
 {
-        struct backlight_device *bd = platform_get_drvdata(pdev);
+        struct backlight_device *bd = dev_get_drvdata(dev);
 
         kb3886bl_flags |= KB3886BL_SUSPENDED;
         backlight_update_status(bd);
         return 0;
 }
 
-static int kb3886bl_resume(struct platform_device *pdev)
+static int kb3886bl_resume(struct device *dev)
 {
-        struct backlight_device *bd = platform_get_drvdata(pdev);
+        struct backlight_device *bd = dev_get_drvdata(dev);
 
         kb3886bl_flags &= ~KB3886BL_SUSPENDED;
         backlight_update_status(bd);
         return 0;
 }
-#else
-#define kb3886bl_suspend        NULL
-#define kb3886bl_resume         NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(kb3886bl_pm_ops, kb3886bl_suspend, kb3886bl_resume);
+
 static int kb3886bl_get_intensity(struct backlight_device *bd)
 {
         return kb3886bl_intensity;
@@ -179,10 +178,9 @@ static int kb3886bl_remove(struct platform_device *pdev)
 static struct platform_driver kb3886bl_driver = {
         .probe          = kb3886bl_probe,
         .remove         = kb3886bl_remove,
-        .suspend        = kb3886bl_suspend,
-        .resume         = kb3886bl_resume,
         .driver         = {
                 .name   = "kb3886-bl",
+                .pm     = &kb3886bl_pm_ops,
         },
 };
 
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index fb6155771326..a35a38c709cf 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -51,14 +51,33 @@ static void l4f00242t03_lcd_init(struct spi_device *spi)
         struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
         struct l4f00242t03_priv *priv = spi_get_drvdata(spi);
         const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };
+        int ret;
 
         dev_dbg(&spi->dev, "initializing LCD\n");
 
-        regulator_set_voltage(priv->io_reg, 1800000, 1800000);
-        regulator_enable(priv->io_reg);
+        ret = regulator_set_voltage(priv->io_reg, 1800000, 1800000);
+        if (ret) {
+                dev_err(&spi->dev, "failed to set the IO regulator voltage.\n");
+                return;
+        }
+        ret = regulator_enable(priv->io_reg);
+        if (ret) {
+                dev_err(&spi->dev, "failed to enable the IO regulator.\n");
+                return;
+        }
 
-        regulator_set_voltage(priv->core_reg, 2800000, 2800000);
-        regulator_enable(priv->core_reg);
+        ret = regulator_set_voltage(priv->core_reg, 2800000, 2800000);
+        if (ret) {
+                dev_err(&spi->dev, "failed to set the core regulator voltage.\n");
+                regulator_disable(priv->io_reg);
+                return;
+        }
+        ret = regulator_enable(priv->core_reg);
+        if (ret) {
+                dev_err(&spi->dev, "failed to enable the core regulator.\n");
+                regulator_disable(priv->io_reg);
+                return;
+        }
 
         l4f00242t03_reset(pdata->reset_gpio);
 
diff --git a/drivers/video/backlight/ld9040.c b/drivers/video/backlight/ld9040.c
index 1b642f5f381a..1e0a3093ce50 100644
--- a/drivers/video/backlight/ld9040.c
+++ b/drivers/video/backlight/ld9040.c
@@ -775,12 +775,12 @@ static int ld9040_remove(struct spi_device *spi)
         return 0;
 }
 
-#if defined(CONFIG_PM)
-static int ld9040_suspend(struct spi_device *spi, pm_message_t mesg)
+#ifdef CONFIG_PM_SLEEP
+static int ld9040_suspend(struct device *dev)
 {
-        struct ld9040 *lcd = spi_get_drvdata(spi);
+        struct ld9040 *lcd = dev_get_drvdata(dev);
 
-        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+        dev_dbg(dev, "lcd->power = %d\n", lcd->power);
 
         /*
          * when lcd panel is suspend, lcd panel becomes off
@@ -789,19 +789,18 @@ static int ld9040_suspend(struct spi_device *spi, pm_message_t mesg)
         return ld9040_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int ld9040_resume(struct spi_device *spi)
+static int ld9040_resume(struct device *dev)
 {
-        struct ld9040 *lcd = spi_get_drvdata(spi);
+        struct ld9040 *lcd = dev_get_drvdata(dev);
 
         lcd->power = FB_BLANK_POWERDOWN;
 
         return ld9040_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define ld9040_suspend          NULL
-#define ld9040_resume           NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ld9040_pm_ops, ld9040_suspend, ld9040_resume);
+
 /* Power down all displays on reboot, poweroff or halt. */
 static void ld9040_shutdown(struct spi_device *spi)
 {
@@ -814,12 +813,11 @@ static struct spi_driver ld9040_driver = {
         .driver = {
                 .name   = "ld9040",
                 .owner  = THIS_MODULE,
+                .pm     = &ld9040_pm_ops,
         },
         .probe          = ld9040_probe,
         .remove         = ld9040_remove,
         .shutdown       = ld9040_shutdown,
-        .suspend        = ld9040_suspend,
-        .resume         = ld9040_resume,
 };
 
 module_spi_driver(ld9040_driver);
diff --git a/drivers/video/backlight/lm3533_bl.c b/drivers/video/backlight/lm3533_bl.c
index 5d18d4d7f470..1d1dbfb789e3 100644
--- a/drivers/video/backlight/lm3533_bl.c
+++ b/drivers/video/backlight/lm3533_bl.c
@@ -368,29 +368,28 @@ static int lm3533_bl_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int lm3533_bl_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int lm3533_bl_suspend(struct device *dev)
 {
-        struct lm3533_bl *bl = platform_get_drvdata(pdev);
+        struct lm3533_bl *bl = dev_get_drvdata(dev);
 
-        dev_dbg(&pdev->dev, "%s\n", __func__);
+        dev_dbg(dev, "%s\n", __func__);
 
         return lm3533_ctrlbank_disable(&bl->cb);
 }
 
-static int lm3533_bl_resume(struct platform_device *pdev)
+static int lm3533_bl_resume(struct device *dev)
 {
-        struct lm3533_bl *bl = platform_get_drvdata(pdev);
+        struct lm3533_bl *bl = dev_get_drvdata(dev);
 
-        dev_dbg(&pdev->dev, "%s\n", __func__);
+        dev_dbg(dev, "%s\n", __func__);
 
         return lm3533_ctrlbank_enable(&bl->cb);
 }
-#else
-#define lm3533_bl_suspend       NULL
-#define lm3533_bl_resume        NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(lm3533_bl_pm_ops, lm3533_bl_suspend, lm3533_bl_resume);
+
 static void lm3533_bl_shutdown(struct platform_device *pdev)
 {
         struct lm3533_bl *bl = platform_get_drvdata(pdev);
@@ -404,12 +403,11 @@ static struct platform_driver lm3533_bl_driver = {
         .driver = {
                 .name   = "lm3533-backlight",
                 .owner  = THIS_MODULE,
+                .pm     = &lm3533_bl_pm_ops,
         },
         .probe          = lm3533_bl_probe,
         .remove         = lm3533_bl_remove,
         .shutdown       = lm3533_bl_shutdown,
-        .suspend        = lm3533_bl_suspend,
-        .resume         = lm3533_bl_resume,
 };
 module_platform_driver(lm3533_bl_driver);
 
diff --git a/drivers/video/backlight/lms501kf03.c b/drivers/video/backlight/lms501kf03.c
index b43882abefaf..cf01b9ac8131 100644
--- a/drivers/video/backlight/lms501kf03.c
+++ b/drivers/video/backlight/lms501kf03.c
@@ -387,13 +387,12 @@ static int lms501kf03_remove(struct spi_device *spi)
         return 0;
 }
 
-#if defined(CONFIG_PM)
-
-static int lms501kf03_suspend(struct spi_device *spi, pm_message_t mesg)
+#ifdef CONFIG_PM_SLEEP
+static int lms501kf03_suspend(struct device *dev)
 {
-        struct lms501kf03 *lcd = spi_get_drvdata(spi);
+        struct lms501kf03 *lcd = dev_get_drvdata(dev);
 
-        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+        dev_dbg(dev, "lcd->power = %d\n", lcd->power);
 
         /*
          * when lcd panel is suspend, lcd panel becomes off
@@ -402,19 +401,19 @@ static int lms501kf03_suspend(struct spi_device *spi, pm_message_t mesg)
         return lms501kf03_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int lms501kf03_resume(struct spi_device *spi)
+static int lms501kf03_resume(struct device *dev)
 {
-        struct lms501kf03 *lcd = spi_get_drvdata(spi);
+        struct lms501kf03 *lcd = dev_get_drvdata(dev);
 
         lcd->power = FB_BLANK_POWERDOWN;
 
         return lms501kf03_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define lms501kf03_suspend      NULL
-#define lms501kf03_resume       NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(lms501kf03_pm_ops, lms501kf03_suspend,
+                        lms501kf03_resume);
+
 static void lms501kf03_shutdown(struct spi_device *spi)
 {
         struct lms501kf03 *lcd = spi_get_drvdata(spi);
@@ -426,12 +425,11 @@ static struct spi_driver lms501kf03_driver = {
         .driver = {
                 .name   = "lms501kf03",
                 .owner  = THIS_MODULE,
+                .pm     = &lms501kf03_pm_ops,
         },
         .probe          = lms501kf03_probe,
         .remove         = lms501kf03_remove,
         .shutdown       = lms501kf03_shutdown,
-        .suspend        = lms501kf03_suspend,
-        .resume         = lms501kf03_resume,
 };
 
 module_spi_driver(lms501kf03_driver);
diff --git a/drivers/video/backlight/locomolcd.c b/drivers/video/backlight/locomolcd.c
index 146fea8aa431..6c3ec4259a60 100644
--- a/drivers/video/backlight/locomolcd.c
+++ b/drivers/video/backlight/locomolcd.c
@@ -157,25 +157,24 @@ static const struct backlight_ops locomobl_data = {
         .update_status  = locomolcd_set_intensity,
 };
 
-#ifdef CONFIG_PM
-static int locomolcd_suspend(struct locomo_dev *dev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int locomolcd_suspend(struct device *dev)
 {
         locomolcd_flags |= LOCOMOLCD_SUSPENDED;
         locomolcd_set_intensity(locomolcd_bl_device);
         return 0;
 }
 
-static int locomolcd_resume(struct locomo_dev *dev)
+static int locomolcd_resume(struct device *dev)
 {
         locomolcd_flags &= ~LOCOMOLCD_SUSPENDED;
         locomolcd_set_intensity(locomolcd_bl_device);
         return 0;
 }
-#else
-#define locomolcd_suspend       NULL
-#define locomolcd_resume        NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(locomolcd_pm_ops, locomolcd_suspend, locomolcd_resume);
+
 static int locomolcd_probe(struct locomo_dev *ldev)
 {
         struct backlight_properties props;
@@ -230,13 +229,12 @@ static int locomolcd_remove(struct locomo_dev *dev)
 
 static struct locomo_driver poodle_lcd_driver = {
         .drv = {
-                .name = "locomo-backlight",
+                .name   = "locomo-backlight",
+                .pm     = &locomolcd_pm_ops,
         },
         .devid  = LOCOMO_DEVID_BACKLIGHT,
         .probe  = locomolcd_probe,
         .remove = locomolcd_remove,
-        .suspend = locomolcd_suspend,
-        .resume = locomolcd_resume,
 };
 
 static int __init locomolcd_init(void)
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c
index 7ae9ae6f4655..a0e1e02bdc2e 100644
--- a/drivers/video/backlight/lp855x_bl.c
+++ b/drivers/video/backlight/lp855x_bl.c
@@ -14,6 +14,7 @@
 #include <linux/i2c.h>
 #include <linux/backlight.h>
 #include <linux/err.h>
+#include <linux/of.h>
 #include <linux/platform_data/lp855x.h>
 #include <linux/pwm.h>
 
@@ -35,10 +36,14 @@
 #define LP8557_EPROM_START              0x10
 #define LP8557_EPROM_END                0x1E
 
-#define BUF_SIZE                20
 #define DEFAULT_BL_NAME         "lcd-backlight"
 #define MAX_BRIGHTNESS          255
 
+enum lp855x_brightness_ctrl_mode {
+        PWM_BASED = 1,
+        REGISTER_BASED,
+};
+
 struct lp855x;
 
 /*
@@ -58,6 +63,7 @@ struct lp855x_device_config {
 struct lp855x {
         const char *chipname;
         enum lp855x_chip_id chip_id;
+        enum lp855x_brightness_ctrl_mode mode;
         struct lp855x_device_config *cfg;
         struct i2c_client *client;
         struct backlight_device *bl;
@@ -187,7 +193,7 @@ static int lp855x_configure(struct lp855x *lp)
         if (ret)
                 goto err;
 
-        if (pd->load_new_rom_data && pd->size_program) {
+        if (pd->size_program > 0) {
                 for (i = 0; i < pd->size_program; i++) {
                         addr = pd->rom_data[i].addr;
                         val = pd->rom_data[i].val;
@@ -239,18 +245,17 @@ static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br)
 static int lp855x_bl_update_status(struct backlight_device *bl)
 {
         struct lp855x *lp = bl_get_data(bl);
-        enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode;
 
         if (bl->props.state & BL_CORE_SUSPENDED)
                 bl->props.brightness = 0;
 
-        if (mode == PWM_BASED) {
+        if (lp->mode == PWM_BASED) {
                 int br = bl->props.brightness;
                 int max_br = bl->props.max_brightness;
 
                 lp855x_pwm_ctrl(lp, br, max_br);
 
-        } else if (mode == REGISTER_BASED) {
+        } else if (lp->mode == REGISTER_BASED) {
                 u8 val = bl->props.brightness;
                 lp855x_write_byte(lp, lp->cfg->reg_brightness, val);
         }
@@ -274,7 +279,7 @@ static int lp855x_backlight_register(struct lp855x *lp)
         struct backlight_device *bl;
         struct backlight_properties props;
         struct lp855x_platform_data *pdata = lp->pdata;
-        char *name = pdata->name ? : DEFAULT_BL_NAME;
+        const char *name = pdata->name ? : DEFAULT_BL_NAME;
 
         props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = MAX_BRIGHTNESS;
@@ -304,22 +309,21 @@ static ssize_t lp855x_get_chip_id(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         struct lp855x *lp = dev_get_drvdata(dev);
-        return scnprintf(buf, BUF_SIZE, "%s\n", lp->chipname);
+        return scnprintf(buf, PAGE_SIZE, "%s\n", lp->chipname);
 }
 
 static ssize_t lp855x_get_bl_ctl_mode(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
         struct lp855x *lp = dev_get_drvdata(dev);
-        enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode;
         char *strmode = NULL;
 
-        if (mode == PWM_BASED)
+        if (lp->mode == PWM_BASED)
                 strmode = "pwm based";
-        else if (mode == REGISTER_BASED)
+        else if (lp->mode == REGISTER_BASED)
                 strmode = "register based";
 
-        return scnprintf(buf, BUF_SIZE, "%s\n", strmode);
+        return scnprintf(buf, PAGE_SIZE, "%s\n", strmode);
 }
 
 static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL);
@@ -335,16 +339,71 @@ static const struct attribute_group lp855x_attr_group = {
         .attrs = lp855x_attributes,
 };
 
+#ifdef CONFIG_OF
+static int lp855x_parse_dt(struct device *dev, struct device_node *node)
+{
+        struct lp855x_platform_data *pdata;
+        int rom_length;
+
+        if (!node) {
+                dev_err(dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        of_property_read_string(node, "bl-name", &pdata->name);
+        of_property_read_u8(node, "dev-ctrl", &pdata->device_control);
+        of_property_read_u8(node, "init-brt", &pdata->initial_brightness);
+        of_property_read_u32(node, "pwm-period", &pdata->period_ns);
+
+        /* Fill ROM platform data if defined */
+        rom_length = of_get_child_count(node);
+        if (rom_length > 0) {
+                struct lp855x_rom_data *rom;
+                struct device_node *child;
+                int i = 0;
+
+                rom = devm_kzalloc(dev, sizeof(*rom) * rom_length, GFP_KERNEL);
+                if (!rom)
+                        return -ENOMEM;
+
+                for_each_child_of_node(node, child) {
+                        of_property_read_u8(child, "rom-addr", &rom[i].addr);
+                        of_property_read_u8(child, "rom-val", &rom[i].val);
+                        i++;
+                }
+
+                pdata->size_program = rom_length;
+                pdata->rom_data = &rom[0];
+        }
+
+        dev->platform_data = pdata;
+
+        return 0;
+}
+#else
+static int lp855x_parse_dt(struct device *dev, struct device_node *node)
+{
+        return -EINVAL;
+}
+#endif
+
 static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
 {
         struct lp855x *lp;
         struct lp855x_platform_data *pdata = cl->dev.platform_data;
-        enum lp855x_brightness_ctrl_mode mode;
+        struct device_node *node = cl->dev.of_node;
         int ret;
 
         if (!pdata) {
-                dev_err(&cl->dev, "no platform data supplied\n");
-                return -EINVAL;
+                ret = lp855x_parse_dt(&cl->dev, node);
+                if (ret < 0)
+                        return ret;
+
+                pdata = cl->dev.platform_data;
         }
 
         if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
@@ -354,7 +413,11 @@ static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
         if (!lp)
                 return -ENOMEM;
 
-        mode = pdata->mode;
+        if (pdata->period_ns > 0)
+                lp->mode = PWM_BASED;
+        else
+                lp->mode = REGISTER_BASED;
+
         lp->client = cl;
         lp->dev = &cl->dev;
         lp->pdata = pdata;
@@ -402,6 +465,17 @@ static int lp855x_remove(struct i2c_client *cl)
         return 0;
 }
 
+static const struct of_device_id lp855x_dt_ids[] = {
+        { .compatible = "ti,lp8550", },
+        { .compatible = "ti,lp8551", },
+        { .compatible = "ti,lp8552", },
+        { .compatible = "ti,lp8553", },
+        { .compatible = "ti,lp8556", },
+        { .compatible = "ti,lp8557", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, lp855x_dt_ids);
+
 static const struct i2c_device_id lp855x_ids[] = {
         {"lp8550", LP8550},
         {"lp8551", LP8551},
@@ -416,6 +490,7 @@ MODULE_DEVICE_TABLE(i2c, lp855x_ids);
 static struct i2c_driver lp855x_driver = {
         .driver = {
                    .name = "lp855x",
+                   .of_match_table = of_match_ptr(lp855x_dt_ids),
                    },
         .probe = lp855x_probe,
         .remove = lp855x_remove,
diff --git a/drivers/video/backlight/ltv350qv.c b/drivers/video/backlight/ltv350qv.c
index c0b4b8f2de98..ed1b39268131 100644
--- a/drivers/video/backlight/ltv350qv.c
+++ b/drivers/video/backlight/ltv350qv.c
@@ -271,25 +271,24 @@ static int ltv350qv_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int ltv350qv_suspend(struct spi_device *spi, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int ltv350qv_suspend(struct device *dev)
 {
-        struct ltv350qv *lcd = spi_get_drvdata(spi);
+        struct ltv350qv *lcd = dev_get_drvdata(dev);
 
         return ltv350qv_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int ltv350qv_resume(struct spi_device *spi)
+static int ltv350qv_resume(struct device *dev)
 {
-        struct ltv350qv *lcd = spi_get_drvdata(spi);
+        struct ltv350qv *lcd = dev_get_drvdata(dev);
 
         return ltv350qv_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define ltv350qv_suspend        NULL
-#define ltv350qv_resume         NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ltv350qv_pm_ops, ltv350qv_suspend, ltv350qv_resume);
+
 /* Power down all displays on reboot, poweroff or halt */
 static void ltv350qv_shutdown(struct spi_device *spi)
 {
@@ -302,13 +301,12 @@ static struct spi_driver ltv350qv_driver = {
         .driver = {
                 .name           = "ltv350qv",
                 .owner          = THIS_MODULE,
+                .pm             = &ltv350qv_pm_ops,
         },
 
         .probe          = ltv350qv_probe,
         .remove         = ltv350qv_remove,
         .shutdown       = ltv350qv_shutdown,
-        .suspend        = ltv350qv_suspend,
-        .resume         = ltv350qv_resume,
 };
 
 module_spi_driver(ltv350qv_driver);
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index 627110163067..812e22e35cab 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -18,8 +18,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -73,27 +71,24 @@ static void omapbl_blank(struct omap_backlight *bl, int mode)
         }
 }
 
-#ifdef CONFIG_PM
-static int omapbl_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int omapbl_suspend(struct device *dev)
 {
-        struct backlight_device *dev = platform_get_drvdata(pdev);
-        struct omap_backlight *bl = bl_get_data(dev);
+        struct backlight_device *bl_dev = dev_get_drvdata(dev);
+        struct omap_backlight *bl = bl_get_data(bl_dev);
 
         omapbl_blank(bl, FB_BLANK_POWERDOWN);
         return 0;
 }
 
-static int omapbl_resume(struct platform_device *pdev)
+static int omapbl_resume(struct device *dev)
 {
-        struct backlight_device *dev = platform_get_drvdata(pdev);
-        struct omap_backlight *bl = bl_get_data(dev);
+        struct backlight_device *bl_dev = dev_get_drvdata(dev);
+        struct omap_backlight *bl = bl_get_data(bl_dev);
 
         omapbl_blank(bl, bl->powermode);
         return 0;
 }
-#else
-#define omapbl_suspend  NULL
-#define omapbl_resume   NULL
 #endif
 
 static int omapbl_set_power(struct backlight_device *dev, int state)
@@ -170,7 +165,7 @@ static int omapbl_probe(struct platform_device *pdev)
         dev->props.brightness = pdata->default_intensity;
         omapbl_update_status(dev);
 
-        pr_info("OMAP LCD backlight initialised\n");
+        dev_info(&pdev->dev, "OMAP LCD backlight initialised\n");
 
         return 0;
 }
@@ -184,13 +179,14 @@ static int omapbl_remove(struct platform_device *pdev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(omapbl_pm_ops, omapbl_suspend, omapbl_resume);
+
 static struct platform_driver omapbl_driver = {
         .probe          = omapbl_probe,
         .remove         = omapbl_remove,
-        .suspend        = omapbl_suspend,
-        .resume         = omapbl_resume,
         .driver         = {
                 .name   = "omap-bl",
+                .pm     = &omapbl_pm_ops,
         },
 };
 
diff --git a/drivers/video/backlight/platform_lcd.c b/drivers/video/backlight/platform_lcd.c
index 17a6b83f97af..056836706708 100644
--- a/drivers/video/backlight/platform_lcd.c
+++ b/drivers/video/backlight/platform_lcd.c
@@ -86,6 +86,12 @@ static int platform_lcd_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
+        if (pdata->probe) {
+                err = pdata->probe(pdata);
+                if (err)
+                        return err;
+        }
+
         plcd = devm_kzalloc(&pdev->dev, sizeof(struct platform_lcd),
                             GFP_KERNEL);
         if (!plcd) {
@@ -121,7 +127,7 @@ static int platform_lcd_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int platform_lcd_suspend(struct device *dev)
 {
         struct platform_lcd *plcd = dev_get_drvdata(dev);
@@ -141,10 +147,10 @@ static int platform_lcd_resume(struct device *dev)
 
         return 0;
 }
+#endif
 
 static SIMPLE_DEV_PM_OPS(platform_lcd_pm_ops, platform_lcd_suspend,
                         platform_lcd_resume);
-#endif
 
 #ifdef CONFIG_OF
 static const struct of_device_id platform_lcd_of_match[] = {
@@ -158,9 +164,7 @@ static struct platform_driver platform_lcd_driver = {
         .driver         = {
                 .name   = "platform-lcd",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
                 .pm     = &platform_lcd_pm_ops,
-#endif
                 .of_match_table = of_match_ptr(platform_lcd_of_match),
         },
         .probe          = platform_lcd_probe,
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index fa00304a63d8..1fea627394d7 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -274,7 +274,7 @@ static int pwm_backlight_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int pwm_backlight_suspend(struct device *dev)
 {
         struct backlight_device *bl = dev_get_drvdata(dev);
@@ -296,19 +296,16 @@ static int pwm_backlight_resume(struct device *dev)
         backlight_update_status(bl);
         return 0;
 }
+#endif
 
 static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops, pwm_backlight_suspend,
                          pwm_backlight_resume);
 
-#endif
-
 static struct platform_driver pwm_backlight_driver = {
         .driver         = {
                 .name           = "pwm-backlight",
                 .owner          = THIS_MODULE,
-#ifdef CONFIG_PM
                 .pm             = &pwm_backlight_pm_ops,
-#endif
                 .of_match_table = of_match_ptr(pwm_backlight_of_match),
         },
         .probe          = pwm_backlight_probe,
diff --git a/drivers/video/backlight/s6e63m0.c b/drivers/video/backlight/s6e63m0.c
index 9c2677f0ef7d..b37bb1854bf4 100644
--- a/drivers/video/backlight/s6e63m0.c
+++ b/drivers/video/backlight/s6e63m0.c
@@ -817,12 +817,12 @@ static int s6e63m0_remove(struct spi_device *spi)
         return 0;
 }
 
-#if defined(CONFIG_PM)
-static int s6e63m0_suspend(struct spi_device *spi, pm_message_t mesg)
+#ifdef CONFIG_PM_SLEEP
+static int s6e63m0_suspend(struct device *dev)
 {
-        struct s6e63m0 *lcd = spi_get_drvdata(spi);
+        struct s6e63m0 *lcd = dev_get_drvdata(dev);
 
-        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+        dev_dbg(dev, "lcd->power = %d\n", lcd->power);
 
         /*
          * when lcd panel is suspend, lcd panel becomes off
@@ -831,19 +831,18 @@ static int s6e63m0_suspend(struct spi_device *spi, pm_message_t mesg)
         return s6e63m0_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int s6e63m0_resume(struct spi_device *spi)
+static int s6e63m0_resume(struct device *dev)
 {
-        struct s6e63m0 *lcd = spi_get_drvdata(spi);
+        struct s6e63m0 *lcd = dev_get_drvdata(dev);
 
         lcd->power = FB_BLANK_POWERDOWN;
 
         return s6e63m0_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define s6e63m0_suspend         NULL
-#define s6e63m0_resume          NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(s6e63m0_pm_ops, s6e63m0_suspend, s6e63m0_resume);
+
 /* Power down all displays on reboot, poweroff or halt. */
 static void s6e63m0_shutdown(struct spi_device *spi)
 {
@@ -856,12 +855,11 @@ static struct spi_driver s6e63m0_driver = {
         .driver = {
                 .name   = "s6e63m0",
                 .owner  = THIS_MODULE,
+                .pm     = &s6e63m0_pm_ops,
         },
         .probe          = s6e63m0_probe,
         .remove         = s6e63m0_remove,
         .shutdown       = s6e63m0_shutdown,
-        .suspend        = s6e63m0_suspend,
-        .resume         = s6e63m0_resume,
 };
 
 module_spi_driver(s6e63m0_driver);
diff --git a/drivers/video/backlight/tdo24m.c b/drivers/video/backlight/tdo24m.c
index 00162085eec0..18cdf466d50a 100644
--- a/drivers/video/backlight/tdo24m.c
+++ b/drivers/video/backlight/tdo24m.c
@@ -412,25 +412,24 @@ static int tdo24m_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int tdo24m_suspend(struct spi_device *spi, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int tdo24m_suspend(struct device *dev)
 {
-        struct tdo24m *lcd = spi_get_drvdata(spi);
+        struct tdo24m *lcd = dev_get_drvdata(dev);
 
         return tdo24m_power(lcd, FB_BLANK_POWERDOWN);
 }
 
-static int tdo24m_resume(struct spi_device *spi)
+static int tdo24m_resume(struct device *dev)
 {
-        struct tdo24m *lcd = spi_get_drvdata(spi);
+        struct tdo24m *lcd = dev_get_drvdata(dev);
 
         return tdo24m_power(lcd, FB_BLANK_UNBLANK);
 }
-#else
-#define tdo24m_suspend  NULL
-#define tdo24m_resume   NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(tdo24m_pm_ops, tdo24m_suspend, tdo24m_resume);
+
 /* Power down all displays on reboot, poweroff or halt */
 static void tdo24m_shutdown(struct spi_device *spi)
 {
@@ -443,12 +442,11 @@ static struct spi_driver tdo24m_driver = {
         .driver = {
                 .name           = "tdo24m",
                 .owner          = THIS_MODULE,
+                .pm             = &tdo24m_pm_ops,
         },
         .probe          = tdo24m_probe,
         .remove         = tdo24m_remove,
         .shutdown       = tdo24m_shutdown,
-        .suspend        = tdo24m_suspend,
-        .resume         = tdo24m_resume,
 };
 
 module_spi_driver(tdo24m_driver);
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index 2326fa810c59..9df66ac68b34 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -134,28 +134,27 @@ static int tosa_bl_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int tosa_bl_suspend(struct i2c_client *client, pm_message_t pm)
+#ifdef CONFIG_PM_SLEEP
+static int tosa_bl_suspend(struct device *dev)
 {
-        struct tosa_bl_data *data = i2c_get_clientdata(client);
+        struct tosa_bl_data *data = dev_get_drvdata(dev);
 
         tosa_bl_set_backlight(data, 0);
 
         return 0;
 }
 
-static int tosa_bl_resume(struct i2c_client *client)
+static int tosa_bl_resume(struct device *dev)
 {
-        struct tosa_bl_data *data = i2c_get_clientdata(client);
+        struct tosa_bl_data *data = dev_get_drvdata(dev);
 
         backlight_update_status(data->bl);
         return 0;
 }
-#else
-#define tosa_bl_suspend NULL
-#define tosa_bl_resume NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(tosa_bl_pm_ops, tosa_bl_suspend, tosa_bl_resume);
+
 static const struct i2c_device_id tosa_bl_id[] = {
         { "tosa-bl", 0 },
         { },
@@ -165,11 +164,10 @@ static struct i2c_driver tosa_bl_driver = {
         .driver = {
                 .name           = "tosa-bl",
                 .owner          = THIS_MODULE,
+                .pm             = &tosa_bl_pm_ops,
         },
         .probe          = tosa_bl_probe,
         .remove         = tosa_bl_remove,
-        .suspend        = tosa_bl_suspend,
-        .resume         = tosa_bl_resume,
         .id_table       = tosa_bl_id,
 };
 
diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c
index 666fe2593ea4..bf081573e5b5 100644
--- a/drivers/video/backlight/tosa_lcd.c
+++ b/drivers/video/backlight/tosa_lcd.c
@@ -240,19 +240,19 @@ static int tosa_lcd_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int tosa_lcd_suspend(struct spi_device *spi, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int tosa_lcd_suspend(struct device *dev)
 {
-        struct tosa_lcd_data *data = spi_get_drvdata(spi);
+        struct tosa_lcd_data *data = dev_get_drvdata(dev);
 
         tosa_lcd_tg_off(data);
 
         return 0;
 }
 
-static int tosa_lcd_resume(struct spi_device *spi)
+static int tosa_lcd_resume(struct device *dev)
 {
-        struct tosa_lcd_data *data = spi_get_drvdata(spi);
+        struct tosa_lcd_data *data = dev_get_drvdata(dev);
 
         tosa_lcd_tg_init(data);
         if (POWER_IS_ON(data->lcd_power))
@@ -262,20 +262,18 @@ static int tosa_lcd_resume(struct spi_device *spi)
 
         return 0;
 }
-#else
-#define tosa_lcd_suspend        NULL
-#define tosa_lcd_resume NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(tosa_lcd_pm_ops, tosa_lcd_suspend, tosa_lcd_resume);
+
 static struct spi_driver tosa_lcd_driver = {
         .driver = {
                 .name           = "tosa-lcd",
                 .owner          = THIS_MODULE,
+                .pm             = &tosa_lcd_pm_ops,
         },
         .probe          = tosa_lcd_probe,
         .remove         = tosa_lcd_remove,
-        .suspend        = tosa_lcd_suspend,
-        .resume         = tosa_lcd_resume,
 };
 
 module_spi_driver(tosa_lcd_driver);
diff --git a/drivers/video/backlight/tps65217_bl.c b/drivers/video/backlight/tps65217_bl.c
index 70881633b45a..05782312aeb3 100644
--- a/drivers/video/backlight/tps65217_bl.c
+++ b/drivers/video/backlight/tps65217_bl.c
@@ -245,6 +245,18 @@ tps65217_bl_parse_dt(struct platform_device *pdev)
                 }
         }
 
+        if (!of_property_read_u32(node, "default-brightness", &val)) {
+                if (val < 0 ||
+                        val > 100) {
+                        dev_err(&pdev->dev,
+                                "invalid 'default-brightness' value in the device tree\n");
+                        err = ERR_PTR(-EINVAL);
+                        goto err;
+                }
+
+                pdata->dft_brightness = val;
+        }
+
         of_node_put(node);
 
         return pdata;
@@ -311,7 +323,8 @@ static int tps65217_bl_probe(struct platform_device *pdev)
                 return PTR_ERR(tps65217_bl->bl);
         }
 
-        tps65217_bl->bl->props.brightness = 0;
+        tps65217_bl->bl->props.brightness = pdata->dft_brightness;
+        backlight_update_status(tps65217_bl->bl);
         platform_set_drvdata(pdev, tps65217_bl);
 
         return 0;
diff --git a/drivers/video/backlight/vgg2432a4.c b/drivers/video/backlight/vgg2432a4.c
index 84d582f591dc..d538947a67d3 100644
--- a/drivers/video/backlight/vgg2432a4.c
+++ b/drivers/video/backlight/vgg2432a4.c
@@ -205,18 +205,15 @@ static int vgg2432a4_lcd_init(struct ili9320 *lcd,
         return ret;
 }
 
-#ifdef CONFIG_PM
-static int vgg2432a4_suspend(struct spi_device *spi, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int vgg2432a4_suspend(struct device *dev)
 {
-        return ili9320_suspend(spi_get_drvdata(spi), state);
+        return ili9320_suspend(dev_get_drvdata(dev));
 }
-static int vgg2432a4_resume(struct spi_device *spi)
+static int vgg2432a4_resume(struct device *dev)
 {
-        return ili9320_resume(spi_get_drvdata(spi));
+        return ili9320_resume(dev_get_drvdata(dev));
 }
-#else
-#define vgg2432a4_suspend       NULL
-#define vgg2432a4_resume        NULL
 #endif
 
 static struct ili9320_client vgg2432a4_client = {
@@ -249,16 +246,17 @@ static void vgg2432a4_shutdown(struct spi_device *spi)
         ili9320_shutdown(spi_get_drvdata(spi));
 }
 
+static SIMPLE_DEV_PM_OPS(vgg2432a4_pm_ops, vgg2432a4_suspend, vgg2432a4_resume);
+
 static struct spi_driver vgg2432a4_driver = {
         .driver = {
                 .name           = "VGG2432A4",
                 .owner          = THIS_MODULE,
+                .pm             = &vgg2432a4_pm_ops,
         },
         .probe          = vgg2432a4_probe,
         .remove         = vgg2432a4_remove,
         .shutdown       = vgg2432a4_shutdown,
-        .suspend        = vgg2432a4_suspend,
-        .resume         = vgg2432a4_resume,
 };
 
 module_spi_driver(vgg2432a4_driver);
diff --git a/drivers/video/bfin_adv7393fb.c b/drivers/video/bfin_adv7393fb.c
index 8d411a3c9966..a54f7f7d763b 100644
--- a/drivers/video/bfin_adv7393fb.c
+++ b/drivers/video/bfin_adv7393fb.c
@@ -333,29 +333,23 @@ static int proc_output(char *buf)
         return p - buf;
 }
 
-static int
-adv7393_read_proc(char *page, char **start, off_t off,
-                  int count, int *eof, void *data)
+static ssize_t
+adv7393_read_proc(struct file *file, char __user *buf,
+                  size_t size, loff_t *ppos)
 {
-        int len;
-
-        len = proc_output(page);
-        if (len <= off + count)
-                *eof = 1;
-        *start = page + off;
-        len -= off;
-        if (len > count)
-                len = count;
-        if (len < 0)
-                len = 0;
-        return len;
+        static const char message[] = "Usage:\n"
+                "echo 0x[REG][Value] > adv7393\n"
+                "example: echo 0x1234 >adv7393\n"
+                "writes 0x34 into Register 0x12\n";
+        return simple_read_from_buffer(buf, size, ppos, message,
+                                        sizeof(message));
 }
 
-static int
+static ssize_t
 adv7393_write_proc(struct file *file, const char __user * buffer,
-                   size_t count, void *data)
+                   size_t count, loff_t *ppos)
 {
-        struct adv7393fb_device *fbdev = data;
+        struct adv7393fb_device *fbdev = PDE_DATA(file_inode(file));
         unsigned int val;
         int ret;
 
@@ -368,6 +362,12 @@ adv7393_write_proc(struct file *file, const char __user * buffer,
         return count;
 }
 
+static const struct file_operations fops = {
+        .read = adv7393_read_proc,
+        .write = adv7393_write_proc,
+        .llseek = default_llseek,
+};
+
 static int bfin_adv7393_fb_probe(struct i2c_client *client,
                                  const struct i2c_device_id *id)
 {
@@ -506,17 +506,12 @@ static int bfin_adv7393_fb_probe(struct i2c_client *client,
                fbdev->info.node, fbdev->info.fix.id);
         dev_info(&client->dev, "fb memory address : 0x%p\n", fbdev->fb_mem);
 
-        entry = create_proc_entry("driver/adv7393", 0, NULL);
+        entry = proc_create_data("driver/adv7393", 0, NULL, &fops, fbdev);
         if (!entry) {
                 dev_err(&client->dev, "unable to create /proc entry\n");
                 ret = -EFAULT;
                 goto free_fb;
         }
-
-        entry->read_proc = adv7393_read_proc;
-        entry->write_proc = adv7393_write_proc;
-        entry->data = fbdev;
-
         return 0;
 
 free_fb:
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index c3dbbe6e3acf..97db3ba8f237 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -53,12 +53,6 @@
 #ifdef CONFIG_AMIGA
 #include <asm/amigahw.h>
 #endif
-#ifdef CONFIG_PPC_PREP
-#include <asm/machdep.h>
-#define isPReP machine_is(prep)
-#else
-#define isPReP 0
-#endif
 
 #include <video/vga.h>
 #include <video/cirrus.h>
@@ -557,30 +551,18 @@ static int cirrusfb_check_var(struct fb_var_screeninfo *var,
                 break;
 
         case 16:
-                if (isPReP) {
-                        var->red.offset = 2;
-                        var->green.offset = -3;
-                        var->blue.offset = 8;
-                } else {
-                        var->red.offset = 11;
-                        var->green.offset = 5;
-                        var->blue.offset = 0;
-                }
+                var->red.offset = 11;
+                var->green.offset = 5;
+                var->blue.offset = 0;
                 var->red.length = 5;
                 var->green.length = 6;
                 var->blue.length = 5;
                 break;
 
         case 24:
-                if (isPReP) {
-                        var->red.offset = 0;
-                        var->green.offset = 8;
-                        var->blue.offset = 16;
-                } else {
-                        var->red.offset = 16;
-                        var->green.offset = 8;
-                        var->blue.offset = 0;
-                }
+                var->red.offset = 16;
+                var->green.offset = 8;
+                var->blue.offset = 0;
                 var->red.length = 8;
                 var->green.length = 8;
                 var->blue.length = 8;
@@ -1874,17 +1856,6 @@ static void cirrusfb_imageblit(struct fb_info *info,
         }
 }
 
-#ifdef CONFIG_PPC_PREP
-#define PREP_VIDEO_BASE ((volatile unsigned long) 0xC0000000)
-#define PREP_IO_BASE    ((volatile unsigned char *) 0x80000000)
-static void get_prep_addrs(unsigned long *display, unsigned long *registers)
-{
-        *display = PREP_VIDEO_BASE;
-        *registers = (unsigned long) PREP_IO_BASE;
-}
-
-#endif                          /* CONFIG_PPC_PREP */
-
 #ifdef CONFIG_PCI
 static int release_io_ports;
 
@@ -2139,21 +2110,12 @@ static int cirrusfb_pci_register(struct pci_dev *pdev,
         dev_dbg(info->device, " base address 1 is 0x%Lx\n",
                 (unsigned long long)pdev->resource[1].start);
 
-        if (isPReP) {
-                pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0, 0x00000000);
-#ifdef CONFIG_PPC_PREP
-                get_prep_addrs(&board_addr, &info->fix.mmio_start);
-#endif
-        /* PReP dies if we ioremap the IO registers, but it works w/out... */
-                cinfo->regbase = (char __iomem *) info->fix.mmio_start;
-        } else {
-                dev_dbg(info->device,
-                        "Attempt to get PCI info for Cirrus Graphics Card\n");
-                get_pci_addrs(pdev, &board_addr, &info->fix.mmio_start);
-                /* FIXME: this forces VGA.  alternatives? */
-                cinfo->regbase = NULL;
-                cinfo->laguna_mmio = ioremap(info->fix.mmio_start, 0x1000);
-        }
+        dev_dbg(info->device,
+                "Attempt to get PCI info for Cirrus Graphics Card\n");
+        get_pci_addrs(pdev, &board_addr, &info->fix.mmio_start);
+        /* FIXME: this forces VGA.  alternatives? */
+        cinfo->regbase = NULL;
+        cinfo->laguna_mmio = ioremap(info->fix.mmio_start, 0x1000);
 
         dev_dbg(info->device, "Board address: 0x%lx, register address: 0x%lx\n",
                 board_addr, info->fix.mmio_start);
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 3cd675927826..a92783e480e6 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -1228,6 +1228,8 @@ static void fbcon_deinit(struct vc_data *vc)
 finished:
 
         fbcon_free_font(p, free_font);
+        if (free_font)
+                vc->vc_font.data = NULL;
 
         if (!con_is_bound(&fb_con))
                 fbcon_exit();
diff --git a/drivers/video/console/fbcon_cw.c b/drivers/video/console/fbcon_cw.c
index 6a737827beb1..a93670ef7f89 100644
--- a/drivers/video/console/fbcon_cw.c
+++ b/drivers/video/console/fbcon_cw.c
@@ -27,7 +27,7 @@ static void cw_update_attr(u8 *dst, u8 *src, int attribute,
 {
         int i, j, offset = (vc->vc_font.height < 10) ? 1 : 2;
         int width = (vc->vc_font.height + 7) >> 3;
-        u8 c, t = 0, msk = ~(0xff >> offset);
+        u8 c, msk = ~(0xff >> offset);
 
         for (i = 0; i < vc->vc_font.width; i++) {
                 for (j = 0; j < width; j++) {
@@ -40,7 +40,6 @@ static void cw_update_attr(u8 *dst, u8 *src, int attribute,
                                 c = ~c;
                         src++;
                         *dst++ = c;
-                        t = c;
                 }
         }
 }
diff --git a/drivers/video/controlfb.c b/drivers/video/controlfb.c
index 0c189b32a4c5..67b77b40aa7f 100644
--- a/drivers/video/controlfb.c
+++ b/drivers/video/controlfb.c
@@ -285,36 +285,26 @@ static int controlfb_pan_display(struct fb_var_screeninfo *var,
 static int controlfb_mmap(struct fb_info *info,
                        struct vm_area_struct *vma)
 {
-       unsigned long off, start;
-       u32 len;
-
-       off = vma->vm_pgoff << PAGE_SHIFT;
-
-       /* frame buffer memory */
-       start = info->fix.smem_start;
-       len = PAGE_ALIGN((start & ~PAGE_MASK)+info->fix.smem_len);
-       if (off >= len) {
-               /* memory mapped io */
-               off -= len;
-               if (info->var.accel_flags)
-                       return -EINVAL;
-               start = info->fix.mmio_start;
-               len = PAGE_ALIGN((start & ~PAGE_MASK)+info->fix.mmio_len);
-               vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-       } else {
-               /* framebuffer */
-               vma->vm_page_prot = pgprot_cached_wthru(vma->vm_page_prot);
-       }
-       start &= PAGE_MASK;
-       if ((vma->vm_end - vma->vm_start + off) > len)
-                return -EINVAL;
-       off += start;
-       vma->vm_pgoff = off >> PAGE_SHIFT;
-       if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
-           vma->vm_end - vma->vm_start, vma->vm_page_prot))
-               return -EAGAIN;
-
-       return 0;
+        unsigned long mmio_pgoff;
+        unsigned long start;
+        u32 len;
+
+        start = info->fix.smem_start;
+        len = info->fix.smem_len;
+        mmio_pgoff = PAGE_ALIGN((start & ~PAGE_MASK) + len) >> PAGE_SHIFT;
+        if (vma->vm_pgoff >= mmio_pgoff) {
+                if (info->var.accel_flags)
+                        return -EINVAL;
+                vma->vm_pgoff -= mmio_pgoff;
+                start = info->fix.mmio_start;
+                len = info->fix.mmio_len;
+                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        } else {
+                /* framebuffer */
+                vma->vm_page_prot = pgprot_cached_wthru(vma->vm_page_prot);
+        }
+
+        return vm_iomap_memory(vma, start, len);
 }
 
 static int controlfb_blank(int blank_mode, struct fb_info *info)
diff --git a/drivers/video/ep93xx-fb.c b/drivers/video/ep93xx-fb.c
index e06cd5d90c97..ee1ee5401544 100644
--- a/drivers/video/ep93xx-fb.c
+++ b/drivers/video/ep93xx-fb.c
@@ -419,7 +419,7 @@ static struct fb_ops ep93xxfb_ops = {
         .fb_mmap        = ep93xxfb_mmap,
 };
 
-static int __init ep93xxfb_calc_fbsize(struct ep93xxfb_mach_info *mach_info)
+static int ep93xxfb_calc_fbsize(struct ep93xxfb_mach_info *mach_info)
 {
         int i, fb_size = 0;
 
@@ -441,7 +441,7 @@ static int __init ep93xxfb_calc_fbsize(struct ep93xxfb_mach_info *mach_info)
         return fb_size;
 }
 
-static int __init ep93xxfb_alloc_videomem(struct fb_info *info)
+static int ep93xxfb_alloc_videomem(struct fb_info *info)
 {
         struct ep93xx_fbi *fbi = info->par;
         char __iomem *virt_addr;
@@ -627,19 +627,7 @@ static struct platform_driver ep93xxfb_driver = {
                 .owner  = THIS_MODULE,
         },
 };
-
-static int ep93xxfb_init(void)
-{
-        return platform_driver_register(&ep93xxfb_driver);
-}
-
-static void __exit ep93xxfb_exit(void)
-{
-        platform_driver_unregister(&ep93xxfb_driver);
-}
-
-module_init(ep93xxfb_init);
-module_exit(ep93xxfb_exit);
+module_platform_driver(ep93xxfb_driver);
 
 MODULE_DESCRIPTION("EP93XX Framebuffer Driver");
 MODULE_ALIAS("platform:ep93xx-fb");
diff --git a/drivers/video/exynos/exynos_dp_core.c b/drivers/video/exynos/exynos_dp_core.c
index de9d4da0e3da..12bbede3b091 100644
--- a/drivers/video/exynos/exynos_dp_core.c
+++ b/drivers/video/exynos/exynos_dp_core.c
@@ -976,14 +976,14 @@ static int exynos_dp_dt_parse_phydata(struct exynos_dp_device *dp)
         }
 
         if (of_property_read_u32(dp_phy_node, "reg", &phy_base)) {
-                dev_err(dp->dev, "faild to get reg for dptx-phy\n");
+                dev_err(dp->dev, "failed to get reg for dptx-phy\n");
                 ret = -EINVAL;
                 goto err;
         }
 
         if (of_property_read_u32(dp_phy_node, "samsung,enable-mask",
                                 &dp->enable_mask)) {
-                dev_err(dp->dev, "faild to get enable-mask for dptx-phy\n");
+                dev_err(dp->dev, "failed to get enable-mask for dptx-phy\n");
                 ret = -EINVAL;
                 goto err;
         }
diff --git a/drivers/video/exynos/exynos_mipi_dsi.c b/drivers/video/exynos/exynos_mipi_dsi.c
index fac7df6d1aba..32e540600f99 100644
--- a/drivers/video/exynos/exynos_mipi_dsi.c
+++ b/drivers/video/exynos/exynos_mipi_dsi.c
@@ -32,11 +32,10 @@
 #include <linux/notifier.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
+#include <linux/err.h>
 
 #include <video/exynos_mipi_dsim.h>
 
-#include <plat/fb.h>
-
 #include "exynos_mipi_dsi_common.h"
 #include "exynos_mipi_dsi_lowlevel.h"
 
@@ -384,10 +383,9 @@ static int exynos_mipi_dsi_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
-        dsim->reg_base = devm_request_and_ioremap(&pdev->dev, res);
-        if (!dsim->reg_base) {
-                dev_err(&pdev->dev, "failed to remap io region\n");
-                ret = -ENOMEM;
+        dsim->reg_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(dsim->reg_base)) {
+                ret = PTR_ERR(dsim->reg_base);
                 goto error;
         }
 
diff --git a/drivers/video/exynos/exynos_mipi_dsi_common.c b/drivers/video/exynos/exynos_mipi_dsi_common.c
index c70cb8926df6..520fc9bd887b 100644
--- a/drivers/video/exynos/exynos_mipi_dsi_common.c
+++ b/drivers/video/exynos/exynos_mipi_dsi_common.c
@@ -31,8 +31,6 @@
 #include <video/mipi_display.h>
 #include <video/exynos_mipi_dsim.h>
 
-#include <mach/map.h>
-
 #include "exynos_mipi_dsi_regs.h"
 #include "exynos_mipi_dsi_lowlevel.h"
 #include "exynos_mipi_dsi_common.h"
diff --git a/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c b/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
index 95cb99a1fe2d..15c5abd408dc 100644
--- a/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
+++ b/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
@@ -26,8 +26,6 @@
 
 #include <video/exynos_mipi_dsim.h>
 
-#include <mach/map.h>
-
 #include "exynos_mipi_dsi_regs.h"
 
 void exynos_mipi_dsi_func_reset(struct mipi_dsim_device *dsim)
diff --git a/drivers/video/fb-puv3.c b/drivers/video/fb-puv3.c
index 7d106f1f4906..27fc956166fa 100644
--- a/drivers/video/fb-puv3.c
+++ b/drivers/video/fb-puv3.c
@@ -640,21 +640,9 @@ static int unifb_pan_display(struct fb_var_screeninfo *var,
 int unifb_mmap(struct fb_info *info,
                     struct vm_area_struct *vma)
 {
-        unsigned long size = vma->vm_end - vma->vm_start;
-        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
-        unsigned long pos = info->fix.smem_start + offset;
-
-        if (offset + size > info->fix.smem_len)
-                return -EINVAL;
-
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
-        if (io_remap_pfn_range(vma, vma->vm_start, pos >> PAGE_SHIFT, size,
-                                vma->vm_page_prot))
-                return -EAGAIN;
-
-        /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
-        return 0;
+        return vm_iomap_memory(vma, info->fix.smem_start, info->fix.smem_len);
 }
 
 static struct fb_ops unifb_ops = {
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 7c254084b6a0..098bfc64cfb9 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1373,15 +1373,12 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
 {
         struct fb_info *info = file_fb_info(file);
         struct fb_ops *fb;
-        unsigned long off;
+        unsigned long mmio_pgoff;
         unsigned long start;
         u32 len;
 
         if (!info)
                 return -ENODEV;
-        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
-                return -EINVAL;
-        off = vma->vm_pgoff << PAGE_SHIFT;
         fb = info->fbops;
         if (!fb)
                 return -ENODEV;
@@ -1393,32 +1390,29 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
                 return res;
         }
 
-        /* frame buffer memory */
+        /*
+         * Ugh. This can be either the frame buffer mapping, or
+         * if pgoff points past it, the mmio mapping.
+         */
         start = info->fix.smem_start;
-        len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);
-        if (off >= len) {
-                /* memory mapped io */
-                off -= len;
+        len = info->fix.smem_len;
+        mmio_pgoff = PAGE_ALIGN((start & ~PAGE_MASK) + len) >> PAGE_SHIFT;
+        if (vma->vm_pgoff >= mmio_pgoff) {
                 if (info->var.accel_flags) {
                         mutex_unlock(&info->mm_lock);
                         return -EINVAL;
                 }
+
+                vma->vm_pgoff -= mmio_pgoff;
                 start = info->fix.mmio_start;
-                len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
+                len = info->fix.mmio_len;
         }
         mutex_unlock(&info->mm_lock);
-        start &= PAGE_MASK;
-        if ((vma->vm_end - vma->vm_start + off) > len)
-                return -EINVAL;
-        off += start;
-        vma->vm_pgoff = off >> PAGE_SHIFT;
-        /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by io_remap_pfn_range()*/
+
         vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
-        fb_pgprotect(file, vma, off);
-        if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
-                             vma->vm_end - vma->vm_start, vma->vm_page_prot))
-                return -EAGAIN;
-        return 0;
+        fb_pgprotect(file, vma, start);
+
+        return vm_iomap_memory(vma, start, len);
 }
 
 static int
@@ -1645,6 +1639,11 @@ static int do_register_framebuffer(struct fb_info *fb_info)
         if (!fb_info->modelist.prev || !fb_info->modelist.next)
                 INIT_LIST_HEAD(&fb_info->modelist);
 
+        if (fb_info->skip_vt_switch)
+                pm_vt_switch_required(fb_info->dev, false);
+        else
+                pm_vt_switch_required(fb_info->dev, true);
+
         fb_var_to_videomode(&mode, &fb_info->var);
         fb_add_videomode(&mode, &fb_info->modelist);
         registered_fb[i] = fb_info;
@@ -1679,6 +1678,8 @@ static int do_unregister_framebuffer(struct fb_info *fb_info)
         if (ret)
                 return -EINVAL;
 
+        pm_vt_switch_unregister(fb_info->dev);
+
         unlink_framebuffer(fb_info);
         if (fb_info->pixmap.addr &&
             (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT))
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 7f6709991a5c..6103fa6fb54f 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -1376,7 +1376,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
         return err;
 }
 
-#if IS_ENABLED(CONFIG_VIDEOMODE)
+#ifdef CONFIG_VIDEOMODE_HELPERS
 int fb_videomode_from_videomode(const struct videomode *vm,
                                 struct fb_videomode *fbmode)
 {
@@ -1398,13 +1398,13 @@ int fb_videomode_from_videomode(const struct videomode *vm,
 
         fbmode->sync = 0;
         fbmode->vmode = 0;
-        if (vm->dmt_flags & VESA_DMT_HSYNC_HIGH)
+        if (vm->flags & DISPLAY_FLAGS_HSYNC_HIGH)
                 fbmode->sync |= FB_SYNC_HOR_HIGH_ACT;
-        if (vm->dmt_flags & VESA_DMT_VSYNC_HIGH)
+        if (vm->flags & DISPLAY_FLAGS_VSYNC_HIGH)
                 fbmode->sync |= FB_SYNC_VERT_HIGH_ACT;
-        if (vm->data_flags & DISPLAY_FLAGS_INTERLACED)
+        if (vm->flags & DISPLAY_FLAGS_INTERLACED)
                 fbmode->vmode |= FB_VMODE_INTERLACED;
-        if (vm->data_flags & DISPLAY_FLAGS_DOUBLESCAN)
+        if (vm->flags & DISPLAY_FLAGS_DOUBLESCAN)
                 fbmode->vmode |= FB_VMODE_DOUBLE;
         fbmode->flag = 0;
 
@@ -1424,9 +1424,8 @@ int fb_videomode_from_videomode(const struct videomode *vm,
         return 0;
 }
 EXPORT_SYMBOL_GPL(fb_videomode_from_videomode);
-#endif
 
-#if IS_ENABLED(CONFIG_OF_VIDEOMODE)
+#ifdef CONFIG_OF
 static inline void dump_fb_videomode(const struct fb_videomode *m)
 {
         pr_debug("fb_videomode = %ux%u@%uHz (%ukHz) %u %u %u %u %u %u %u %u %u\n",
@@ -1465,7 +1464,8 @@ int of_get_fb_videomode(struct device_node *np, struct fb_videomode *fb,
         return 0;
 }
 EXPORT_SYMBOL_GPL(of_get_fb_videomode);
-#endif
+#endif /* CONFIG_OF */
+#endif /* CONFIG_VIDEOMODE_HELPERS */
 
 #else
 int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index 41fbd9453c5f..6c278056fc60 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -375,7 +375,10 @@ struct fsl_diu_data {
         struct diu_ad dummy_ad __aligned(8);
         struct diu_ad ad[NUM_AOIS] __aligned(8);
         u8 gamma[256 * 3] __aligned(32);
-        u8 cursor[MAX_CURS * MAX_CURS * 2] __aligned(32);
+        /* It's easier to parse the cursor data as little-endian */
+        __le16 cursor[MAX_CURS * MAX_CURS] __aligned(32);
+        /* Blank cursor data -- used to hide the cursor */
+        __le16 blank_cursor[MAX_CURS * MAX_CURS] __aligned(32);
         uint8_t edid_data[EDID_LENGTH];
         bool has_edid;
 } __aligned(32);
@@ -824,7 +827,6 @@ static void update_lcdc(struct fb_info *info)
         /* Program DIU registers */
 
         out_be32(&hw->gamma, DMA_ADDR(data, gamma));
-        out_be32(&hw->cursor, DMA_ADDR(data, cursor));
 
         out_be32(&hw->bgnd, 0x007F7F7F); /* Set background to grey */
         out_be32(&hw->disp_size, (var->yres << 16) | var->xres);
@@ -968,6 +970,156 @@ static u32 fsl_diu_get_pixel_format(unsigned int bits_per_pixel)
 }
 
 /*
+ * Copies a cursor image from user space to the proper place in driver
+ * memory so that the hardware can display the cursor image.
+ *
+ * Cursor data is represented as a sequence of 'width' bits packed into bytes.
+ * That is, the first 8 bits are in the first byte, the second 8 bits in the
+ * second byte, and so on.  Therefore, the each row of the cursor is (width +
+ * 7) / 8 bytes of 'data'
+ *
+ * The DIU only supports cursors up to 32x32 (MAX_CURS).  We reject cursors
+ * larger than this, so we already know that 'width' <= 32.  Therefore, we can
+ * simplify our code by using a 32-bit big-endian integer ("line") to read in
+ * a single line of pixels, and only look at the top 'width' bits of that
+ * integer.
+ *
+ * This could result in an unaligned 32-bit read.  For example, if the cursor
+ * is 24x24, then the first three bytes of 'image' contain the pixel data for
+ * the top line of the cursor.  We do a 32-bit read of 'image', but we look
+ * only at the top 24 bits.  Then we increment 'image' by 3 bytes.  The next
+ * read is unaligned.  The only problem is that we might read past the end of
+ * 'image' by 1-3 bytes, but that should not cause any problems.
+ */
+static void fsl_diu_load_cursor_image(struct fb_info *info,
+        const void *image, uint16_t bg, uint16_t fg,
+        unsigned int width, unsigned int height)
+{
+        struct mfb_info *mfbi = info->par;
+        struct fsl_diu_data *data = mfbi->parent;
+        __le16 *cursor = data->cursor;
+        __le16 _fg = cpu_to_le16(fg);
+        __le16 _bg = cpu_to_le16(bg);
+        unsigned int h, w;
+
+        for (h = 0; h < height; h++) {
+                uint32_t mask = 1 << 31;
+                uint32_t line = be32_to_cpup(image);
+
+                for (w = 0; w < width; w++) {
+                        cursor[w] = (line & mask) ? _fg : _bg;
+                        mask >>= 1;
+                }
+
+                cursor += MAX_CURS;
+                image += DIV_ROUND_UP(width, 8);
+        }
+}
+
+/*
+ * Set a hardware cursor.  The image data for the cursor is passed via the
+ * fb_cursor object.
+ */
+static int fsl_diu_cursor(struct fb_info *info, struct fb_cursor *cursor)
+{
+        struct mfb_info *mfbi = info->par;
+        struct fsl_diu_data *data = mfbi->parent;
+        struct diu __iomem *hw = data->diu_reg;
+
+        if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)
+                return -EINVAL;
+
+        /* The cursor size has changed */
+        if (cursor->set & FB_CUR_SETSIZE) {
+                /*
+                 * The DIU cursor is a fixed size, so when we get this
+                 * message, instead of resizing the cursor, we just clear
+                 * all the image data, in expectation of new data.  However,
+                 * in tests this control does not appear to be normally
+                 * called.
+                 */
+                memset(data->cursor, 0, sizeof(data->cursor));
+        }
+
+        /* The cursor position has changed (cursor->image.dx|dy) */
+        if (cursor->set & FB_CUR_SETPOS) {
+                uint32_t xx, yy;
+
+                yy = (cursor->image.dy - info->var.yoffset) & 0x7ff;
+                xx = (cursor->image.dx - info->var.xoffset) & 0x7ff;
+
+                out_be32(&hw->curs_pos, yy << 16 | xx);
+        }
+
+        /*
+         * FB_CUR_SETIMAGE - the cursor image has changed
+         * FB_CUR_SETCMAP  - the cursor colors has changed
+         * FB_CUR_SETSHAPE - the cursor bitmask has changed
+         */
+        if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP | FB_CUR_SETIMAGE)) {
+                unsigned int image_size =
+                        DIV_ROUND_UP(cursor->image.width, 8) * cursor->image.height;
+                unsigned int image_words =
+                        DIV_ROUND_UP(image_size, sizeof(uint32_t));
+                unsigned int bg_idx = cursor->image.bg_color;
+                unsigned int fg_idx = cursor->image.fg_color;
+                uint8_t buffer[image_size];
+                uint32_t *image, *source, *mask;
+                uint16_t fg, bg;
+                unsigned int i;
+
+                if (info->state != FBINFO_STATE_RUNNING)
+                        return 0;
+
+                /*
+                 * Determine the size of the cursor image data.  Normally,
+                 * it's 8x16.
+                 */
+                image_size = DIV_ROUND_UP(cursor->image.width, 8) *
+                        cursor->image.height;
+
+                bg = ((info->cmap.red[bg_idx] & 0xf8) << 7) |
+                     ((info->cmap.green[bg_idx] & 0xf8) << 2) |
+                     ((info->cmap.blue[bg_idx] & 0xf8) >> 3) |
+                     1 << 15;
+
+                fg = ((info->cmap.red[fg_idx] & 0xf8) << 7) |
+                     ((info->cmap.green[fg_idx] & 0xf8) << 2) |
+                     ((info->cmap.blue[fg_idx] & 0xf8) >> 3) |
+                     1 << 15;
+
+                /* Use 32-bit operations on the data to improve performance */
+                image = (uint32_t *)buffer;
+                source = (uint32_t *)cursor->image.data;
+                mask = (uint32_t *)cursor->mask;
+
+                if (cursor->rop == ROP_XOR)
+                        for (i = 0; i < image_words; i++)
+                                image[i] = source[i] ^ mask[i];
+                else
+                        for (i = 0; i < image_words; i++)
+                                image[i] = source[i] & mask[i];
+
+                fsl_diu_load_cursor_image(info, image, bg, fg,
+                        cursor->image.width, cursor->image.height);
+        };
+
+        /*
+         * Show or hide the cursor.  The cursor data is always stored in the
+         * 'cursor' memory block, and the actual cursor position is always in
+         * the DIU's CURS_POS register.  To hide the cursor, we redirect the
+         * CURSOR register to a blank cursor.  The show the cursor, we
+         * redirect the CURSOR register to the real cursor data.
+         */
+        if (cursor->enable)
+                out_be32(&hw->cursor, DMA_ADDR(data, cursor));
+        else
+                out_be32(&hw->cursor, DMA_ADDR(data, blank_cursor));
+
+        return 0;
+}
+
+/*
  * Using the fb_var_screeninfo in fb_info we set the resolution of this
  * particular framebuffer. This function alters the fb_fix_screeninfo stored
  * in fb_info. It does not alter var in fb_info since we are using that
@@ -1312,6 +1464,7 @@ static struct fb_ops fsl_diu_ops = {
         .fb_ioctl = fsl_diu_ioctl,
         .fb_open = fsl_diu_open,
         .fb_release = fsl_diu_release,
+        .fb_cursor = fsl_diu_cursor,
 };
 
 static int install_fb(struct fb_info *info)
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index bda5e3941510..ceab37020fff 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -1016,7 +1016,9 @@ static int gbefb_mmap(struct fb_info *info,
         /* check range */
         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
                 return -EINVAL;
-        if (offset + size > gbe_mem_size)
+        if (size > gbe_mem_size)
+                return -EINVAL;
+        if (offset > gbe_mem_size - size)
                 return -EINVAL;
 
         /* remap using the fastest write-through mode on architecture */
diff --git a/drivers/video/goldfishfb.c b/drivers/video/goldfishfb.c
index 489abb32fc04..7f6c9e6cfc6c 100644
--- a/drivers/video/goldfishfb.c
+++ b/drivers/video/goldfishfb.c
@@ -148,7 +148,7 @@ static int goldfish_fb_pan_display(struct fb_var_screeninfo *var,
         wait_event_timeout(fb->wait,
                         fb->base_update_count != base_update_count, HZ / 15);
         if (fb->base_update_count == base_update_count)
-                pr_err("goldfish_fb_pan_display: timeout wating for base update\n");
+                pr_err("goldfish_fb_pan_display: timeout waiting for base update\n");
         return 0;
 }
 
diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c
index ab23c9b79143..40178338b619 100644
--- a/drivers/video/hdmi.c
+++ b/drivers/video/hdmi.c
@@ -1,9 +1,24 @@
 /*
  * Copyright (C) 2012 Avionic Design GmbH
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
  */
 
 #include <linux/bitops.h>
diff --git a/drivers/video/hyperv_fb.c b/drivers/video/hyperv_fb.c
new file mode 100644
index 000000000000..d4d2c5fe2488
--- /dev/null
+++ b/drivers/video/hyperv_fb.c
@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2012, Microsoft Corporation.
+ *
+ * Author:
+ *   Haiyang Zhang <haiyangz@microsoft.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ */
+
+/*
+ * Hyper-V Synthetic Video Frame Buffer Driver
+ *
+ * This is the driver for the Hyper-V Synthetic Video, which supports
+ * screen resolution up to Full HD 1920x1080 with 32 bit color on Windows
+ * Server 2012, and 1600x1200 with 16 bit color on Windows Server 2008 R2
+ * or earlier.
+ *
+ * It also solves the double mouse cursor issue of the emulated video mode.
+ *
+ * The default screen resolution is 1152x864, which may be changed by a
+ * kernel parameter:
+ *     video=hyperv_fb:<width>x<height>
+ *     For example: video=hyperv_fb:1280x1024
+ *
+ * Portrait orientation is also supported:
+ *     For example: video=hyperv_fb:864x1152
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/completion.h>
+#include <linux/fb.h>
+#include <linux/pci.h>
+
+#include <linux/hyperv.h>
+
+
+/* Hyper-V Synthetic Video Protocol definitions and structures */
+#define MAX_VMBUS_PKT_SIZE 0x4000
+
+#define SYNTHVID_VERSION(major, minor) ((minor) << 16 | (major))
+#define SYNTHVID_VERSION_WIN7 SYNTHVID_VERSION(3, 0)
+#define SYNTHVID_VERSION_WIN8 SYNTHVID_VERSION(3, 2)
+
+#define SYNTHVID_DEPTH_WIN7 16
+#define SYNTHVID_DEPTH_WIN8 32
+
+#define SYNTHVID_FB_SIZE_WIN7 (4 * 1024 * 1024)
+#define SYNTHVID_WIDTH_MAX_WIN7 1600
+#define SYNTHVID_HEIGHT_MAX_WIN7 1200
+
+#define SYNTHVID_FB_SIZE_WIN8 (8 * 1024 * 1024)
+
+#define PCI_VENDOR_ID_MICROSOFT 0x1414
+#define PCI_DEVICE_ID_HYPERV_VIDEO 0x5353
+
+
+enum pipe_msg_type {
+        PIPE_MSG_INVALID,
+        PIPE_MSG_DATA,
+        PIPE_MSG_MAX
+};
+
+struct pipe_msg_hdr {
+        u32 type;
+        u32 size; /* size of message after this field */
+} __packed;
+
+
+enum synthvid_msg_type {
+        SYNTHVID_ERROR                  = 0,
+        SYNTHVID_VERSION_REQUEST        = 1,
+        SYNTHVID_VERSION_RESPONSE       = 2,
+        SYNTHVID_VRAM_LOCATION          = 3,
+        SYNTHVID_VRAM_LOCATION_ACK      = 4,
+        SYNTHVID_SITUATION_UPDATE       = 5,
+        SYNTHVID_SITUATION_UPDATE_ACK   = 6,
+        SYNTHVID_POINTER_POSITION       = 7,
+        SYNTHVID_POINTER_SHAPE          = 8,
+        SYNTHVID_FEATURE_CHANGE         = 9,
+        SYNTHVID_DIRT                   = 10,
+
+        SYNTHVID_MAX                    = 11
+};
+
+struct synthvid_msg_hdr {
+        u32 type;
+        u32 size;  /* size of this header + payload after this field*/
+} __packed;
+
+
+struct synthvid_version_req {
+        u32 version;
+} __packed;
+
+struct synthvid_version_resp {
+        u32 version;
+        u8 is_accepted;
+        u8 max_video_outputs;
+} __packed;
+
+struct synthvid_vram_location {
+        u64 user_ctx;
+        u8 is_vram_gpa_specified;
+        u64 vram_gpa;
+} __packed;
+
+struct synthvid_vram_location_ack {
+        u64 user_ctx;
+} __packed;
+
+struct video_output_situation {
+        u8 active;
+        u32 vram_offset;
+        u8 depth_bits;
+        u32 width_pixels;
+        u32 height_pixels;
+        u32 pitch_bytes;
+} __packed;
+
+struct synthvid_situation_update {
+        u64 user_ctx;
+        u8 video_output_count;
+        struct video_output_situation video_output[1];
+} __packed;
+
+struct synthvid_situation_update_ack {
+        u64 user_ctx;
+} __packed;
+
+struct synthvid_pointer_position {
+        u8 is_visible;
+        u8 video_output;
+        s32 image_x;
+        s32 image_y;
+} __packed;
+
+
+#define CURSOR_MAX_X 96
+#define CURSOR_MAX_Y 96
+#define CURSOR_ARGB_PIXEL_SIZE 4
+#define CURSOR_MAX_SIZE (CURSOR_MAX_X * CURSOR_MAX_Y * CURSOR_ARGB_PIXEL_SIZE)
+#define CURSOR_COMPLETE (-1)
+
+struct synthvid_pointer_shape {
+        u8 part_idx;
+        u8 is_argb;
+        u32 width; /* CURSOR_MAX_X at most */
+        u32 height; /* CURSOR_MAX_Y at most */
+        u32 hot_x; /* hotspot relative to upper-left of pointer image */
+        u32 hot_y;
+        u8 data[4];
+} __packed;
+
+struct synthvid_feature_change {
+        u8 is_dirt_needed;
+        u8 is_ptr_pos_needed;
+        u8 is_ptr_shape_needed;
+        u8 is_situ_needed;
+} __packed;
+
+struct rect {
+        s32 x1, y1; /* top left corner */
+        s32 x2, y2; /* bottom right corner, exclusive */
+} __packed;
+
+struct synthvid_dirt {
+        u8 video_output;
+        u8 dirt_count;
+        struct rect rect[1];
+} __packed;
+
+struct synthvid_msg {
+        struct pipe_msg_hdr pipe_hdr;
+        struct synthvid_msg_hdr vid_hdr;
+        union {
+                struct synthvid_version_req ver_req;
+                struct synthvid_version_resp ver_resp;
+                struct synthvid_vram_location vram;
+                struct synthvid_vram_location_ack vram_ack;
+                struct synthvid_situation_update situ;
+                struct synthvid_situation_update_ack situ_ack;
+                struct synthvid_pointer_position ptr_pos;
+                struct synthvid_pointer_shape ptr_shape;
+                struct synthvid_feature_change feature_chg;
+                struct synthvid_dirt dirt;
+        };
+} __packed;
+
+
+
+/* FB driver definitions and structures */
+#define HVFB_WIDTH 1152 /* default screen width */
+#define HVFB_HEIGHT 864 /* default screen height */
+#define HVFB_WIDTH_MIN 640
+#define HVFB_HEIGHT_MIN 480
+
+#define RING_BUFSIZE (256 * 1024)
+#define VSP_TIMEOUT (10 * HZ)
+#define HVFB_UPDATE_DELAY (HZ / 20)
+
+struct hvfb_par {
+        struct fb_info *info;
+        bool fb_ready; /* fb device is ready */
+        struct completion wait;
+        u32 synthvid_version;
+
+        struct delayed_work dwork;
+        bool update;
+
+        u32 pseudo_palette[16];
+        u8 init_buf[MAX_VMBUS_PKT_SIZE];
+        u8 recv_buf[MAX_VMBUS_PKT_SIZE];
+};
+
+static uint screen_width = HVFB_WIDTH;
+static uint screen_height = HVFB_HEIGHT;
+static uint screen_depth;
+static uint screen_fb_size;
+
+/* Send message to Hyper-V host */
+static inline int synthvid_send(struct hv_device *hdev,
+                                struct synthvid_msg *msg)
+{
+        static atomic64_t request_id = ATOMIC64_INIT(0);
+        int ret;
+
+        msg->pipe_hdr.type = PIPE_MSG_DATA;
+        msg->pipe_hdr.size = msg->vid_hdr.size;
+
+        ret = vmbus_sendpacket(hdev->channel, msg,
+                               msg->vid_hdr.size + sizeof(struct pipe_msg_hdr),
+                               atomic64_inc_return(&request_id),
+                               VM_PKT_DATA_INBAND, 0);
+
+        if (ret)
+                pr_err("Unable to send packet via vmbus\n");
+
+        return ret;
+}
+
+
+/* Send screen resolution info to host */
+static int synthvid_send_situ(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct synthvid_msg msg;
+
+        if (!info)
+                return -ENODEV;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+
+        msg.vid_hdr.type = SYNTHVID_SITUATION_UPDATE;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_situation_update);
+        msg.situ.user_ctx = 0;
+        msg.situ.video_output_count = 1;
+        msg.situ.video_output[0].active = 1;
+        msg.situ.video_output[0].vram_offset = 0;
+        msg.situ.video_output[0].depth_bits = info->var.bits_per_pixel;
+        msg.situ.video_output[0].width_pixels = info->var.xres;
+        msg.situ.video_output[0].height_pixels = info->var.yres;
+        msg.situ.video_output[0].pitch_bytes = info->fix.line_length;
+
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+/* Send mouse pointer info to host */
+static int synthvid_send_ptr(struct hv_device *hdev)
+{
+        struct synthvid_msg msg;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+        msg.vid_hdr.type = SYNTHVID_POINTER_POSITION;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_pointer_position);
+        msg.ptr_pos.is_visible = 1;
+        msg.ptr_pos.video_output = 0;
+        msg.ptr_pos.image_x = 0;
+        msg.ptr_pos.image_y = 0;
+        synthvid_send(hdev, &msg);
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+        msg.vid_hdr.type = SYNTHVID_POINTER_SHAPE;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_pointer_shape);
+        msg.ptr_shape.part_idx = CURSOR_COMPLETE;
+        msg.ptr_shape.is_argb = 1;
+        msg.ptr_shape.width = 1;
+        msg.ptr_shape.height = 1;
+        msg.ptr_shape.hot_x = 0;
+        msg.ptr_shape.hot_y = 0;
+        msg.ptr_shape.data[0] = 0;
+        msg.ptr_shape.data[1] = 1;
+        msg.ptr_shape.data[2] = 1;
+        msg.ptr_shape.data[3] = 1;
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+/* Send updated screen area (dirty rectangle) location to host */
+static int synthvid_update(struct fb_info *info)
+{
+        struct hv_device *hdev = device_to_hv_device(info->device);
+        struct synthvid_msg msg;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+
+        msg.vid_hdr.type = SYNTHVID_DIRT;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_dirt);
+        msg.dirt.video_output = 0;
+        msg.dirt.dirt_count = 1;
+        msg.dirt.rect[0].x1 = 0;
+        msg.dirt.rect[0].y1 = 0;
+        msg.dirt.rect[0].x2 = info->var.xres;
+        msg.dirt.rect[0].y2 = info->var.yres;
+
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+
+/*
+ * Actions on received messages from host:
+ * Complete the wait event.
+ * Or, reply with screen and cursor info.
+ */
+static void synthvid_recv_sub(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par;
+        struct synthvid_msg *msg;
+
+        if (!info)
+                return;
+
+        par = info->par;
+        msg = (struct synthvid_msg *)par->recv_buf;
+
+        /* Complete the wait event */
+        if (msg->vid_hdr.type == SYNTHVID_VERSION_RESPONSE ||
+            msg->vid_hdr.type == SYNTHVID_VRAM_LOCATION_ACK) {
+                memcpy(par->init_buf, msg, MAX_VMBUS_PKT_SIZE);
+                complete(&par->wait);
+                return;
+        }
+
+        /* Reply with screen and cursor info */
+        if (msg->vid_hdr.type == SYNTHVID_FEATURE_CHANGE) {
+                if (par->fb_ready) {
+                        synthvid_send_ptr(hdev);
+                        synthvid_send_situ(hdev);
+                }
+
+                par->update = msg->feature_chg.is_dirt_needed;
+                if (par->update)
+                        schedule_delayed_work(&par->dwork, HVFB_UPDATE_DELAY);
+        }
+}
+
+/* Receive callback for messages from the host */
+static void synthvid_receive(void *ctx)
+{
+        struct hv_device *hdev = ctx;
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par;
+        struct synthvid_msg *recv_buf;
+        u32 bytes_recvd;
+        u64 req_id;
+        int ret;
+
+        if (!info)
+                return;
+
+        par = info->par;
+        recv_buf = (struct synthvid_msg *)par->recv_buf;
+
+        do {
+                ret = vmbus_recvpacket(hdev->channel, recv_buf,
+                                       MAX_VMBUS_PKT_SIZE,
+                                       &bytes_recvd, &req_id);
+                if (bytes_recvd > 0 &&
+                    recv_buf->pipe_hdr.type == PIPE_MSG_DATA)
+                        synthvid_recv_sub(hdev);
+        } while (bytes_recvd > 0 && ret == 0);
+}
+
+/* Check synthetic video protocol version with the host */
+static int synthvid_negotiate_ver(struct hv_device *hdev, u32 ver)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        struct synthvid_msg *msg = (struct synthvid_msg *)par->init_buf;
+        int t, ret = 0;
+
+        memset(msg, 0, sizeof(struct synthvid_msg));
+        msg->vid_hdr.type = SYNTHVID_VERSION_REQUEST;
+        msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_version_req);
+        msg->ver_req.version = ver;
+        synthvid_send(hdev, msg);
+
+        t = wait_for_completion_timeout(&par->wait, VSP_TIMEOUT);
+        if (!t) {
+                pr_err("Time out on waiting version response\n");
+                ret = -ETIMEDOUT;
+                goto out;
+        }
+        if (!msg->ver_resp.is_accepted) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        par->synthvid_version = ver;
+
+out:
+        return ret;
+}
+
+/* Connect to VSP (Virtual Service Provider) on host */
+static int synthvid_connect_vsp(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        int ret;
+
+        ret = vmbus_open(hdev->channel, RING_BUFSIZE, RING_BUFSIZE,
+                         NULL, 0, synthvid_receive, hdev);
+        if (ret) {
+                pr_err("Unable to open vmbus channel\n");
+                return ret;
+        }
+
+        /* Negotiate the protocol version with host */
+        if (vmbus_proto_version == VERSION_WS2008 ||
+            vmbus_proto_version == VERSION_WIN7)
+                ret = synthvid_negotiate_ver(hdev, SYNTHVID_VERSION_WIN7);
+        else
+                ret = synthvid_negotiate_ver(hdev, SYNTHVID_VERSION_WIN8);
+
+        if (ret) {
+                pr_err("Synthetic video device version not accepted\n");
+                goto error;
+        }
+
+        if (par->synthvid_version == SYNTHVID_VERSION_WIN7) {
+                screen_depth = SYNTHVID_DEPTH_WIN7;
+                screen_fb_size = SYNTHVID_FB_SIZE_WIN7;
+        } else {
+                screen_depth = SYNTHVID_DEPTH_WIN8;
+                screen_fb_size = SYNTHVID_FB_SIZE_WIN8;
+        }
+
+        return 0;
+
+error:
+        vmbus_close(hdev->channel);
+        return ret;
+}
+
+/* Send VRAM and Situation messages to the host */
+static int synthvid_send_config(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        struct synthvid_msg *msg = (struct synthvid_msg *)par->init_buf;
+        int t, ret = 0;
+
+        /* Send VRAM location */
+        memset(msg, 0, sizeof(struct synthvid_msg));
+        msg->vid_hdr.type = SYNTHVID_VRAM_LOCATION;
+        msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_vram_location);
+        msg->vram.user_ctx = msg->vram.vram_gpa = info->fix.smem_start;
+        msg->vram.is_vram_gpa_specified = 1;
+        synthvid_send(hdev, msg);
+
+        t = wait_for_completion_timeout(&par->wait, VSP_TIMEOUT);
+        if (!t) {
+                pr_err("Time out on waiting vram location ack\n");
+                ret = -ETIMEDOUT;
+                goto out;
+        }
+        if (msg->vram_ack.user_ctx != info->fix.smem_start) {
+                pr_err("Unable to set VRAM location\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        /* Send pointer and situation update */
+        synthvid_send_ptr(hdev);
+        synthvid_send_situ(hdev);
+
+out:
+        return ret;
+}
+
+
+/*
+ * Delayed work callback:
+ * It is called at HVFB_UPDATE_DELAY or longer time interval to process
+ * screen updates. It is re-scheduled if further update is necessary.
+ */
+static void hvfb_update_work(struct work_struct *w)
+{
+        struct hvfb_par *par = container_of(w, struct hvfb_par, dwork.work);
+        struct fb_info *info = par->info;
+
+        if (par->fb_ready)
+                synthvid_update(info);
+
+        if (par->update)
+                schedule_delayed_work(&par->dwork, HVFB_UPDATE_DELAY);
+}
+
+
+/* Framebuffer operation handlers */
+
+static int hvfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        if (var->xres < HVFB_WIDTH_MIN || var->yres < HVFB_HEIGHT_MIN ||
+            var->xres > screen_width || var->yres >  screen_height ||
+            var->bits_per_pixel != screen_depth)
+                return -EINVAL;
+
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        return 0;
+}
+
+static int hvfb_set_par(struct fb_info *info)
+{
+        struct hv_device *hdev = device_to_hv_device(info->device);
+
+        return synthvid_send_situ(hdev);
+}
+
+
+static inline u32 chan_to_field(u32 chan, struct fb_bitfield *bf)
+{
+        return ((chan & 0xffff) >> (16 - bf->length)) << bf->offset;
+}
+
+static int hvfb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                          unsigned blue, unsigned transp, struct fb_info *info)
+{
+        u32 *pal = info->pseudo_palette;
+
+        if (regno > 15)
+                return -EINVAL;
+
+        pal[regno] = chan_to_field(red, &info->var.red)
+                | chan_to_field(green, &info->var.green)
+                | chan_to_field(blue, &info->var.blue)
+                | chan_to_field(transp, &info->var.transp);
+
+        return 0;
+}
+
+
+static struct fb_ops hvfb_ops = {
+        .owner = THIS_MODULE,
+        .fb_check_var = hvfb_check_var,
+        .fb_set_par = hvfb_set_par,
+        .fb_setcolreg = hvfb_setcolreg,
+        .fb_fillrect = cfb_fillrect,
+        .fb_copyarea = cfb_copyarea,
+        .fb_imageblit = cfb_imageblit,
+};
+
+
+/* Get options from kernel paramenter "video=" */
+static void hvfb_get_option(struct fb_info *info)
+{
+        struct hvfb_par *par = info->par;
+        char *opt = NULL, *p;
+        uint x = 0, y = 0;
+
+        if (fb_get_options(KBUILD_MODNAME, &opt) || !opt || !*opt)
+                return;
+
+        p = strsep(&opt, "x");
+        if (!*p || kstrtouint(p, 0, &x) ||
+            !opt || !*opt || kstrtouint(opt, 0, &y)) {
+                pr_err("Screen option is invalid: skipped\n");
+                return;
+        }
+
+        if (x < HVFB_WIDTH_MIN || y < HVFB_HEIGHT_MIN ||
+            (par->synthvid_version == SYNTHVID_VERSION_WIN8 &&
+             x * y * screen_depth / 8 > SYNTHVID_FB_SIZE_WIN8) ||
+            (par->synthvid_version == SYNTHVID_VERSION_WIN7 &&
+             (x > SYNTHVID_WIDTH_MAX_WIN7 || y > SYNTHVID_HEIGHT_MAX_WIN7))) {
+                pr_err("Screen resolution option is out of range: skipped\n");
+                return;
+        }
+
+        screen_width = x;
+        screen_height = y;
+        return;
+}
+
+
+/* Get framebuffer memory from Hyper-V video pci space */
+static int hvfb_getmem(struct fb_info *info)
+{
+        struct pci_dev *pdev;
+        ulong fb_phys;
+        void __iomem *fb_virt;
+
+        pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT,
+                              PCI_DEVICE_ID_HYPERV_VIDEO, NULL);
+        if (!pdev) {
+                pr_err("Unable to find PCI Hyper-V video\n");
+                return -ENODEV;
+        }
+
+        if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM) ||
+            pci_resource_len(pdev, 0) < screen_fb_size)
+                goto err1;
+
+        fb_phys = pci_resource_end(pdev, 0) - screen_fb_size + 1;
+        if (!request_mem_region(fb_phys, screen_fb_size, KBUILD_MODNAME))
+                goto err1;
+
+        fb_virt = ioremap(fb_phys, screen_fb_size);
+        if (!fb_virt)
+                goto err2;
+
+        info->apertures = alloc_apertures(1);
+        if (!info->apertures)
+                goto err3;
+
+        info->apertures->ranges[0].base = pci_resource_start(pdev, 0);
+        info->apertures->ranges[0].size = pci_resource_len(pdev, 0);
+        info->fix.smem_start = fb_phys;
+        info->fix.smem_len = screen_fb_size;
+        info->screen_base = fb_virt;
+        info->screen_size = screen_fb_size;
+
+        pci_dev_put(pdev);
+        return 0;
+
+err3:
+        iounmap(fb_virt);
+err2:
+        release_mem_region(fb_phys, screen_fb_size);
+err1:
+        pci_dev_put(pdev);
+        return -ENOMEM;
+}
+
+/* Release the framebuffer */
+static void hvfb_putmem(struct fb_info *info)
+{
+        iounmap(info->screen_base);
+        release_mem_region(info->fix.smem_start, screen_fb_size);
+}
+
+
+static int hvfb_probe(struct hv_device *hdev,
+                      const struct hv_vmbus_device_id *dev_id)
+{
+        struct fb_info *info;
+        struct hvfb_par *par;
+        int ret;
+
+        info = framebuffer_alloc(sizeof(struct hvfb_par), &hdev->device);
+        if (!info) {
+                pr_err("No memory for framebuffer info\n");
+                return -ENOMEM;
+        }
+
+        par = info->par;
+        par->info = info;
+        par->fb_ready = false;
+        init_completion(&par->wait);
+        INIT_DELAYED_WORK(&par->dwork, hvfb_update_work);
+
+        /* Connect to VSP */
+        hv_set_drvdata(hdev, info);
+        ret = synthvid_connect_vsp(hdev);
+        if (ret) {
+                pr_err("Unable to connect to VSP\n");
+                goto error1;
+        }
+
+        ret = hvfb_getmem(info);
+        if (ret) {
+                pr_err("No memory for framebuffer\n");
+                goto error2;
+        }
+
+        hvfb_get_option(info);
+        pr_info("Screen resolution: %dx%d, Color depth: %d\n",
+                screen_width, screen_height, screen_depth);
+
+
+        /* Set up fb_info */
+        info->flags = FBINFO_DEFAULT;
+
+        info->var.xres_virtual = info->var.xres = screen_width;
+        info->var.yres_virtual = info->var.yres = screen_height;
+        info->var.bits_per_pixel = screen_depth;
+
+        if (info->var.bits_per_pixel == 16) {
+                info->var.red = (struct fb_bitfield){11, 5, 0};
+                info->var.green = (struct fb_bitfield){5, 6, 0};
+                info->var.blue = (struct fb_bitfield){0, 5, 0};
+                info->var.transp = (struct fb_bitfield){0, 0, 0};
+        } else {
+                info->var.red = (struct fb_bitfield){16, 8, 0};
+                info->var.green = (struct fb_bitfield){8, 8, 0};
+                info->var.blue = (struct fb_bitfield){0, 8, 0};
+                info->var.transp = (struct fb_bitfield){24, 8, 0};
+        }
+
+        info->var.activate = FB_ACTIVATE_NOW;
+        info->var.height = -1;
+        info->var.width = -1;
+        info->var.vmode = FB_VMODE_NONINTERLACED;
+
+        strcpy(info->fix.id, KBUILD_MODNAME);
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.visual = FB_VISUAL_TRUECOLOR;
+        info->fix.line_length = screen_width * screen_depth / 8;
+        info->fix.accel = FB_ACCEL_NONE;
+
+        info->fbops = &hvfb_ops;
+        info->pseudo_palette = par->pseudo_palette;
+
+        /* Send config to host */
+        ret = synthvid_send_config(hdev);
+        if (ret)
+                goto error;
+
+        ret = register_framebuffer(info);
+        if (ret) {
+                pr_err("Unable to register framebuffer\n");
+                goto error;
+        }
+
+        par->fb_ready = true;
+
+        return 0;
+
+error:
+        hvfb_putmem(info);
+error2:
+        vmbus_close(hdev->channel);
+error1:
+        cancel_delayed_work_sync(&par->dwork);
+        hv_set_drvdata(hdev, NULL);
+        framebuffer_release(info);
+        return ret;
+}
+
+
+static int hvfb_remove(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+
+        par->update = false;
+        par->fb_ready = false;
+
+        unregister_framebuffer(info);
+        cancel_delayed_work_sync(&par->dwork);
+
+        vmbus_close(hdev->channel);
+        hv_set_drvdata(hdev, NULL);
+
+        hvfb_putmem(info);
+        framebuffer_release(info);
+
+        return 0;
+}
+
+
+static const struct hv_vmbus_device_id id_table[] = {
+        /* Synthetic Video Device GUID */
+        {HV_SYNTHVID_GUID},
+        {}
+};
+
+MODULE_DEVICE_TABLE(vmbus, id_table);
+
+static struct hv_driver hvfb_drv = {
+        .name = KBUILD_MODNAME,
+        .id_table = id_table,
+        .probe = hvfb_probe,
+        .remove = hvfb_remove,
+};
+
+
+static int __init hvfb_drv_init(void)
+{
+        return vmbus_driver_register(&hvfb_drv);
+}
+
+static void __exit hvfb_drv_exit(void)
+{
+        vmbus_driver_unregister(&hvfb_drv);
+}
+
+module_init(hvfb_drv_init);
+module_exit(hvfb_drv_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_VERSION(HV_DRV_VERSION);
+MODULE_DESCRIPTION("Microsoft Hyper-V Synthetic Video Frame Buffer Driver");
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index 217678e0b983..fd2897455696 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -137,8 +137,20 @@ static int* get_ctrl_ptr(struct maven_data* md, int idx) {
 
 static int maven_get_reg(struct i2c_client* c, char reg) {
         char dst;
-        struct i2c_msg msgs[] = {{ c->addr, I2C_M_REV_DIR_ADDR, sizeof(reg), &reg },
-                                 { c->addr, I2C_M_RD | I2C_M_NOSTART, sizeof(dst), &dst }};
+        struct i2c_msg msgs[] = {
+                {
+                        .addr = c->addr,
+                        .flags = I2C_M_REV_DIR_ADDR,
+                        .len = sizeof(reg),
+                        .buf = &reg
+                },
+                {
+                        .addr = c->addr,
+                        .flags = I2C_M_RD | I2C_M_NOSTART,
+                        .len = sizeof(dst),
+                        .buf = &dst
+                }
+        };
         s32 err;
 
         err = i2c_transfer(c->adapter, msgs, 2);
diff --git a/drivers/video/mmp/core.c b/drivers/video/mmp/core.c
index 9ed83419038b..84de2632857a 100644
--- a/drivers/video/mmp/core.c
+++ b/drivers/video/mmp/core.c
@@ -252,7 +252,5 @@ void mmp_unregister_path(struct mmp_path *path)
 
         kfree(path);
         mutex_unlock(&disp_lock);
-
-        dev_info(path->dev, "de-register %s\n", path->name);
 }
 EXPORT_SYMBOL_GPL(mmp_unregister_path);
diff --git a/drivers/video/mmp/hw/mmp_ctrl.h b/drivers/video/mmp/hw/mmp_ctrl.h
index 6408d8ef3abb..edd2002b0e99 100644
--- a/drivers/video/mmp/hw/mmp_ctrl.h
+++ b/drivers/video/mmp/hw/mmp_ctrl.h
@@ -961,56 +961,7 @@ struct lcd_regs {
         LCD_TVG_CUTVLN : PN2_LCD_GRA_CUTVLN) : LCD_GRA_CUTVLN)
 
 /*
- * defined Video Memory Color format for DMA control 0 register
- * DMA0 bit[23:20]
- */
-#define VMODE_RGB565            0x0
-#define VMODE_RGB1555           0x1
-#define VMODE_RGB888PACKED      0x2
-#define VMODE_RGB888UNPACKED    0x3
-#define VMODE_RGBA888           0x4
-#define VMODE_YUV422PACKED      0x5
-#define VMODE_YUV422PLANAR      0x6
-#define VMODE_YUV420PLANAR      0x7
-#define VMODE_SMPNCMD           0x8
-#define VMODE_PALETTE4BIT       0x9
-#define VMODE_PALETTE8BIT       0xa
-#define VMODE_RESERVED          0xb
-
-/*
- * defined Graphic Memory Color format for DMA control 0 register
- * DMA0 bit[19:16]
- */
-#define GMODE_RGB565            0x0
-#define GMODE_RGB1555           0x1
-#define GMODE_RGB888PACKED      0x2
-#define GMODE_RGB888UNPACKED    0x3
-#define GMODE_RGBA888           0x4
-#define GMODE_YUV422PACKED      0x5
-#define GMODE_YUV422PLANAR      0x6
-#define GMODE_YUV420PLANAR      0x7
-#define GMODE_SMPNCMD           0x8
-#define GMODE_PALETTE4BIT       0x9
-#define GMODE_PALETTE8BIT       0xa
-#define GMODE_RESERVED          0xb
-
-/*
- * define for DMA control 1 register
- */
-#define DMA1_FRAME_TRIG         31 /* bit location */
-#define DMA1_VSYNC_MODE         28
-#define DMA1_VSYNC_INV          27
-#define DMA1_CKEY               24
-#define DMA1_CARRY              23
-#define DMA1_LNBUF_ENA          22
-#define DMA1_GATED_ENA          21
-#define DMA1_PWRDN_ENA          20
-#define DMA1_DSCALE             18
-#define DMA1_ALPHA_MODE         16
-#define DMA1_ALPHA              08
-#define DMA1_PXLCMD             00
-
-/*
+ * defined for Configure Dumb Mode
  * defined for Configure Dumb Mode
  * DUMB LCD Panel bit[31:28]
  */
@@ -1050,18 +1001,6 @@ struct lcd_regs {
 #define  CFG_CYC_BURST_LEN16                    (1<<4)
 #define  CFG_CYC_BURST_LEN8                     (0<<4)
 
-/*
- * defined Dumb Panel Clock Divider register
- * SCLK_Source bit[31]
- */
- /* 0: PLL clock select*/
-#define AXI_BUS_SEL                     0x80000000
-#define CCD_CLK_SEL                     0x40000000
-#define DCON_CLK_SEL                    0x20000000
-#define ENA_CLK_INT_DIV                 CONFIG_FB_DOVE_CLCD_SCLK_DIV
-#define IDLE_CLK_INT_DIV                0x1       /* idle Integer Divider */
-#define DIS_CLK_INT_DIV                 0x0       /* Disable Integer Divider */
-
 /* SRAM ID */
 #define SRAMID_GAMMA_YR                 0x0
 #define SRAMID_GAMMA_UG                 0x1
@@ -1471,422 +1410,6 @@ struct dsi_regs {
 #define LVDS_FREQ_OFFSET_MODE_CK_DIV4_OUT       (0x1 << 1)
 #define LVDS_FREQ_OFFSET_MODE_EN                (0x1 << 0)
 
-/* VDMA */
-struct vdma_ch_regs {
-#define VDMA_DC_SADDR_1         0x320
-#define VDMA_DC_SADDR_2         0x3A0
-#define VDMA_DC_SZ_1            0x324
-#define VDMA_DC_SZ_2            0x3A4
-#define VDMA_CTRL_1             0x328
-#define VDMA_CTRL_2             0x3A8
-#define VDMA_SRC_SZ_1           0x32C
-#define VDMA_SRC_SZ_2           0x3AC
-#define VDMA_SA_1               0x330
-#define VDMA_SA_2               0x3B0
-#define VDMA_DA_1               0x334
-#define VDMA_DA_2               0x3B4
-#define VDMA_SZ_1               0x338
-#define VDMA_SZ_2               0x3B8
-        u32     dc_saddr;
-        u32     dc_size;
-        u32     ctrl;
-        u32     src_size;
-        u32     src_addr;
-        u32     dst_addr;
-        u32     dst_size;
-#define VDMA_PITCH_1            0x33C
-#define VDMA_PITCH_2            0x3BC
-#define VDMA_ROT_CTRL_1         0x340
-#define VDMA_ROT_CTRL_2         0x3C0
-#define VDMA_RAM_CTRL0_1        0x344
-#define VDMA_RAM_CTRL0_2        0x3C4
-#define VDMA_RAM_CTRL1_1        0x348
-#define VDMA_RAM_CTRL1_2        0x3C8
-        u32     pitch;
-        u32     rot_ctrl;
-        u32     ram_ctrl0;
-        u32     ram_ctrl1;
-
-};
-struct vdma_regs {
-#define VDMA_ARBR_CTRL          0x300
-#define VDMA_IRQR               0x304
-#define VDMA_IRQM               0x308
-#define VDMA_IRQS               0x30C
-#define VDMA_MDMA_ARBR_CTRL     0x310
-        u32     arbr_ctr;
-        u32     irq_raw;
-        u32     irq_mask;
-        u32     irq_status;
-        u32     mdma_arbr_ctrl;
-        u32     reserved[3];
-
-        struct vdma_ch_regs     ch1;
-        u32     reserved2[21];
-        struct vdma_ch_regs     ch2;
-};
-
-/* CMU */
-#define CMU_PIP_DE_H_CFG        0x0008
-#define CMU_PRI1_H_CFG          0x000C
-#define CMU_PRI2_H_CFG          0x0010
-#define CMU_ACE_MAIN_DE1_H_CFG  0x0014
-#define CMU_ACE_MAIN_DE2_H_CFG  0x0018
-#define CMU_ACE_PIP_DE1_H_CFG   0x001C
-#define CMU_ACE_PIP_DE2_H_CFG   0x0020
-#define CMU_PIP_DE_V_CFG        0x0024
-#define CMU_PRI_V_CFG           0x0028
-#define CMU_ACE_MAIN_DE_V_CFG   0x002C
-#define CMU_ACE_PIP_DE_V_CFG    0x0030
-#define CMU_BAR_0_CFG           0x0034
-#define CMU_BAR_1_CFG           0x0038
-#define CMU_BAR_2_CFG           0x003C
-#define CMU_BAR_3_CFG           0x0040
-#define CMU_BAR_4_CFG           0x0044
-#define CMU_BAR_5_CFG           0x0048
-#define CMU_BAR_6_CFG           0x004C
-#define CMU_BAR_7_CFG           0x0050
-#define CMU_BAR_8_CFG           0x0054
-#define CMU_BAR_9_CFG           0x0058
-#define CMU_BAR_10_CFG          0x005C
-#define CMU_BAR_11_CFG          0x0060
-#define CMU_BAR_12_CFG          0x0064
-#define CMU_BAR_13_CFG          0x0068
-#define CMU_BAR_14_CFG          0x006C
-#define CMU_BAR_15_CFG          0x0070
-#define CMU_BAR_CTRL            0x0074
-#define PATTERN_TOTAL           0x0078
-#define PATTERN_ACTIVE          0x007C
-#define PATTERN_FRONT_PORCH     0x0080
-#define PATTERN_BACK_PORCH      0x0084
-#define CMU_CLK_CTRL            0x0088
-
-#define CMU_ICSC_M_C0_L         0x0900
-#define CMU_ICSC_M_C0_H         0x0901
-#define CMU_ICSC_M_C1_L         0x0902
-#define CMU_ICSC_M_C1_H         0x0903
-#define CMU_ICSC_M_C2_L         0x0904
-#define CMU_ICSC_M_C2_H         0x0905
-#define CMU_ICSC_M_C3_L         0x0906
-#define CMU_ICSC_M_C3_H         0x0907
-#define CMU_ICSC_M_C4_L         0x0908
-#define CMU_ICSC_M_C4_H         0x0909
-#define CMU_ICSC_M_C5_L         0x090A
-#define CMU_ICSC_M_C5_H         0x090B
-#define CMU_ICSC_M_C6_L         0x090C
-#define CMU_ICSC_M_C6_H         0x090D
-#define CMU_ICSC_M_C7_L         0x090E
-#define CMU_ICSC_M_C7_H         0x090F
-#define CMU_ICSC_M_C8_L         0x0910
-#define CMU_ICSC_M_C8_H         0x0911
-#define CMU_ICSC_M_O1_0         0x0914
-#define CMU_ICSC_M_O1_1         0x0915
-#define CMU_ICSC_M_O1_2         0x0916
-#define CMU_ICSC_M_O2_0         0x0918
-#define CMU_ICSC_M_O2_1         0x0919
-#define CMU_ICSC_M_O2_2         0x091A
-#define CMU_ICSC_M_O3_0         0x091C
-#define CMU_ICSC_M_O3_1         0x091D
-#define CMU_ICSC_M_O3_2         0x091E
-#define CMU_ICSC_P_C0_L         0x0920
-#define CMU_ICSC_P_C0_H         0x0921
-#define CMU_ICSC_P_C1_L         0x0922
-#define CMU_ICSC_P_C1_H         0x0923
-#define CMU_ICSC_P_C2_L         0x0924
-#define CMU_ICSC_P_C2_H         0x0925
-#define CMU_ICSC_P_C3_L         0x0926
-#define CMU_ICSC_P_C3_H         0x0927
-#define CMU_ICSC_P_C4_L         0x0928
-#define CMU_ICSC_P_C4_H         0x0929
-#define CMU_ICSC_P_C5_L         0x092A
-#define CMU_ICSC_P_C5_H         0x092B
-#define CMU_ICSC_P_C6_L         0x092C
-#define CMU_ICSC_P_C6_H         0x092D
-#define CMU_ICSC_P_C7_L         0x092E
-#define CMU_ICSC_P_C7_H         0x092F
-#define CMU_ICSC_P_C8_L         0x0930
-#define CMU_ICSC_P_C8_H         0x0931
-#define CMU_ICSC_P_O1_0         0x0934
-#define CMU_ICSC_P_O1_1         0x0935
-#define CMU_ICSC_P_O1_2         0x0936
-#define CMU_ICSC_P_O2_0         0x0938
-#define CMU_ICSC_P_O2_1         0x0939
-#define CMU_ICSC_P_O2_2         0x093A
-#define CMU_ICSC_P_O3_0         0x093C
-#define CMU_ICSC_P_O3_1         0x093D
-#define CMU_ICSC_P_O3_2         0x093E
-#define CMU_BR_M_EN             0x0940
-#define CMU_BR_M_TH1_L          0x0942
-#define CMU_BR_M_TH1_H          0x0943
-#define CMU_BR_M_TH2_L          0x0944
-#define CMU_BR_M_TH2_H          0x0945
-#define CMU_ACE_M_EN            0x0950
-#define CMU_ACE_M_WFG1          0x0951
-#define CMU_ACE_M_WFG2          0x0952
-#define CMU_ACE_M_WFG3          0x0953
-#define CMU_ACE_M_TH0           0x0954
-#define CMU_ACE_M_TH1           0x0955
-#define CMU_ACE_M_TH2           0x0956
-#define CMU_ACE_M_TH3           0x0957
-#define CMU_ACE_M_TH4           0x0958
-#define CMU_ACE_M_TH5           0x0959
-#define CMU_ACE_M_OP0_L         0x095A
-#define CMU_ACE_M_OP0_H         0x095B
-#define CMU_ACE_M_OP5_L         0x095C
-#define CMU_ACE_M_OP5_H         0x095D
-#define CMU_ACE_M_GB2           0x095E
-#define CMU_ACE_M_GB3           0x095F
-#define CMU_ACE_M_MS1           0x0960
-#define CMU_ACE_M_MS2           0x0961
-#define CMU_ACE_M_MS3           0x0962
-#define CMU_BR_P_EN             0x0970
-#define CMU_BR_P_TH1_L          0x0972
-#define CMU_BR_P_TH1_H          0x0973
-#define CMU_BR_P_TH2_L          0x0974
-#define CMU_BR_P_TH2_H          0x0975
-#define CMU_ACE_P_EN            0x0980
-#define CMU_ACE_P_WFG1          0x0981
-#define CMU_ACE_P_WFG2          0x0982
-#define CMU_ACE_P_WFG3          0x0983
-#define CMU_ACE_P_TH0           0x0984
-#define CMU_ACE_P_TH1           0x0985
-#define CMU_ACE_P_TH2           0x0986
-#define CMU_ACE_P_TH3           0x0987
-#define CMU_ACE_P_TH4           0x0988
-#define CMU_ACE_P_TH5           0x0989
-#define CMU_ACE_P_OP0_L         0x098A
-#define CMU_ACE_P_OP0_H         0x098B
-#define CMU_ACE_P_OP5_L         0x098C
-#define CMU_ACE_P_OP5_H         0x098D
-#define CMU_ACE_P_GB2           0x098E
-#define CMU_ACE_P_GB3           0x098F
-#define CMU_ACE_P_MS1           0x0990
-#define CMU_ACE_P_MS2           0x0991
-#define CMU_ACE_P_MS3           0x0992
-#define CMU_FTDC_M_EN           0x09A0
-#define CMU_FTDC_P_EN           0x09A1
-#define CMU_FTDC_INLOW_L        0x09A2
-#define CMU_FTDC_INLOW_H        0x09A3
-#define CMU_FTDC_INHIGH_L       0x09A4
-#define CMU_FTDC_INHIGH_H       0x09A5
-#define CMU_FTDC_OUTLOW_L       0x09A6
-#define CMU_FTDC_OUTLOW_H       0x09A7
-#define CMU_FTDC_OUTHIGH_L      0x09A8
-#define CMU_FTDC_OUTHIGH_H      0x09A9
-#define CMU_FTDC_YLOW           0x09AA
-#define CMU_FTDC_YHIGH          0x09AB
-#define CMU_FTDC_CH1            0x09AC
-#define CMU_FTDC_CH2_L          0x09AE
-#define CMU_FTDC_CH2_H          0x09AF
-#define CMU_FTDC_CH3_L          0x09B0
-#define CMU_FTDC_CH3_H          0x09B1
-#define CMU_FTDC_1_C00_6        0x09B2
-#define CMU_FTDC_1_C01_6        0x09B8
-#define CMU_FTDC_1_C11_6        0x09BE
-#define CMU_FTDC_1_C10_6        0x09C4
-#define CMU_FTDC_1_OFF00_6      0x09CA
-#define CMU_FTDC_1_OFF10_6      0x09D0
-#define CMU_HS_M_EN             0x0A00
-#define CMU_HS_M_AX1_L          0x0A02
-#define CMU_HS_M_AX1_H          0x0A03
-#define CMU_HS_M_AX2_L          0x0A04
-#define CMU_HS_M_AX2_H          0x0A05
-#define CMU_HS_M_AX3_L          0x0A06
-#define CMU_HS_M_AX3_H          0x0A07
-#define CMU_HS_M_AX4_L          0x0A08
-#define CMU_HS_M_AX4_H          0x0A09
-#define CMU_HS_M_AX5_L          0x0A0A
-#define CMU_HS_M_AX5_H          0x0A0B
-#define CMU_HS_M_AX6_L          0x0A0C
-#define CMU_HS_M_AX6_H          0x0A0D
-#define CMU_HS_M_AX7_L          0x0A0E
-#define CMU_HS_M_AX7_H          0x0A0F
-#define CMU_HS_M_AX8_L          0x0A10
-#define CMU_HS_M_AX8_H          0x0A11
-#define CMU_HS_M_AX9_L          0x0A12
-#define CMU_HS_M_AX9_H          0x0A13
-#define CMU_HS_M_AX10_L         0x0A14
-#define CMU_HS_M_AX10_H         0x0A15
-#define CMU_HS_M_AX11_L         0x0A16
-#define CMU_HS_M_AX11_H         0x0A17
-#define CMU_HS_M_AX12_L         0x0A18
-#define CMU_HS_M_AX12_H         0x0A19
-#define CMU_HS_M_AX13_L         0x0A1A
-#define CMU_HS_M_AX13_H         0x0A1B
-#define CMU_HS_M_AX14_L         0x0A1C
-#define CMU_HS_M_AX14_H         0x0A1D
-#define CMU_HS_M_H1_H14         0x0A1E
-#define CMU_HS_M_S1_S14         0x0A2C
-#define CMU_HS_M_GL             0x0A3A
-#define CMU_HS_M_MAXSAT_RGB_Y_L 0x0A3C
-#define CMU_HS_M_MAXSAT_RGB_Y_H 0x0A3D
-#define CMU_HS_M_MAXSAT_RCR_L   0x0A3E
-#define CMU_HS_M_MAXSAT_RCR_H   0x0A3F
-#define CMU_HS_M_MAXSAT_RCB_L   0x0A40
-#define CMU_HS_M_MAXSAT_RCB_H   0x0A41
-#define CMU_HS_M_MAXSAT_GCR_L   0x0A42
-#define CMU_HS_M_MAXSAT_GCR_H   0x0A43
-#define CMU_HS_M_MAXSAT_GCB_L   0x0A44
-#define CMU_HS_M_MAXSAT_GCB_H   0x0A45
-#define CMU_HS_M_MAXSAT_BCR_L   0x0A46
-#define CMU_HS_M_MAXSAT_BCR_H   0x0A47
-#define CMU_HS_M_MAXSAT_BCB_L   0x0A48
-#define CMU_HS_M_MAXSAT_BCB_H   0x0A49
-#define CMU_HS_M_ROFF_L         0x0A4A
-#define CMU_HS_M_ROFF_H         0x0A4B
-#define CMU_HS_M_GOFF_L         0x0A4C
-#define CMU_HS_M_GOFF_H         0x0A4D
-#define CMU_HS_M_BOFF_L         0x0A4E
-#define CMU_HS_M_BOFF_H         0x0A4F
-#define CMU_HS_P_EN             0x0A50
-#define CMU_HS_P_AX1_L          0x0A52
-#define CMU_HS_P_AX1_H          0x0A53
-#define CMU_HS_P_AX2_L          0x0A54
-#define CMU_HS_P_AX2_H          0x0A55
-#define CMU_HS_P_AX3_L          0x0A56
-#define CMU_HS_P_AX3_H          0x0A57
-#define CMU_HS_P_AX4_L          0x0A58
-#define CMU_HS_P_AX4_H          0x0A59
-#define CMU_HS_P_AX5_L          0x0A5A
-#define CMU_HS_P_AX5_H          0x0A5B
-#define CMU_HS_P_AX6_L          0x0A5C
-#define CMU_HS_P_AX6_H          0x0A5D
-#define CMU_HS_P_AX7_L          0x0A5E
-#define CMU_HS_P_AX7_H          0x0A5F
-#define CMU_HS_P_AX8_L          0x0A60
-#define CMU_HS_P_AX8_H          0x0A61
-#define CMU_HS_P_AX9_L          0x0A62
-#define CMU_HS_P_AX9_H          0x0A63
-#define CMU_HS_P_AX10_L         0x0A64
-#define CMU_HS_P_AX10_H         0x0A65
-#define CMU_HS_P_AX11_L         0x0A66
-#define CMU_HS_P_AX11_H         0x0A67
-#define CMU_HS_P_AX12_L         0x0A68
-#define CMU_HS_P_AX12_H         0x0A69
-#define CMU_HS_P_AX13_L         0x0A6A
-#define CMU_HS_P_AX13_H         0x0A6B
-#define CMU_HS_P_AX14_L         0x0A6C
-#define CMU_HS_P_AX14_H         0x0A6D
-#define CMU_HS_P_H1_H14         0x0A6E
-#define CMU_HS_P_S1_S14         0x0A7C
-#define CMU_HS_P_GL             0x0A8A
-#define CMU_HS_P_MAXSAT_RGB_Y_L 0x0A8C
-#define CMU_HS_P_MAXSAT_RGB_Y_H 0x0A8D
-#define CMU_HS_P_MAXSAT_RCR_L   0x0A8E
-#define CMU_HS_P_MAXSAT_RCR_H   0x0A8F
-#define CMU_HS_P_MAXSAT_RCB_L   0x0A90
-#define CMU_HS_P_MAXSAT_RCB_H   0x0A91
-#define CMU_HS_P_MAXSAT_GCR_L   0x0A92
-#define CMU_HS_P_MAXSAT_GCR_H   0x0A93
-#define CMU_HS_P_MAXSAT_GCB_L   0x0A94
-#define CMU_HS_P_MAXSAT_GCB_H   0x0A95
-#define CMU_HS_P_MAXSAT_BCR_L   0x0A96
-#define CMU_HS_P_MAXSAT_BCR_H   0x0A97
-#define CMU_HS_P_MAXSAT_BCB_L   0x0A98
-#define CMU_HS_P_MAXSAT_BCB_H   0x0A99
-#define CMU_HS_P_ROFF_L         0x0A9A
-#define CMU_HS_P_ROFF_H         0x0A9B
-#define CMU_HS_P_GOFF_L         0x0A9C
-#define CMU_HS_P_GOFF_H         0x0A9D
-#define CMU_HS_P_BOFF_L         0x0A9E
-#define CMU_HS_P_BOFF_H         0x0A9F
-#define CMU_GLCSC_M_C0_L        0x0AA0
-#define CMU_GLCSC_M_C0_H        0x0AA1
-#define CMU_GLCSC_M_C1_L        0x0AA2
-#define CMU_GLCSC_M_C1_H        0x0AA3
-#define CMU_GLCSC_M_C2_L        0x0AA4
-#define CMU_GLCSC_M_C2_H        0x0AA5
-#define CMU_GLCSC_M_C3_L        0x0AA6
-#define CMU_GLCSC_M_C3_H        0x0AA7
-#define CMU_GLCSC_M_C4_L        0x0AA8
-#define CMU_GLCSC_M_C4_H        0x0AA9
-#define CMU_GLCSC_M_C5_L        0x0AAA
-#define CMU_GLCSC_M_C5_H        0x0AAB
-#define CMU_GLCSC_M_C6_L        0x0AAC
-#define CMU_GLCSC_M_C6_H        0x0AAD
-#define CMU_GLCSC_M_C7_L        0x0AAE
-#define CMU_GLCSC_M_C7_H        0x0AAF
-#define CMU_GLCSC_M_C8_L        0x0AB0
-#define CMU_GLCSC_M_C8_H        0x0AB1
-#define CMU_GLCSC_M_O1_1        0x0AB4
-#define CMU_GLCSC_M_O1_2        0x0AB5
-#define CMU_GLCSC_M_O1_3        0x0AB6
-#define CMU_GLCSC_M_O2_1        0x0AB8
-#define CMU_GLCSC_M_O2_2        0x0AB9
-#define CMU_GLCSC_M_O2_3        0x0ABA
-#define CMU_GLCSC_M_O3_1        0x0ABC
-#define CMU_GLCSC_M_O3_2        0x0ABD
-#define CMU_GLCSC_M_O3_3        0x0ABE
-#define CMU_GLCSC_P_C0_L        0x0AC0
-#define CMU_GLCSC_P_C0_H        0x0AC1
-#define CMU_GLCSC_P_C1_L        0x0AC2
-#define CMU_GLCSC_P_C1_H        0x0AC3
-#define CMU_GLCSC_P_C2_L        0x0AC4
-#define CMU_GLCSC_P_C2_H        0x0AC5
-#define CMU_GLCSC_P_C3_L        0x0AC6
-#define CMU_GLCSC_P_C3_H        0x0AC7
-#define CMU_GLCSC_P_C4_L        0x0AC8
-#define CMU_GLCSC_P_C4_H        0x0AC9
-#define CMU_GLCSC_P_C5_L        0x0ACA
-#define CMU_GLCSC_P_C5_H        0x0ACB
-#define CMU_GLCSC_P_C6_L        0x0ACC
-#define CMU_GLCSC_P_C6_H        0x0ACD
-#define CMU_GLCSC_P_C7_L        0x0ACE
-#define CMU_GLCSC_P_C7_H        0x0ACF
-#define CMU_GLCSC_P_C8_L        0x0AD0
-#define CMU_GLCSC_P_C8_H        0x0AD1
-#define CMU_GLCSC_P_O1_1        0x0AD4
-#define CMU_GLCSC_P_O1_2        0x0AD5
-#define CMU_GLCSC_P_O1_3        0x0AD6
-#define CMU_GLCSC_P_O2_1        0x0AD8
-#define CMU_GLCSC_P_O2_2        0x0AD9
-#define CMU_GLCSC_P_O2_3        0x0ADA
-#define CMU_GLCSC_P_O3_1        0x0ADC
-#define CMU_GLCSC_P_O3_2        0x0ADD
-#define CMU_GLCSC_P_O3_3        0x0ADE
-#define CMU_PIXVAL_M_EN         0x0AE0
-#define CMU_PIXVAL_P_EN         0x0AE1
-
-#define CMU_CLK_CTRL_TCLK       0x0
-#define CMU_CLK_CTRL_SCLK       0x2
-#define CMU_CLK_CTRL_MSK        0x2
-#define CMU_CLK_CTRL_ENABLE     0x1
-
-#define LCD_TOP_CTRL_TV         0x2
-#define LCD_TOP_CTRL_PN         0x0
-#define LCD_TOP_CTRL_SEL_MSK    0x2
-#define LCD_IO_CMU_IN_SEL_MSK   (0x3 << 20)
-#define LCD_IO_CMU_IN_SEL_TV    0
-#define LCD_IO_CMU_IN_SEL_PN    1
-#define LCD_IO_CMU_IN_SEL_PN2   2
-#define LCD_IO_TV_OUT_SEL_MSK   (0x3 << 26)
-#define LCD_IO_PN_OUT_SEL_MSK   (0x3 << 24)
-#define LCD_IO_PN2_OUT_SEL_MSK  (0x3 << 28)
-#define LCD_IO_TV_OUT_SEL_NON   3
-#define LCD_IO_PN_OUT_SEL_NON   3
-#define LCD_IO_PN2_OUT_SEL_NON  3
-#define LCD_TOP_CTRL_CMU_ENABLE 0x1
-#define LCD_IO_OVERL_MSK        0xC00000
-#define LCD_IO_OVERL_TV         0x0
-#define LCD_IO_OVERL_LCD1       0x400000
-#define LCD_IO_OVERL_LCD2       0xC00000
-#define HINVERT_MSK             0x4
-#define VINVERT_MSK             0x8
-#define HINVERT_LEN             0x2
-#define VINVERT_LEN             0x3
-
-#define CMU_CTRL                0x88
-#define CMU_CTRL_A0_MSK         0x6
-#define CMU_CTRL_A0_TV          0x0
-#define CMU_CTRL_A0_LCD1        0x1
-#define CMU_CTRL_A0_LCD2        0x2
-#define CMU_CTRL_A0_HDMI        0x3
-
-#define ICR_DRV_ROUTE_OFF       0x0
-#define ICR_DRV_ROUTE_TV        0x1
-#define ICR_DRV_ROUTE_LCD1      0x2
-#define ICR_DRV_ROUTE_LCD2      0x3
-
 enum {
         PATH_PN = 0,
         PATH_TV,
diff --git a/drivers/video/of_display_timing.c b/drivers/video/of_display_timing.c
index 13ecd9897010..56009bc02b02 100644
--- a/drivers/video/of_display_timing.c
+++ b/drivers/video/of_display_timing.c
@@ -79,25 +79,24 @@ static struct display_timing *of_get_display_timing(struct device_node *np)
         ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
         ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
 
-        dt->dmt_flags = 0;
-        dt->data_flags = 0;
+        dt->flags = 0;
         if (!of_property_read_u32(np, "vsync-active", &val))
-                dt->dmt_flags |= val ? VESA_DMT_VSYNC_HIGH :
-                                VESA_DMT_VSYNC_LOW;
+                dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
+                                DISPLAY_FLAGS_VSYNC_LOW;
         if (!of_property_read_u32(np, "hsync-active", &val))
-                dt->dmt_flags |= val ? VESA_DMT_HSYNC_HIGH :
-                                VESA_DMT_HSYNC_LOW;
+                dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
+                                DISPLAY_FLAGS_HSYNC_LOW;
         if (!of_property_read_u32(np, "de-active", &val))
-                dt->data_flags |= val ? DISPLAY_FLAGS_DE_HIGH :
+                dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
                                 DISPLAY_FLAGS_DE_LOW;
         if (!of_property_read_u32(np, "pixelclk-active", &val))
-                dt->data_flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
+                dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
                                 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
 
         if (of_property_read_bool(np, "interlaced"))
-                dt->data_flags |= DISPLAY_FLAGS_INTERLACED;
+                dt->flags |= DISPLAY_FLAGS_INTERLACED;
         if (of_property_read_bool(np, "doublescan"))
-                dt->data_flags |= DISPLAY_FLAGS_DOUBLESCAN;
+                dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
 
         if (ret) {
                 pr_err("%s: error reading timing properties\n",
diff --git a/drivers/video/of_videomode.c b/drivers/video/of_videomode.c
index 5b8066cd397f..111c2d1911d3 100644
--- a/drivers/video/of_videomode.c
+++ b/drivers/video/of_videomode.c
@@ -43,7 +43,7 @@ int of_get_videomode(struct device_node *np, struct videomode *vm,
         if (index == OF_USE_NATIVE_MODE)
                 index = disp->native_mode;
 
-        ret = videomode_from_timing(disp, vm, index);
+        ret = videomode_from_timings(disp, vm, index);
         if (ret)
                 return ret;
 
diff --git a/drivers/video/omap/Kconfig b/drivers/video/omap/Kconfig
index e512581300fc..0bc3a936ce2b 100644
--- a/drivers/video/omap/Kconfig
+++ b/drivers/video/omap/Kconfig
@@ -39,17 +39,6 @@ config FB_OMAP_LCD_MIPID
           the Mobile Industry Processor Interface DBI-C/DCS
           specification. (Supported LCDs: Philips LPH8923, Sharp LS041Y3)
 
-config FB_OMAP_CONSISTENT_DMA_SIZE
-        int "Consistent DMA memory size (MB)"
-        depends on FB_OMAP
-        range 1 14
-        default 2
-        help
-          Increase the DMA consistent memory size according to your video
-          memory needs, for example if you want to use multiple planes.
-          The size must be 2MB aligned.
-          If unsure say 1.
-
 config FB_OMAP_DMA_TUNE
         bool "Set DMA SDRAM access priority high"
         depends on FB_OMAP
diff --git a/drivers/video/omap2/Makefile b/drivers/video/omap2/Makefile
index 5ea7cb9aed17..296e5c5281c5 100644
--- a/drivers/video/omap2/Makefile
+++ b/drivers/video/omap2/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_OMAP2_VRFB) += vrfb.o
 
 obj-$(CONFIG_OMAP2_DSS) += dss/
-obj-$(CONFIG_FB_OMAP2) += omapfb/
 obj-y += displays/
+obj-$(CONFIG_FB_OMAP2) += omapfb/
diff --git a/drivers/video/omap2/displays/panel-acx565akm.c b/drivers/video/omap2/displays/panel-acx565akm.c
index 72699f88c002..d7f69c09ecf1 100644
--- a/drivers/video/omap2/displays/panel-acx565akm.c
+++ b/drivers/video/omap2/displays/panel-acx565akm.c
@@ -29,8 +29,10 @@
 #include <linux/sched.h>
 #include <linux/backlight.h>
 #include <linux/fb.h>
+#include <linux/gpio.h>
 
 #include <video/omapdss.h>
+#include <video/omap-panel-data.h>
 
 #define MIPID_CMD_READ_DISP_ID          0x04
 #define MIPID_CMD_READ_RED              0x06
@@ -336,8 +338,6 @@ static int acx565akm_bl_update_status(struct backlight_device *dev)
         r = 0;
         if (md->has_bc)
                 acx565akm_set_brightness(md, level);
-        else if (md->dssdev->set_backlight)
-                r = md->dssdev->set_backlight(md->dssdev, level);
         else
                 r = -ENODEV;
 
@@ -352,7 +352,7 @@ static int acx565akm_bl_get_intensity(struct backlight_device *dev)
 
         dev_dbg(&dev->dev, "%s\n", __func__);
 
-        if (!md->has_bc && md->dssdev->set_backlight == NULL)
+        if (!md->has_bc)
                 return -ENODEV;
 
         if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
@@ -496,21 +496,38 @@ static struct omap_video_timings acx_panel_timings = {
         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
 };
 
+static struct panel_acx565akm_data *get_panel_data(struct omap_dss_device *dssdev)
+{
+        return (struct panel_acx565akm_data *) dssdev->data;
+}
+
 static int acx_panel_probe(struct omap_dss_device *dssdev)
 {
         int r;
         struct acx565akm_device *md = &acx_dev;
+        struct panel_acx565akm_data *panel_data = get_panel_data(dssdev);
         struct backlight_device *bldev;
         int max_brightness, brightness;
         struct backlight_properties props;
 
         dev_dbg(&dssdev->dev, "%s\n", __func__);
 
+        if (!panel_data)
+                return -EINVAL;
+
         /* FIXME AC bias ? */
         dssdev->panel.timings = acx_panel_timings;
 
-        if (dssdev->platform_enable)
-                dssdev->platform_enable(dssdev);
+        if (gpio_is_valid(panel_data->reset_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, panel_data->reset_gpio,
+                                GPIOF_OUT_INIT_LOW, "lcd reset");
+                if (r)
+                        return r;
+        }
+
+        if (gpio_is_valid(panel_data->reset_gpio))
+                gpio_set_value(panel_data->reset_gpio, 1);
+
         /*
          * After reset we have to wait 5 msec before the first
          * command can be sent.
@@ -522,8 +539,9 @@ static int acx_panel_probe(struct omap_dss_device *dssdev)
         r = panel_detect(md);
         if (r) {
                 dev_err(&dssdev->dev, "%s panel detect error\n", __func__);
-                if (!md->enabled && dssdev->platform_disable)
-                        dssdev->platform_disable(dssdev);
+                if (!md->enabled && gpio_is_valid(panel_data->reset_gpio))
+                        gpio_set_value(panel_data->reset_gpio, 0);
+
                 return r;
         }
 
@@ -532,8 +550,8 @@ static int acx_panel_probe(struct omap_dss_device *dssdev)
         mutex_unlock(&acx_dev.mutex);
 
         if (!md->enabled) {
-                if (dssdev->platform_disable)
-                        dssdev->platform_disable(dssdev);
+                if (gpio_is_valid(panel_data->reset_gpio))
+                        gpio_set_value(panel_data->reset_gpio, 0);
         }
 
         /*------- Backlight control --------*/
@@ -557,15 +575,10 @@ static int acx_panel_probe(struct omap_dss_device *dssdev)
                 md->cabc_mode = get_hw_cabc_mode(md);
         }
 
-        if (md->has_bc)
-                max_brightness = 255;
-        else
-                max_brightness = dssdev->max_backlight_level;
+        max_brightness = 255;
 
         if (md->has_bc)
                 brightness = acx565akm_get_actual_brightness(md);
-        else if (dssdev->get_backlight)
-                brightness = dssdev->get_backlight(dssdev);
         else
                 brightness = 0;
 
@@ -591,6 +604,7 @@ static void acx_panel_remove(struct omap_dss_device *dssdev)
 static int acx_panel_power_on(struct omap_dss_device *dssdev)
 {
         struct acx565akm_device *md = &acx_dev;
+        struct panel_acx565akm_data *panel_data = get_panel_data(dssdev);
         int r;
 
         dev_dbg(&dssdev->dev, "%s\n", __func__);
@@ -612,11 +626,8 @@ static int acx_panel_power_on(struct omap_dss_device *dssdev)
         /*FIXME tweak me */
         msleep(50);
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        goto fail;
-        }
+        if (gpio_is_valid(panel_data->reset_gpio))
+                gpio_set_value(panel_data->reset_gpio, 1);
 
         if (md->enabled) {
                 dev_dbg(&md->spi->dev, "panel already enabled\n");
@@ -645,8 +656,7 @@ static int acx_panel_power_on(struct omap_dss_device *dssdev)
         mutex_unlock(&md->mutex);
 
         return acx565akm_bl_update_status(md->bl_dev);
-fail:
-        omapdss_sdi_display_disable(dssdev);
+
 fail_unlock:
         mutex_unlock(&md->mutex);
         return r;
@@ -655,6 +665,7 @@ fail_unlock:
 static void acx_panel_power_off(struct omap_dss_device *dssdev)
 {
         struct acx565akm_device *md = &acx_dev;
+        struct panel_acx565akm_data *panel_data = get_panel_data(dssdev);
 
         dev_dbg(&dssdev->dev, "%s\n", __func__);
 
@@ -678,8 +689,8 @@ static void acx_panel_power_off(struct omap_dss_device *dssdev)
          */
         msleep(50);
 
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
+        if (gpio_is_valid(panel_data->reset_gpio))
+                gpio_set_value(panel_data->reset_gpio, 0);
 
         /* FIXME need to tweak this delay */
         msleep(100);
diff --git a/drivers/video/omap2/displays/panel-generic-dpi.c b/drivers/video/omap2/displays/panel-generic-dpi.c
index c904f42d81c1..97363f733683 100644
--- a/drivers/video/omap2/displays/panel-generic-dpi.c
+++ b/drivers/video/omap2/displays/panel-generic-dpi.c
@@ -33,9 +33,10 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
+#include <linux/gpio.h>
 #include <video/omapdss.h>
 
-#include <video/omap-panel-generic-dpi.h>
+#include <video/omap-panel-data.h>
 
 struct panel_config {
         struct omap_video_timings timings;
@@ -533,7 +534,7 @@ static inline struct panel_generic_dpi_data
 
 static int generic_dpi_panel_power_on(struct omap_dss_device *dssdev)
 {
-        int r;
+        int r, i;
         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
         struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
         struct panel_config *panel_config = drv_data->panel_config;
@@ -552,15 +553,13 @@ static int generic_dpi_panel_power_on(struct omap_dss_device *dssdev)
         if (panel_config->power_on_delay)
                 msleep(panel_config->power_on_delay);
 
-        if (panel_data->platform_enable) {
-                r = panel_data->platform_enable(dssdev);
-                if (r)
-                        goto err1;
+        for (i = 0; i < panel_data->num_gpios; ++i) {
+                gpio_set_value_cansleep(panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ? 0 : 1);
         }
 
         return 0;
-err1:
-        omapdss_dpi_display_disable(dssdev);
+
 err0:
         return r;
 }
@@ -570,12 +569,15 @@ static void generic_dpi_panel_power_off(struct omap_dss_device *dssdev)
         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
         struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
         struct panel_config *panel_config = drv_data->panel_config;
+        int i;
 
         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return;
 
-        if (panel_data->platform_disable)
-                panel_data->platform_disable(dssdev);
+        for (i = panel_data->num_gpios - 1; i >= 0; --i) {
+                gpio_set_value_cansleep(panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ? 1 : 0);
+        }
 
         /* wait couple of vsyncs after disabling the LCD */
         if (panel_config->power_off_delay)
@@ -589,7 +591,7 @@ static int generic_dpi_panel_probe(struct omap_dss_device *dssdev)
         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
         struct panel_config *panel_config = NULL;
         struct panel_drv_data *drv_data = NULL;
-        int i;
+        int i, r;
 
         dev_dbg(&dssdev->dev, "probe\n");
 
@@ -606,9 +608,18 @@ static int generic_dpi_panel_probe(struct omap_dss_device *dssdev)
         if (!panel_config)
                 return -EINVAL;
 
+        for (i = 0; i < panel_data->num_gpios; ++i) {
+                r = devm_gpio_request_one(&dssdev->dev, panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ?
+                                GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
+                                "panel gpio");
+                if (r)
+                        return r;
+        }
+
         dssdev->panel.timings = panel_config->timings;
 
-        drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
+        drv_data = devm_kzalloc(&dssdev->dev, sizeof(*drv_data), GFP_KERNEL);
         if (!drv_data)
                 return -ENOMEM;
 
@@ -624,12 +635,8 @@ static int generic_dpi_panel_probe(struct omap_dss_device *dssdev)
 
 static void __exit generic_dpi_panel_remove(struct omap_dss_device *dssdev)
 {
-        struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
-
         dev_dbg(&dssdev->dev, "remove\n");
 
-        kfree(drv_data);
-
         dev_set_drvdata(&dssdev->dev, NULL);
 }
 
diff --git a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
index 6e5abe8fd2dd..4ea6548c0ae9 100644
--- a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
+++ b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
@@ -20,8 +20,10 @@
 #include <linux/delay.h>
 #include <linux/spi/spi.h>
 #include <linux/mutex.h>
+#include <linux/gpio.h>
 
 #include <video/omapdss.h>
+#include <video/omap-panel-data.h>
 
 struct lb035q02_data {
         struct mutex lock;
@@ -48,9 +50,16 @@ static struct omap_video_timings lb035q02_timings = {
         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
 };
 
+static inline struct panel_generic_dpi_data
+*get_panel_data(const struct omap_dss_device *dssdev)
+{
+        return (struct panel_generic_dpi_data *) dssdev->data;
+}
+
 static int lb035q02_panel_power_on(struct omap_dss_device *dssdev)
 {
-        int r;
+        struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
+        int r, i;
 
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
@@ -62,54 +71,65 @@ static int lb035q02_panel_power_on(struct omap_dss_device *dssdev)
         if (r)
                 goto err0;
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        goto err1;
+        for (i = 0; i < panel_data->num_gpios; ++i) {
+                gpio_set_value_cansleep(panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ? 0 : 1);
         }
 
         return 0;
-err1:
-        omapdss_dpi_display_disable(dssdev);
+
 err0:
         return r;
 }
 
 static void lb035q02_panel_power_off(struct omap_dss_device *dssdev)
 {
+        struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
+        int i;
+
         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return;
 
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
+        for (i = panel_data->num_gpios - 1; i >= 0; --i) {
+                gpio_set_value_cansleep(panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ? 1 : 0);
+        }
 
         omapdss_dpi_display_disable(dssdev);
 }
 
 static int lb035q02_panel_probe(struct omap_dss_device *dssdev)
 {
+        struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
         struct lb035q02_data *ld;
-        int r;
+        int r, i;
+
+        if (!panel_data)
+                return -EINVAL;
 
         dssdev->panel.timings = lb035q02_timings;
 
-        ld = kzalloc(sizeof(*ld), GFP_KERNEL);
-        if (!ld) {
-                r = -ENOMEM;
-                goto err;
+        ld = devm_kzalloc(&dssdev->dev, sizeof(*ld), GFP_KERNEL);
+        if (!ld)
+                return -ENOMEM;
+
+        for (i = 0; i < panel_data->num_gpios; ++i) {
+                r = devm_gpio_request_one(&dssdev->dev, panel_data->gpios[i],
+                                panel_data->gpio_invert[i] ?
+                                GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
+                                "panel gpio");
+                if (r)
+                        return r;
         }
+
         mutex_init(&ld->lock);
         dev_set_drvdata(&dssdev->dev, ld);
+
         return 0;
-err:
-        return r;
 }
 
 static void lb035q02_panel_remove(struct omap_dss_device *dssdev)
 {
-        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
-
-        kfree(ld);
 }
 
 static int lb035q02_panel_enable(struct omap_dss_device *dssdev)
diff --git a/drivers/video/omap2/displays/panel-n8x0.c b/drivers/video/omap2/displays/panel-n8x0.c
index dd1294750802..f94ead6a3183 100644
--- a/drivers/video/omap2/displays/panel-n8x0.c
+++ b/drivers/video/omap2/displays/panel-n8x0.c
@@ -5,11 +5,10 @@
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/spi/spi.h>
-#include <linux/backlight.h>
 #include <linux/fb.h>
 
 #include <video/omapdss.h>
-#include <video/omap-panel-n8x0.h>
+#include <video/omap-panel-data.h>
 
 #define BLIZZARD_REV_CODE                      0x00
 #define BLIZZARD_CONFIG                        0x02
@@ -69,7 +68,6 @@ static struct panel_drv_data {
 
         struct omap_dss_device *dssdev;
         struct spi_device *spidev;
-        struct backlight_device *bldev;
 
         int blizzard_ver;
 } s_drv_data;
@@ -297,12 +295,6 @@ static int n8x0_panel_power_on(struct omap_dss_device *dssdev)
 
         gpio_direction_output(bdata->ctrl_pwrdown, 1);
 
-        if (bdata->platform_enable) {
-                r = bdata->platform_enable(dssdev);
-                if (r)
-                        goto err_plat_en;
-        }
-
         omapdss_rfbi_set_size(dssdev, dssdev->panel.timings.x_res,
                 dssdev->panel.timings.y_res);
         omapdss_rfbi_set_pixel_size(dssdev, dssdev->ctrl.pixel_size);
@@ -375,9 +367,6 @@ err_inv_panel:
 err_inv_chip:
         omapdss_rfbi_display_disable(dssdev);
 err_rfbi_en:
-        if (bdata->platform_disable)
-                bdata->platform_disable(dssdev);
-err_plat_en:
         gpio_direction_output(bdata->ctrl_pwrdown, 0);
         return r;
 }
@@ -394,9 +383,6 @@ static void n8x0_panel_power_off(struct omap_dss_device *dssdev)
         send_display_off(spi);
         send_sleep_in(spi);
 
-        if (bdata->platform_disable)
-                bdata->platform_disable(dssdev);
-
         /*
          * HACK: we should turn off the panel here, but there is some problem
          * with the initialization sequence, and we fail to init the panel if we
@@ -424,54 +410,10 @@ static const struct rfbi_timings n8x0_panel_timings = {
         .cs_pulse_width = 0,
 };
 
-static int n8x0_bl_update_status(struct backlight_device *dev)
-{
-        struct omap_dss_device *dssdev = dev_get_drvdata(&dev->dev);
-        struct panel_n8x0_data *bdata = get_board_data(dssdev);
-        struct panel_drv_data *ddata = get_drv_data(dssdev);
-        int r;
-        int level;
-
-        mutex_lock(&ddata->lock);
-
-        if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
-                        dev->props.power == FB_BLANK_UNBLANK)
-                level = dev->props.brightness;
-        else
-                level = 0;
-
-        dev_dbg(&dssdev->dev, "update brightness to %d\n", level);
-
-        if (!bdata->set_backlight)
-                r = -EINVAL;
-        else
-                r = bdata->set_backlight(dssdev, level);
-
-        mutex_unlock(&ddata->lock);
-
-        return r;
-}
-
-static int n8x0_bl_get_intensity(struct backlight_device *dev)
-{
-        if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
-                        dev->props.power == FB_BLANK_UNBLANK)
-                return dev->props.brightness;
-
-        return 0;
-}
-
-static const struct backlight_ops n8x0_bl_ops = {
-        .get_brightness = n8x0_bl_get_intensity,
-        .update_status  = n8x0_bl_update_status,
-};
-
 static int n8x0_panel_probe(struct omap_dss_device *dssdev)
 {
         struct panel_n8x0_data *bdata = get_board_data(dssdev);
         struct panel_drv_data *ddata;
-        struct backlight_device *bldev;
-        struct backlight_properties props;
         int r;
 
         dev_dbg(&dssdev->dev, "probe\n");
@@ -491,40 +433,27 @@ static int n8x0_panel_probe(struct omap_dss_device *dssdev)
         dssdev->ctrl.rfbi_timings = n8x0_panel_timings;
         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
 
-        memset(&props, 0, sizeof(props));
-        props.max_brightness = 127;
-        props.type = BACKLIGHT_PLATFORM;
-        bldev = backlight_device_register(dev_name(&dssdev->dev), &dssdev->dev,
-                        dssdev, &n8x0_bl_ops, &props);
-        if (IS_ERR(bldev)) {
-                r = PTR_ERR(bldev);
-                dev_err(&dssdev->dev, "register backlight failed\n");
-                return r;
+        if (gpio_is_valid(bdata->panel_reset)) {
+                r = devm_gpio_request_one(&dssdev->dev, bdata->panel_reset,
+                                GPIOF_OUT_INIT_LOW, "PANEL RESET");
+                if (r)
+                        return r;
         }
 
-        ddata->bldev = bldev;
-
-        bldev->props.fb_blank = FB_BLANK_UNBLANK;
-        bldev->props.power = FB_BLANK_UNBLANK;
-        bldev->props.brightness = 127;
-
-        n8x0_bl_update_status(bldev);
+        if (gpio_is_valid(bdata->ctrl_pwrdown)) {
+                r = devm_gpio_request_one(&dssdev->dev, bdata->ctrl_pwrdown,
+                                GPIOF_OUT_INIT_LOW, "PANEL PWRDOWN");
+                if (r)
+                        return r;
+        }
 
         return 0;
 }
 
 static void n8x0_panel_remove(struct omap_dss_device *dssdev)
 {
-        struct panel_drv_data *ddata = get_drv_data(dssdev);
-        struct backlight_device *bldev;
-
         dev_dbg(&dssdev->dev, "remove\n");
 
-        bldev = ddata->bldev;
-        bldev->props.power = FB_BLANK_POWERDOWN;
-        n8x0_bl_update_status(bldev);
-        backlight_device_unregister(bldev);
-
         dev_set_drvdata(&dssdev->dev, NULL);
 }
 
diff --git a/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c b/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
index c4e9c2b1b465..20c3cd91ff9b 100644
--- a/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
+++ b/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
@@ -19,10 +19,11 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/spi/spi.h>
-#include <linux/backlight.h>
 #include <linux/fb.h>
+#include <linux/gpio.h>
 
 #include <video/omapdss.h>
+#include <video/omap-panel-data.h>
 
 #define LCD_XRES                800
 #define LCD_YRES                480
@@ -32,10 +33,6 @@
  */
 #define LCD_PIXEL_CLOCK         23800
 
-struct nec_8048_data {
-        struct backlight_device *bl;
-};
-
 static const struct {
         unsigned char addr;
         unsigned char dat;
@@ -84,93 +81,47 @@ static struct omap_video_timings nec_8048_panel_timings = {
         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
 };
 
-static int nec_8048_bl_update_status(struct backlight_device *bl)
-{
-        struct omap_dss_device *dssdev = dev_get_drvdata(&bl->dev);
-        int level;
-
-        if (!dssdev->set_backlight)
-                return -EINVAL;
-
-        if (bl->props.fb_blank == FB_BLANK_UNBLANK &&
-                        bl->props.power == FB_BLANK_UNBLANK)
-                level = bl->props.brightness;
-        else
-                level = 0;
-
-        return dssdev->set_backlight(dssdev, level);
-}
-
-static int nec_8048_bl_get_brightness(struct backlight_device *bl)
+static inline struct panel_nec_nl8048_data
+*get_panel_data(const struct omap_dss_device *dssdev)
 {
-        if (bl->props.fb_blank == FB_BLANK_UNBLANK &&
-                        bl->props.power == FB_BLANK_UNBLANK)
-                return bl->props.brightness;
-
-        return 0;
+        return (struct panel_nec_nl8048_data *) dssdev->data;
 }
 
-static const struct backlight_ops nec_8048_bl_ops = {
-        .get_brightness = nec_8048_bl_get_brightness,
-        .update_status  = nec_8048_bl_update_status,
-};
-
 static int nec_8048_panel_probe(struct omap_dss_device *dssdev)
 {
-        struct backlight_device *bl;
-        struct nec_8048_data *necd;
-        struct backlight_properties props;
+        struct panel_nec_nl8048_data *pd = get_panel_data(dssdev);
         int r;
 
-        dssdev->panel.timings = nec_8048_panel_timings;
-
-        necd = kzalloc(sizeof(*necd), GFP_KERNEL);
-        if (!necd)
-                return -ENOMEM;
-
-        dev_set_drvdata(&dssdev->dev, necd);
+        if (!pd)
+                return -EINVAL;
 
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = 255;
+        dssdev->panel.timings = nec_8048_panel_timings;
 
-        bl = backlight_device_register("nec-8048", &dssdev->dev, dssdev,
-                        &nec_8048_bl_ops, &props);
-        if (IS_ERR(bl)) {
-                r = PTR_ERR(bl);
-                kfree(necd);
-                return r;
+        if (gpio_is_valid(pd->qvga_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->qvga_gpio,
+                                GPIOF_OUT_INIT_HIGH, "lcd QVGA");
+                if (r)
+                        return r;
         }
-        necd->bl = bl;
-
-        bl->props.fb_blank = FB_BLANK_UNBLANK;
-        bl->props.power = FB_BLANK_UNBLANK;
-        bl->props.max_brightness = dssdev->max_backlight_level;
-        bl->props.brightness = dssdev->max_backlight_level;
 
-        r = nec_8048_bl_update_status(bl);
-        if (r < 0)
-                dev_err(&dssdev->dev, "failed to set lcd brightness\n");
+        if (gpio_is_valid(pd->res_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->res_gpio,
+                                GPIOF_OUT_INIT_LOW, "lcd RES");
+                if (r)
+                        return r;
+        }
 
         return 0;
 }
 
 static void nec_8048_panel_remove(struct omap_dss_device *dssdev)
 {
-        struct nec_8048_data *necd = dev_get_drvdata(&dssdev->dev);
-        struct backlight_device *bl = necd->bl;
-
-        bl->props.power = FB_BLANK_POWERDOWN;
-        nec_8048_bl_update_status(bl);
-        backlight_device_unregister(bl);
-
-        kfree(necd);
 }
 
 static int nec_8048_panel_power_on(struct omap_dss_device *dssdev)
 {
+        struct panel_nec_nl8048_data *pd = get_panel_data(dssdev);
         int r;
-        struct nec_8048_data *necd = dev_get_drvdata(&dssdev->dev);
-        struct backlight_device *bl = necd->bl;
 
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
@@ -182,36 +133,24 @@ static int nec_8048_panel_power_on(struct omap_dss_device *dssdev)
         if (r)
                 goto err0;
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        goto err1;
-        }
-
-        r = nec_8048_bl_update_status(bl);
-        if (r < 0)
-                dev_err(&dssdev->dev, "failed to set lcd brightness\n");
+        if (gpio_is_valid(pd->res_gpio))
+                gpio_set_value_cansleep(pd->res_gpio, 1);
 
         return 0;
-err1:
-        omapdss_dpi_display_disable(dssdev);
+
 err0:
         return r;
 }
 
 static void nec_8048_panel_power_off(struct omap_dss_device *dssdev)
 {
-        struct nec_8048_data *necd = dev_get_drvdata(&dssdev->dev);
-        struct backlight_device *bl = necd->bl;
+        struct panel_nec_nl8048_data *pd = get_panel_data(dssdev);
 
         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return;
 
-        bl->props.brightness = 0;
-        nec_8048_bl_update_status(bl);
-
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
+        if (gpio_is_valid(pd->res_gpio))
+                gpio_set_value_cansleep(pd->res_gpio, 0);
 
         omapdss_dpi_display_disable(dssdev);
 }
@@ -303,16 +242,22 @@ static int nec_8048_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-static int nec_8048_spi_suspend(struct spi_device *spi, pm_message_t mesg)
+#ifdef CONFIG_PM_SLEEP
+
+static int nec_8048_spi_suspend(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
+
         nec_8048_spi_send(spi, 2, 0x01);
         mdelay(40);
 
         return 0;
 }
 
-static int nec_8048_spi_resume(struct spi_device *spi)
+static int nec_8048_spi_resume(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
+
         /* reinitialize the panel */
         spi_setup(spi);
         nec_8048_spi_send(spi, 2, 0x00);
@@ -321,14 +266,20 @@ static int nec_8048_spi_resume(struct spi_device *spi)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(nec_8048_spi_pm_ops, nec_8048_spi_suspend,
+                nec_8048_spi_resume);
+#define NEC_8048_SPI_PM_OPS (&nec_8048_spi_pm_ops)
+#else
+#define NEC_8048_SPI_PM_OPS NULL
+#endif
+
 static struct spi_driver nec_8048_spi_driver = {
         .probe          = nec_8048_spi_probe,
         .remove         = nec_8048_spi_remove,
-        .suspend        = nec_8048_spi_suspend,
-        .resume         = nec_8048_spi_resume,
         .driver         = {
                 .name   = "nec_8048_spi",
                 .owner  = THIS_MODULE,
+                .pm     = NEC_8048_SPI_PM_OPS,
         },
 };
 
diff --git a/drivers/video/omap2/displays/panel-picodlp.c b/drivers/video/omap2/displays/panel-picodlp.c
index 1b94018aac3e..62f2db04fbc8 100644
--- a/drivers/video/omap2/displays/panel-picodlp.c
+++ b/drivers/video/omap2/displays/panel-picodlp.c
@@ -31,7 +31,7 @@
 #include <linux/gpio.h>
 
 #include <video/omapdss.h>
-#include <video/omap-panel-picodlp.h>
+#include <video/omap-panel-data.h>
 
 #include "panel-picodlp.h"
 
@@ -354,12 +354,6 @@ static int picodlp_panel_power_on(struct omap_dss_device *dssdev)
         struct picodlp_data *picod = dev_get_drvdata(&dssdev->dev);
         struct picodlp_panel_data *picodlp_pdata = get_panel_data(dssdev);
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        return r;
-        }
-
         gpio_set_value(picodlp_pdata->pwrgood_gpio, 0);
         msleep(1);
         gpio_set_value(picodlp_pdata->pwrgood_gpio, 1);
@@ -398,9 +392,6 @@ static int picodlp_panel_power_on(struct omap_dss_device *dssdev)
 err:
         omapdss_dpi_display_disable(dssdev);
 err1:
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
-
         return r;
 }
 
@@ -412,9 +403,6 @@ static void picodlp_panel_power_off(struct omap_dss_device *dssdev)
 
         gpio_set_value(picodlp_pdata->emu_done_gpio, 0);
         gpio_set_value(picodlp_pdata->pwrgood_gpio, 0);
-
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
 }
 
 static int picodlp_panel_probe(struct omap_dss_device *dssdev)
@@ -423,11 +411,14 @@ static int picodlp_panel_probe(struct omap_dss_device *dssdev)
         struct picodlp_panel_data *picodlp_pdata = get_panel_data(dssdev);
         struct i2c_adapter *adapter;
         struct i2c_client *picodlp_i2c_client;
-        int r = 0, picodlp_adapter_id;
+        int r, picodlp_adapter_id;
 
         dssdev->panel.timings = pico_ls_timings;
 
-        picod =  kzalloc(sizeof(struct picodlp_data), GFP_KERNEL);
+        if (!picodlp_pdata)
+                return -EINVAL;
+
+        picod = devm_kzalloc(&dssdev->dev, sizeof(*picod), GFP_KERNEL);
         if (!picod)
                 return -ENOMEM;
 
@@ -438,25 +429,37 @@ static int picodlp_panel_probe(struct omap_dss_device *dssdev)
         adapter = i2c_get_adapter(picodlp_adapter_id);
         if (!adapter) {
                 dev_err(&dssdev->dev, "can't get i2c adapter\n");
-                r = -ENODEV;
-                goto err;
+                return -ENODEV;
         }
 
         picodlp_i2c_client = i2c_new_device(adapter, &picodlp_i2c_board_info);
         if (!picodlp_i2c_client) {
                 dev_err(&dssdev->dev, "can't add i2c device::"
                                          " picodlp_i2c_client is NULL\n");
-                r = -ENODEV;
-                goto err;
+                return -ENODEV;
         }
 
         picod->picodlp_i2c_client = picodlp_i2c_client;
 
         dev_set_drvdata(&dssdev->dev, picod);
-        return r;
-err:
-        kfree(picod);
-        return r;
+
+        if (gpio_is_valid(picodlp_pdata->emu_done_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev,
+                                picodlp_pdata->emu_done_gpio,
+                                GPIOF_IN, "DLP EMU DONE");
+                if (r)
+                        return r;
+        }
+
+        if (gpio_is_valid(picodlp_pdata->pwrgood_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev,
+                                picodlp_pdata->pwrgood_gpio,
+                                GPIOF_OUT_INIT_LOW, "DLP PWRGOOD");
+                if (r)
+                        return r;
+        }
+
+        return 0;
 }
 
 static void picodlp_panel_remove(struct omap_dss_device *dssdev)
diff --git a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
index cada8c621e01..74cb0eb45311 100644
--- a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
+++ b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
@@ -20,16 +20,13 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/device.h>
-#include <linux/backlight.h>
 #include <linux/fb.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/gpio.h>
 
 #include <video/omapdss.h>
-
-struct sharp_data {
-        struct backlight_device *bl;
-};
+#include <video/omap-panel-data.h>
 
 static struct omap_video_timings sharp_ls_timings = {
         .x_res = 480,
@@ -52,91 +49,67 @@ static struct omap_video_timings sharp_ls_timings = {
         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
 };
 
-static int sharp_ls_bl_update_status(struct backlight_device *bl)
+static inline struct panel_sharp_ls037v7dw01_data
+*get_panel_data(const struct omap_dss_device *dssdev)
 {
-        struct omap_dss_device *dssdev = dev_get_drvdata(&bl->dev);
-        int level;
-
-        if (!dssdev->set_backlight)
-                return -EINVAL;
-
-        if (bl->props.fb_blank == FB_BLANK_UNBLANK &&
-                        bl->props.power == FB_BLANK_UNBLANK)
-                level = bl->props.brightness;
-        else
-                level = 0;
-
-        return dssdev->set_backlight(dssdev, level);
+        return (struct panel_sharp_ls037v7dw01_data *) dssdev->data;
 }
 
-static int sharp_ls_bl_get_brightness(struct backlight_device *bl)
-{
-        if (bl->props.fb_blank == FB_BLANK_UNBLANK &&
-                        bl->props.power == FB_BLANK_UNBLANK)
-                return bl->props.brightness;
-
-        return 0;
-}
-
-static const struct backlight_ops sharp_ls_bl_ops = {
-        .get_brightness = sharp_ls_bl_get_brightness,
-        .update_status  = sharp_ls_bl_update_status,
-};
-
-
-
 static int sharp_ls_panel_probe(struct omap_dss_device *dssdev)
 {
-        struct backlight_properties props;
-        struct backlight_device *bl;
-        struct sharp_data *sd;
+        struct panel_sharp_ls037v7dw01_data *pd = get_panel_data(dssdev);
         int r;
 
+        if (!pd)
+                return -EINVAL;
+
         dssdev->panel.timings = sharp_ls_timings;
 
-        sd = kzalloc(sizeof(*sd), GFP_KERNEL);
-        if (!sd)
-                return -ENOMEM;
+        if (gpio_is_valid(pd->mo_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->mo_gpio,
+                                GPIOF_OUT_INIT_LOW, "lcd MO");
+                if (r)
+                        return r;
+        }
 
-        dev_set_drvdata(&dssdev->dev, sd);
+        if (gpio_is_valid(pd->lr_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->lr_gpio,
+                                GPIOF_OUT_INIT_HIGH, "lcd LR");
+                if (r)
+                        return r;
+        }
 
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = dssdev->max_backlight_level;
-        props.type = BACKLIGHT_RAW;
+        if (gpio_is_valid(pd->ud_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->ud_gpio,
+                                GPIOF_OUT_INIT_HIGH, "lcd UD");
+                if (r)
+                        return r;
+        }
 
-        bl = backlight_device_register("sharp-ls", &dssdev->dev, dssdev,
-                        &sharp_ls_bl_ops, &props);
-        if (IS_ERR(bl)) {
-                r = PTR_ERR(bl);
-                kfree(sd);
-                return r;
+        if (gpio_is_valid(pd->resb_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->resb_gpio,
+                                GPIOF_OUT_INIT_LOW, "lcd RESB");
+                if (r)
+                        return r;
         }
-        sd->bl = bl;
 
-        bl->props.fb_blank = FB_BLANK_UNBLANK;
-        bl->props.power = FB_BLANK_UNBLANK;
-        bl->props.brightness = dssdev->max_backlight_level;
-        r = sharp_ls_bl_update_status(bl);
-        if (r < 0)
-                dev_err(&dssdev->dev, "failed to set lcd brightness\n");
+        if (gpio_is_valid(pd->ini_gpio)) {
+                r = devm_gpio_request_one(&dssdev->dev, pd->ini_gpio,
+                                GPIOF_OUT_INIT_LOW, "lcd INI");
+                if (r)
+                        return r;
+        }
 
         return 0;
 }
 
 static void __exit sharp_ls_panel_remove(struct omap_dss_device *dssdev)
 {
-        struct sharp_data *sd = dev_get_drvdata(&dssdev->dev);
-        struct backlight_device *bl = sd->bl;
-
-        bl->props.power = FB_BLANK_POWERDOWN;
-        sharp_ls_bl_update_status(bl);
-        backlight_device_unregister(bl);
-
-        kfree(sd);
 }
 
 static int sharp_ls_power_on(struct omap_dss_device *dssdev)
 {
+        struct panel_sharp_ls037v7dw01_data *pd = get_panel_data(dssdev);
         int r = 0;
 
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
@@ -152,26 +125,29 @@ static int sharp_ls_power_on(struct omap_dss_device *dssdev)
         /* wait couple of vsyncs until enabling the LCD */
         msleep(50);
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        goto err1;
-        }
+        if (gpio_is_valid(pd->resb_gpio))
+                gpio_set_value_cansleep(pd->resb_gpio, 1);
+
+        if (gpio_is_valid(pd->ini_gpio))
+                gpio_set_value_cansleep(pd->ini_gpio, 1);
 
         return 0;
-err1:
-        omapdss_dpi_display_disable(dssdev);
 err0:
         return r;
 }
 
 static void sharp_ls_power_off(struct omap_dss_device *dssdev)
 {
+        struct panel_sharp_ls037v7dw01_data *pd = get_panel_data(dssdev);
+
         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return;
 
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
+        if (gpio_is_valid(pd->ini_gpio))
+                gpio_set_value_cansleep(pd->ini_gpio, 0);
+
+        if (gpio_is_valid(pd->resb_gpio))
+                gpio_set_value_cansleep(pd->resb_gpio, 0);
 
         /* wait at least 5 vsyncs after disabling the LCD */
 
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index a32407a5735a..c4f78bda115a 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -33,7 +33,7 @@
 #include <linux/mutex.h>
 
 #include <video/omapdss.h>
-#include <video/omap-panel-nokia-dsi.h>
+#include <video/omap-panel-data.h>
 #include <video/mipi_display.h>
 
 /* DSI Virtual channel. Hardcoded for now. */
@@ -54,61 +54,6 @@ static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable);
 
 static int taal_panel_reset(struct omap_dss_device *dssdev);
 
-/**
- * struct panel_config - panel configuration
- * @name: panel name
- * @type: panel type
- * @timings: panel resolution
- * @sleep: various panel specific delays, passed to msleep() if non-zero
- * @reset_sequence: reset sequence timings, passed to udelay() if non-zero
- * @regulators: array of panel regulators
- * @num_regulators: number of regulators in the array
- */
-struct panel_config {
-        const char *name;
-        int type;
-
-        struct omap_video_timings timings;
-
-        struct {
-                unsigned int sleep_in;
-                unsigned int sleep_out;
-                unsigned int hw_reset;
-                unsigned int enable_te;
-        } sleep;
-
-        struct {
-                unsigned int high;
-                unsigned int low;
-        } reset_sequence;
-
-};
-
-enum {
-        PANEL_TAAL,
-};
-
-static struct panel_config panel_configs[] = {
-        {
-                .name           = "taal",
-                .type           = PANEL_TAAL,
-                .timings        = {
-                        .x_res          = 864,
-                        .y_res          = 480,
-                },
-                .sleep          = {
-                        .sleep_in       = 5,
-                        .sleep_out      = 5,
-                        .hw_reset       = 5,
-                        .enable_te      = 100, /* possible panel bug */
-                },
-                .reset_sequence = {
-                        .high           = 10,
-                        .low            = 10,
-                },
-        },
-};
-
 struct taal_data {
         struct mutex lock;
 
@@ -121,9 +66,6 @@ struct taal_data {
 
         struct omap_dss_device *dssdev;
 
-        /* panel specific HW info */
-        struct panel_config *panel_config;
-
         /* panel HW configuration from DT or platform data */
         int reset_gpio;
         int ext_te_gpio;
@@ -134,8 +76,6 @@ struct taal_data {
 
         /* runtime variables */
         bool enabled;
-        u8 rotate;
-        bool mirror;
 
         bool te_enabled;
 
@@ -221,8 +161,7 @@ static int taal_sleep_in(struct taal_data *td)
 
         hw_guard_start(td, 120);
 
-        if (td->panel_config->sleep.sleep_in)
-                msleep(td->panel_config->sleep.sleep_in);
+        msleep(5);
 
         return 0;
 }
@@ -239,8 +178,7 @@ static int taal_sleep_out(struct taal_data *td)
 
         hw_guard_start(td, 120);
 
-        if (td->panel_config->sleep.sleep_out)
-                msleep(td->panel_config->sleep.sleep_out);
+        msleep(5);
 
         return 0;
 }
@@ -262,49 +200,6 @@ static int taal_get_id(struct taal_data *td, u8 *id1, u8 *id2, u8 *id3)
         return 0;
 }
 
-static int taal_set_addr_mode(struct taal_data *td, u8 rotate, bool mirror)
-{
-        int r;
-        u8 mode;
-        int b5, b6, b7;
-
-        r = taal_dcs_read_1(td, MIPI_DCS_GET_ADDRESS_MODE, &mode);
-        if (r)
-                return r;
-
-        switch (rotate) {
-        default:
-        case 0:
-                b7 = 0;
-                b6 = 0;
-                b5 = 0;
-                break;
-        case 1:
-                b7 = 0;
-                b6 = 1;
-                b5 = 1;
-                break;
-        case 2:
-                b7 = 1;
-                b6 = 1;
-                b5 = 0;
-                break;
-        case 3:
-                b7 = 1;
-                b6 = 0;
-                b5 = 1;
-                break;
-        }
-
-        if (mirror)
-                b6 = !b6;
-
-        mode &= ~((1<<7) | (1<<6) | (1<<5));
-        mode |= (b7 << 7) | (b6 << 6) | (b5 << 5);
-
-        return taal_dcs_write_1(td, MIPI_DCS_SET_ADDRESS_MODE, mode);
-}
-
 static int taal_set_update_window(struct taal_data *td,
                 u16 x, u16 y, u16 w, u16 h)
 {
@@ -515,15 +410,8 @@ static const struct backlight_ops taal_bl_ops = {
 static void taal_get_resolution(struct omap_dss_device *dssdev,
                 u16 *xres, u16 *yres)
 {
-        struct taal_data *td = dev_get_drvdata(&dssdev->dev);
-
-        if (td->rotate == 0 || td->rotate == 2) {
-                *xres = dssdev->panel.timings.x_res;
-                *yres = dssdev->panel.timings.y_res;
-        } else {
-                *yres = dssdev->panel.timings.x_res;
-                *xres = dssdev->panel.timings.y_res;
-        }
+        *xres = dssdev->panel.timings.x_res;
+        *yres = dssdev->panel.timings.y_res;
 }
 
 static ssize_t taal_num_errors_show(struct device *dev,
@@ -845,17 +733,14 @@ static void taal_hw_reset(struct omap_dss_device *dssdev)
                 return;
 
         gpio_set_value(td->reset_gpio, 1);
-        if (td->panel_config->reset_sequence.high)
-                udelay(td->panel_config->reset_sequence.high);
+        udelay(10);
         /* reset the panel */
         gpio_set_value(td->reset_gpio, 0);
         /* assert reset */
-        if (td->panel_config->reset_sequence.low)
-                udelay(td->panel_config->reset_sequence.low);
+        udelay(10);
         gpio_set_value(td->reset_gpio, 1);
         /* wait after releasing reset */
-        if (td->panel_config->sleep.hw_reset)
-                msleep(td->panel_config->sleep.hw_reset);
+        msleep(5);
 }
 
 static void taal_probe_pdata(struct taal_data *td,
@@ -881,8 +766,7 @@ static int taal_probe(struct omap_dss_device *dssdev)
         struct backlight_properties props;
         struct taal_data *td;
         struct backlight_device *bldev = NULL;
-        int r, i;
-        const char *panel_name;
+        int r;
 
         dev_dbg(&dssdev->dev, "probe\n");
 
@@ -897,26 +781,13 @@ static int taal_probe(struct omap_dss_device *dssdev)
                 const struct nokia_dsi_panel_data *pdata = dssdev->data;
 
                 taal_probe_pdata(td, pdata);
-
-                panel_name = pdata->name;
         } else {
                 return -ENODEV;
         }
 
-        if (panel_name == NULL)
-                return -EINVAL;
-
-        for (i = 0; i < ARRAY_SIZE(panel_configs); i++) {
-                if (strcmp(panel_name, panel_configs[i].name) == 0) {
-                        td->panel_config = &panel_configs[i];
-                        break;
-                }
-        }
-
-        if (!td->panel_config)
-                return -EINVAL;
-
-        dssdev->panel.timings = td->panel_config->timings;
+        dssdev->panel.timings.x_res = 864;
+        dssdev->panel.timings.y_res = 480;
+        dssdev->panel.timings.pixel_clock = DIV_ROUND_UP(864 * 480 * 60, 1000);
         dssdev->panel.dsi_pix_fmt = OMAP_DSS_DSI_FMT_RGB888;
         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
                 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
@@ -1049,6 +920,15 @@ static int taal_power_on(struct omap_dss_device *dssdev)
         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
         u8 id1, id2, id3;
         int r;
+        struct omap_dss_dsi_config dsi_config = {
+                .mode = OMAP_DSS_DSI_CMD_MODE,
+                .pixel_format = OMAP_DSS_DSI_FMT_RGB888,
+                .timings = &dssdev->panel.timings,
+                .hs_clk_min = 150000000,
+                .hs_clk_max = 300000000,
+                .lp_clk_min = 7000000,
+                .lp_clk_max = 10000000,
+        };
 
         r = omapdss_dsi_configure_pins(dssdev, &td->pin_config);
         if (r) {
@@ -1056,14 +936,9 @@ static int taal_power_on(struct omap_dss_device *dssdev)
                 goto err0;
         };
 
-        omapdss_dsi_set_size(dssdev, dssdev->panel.timings.x_res,
-                dssdev->panel.timings.y_res);
-        omapdss_dsi_set_pixel_format(dssdev, OMAP_DSS_DSI_FMT_RGB888);
-        omapdss_dsi_set_operation_mode(dssdev, OMAP_DSS_DSI_CMD_MODE);
-
-        r = omapdss_dsi_set_clocks(dssdev, 216000000, 10000000);
+        r = omapdss_dsi_set_config(dssdev, &dsi_config);
         if (r) {
-                dev_err(&dssdev->dev, "failed to set HS and LP clocks\n");
+                dev_err(&dssdev->dev, "failed to configure DSI\n");
                 goto err0;
         }
 
@@ -1086,8 +961,7 @@ static int taal_power_on(struct omap_dss_device *dssdev)
                 goto err;
 
         /* on early Taal revisions CABC is broken */
-        if (td->panel_config->type == PANEL_TAAL &&
-                (id2 == 0x00 || id2 == 0xff || id2 == 0x81))
+        if (id2 == 0x00 || id2 == 0xff || id2 == 0x81)
                 td->cabc_broken = true;
 
         r = taal_dcs_write_1(td, DCS_BRIGHTNESS, 0xff);
@@ -1104,10 +978,6 @@ static int taal_power_on(struct omap_dss_device *dssdev)
         if (r)
                 goto err;
 
-        r = taal_set_addr_mode(td, td->rotate, td->mirror);
-        if (r)
-                goto err;
-
         if (!td->cabc_broken) {
                 r = taal_dcs_write_1(td, DCS_WRITE_CABC, td->cabc_mode);
                 if (r)
@@ -1129,8 +999,8 @@ static int taal_power_on(struct omap_dss_device *dssdev)
         td->enabled = 1;
 
         if (!td->intro_printed) {
-                dev_info(&dssdev->dev, "%s panel revision %02x.%02x.%02x\n",
-                        td->panel_config->name, id1, id2, id3);
+                dev_info(&dssdev->dev, "panel revision %02x.%02x.%02x\n",
+                        id1, id2, id3);
                 if (td->cabc_broken)
                         dev_info(&dssdev->dev,
                                         "old Taal version, CABC disabled\n");
@@ -1311,8 +1181,8 @@ static int taal_update(struct omap_dss_device *dssdev,
 
         /* XXX no need to send this every frame, but dsi break if not done */
         r = taal_set_update_window(td, 0, 0,
-                        td->panel_config->timings.x_res,
-                        td->panel_config->timings.y_res);
+                        dssdev->panel.timings.x_res,
+                        dssdev->panel.timings.y_res);
         if (r)
                 goto err;
 
@@ -1365,8 +1235,8 @@ static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable)
         if (!gpio_is_valid(td->ext_te_gpio))
                 omapdss_dsi_enable_te(dssdev, enable);
 
-        if (td->panel_config->sleep.enable_te)
-                msleep(td->panel_config->sleep.enable_te);
+        /* possible panel bug */
+        msleep(100);
 
         return r;
 }
@@ -1419,112 +1289,6 @@ static int taal_get_te(struct omap_dss_device *dssdev)
         return r;
 }
 
-static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
-{
-        struct taal_data *td = dev_get_drvdata(&dssdev->dev);
-        u16 dw, dh;
-        int r;
-
-        dev_dbg(&dssdev->dev, "rotate %d\n", rotate);
-
-        mutex_lock(&td->lock);
-
-        if (td->rotate == rotate)
-                goto end;
-
-        dsi_bus_lock(dssdev);
-
-        if (td->enabled) {
-                r = taal_wake_up(dssdev);
-                if (r)
-                        goto err;
-
-                r = taal_set_addr_mode(td, rotate, td->mirror);
-                if (r)
-                        goto err;
-        }
-
-        if (rotate == 0 || rotate == 2) {
-                dw = dssdev->panel.timings.x_res;
-                dh = dssdev->panel.timings.y_res;
-        } else {
-                dw = dssdev->panel.timings.y_res;
-                dh = dssdev->panel.timings.x_res;
-        }
-
-        omapdss_dsi_set_size(dssdev, dw, dh);
-
-        td->rotate = rotate;
-
-        dsi_bus_unlock(dssdev);
-end:
-        mutex_unlock(&td->lock);
-        return 0;
-err:
-        dsi_bus_unlock(dssdev);
-        mutex_unlock(&td->lock);
-        return r;
-}
-
-static u8 taal_get_rotate(struct omap_dss_device *dssdev)
-{
-        struct taal_data *td = dev_get_drvdata(&dssdev->dev);
-        int r;
-
-        mutex_lock(&td->lock);
-        r = td->rotate;
-        mutex_unlock(&td->lock);
-
-        return r;
-}
-
-static int taal_mirror(struct omap_dss_device *dssdev, bool enable)
-{
-        struct taal_data *td = dev_get_drvdata(&dssdev->dev);
-        int r;
-
-        dev_dbg(&dssdev->dev, "mirror %d\n", enable);
-
-        mutex_lock(&td->lock);
-
-        if (td->mirror == enable)
-                goto end;
-
-        dsi_bus_lock(dssdev);
-        if (td->enabled) {
-                r = taal_wake_up(dssdev);
-                if (r)
-                        goto err;
-
-                r = taal_set_addr_mode(td, td->rotate, enable);
-                if (r)
-                        goto err;
-        }
-
-        td->mirror = enable;
-
-        dsi_bus_unlock(dssdev);
-end:
-        mutex_unlock(&td->lock);
-        return 0;
-err:
-        dsi_bus_unlock(dssdev);
-        mutex_unlock(&td->lock);
-        return r;
-}
-
-static bool taal_get_mirror(struct omap_dss_device *dssdev)
-{
-        struct taal_data *td = dev_get_drvdata(&dssdev->dev);
-        int r;
-
-        mutex_lock(&td->lock);
-        r = td->mirror;
-        mutex_unlock(&td->lock);
-
-        return r;
-}
-
 static int taal_run_test(struct omap_dss_device *dssdev, int test_num)
 {
         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
@@ -1758,10 +1522,6 @@ static struct omap_dss_driver taal_driver = {
         .enable_te      = taal_enable_te,
         .get_te         = taal_get_te,
 
-        .set_rotate     = taal_rotate,
-        .get_rotate     = taal_get_rotate,
-        .set_mirror     = taal_mirror,
-        .get_mirror     = taal_get_mirror,
         .run_test       = taal_run_test,
         .memory_read    = taal_memory_read,
 
diff --git a/drivers/video/omap2/displays/panel-tfp410.c b/drivers/video/omap2/displays/panel-tfp410.c
index 8281baafe1ef..46039c4bf1ed 100644
--- a/drivers/video/omap2/displays/panel-tfp410.c
+++ b/drivers/video/omap2/displays/panel-tfp410.c
@@ -24,7 +24,7 @@
 #include <linux/gpio.h>
 #include <drm/drm_edid.h>
 
-#include <video/omap-panel-tfp410.h>
+#include <video/omap-panel-data.h>
 
 static const struct omap_video_timings tfp410_default_timings = {
         .x_res          = 640,
@@ -135,7 +135,7 @@ static int tfp410_probe(struct omap_dss_device *dssdev)
                 if (!adapter) {
                         dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
                                         i2c_bus_num);
-                        return -EINVAL;
+                        return -EPROBE_DEFER;
                 }
 
                 ddata->i2c_adapter = adapter;
diff --git a/drivers/video/omap2/displays/panel-tpo-td043mtea1.c b/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
index 048c98381ef6..abf2bc4a18ab 100644
--- a/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
+++ b/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 
 #include <video/omapdss.h>
+#include <video/omap-panel-data.h>
 
 #define TPO_R02_MODE(x)         ((x) & 7)
 #define TPO_R02_MODE_800x480    7
@@ -278,9 +279,14 @@ static const struct omap_video_timings tpo_td043_timings = {
         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
 };
 
+static inline struct panel_tpo_td043_data
+*get_panel_data(const struct omap_dss_device *dssdev)
+{
+        return (struct panel_tpo_td043_data *) dssdev->data;
+}
+
 static int tpo_td043_power_on(struct tpo_td043_device *tpo_td043)
 {
-        int nreset_gpio = tpo_td043->nreset_gpio;
         int r;
 
         if (tpo_td043->powered_on)
@@ -293,8 +299,8 @@ static int tpo_td043_power_on(struct tpo_td043_device *tpo_td043)
         /* wait for panel to stabilize */
         msleep(160);
 
-        if (gpio_is_valid(nreset_gpio))
-                gpio_set_value(nreset_gpio, 1);
+        if (gpio_is_valid(tpo_td043->nreset_gpio))
+                gpio_set_value(tpo_td043->nreset_gpio, 1);
 
         tpo_td043_write(tpo_td043->spi, 2,
                         TPO_R02_MODE(tpo_td043->mode) | TPO_R02_NCLK_RISING);
@@ -311,16 +317,14 @@ static int tpo_td043_power_on(struct tpo_td043_device *tpo_td043)
 
 static void tpo_td043_power_off(struct tpo_td043_device *tpo_td043)
 {
-        int nreset_gpio = tpo_td043->nreset_gpio;
-
         if (!tpo_td043->powered_on)
                 return;
 
         tpo_td043_write(tpo_td043->spi, 3,
                         TPO_R03_VAL_STANDBY | TPO_R03_EN_PWM);
 
-        if (gpio_is_valid(nreset_gpio))
-                gpio_set_value(nreset_gpio, 0);
+        if (gpio_is_valid(tpo_td043->nreset_gpio))
+                gpio_set_value(tpo_td043->nreset_gpio, 0);
 
         /* wait for at least 2 vsyncs before cutting off power */
         msleep(50);
@@ -347,12 +351,6 @@ static int tpo_td043_enable_dss(struct omap_dss_device *dssdev)
         if (r)
                 goto err0;
 
-        if (dssdev->platform_enable) {
-                r = dssdev->platform_enable(dssdev);
-                if (r)
-                        goto err1;
-        }
-
         /*
          * If we are resuming from system suspend, SPI clocks might not be
          * enabled yet, so we'll program the LCD from SPI PM resume callback.
@@ -379,9 +377,6 @@ static void tpo_td043_disable_dss(struct omap_dss_device *dssdev)
         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return;
 
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
-
         omapdss_dpi_display_disable(dssdev);
 
         if (!tpo_td043->spi_suspended)
@@ -407,7 +402,7 @@ static void tpo_td043_disable(struct omap_dss_device *dssdev)
 static int tpo_td043_probe(struct omap_dss_device *dssdev)
 {
         struct tpo_td043_device *tpo_td043 = g_tpo_td043;
-        int nreset_gpio = dssdev->reset_gpio;
+        struct panel_tpo_td043_data *pdata = get_panel_data(dssdev);
         int ret = 0;
 
         dev_dbg(&dssdev->dev, "probe\n");
@@ -417,6 +412,11 @@ static int tpo_td043_probe(struct omap_dss_device *dssdev)
                 return -ENODEV;
         }
 
+        if (!pdata)
+                return -EINVAL;
+
+        tpo_td043->nreset_gpio = pdata->nreset_gpio;
+
         dssdev->panel.timings = tpo_td043_timings;
         dssdev->ctrl.pixel_size = 24;
 
@@ -430,9 +430,10 @@ static int tpo_td043_probe(struct omap_dss_device *dssdev)
                 goto fail_regulator;
         }
 
-        if (gpio_is_valid(nreset_gpio)) {
-                ret = gpio_request_one(nreset_gpio, GPIOF_OUT_INIT_LOW,
-                                        "lcd reset");
+        if (gpio_is_valid(tpo_td043->nreset_gpio)) {
+                ret = devm_gpio_request_one(&dssdev->dev,
+                                tpo_td043->nreset_gpio, GPIOF_OUT_INIT_LOW,
+                                "lcd reset");
                 if (ret < 0) {
                         dev_err(&dssdev->dev, "couldn't request reset GPIO\n");
                         goto fail_gpio_req;
@@ -457,14 +458,11 @@ fail_regulator:
 static void tpo_td043_remove(struct omap_dss_device *dssdev)
 {
         struct tpo_td043_device *tpo_td043 = dev_get_drvdata(&dssdev->dev);
-        int nreset_gpio = dssdev->reset_gpio;
 
         dev_dbg(&dssdev->dev, "remove\n");
 
         sysfs_remove_group(&dssdev->dev.kobj, &tpo_td043_attr_group);
         regulator_put(tpo_td043->vcc_reg);
-        if (gpio_is_valid(nreset_gpio))
-                gpio_free(nreset_gpio);
 }
 
 static void tpo_td043_set_timings(struct omap_dss_device *dssdev,
@@ -527,7 +525,6 @@ static int tpo_td043_spi_probe(struct spi_device *spi)
                 return -ENOMEM;
 
         tpo_td043->spi = spi;
-        tpo_td043->nreset_gpio = dssdev->reset_gpio;
         dev_set_drvdata(&spi->dev, tpo_td043);
         g_tpo_td043 = tpo_td043;
 
diff --git a/drivers/video/omap2/dss/apply.c b/drivers/video/omap2/dss/apply.c
index d446bdfc4c82..a4b356a9780d 100644
--- a/drivers/video/omap2/dss/apply.c
+++ b/drivers/video/omap2/dss/apply.c
@@ -435,20 +435,27 @@ static inline struct omap_dss_device *dss_mgr_get_device(struct omap_overlay_man
 static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
 {
         unsigned long timeout = msecs_to_jiffies(500);
-        struct omap_dss_device *dssdev = mgr->get_device(mgr);
         u32 irq;
         int r;
 
+        if (mgr->output == NULL)
+                return -ENODEV;
+
         r = dispc_runtime_get();
         if (r)
                 return r;
 
-        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC)
+        switch (mgr->output->id) {
+        case OMAP_DSS_OUTPUT_VENC:
                 irq = DISPC_IRQ_EVSYNC_ODD;
-        else if (dssdev->type == OMAP_DISPLAY_TYPE_HDMI)
+                break;
+        case OMAP_DSS_OUTPUT_HDMI:
                 irq = DISPC_IRQ_EVSYNC_EVEN;
-        else
+                break;
+        default:
                 irq = dispc_mgr_get_vsync_irq(mgr->id);
+                break;
+        }
 
         r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
 
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index f8779d4750ba..60cc6fee6548 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -181,10 +181,7 @@ int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
         d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir,
                         write, &dss_debug_fops);
 
-        if (IS_ERR(d))
-                return PTR_ERR(d);
-
-        return 0;
+        return PTR_RET(d);
 }
 #else /* CONFIG_OMAP2_DSS_DEBUGFS */
 static inline int dss_initialize_debugfs(void)
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 05ff2b91d9e8..b33b0169bb3b 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -69,6 +69,8 @@ struct dispc_features {
         u8 mgr_height_start;
         u16 mgr_width_max;
         u16 mgr_height_max;
+        unsigned long max_lcd_pclk;
+        unsigned long max_tv_pclk;
         int (*calc_scaling) (unsigned long pclk, unsigned long lclk,
                 const struct omap_video_timings *mgr_timings,
                 u16 width, u16 height, u16 out_width, u16 out_height,
@@ -85,6 +87,9 @@ struct dispc_features {
 
         /* no DISPC_IRQ_FRAMEDONETV on this SoC */
         bool no_framedone_tv:1;
+
+        /* revert to the OMAP4 mechanism of DISPC Smart Standby operation */
+        bool mstandby_workaround:1;
 };
 
 #define DISPC_MAX_NR_FIFOS 5
@@ -97,6 +102,8 @@ static struct {
 
         int irq;
 
+        unsigned long core_clk_rate;
+
         u32 fifo_size[DISPC_MAX_NR_FIFOS];
         /* maps which plane is using a fifo. fifo-id -> plane-id */
         int fifo_assignment[DISPC_MAX_NR_FIFOS];
@@ -1584,6 +1591,7 @@ static void dispc_ovl_set_scaling(enum omap_plane plane,
 }
 
 static void dispc_ovl_set_rotation_attrs(enum omap_plane plane, u8 rotation,
+                enum omap_dss_rotation_type rotation_type,
                 bool mirroring, enum omap_color_mode color_mode)
 {
         bool row_repeat = false;
@@ -1634,6 +1642,15 @@ static void dispc_ovl_set_rotation_attrs(enum omap_plane plane, u8 rotation,
         if (dss_has_feature(FEAT_ROWREPEATENABLE))
                 REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane),
                         row_repeat ? 1 : 0, 18, 18);
+
+        if (color_mode == OMAP_DSS_COLOR_NV12) {
+                bool doublestride = (rotation_type == OMAP_DSS_ROT_TILER) &&
+                                        (rotation == OMAP_DSS_ROT_0 ||
+                                        rotation == OMAP_DSS_ROT_180);
+                /* DOUBLESTRIDE */
+                REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane), doublestride, 22, 22);
+        }
+
 }
 
 static int color_mode_to_bpp(enum omap_color_mode color_mode)
@@ -2512,7 +2529,8 @@ static int dispc_ovl_setup_common(enum omap_plane plane,
                 dispc_ovl_set_vid_color_conv(plane, cconv);
         }
 
-        dispc_ovl_set_rotation_attrs(plane, rotation, mirror, color_mode);
+        dispc_ovl_set_rotation_attrs(plane, rotation, rotation_type, mirror,
+                        color_mode);
 
         dispc_ovl_set_zorder(plane, caps, zorder);
         dispc_ovl_set_pre_mult_alpha(plane, caps, pre_mult_alpha);
@@ -2823,6 +2841,15 @@ static bool _dispc_lcd_timings_ok(int hsw, int hfp, int hbp,
         return true;
 }
 
+static bool _dispc_mgr_pclk_ok(enum omap_channel channel,
+                unsigned long pclk)
+{
+        if (dss_mgr_is_lcd(channel))
+                return pclk <= dispc.feat->max_lcd_pclk ? true : false;
+        else
+                return pclk <= dispc.feat->max_tv_pclk ? true : false;
+}
+
 bool dispc_mgr_timings_ok(enum omap_channel channel,
                 const struct omap_video_timings *timings)
 {
@@ -2830,11 +2857,13 @@ bool dispc_mgr_timings_ok(enum omap_channel channel,
 
         timings_ok = _dispc_mgr_size_ok(timings->x_res, timings->y_res);
 
-        if (dss_mgr_is_lcd(channel))
-                timings_ok =  timings_ok && _dispc_lcd_timings_ok(timings->hsw,
-                                                timings->hfp, timings->hbp,
-                                                timings->vsw, timings->vfp,
-                                                timings->vbp);
+        timings_ok &= _dispc_mgr_pclk_ok(channel, timings->pixel_clock * 1000);
+
+        if (dss_mgr_is_lcd(channel)) {
+                timings_ok &= _dispc_lcd_timings_ok(timings->hsw, timings->hfp,
+                                timings->hbp, timings->vsw, timings->vfp,
+                                timings->vbp);
+        }
 
         return timings_ok;
 }
@@ -2951,6 +2980,10 @@ static void dispc_mgr_set_lcd_divisor(enum omap_channel channel, u16 lck_div,
 
         dispc_write_reg(DISPC_DIVISORo(channel),
                         FLD_VAL(lck_div, 23, 16) | FLD_VAL(pck_div, 7, 0));
+
+        if (dss_has_feature(FEAT_CORE_CLK_DIV) == false &&
+                        channel == OMAP_DSS_CHANNEL_LCD)
+                dispc.core_clk_rate = dispc_fclk_rate() / lck_div;
 }
 
 static void dispc_mgr_get_lcd_divisor(enum omap_channel channel, int *lck_div,
@@ -3056,15 +3089,7 @@ unsigned long dispc_mgr_pclk_rate(enum omap_channel channel)
 
 unsigned long dispc_core_clk_rate(void)
 {
-        int lcd;
-        unsigned long fclk = dispc_fclk_rate();
-
-        if (dss_has_feature(FEAT_CORE_CLK_DIV))
-                lcd = REG_GET(DISPC_DIVISOR, 23, 16);
-        else
-                lcd = REG_GET(DISPC_DIVISORo(OMAP_DSS_CHANNEL_LCD), 23, 16);
-
-        return fclk / lcd;
+        return dispc.core_clk_rate;
 }
 
 static unsigned long dispc_plane_pclk_rate(enum omap_plane plane)
@@ -3313,67 +3338,79 @@ static void dispc_dump_regs(struct seq_file *s)
 #undef DUMPREG
 }
 
-/* with fck as input clock rate, find dispc dividers that produce req_pck */
-void dispc_find_clk_divs(unsigned long req_pck, unsigned long fck,
+/* calculate clock rates using dividers in cinfo */
+int dispc_calc_clock_rates(unsigned long dispc_fclk_rate,
                 struct dispc_clock_info *cinfo)
 {
-        u16 pcd_min, pcd_max;
-        unsigned long best_pck;
-        u16 best_ld, cur_ld;
-        u16 best_pd, cur_pd;
+        if (cinfo->lck_div > 255 || cinfo->lck_div == 0)
+                return -EINVAL;
+        if (cinfo->pck_div < 1 || cinfo->pck_div > 255)
+                return -EINVAL;
 
-        pcd_min = dss_feat_get_param_min(FEAT_PARAM_DSS_PCD);
-        pcd_max = dss_feat_get_param_max(FEAT_PARAM_DSS_PCD);
+        cinfo->lck = dispc_fclk_rate / cinfo->lck_div;
+        cinfo->pck = cinfo->lck / cinfo->pck_div;
 
-        best_pck = 0;
-        best_ld = 0;
-        best_pd = 0;
+        return 0;
+}
 
-        for (cur_ld = 1; cur_ld <= 255; ++cur_ld) {
-                unsigned long lck = fck / cur_ld;
+bool dispc_div_calc(unsigned long dispc,
+                unsigned long pck_min, unsigned long pck_max,
+                dispc_div_calc_func func, void *data)
+{
+        int lckd, lckd_start, lckd_stop;
+        int pckd, pckd_start, pckd_stop;
+        unsigned long pck, lck;
+        unsigned long lck_max;
+        unsigned long pckd_hw_min, pckd_hw_max;
+        unsigned min_fck_per_pck;
+        unsigned long fck;
 
-                for (cur_pd = pcd_min; cur_pd <= pcd_max; ++cur_pd) {
-                        unsigned long pck = lck / cur_pd;
-                        long old_delta = abs(best_pck - req_pck);
-                        long new_delta = abs(pck - req_pck);
+#ifdef CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK
+        min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
+#else
+        min_fck_per_pck = 0;
+#endif
 
-                        if (best_pck == 0 || new_delta < old_delta) {
-                                best_pck = pck;
-                                best_ld = cur_ld;
-                                best_pd = cur_pd;
+        pckd_hw_min = dss_feat_get_param_min(FEAT_PARAM_DSS_PCD);
+        pckd_hw_max = dss_feat_get_param_max(FEAT_PARAM_DSS_PCD);
 
-                                if (pck == req_pck)
-                                        goto found;
-                        }
+        lck_max = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
 
-                        if (pck < req_pck)
-                                break;
-                }
+        pck_min = pck_min ? pck_min : 1;
+        pck_max = pck_max ? pck_max : ULONG_MAX;
 
-                if (lck / pcd_min < req_pck)
-                        break;
-        }
+        lckd_start = max(DIV_ROUND_UP(dispc, lck_max), 1ul);
+        lckd_stop = min(dispc / pck_min, 255ul);
 
-found:
-        cinfo->lck_div = best_ld;
-        cinfo->pck_div = best_pd;
-        cinfo->lck = fck / cinfo->lck_div;
-        cinfo->pck = cinfo->lck / cinfo->pck_div;
-}
+        for (lckd = lckd_start; lckd <= lckd_stop; ++lckd) {
+                lck = dispc / lckd;
 
-/* calculate clock rates using dividers in cinfo */
-int dispc_calc_clock_rates(unsigned long dispc_fclk_rate,
-                struct dispc_clock_info *cinfo)
-{
-        if (cinfo->lck_div > 255 || cinfo->lck_div == 0)
-                return -EINVAL;
-        if (cinfo->pck_div < 1 || cinfo->pck_div > 255)
-                return -EINVAL;
+                pckd_start = max(DIV_ROUND_UP(lck, pck_max), pckd_hw_min);
+                pckd_stop = min(lck / pck_min, pckd_hw_max);
 
-        cinfo->lck = dispc_fclk_rate / cinfo->lck_div;
-        cinfo->pck = cinfo->lck / cinfo->pck_div;
+                for (pckd = pckd_start; pckd <= pckd_stop; ++pckd) {
+                        pck = lck / pckd;
 
-        return 0;
+                        /*
+                         * For OMAP2/3 the DISPC fclk is the same as LCD's logic
+                         * clock, which means we're configuring DISPC fclk here
+                         * also. Thus we need to use the calculated lck. For
+                         * OMAP4+ the DISPC fclk is a separate clock.
+                         */
+                        if (dss_has_feature(FEAT_CORE_CLK_DIV))
+                                fck = dispc_core_clk_rate();
+                        else
+                                fck = lck;
+
+                        if (fck < pck * min_fck_per_pck)
+                                continue;
+
+                        if (func(lckd, pckd, lck, pck, data))
+                                return true;
+                }
+        }
+
+        return false;
 }
 
 void dispc_mgr_set_clock_div(enum omap_channel channel,
@@ -3451,6 +3488,8 @@ static void _omap_dispc_initial_config(void)
                 l = FLD_MOD(l, 1, 0, 0);
                 l = FLD_MOD(l, 1, 23, 16);
                 dispc_write_reg(DISPC_DIVISOR, l);
+
+                dispc.core_clk_rate = dispc_fclk_rate();
         }
 
         /* FUNCGATED */
@@ -3466,6 +3505,9 @@ static void _omap_dispc_initial_config(void)
         dispc_configure_burst_sizes();
 
         dispc_ovl_enable_zorder_planes();
+
+        if (dispc.feat->mstandby_workaround)
+                REG_FLD_MOD(DISPC_MSTANDBY_CTRL, 1, 0, 0);
 }
 
 static const struct dispc_features omap24xx_dispc_feats __initconst = {
@@ -3479,6 +3521,7 @@ static const struct dispc_features omap24xx_dispc_feats __initconst = {
         .mgr_height_start       =       26,
         .mgr_width_max          =       2048,
         .mgr_height_max         =       2048,
+        .max_lcd_pclk           =       66500000,
         .calc_scaling           =       dispc_ovl_calc_scaling_24xx,
         .calc_core_clk          =       calc_core_clk_24xx,
         .num_fifos              =       3,
@@ -3496,6 +3539,8 @@ static const struct dispc_features omap34xx_rev1_0_dispc_feats __initconst = {
         .mgr_height_start       =       26,
         .mgr_width_max          =       2048,
         .mgr_height_max         =       2048,
+        .max_lcd_pclk           =       173000000,
+        .max_tv_pclk            =       59000000,
         .calc_scaling           =       dispc_ovl_calc_scaling_34xx,
         .calc_core_clk          =       calc_core_clk_34xx,
         .num_fifos              =       3,
@@ -3513,6 +3558,8 @@ static const struct dispc_features omap34xx_rev3_0_dispc_feats __initconst = {
         .mgr_height_start       =       26,
         .mgr_width_max          =       2048,
         .mgr_height_max         =       2048,
+        .max_lcd_pclk           =       173000000,
+        .max_tv_pclk            =       59000000,
         .calc_scaling           =       dispc_ovl_calc_scaling_34xx,
         .calc_core_clk          =       calc_core_clk_34xx,
         .num_fifos              =       3,
@@ -3530,6 +3577,8 @@ static const struct dispc_features omap44xx_dispc_feats __initconst = {
         .mgr_height_start       =       26,
         .mgr_width_max          =       2048,
         .mgr_height_max         =       2048,
+        .max_lcd_pclk           =       170000000,
+        .max_tv_pclk            =       185625000,
         .calc_scaling           =       dispc_ovl_calc_scaling_44xx,
         .calc_core_clk          =       calc_core_clk_44xx,
         .num_fifos              =       5,
@@ -3547,10 +3596,13 @@ static const struct dispc_features omap54xx_dispc_feats __initconst = {
         .mgr_height_start       =       27,
         .mgr_width_max          =       4096,
         .mgr_height_max         =       4096,
+        .max_lcd_pclk           =       170000000,
+        .max_tv_pclk            =       186000000,
         .calc_scaling           =       dispc_ovl_calc_scaling_44xx,
         .calc_core_clk          =       calc_core_clk_44xx,
         .num_fifos              =       5,
         .gfx_fifo_workaround    =       true,
+        .mstandby_workaround    =       true,
 };
 
 static int __init dispc_init_features(struct platform_device *pdev)
diff --git a/drivers/video/omap2/dss/dispc.h b/drivers/video/omap2/dss/dispc.h
index 222363c6e623..de4863d21ab7 100644
--- a/drivers/video/omap2/dss/dispc.h
+++ b/drivers/video/omap2/dss/dispc.h
@@ -39,6 +39,7 @@
 #define DISPC_GLOBAL_BUFFER             0x0800
 #define DISPC_CONTROL3                  0x0848
 #define DISPC_CONFIG3                   0x084C
+#define DISPC_MSTANDBY_CTRL             0x0858
 
 /* DISPC overlay registers */
 #define DISPC_OVL_BA0(n)                (DISPC_OVL_BASE(n) + \
diff --git a/drivers/video/omap2/dss/dpi.c b/drivers/video/omap2/dss/dpi.c
index 4af136a04e53..757b57f7275a 100644
--- a/drivers/video/omap2/dss/dpi.c
+++ b/drivers/video/omap2/dss/dpi.c
@@ -63,15 +63,29 @@ static struct platform_device *dpi_get_dsidev(enum omap_channel channel)
         case OMAPDSS_VER_OMAP3630:
         case OMAPDSS_VER_AM35xx:
                 return NULL;
-        default:
-                break;
-        }
 
-        switch (channel) {
-        case OMAP_DSS_CHANNEL_LCD:
-                return dsi_get_dsidev_from_id(0);
-        case OMAP_DSS_CHANNEL_LCD2:
-                return dsi_get_dsidev_from_id(1);
+        case OMAPDSS_VER_OMAP4430_ES1:
+        case OMAPDSS_VER_OMAP4430_ES2:
+        case OMAPDSS_VER_OMAP4:
+                switch (channel) {
+                case OMAP_DSS_CHANNEL_LCD:
+                        return dsi_get_dsidev_from_id(0);
+                case OMAP_DSS_CHANNEL_LCD2:
+                        return dsi_get_dsidev_from_id(1);
+                default:
+                        return NULL;
+                }
+
+        case OMAPDSS_VER_OMAP5:
+                switch (channel) {
+                case OMAP_DSS_CHANNEL_LCD:
+                        return dsi_get_dsidev_from_id(0);
+                case OMAP_DSS_CHANNEL_LCD3:
+                        return dsi_get_dsidev_from_id(1);
+                default:
+                        return NULL;
+                }
+
         default:
                 return NULL;
         }
@@ -91,75 +105,211 @@ static enum omap_dss_clk_source dpi_get_alt_clk_src(enum omap_channel channel)
         }
 }
 
-static int dpi_set_dsi_clk(struct omap_dss_device *dssdev,
+struct dpi_clk_calc_ctx {
+        struct platform_device *dsidev;
+
+        /* inputs */
+
+        unsigned long pck_min, pck_max;
+
+        /* outputs */
+
+        struct dsi_clock_info dsi_cinfo;
+        struct dss_clock_info dss_cinfo;
+        struct dispc_clock_info dispc_cinfo;
+};
+
+static bool dpi_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
+                unsigned long pck, void *data)
+{
+        struct dpi_clk_calc_ctx *ctx = data;
+
+        /*
+         * Odd dividers give us uneven duty cycle, causing problem when level
+         * shifted. So skip all odd dividers when the pixel clock is on the
+         * higher side.
+         */
+        if (ctx->pck_min >= 1000000) {
+                if (lckd > 1 && lckd % 2 != 0)
+                        return false;
+
+                if (pckd > 1 && pckd % 2 != 0)
+                        return false;
+        }
+
+        ctx->dispc_cinfo.lck_div = lckd;
+        ctx->dispc_cinfo.pck_div = pckd;
+        ctx->dispc_cinfo.lck = lck;
+        ctx->dispc_cinfo.pck = pck;
+
+        return true;
+}
+
+
+static bool dpi_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+                void *data)
+{
+        struct dpi_clk_calc_ctx *ctx = data;
+
+        /*
+         * Odd dividers give us uneven duty cycle, causing problem when level
+         * shifted. So skip all odd dividers when the pixel clock is on the
+         * higher side.
+         */
+        if (regm_dispc > 1 && regm_dispc % 2 != 0 && ctx->pck_min >= 1000000)
+                return false;
+
+        ctx->dsi_cinfo.regm_dispc = regm_dispc;
+        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
+
+        return dispc_div_calc(dispc, ctx->pck_min, ctx->pck_max,
+                        dpi_calc_dispc_cb, ctx);
+}
+
+
+static bool dpi_calc_pll_cb(int regn, int regm, unsigned long fint,
+                unsigned long pll,
+                void *data)
+{
+        struct dpi_clk_calc_ctx *ctx = data;
+
+        ctx->dsi_cinfo.regn = regn;
+        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.fint = fint;
+        ctx->dsi_cinfo.clkin4ddr = pll;
+
+        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->pck_min,
+                        dpi_calc_hsdiv_cb, ctx);
+}
+
+static bool dpi_calc_dss_cb(int fckd, unsigned long fck, void *data)
+{
+        struct dpi_clk_calc_ctx *ctx = data;
+
+        ctx->dss_cinfo.fck = fck;
+        ctx->dss_cinfo.fck_div = fckd;
+
+        return dispc_div_calc(fck, ctx->pck_min, ctx->pck_max,
+                        dpi_calc_dispc_cb, ctx);
+}
+
+static bool dpi_dsi_clk_calc(unsigned long pck, struct dpi_clk_calc_ctx *ctx)
+{
+        unsigned long clkin;
+        unsigned long pll_min, pll_max;
+
+        clkin = dsi_get_pll_clkin(dpi.dsidev);
+
+        memset(ctx, 0, sizeof(*ctx));
+        ctx->dsidev = dpi.dsidev;
+        ctx->pck_min = pck - 1000;
+        ctx->pck_max = pck + 1000;
+        ctx->dsi_cinfo.clkin = clkin;
+
+        pll_min = 0;
+        pll_max = 0;
+
+        return dsi_pll_calc(dpi.dsidev, clkin,
+                        pll_min, pll_max,
+                        dpi_calc_pll_cb, ctx);
+}
+
+static bool dpi_dss_clk_calc(unsigned long pck, struct dpi_clk_calc_ctx *ctx)
+{
+        int i;
+
+        /*
+         * DSS fck gives us very few possibilities, so finding a good pixel
+         * clock may not be possible. We try multiple times to find the clock,
+         * each time widening the pixel clock range we look for, up to
+         * +/- ~15MHz.
+         */
+
+        for (i = 0; i < 25; ++i) {
+                bool ok;
+
+                memset(ctx, 0, sizeof(*ctx));
+                if (pck > 1000 * i * i * i)
+                        ctx->pck_min = max(pck - 1000 * i * i * i, 0lu);
+                else
+                        ctx->pck_min = 0;
+                ctx->pck_max = pck + 1000 * i * i * i;
+
+                ok = dss_div_calc(ctx->pck_min, dpi_calc_dss_cb, ctx);
+                if (ok)
+                        return ok;
+        }
+
+        return false;
+}
+
+
+
+static int dpi_set_dsi_clk(enum omap_channel channel,
                 unsigned long pck_req, unsigned long *fck, int *lck_div,
                 int *pck_div)
 {
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
-        struct dsi_clock_info dsi_cinfo;
-        struct dispc_clock_info dispc_cinfo;
+        struct dpi_clk_calc_ctx ctx;
         int r;
+        bool ok;
 
-        r = dsi_pll_calc_clock_div_pck(dpi.dsidev, pck_req, &dsi_cinfo,
-                        &dispc_cinfo);
-        if (r)
-                return r;
+        ok = dpi_dsi_clk_calc(pck_req, &ctx);
+        if (!ok)
+                return -EINVAL;
 
-        r = dsi_pll_set_clock_div(dpi.dsidev, &dsi_cinfo);
+        r = dsi_pll_set_clock_div(dpi.dsidev, &ctx.dsi_cinfo);
         if (r)
                 return r;
 
-        dss_select_lcd_clk_source(mgr->id,
-                        dpi_get_alt_clk_src(mgr->id));
+        dss_select_lcd_clk_source(channel,
+                        dpi_get_alt_clk_src(channel));
 
-        dpi.mgr_config.clock_info = dispc_cinfo;
+        dpi.mgr_config.clock_info = ctx.dispc_cinfo;
 
-        *fck = dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
-        *lck_div = dispc_cinfo.lck_div;
-        *pck_div = dispc_cinfo.pck_div;
+        *fck = ctx.dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
+        *lck_div = ctx.dispc_cinfo.lck_div;
+        *pck_div = ctx.dispc_cinfo.pck_div;
 
         return 0;
 }
 
-static int dpi_set_dispc_clk(struct omap_dss_device *dssdev,
-                unsigned long pck_req, unsigned long *fck, int *lck_div,
-                int *pck_div)
+static int dpi_set_dispc_clk(unsigned long pck_req, unsigned long *fck,
+                int *lck_div, int *pck_div)
 {
-        struct dss_clock_info dss_cinfo;
-        struct dispc_clock_info dispc_cinfo;
+        struct dpi_clk_calc_ctx ctx;
         int r;
+        bool ok;
 
-        r = dss_calc_clock_div(pck_req, &dss_cinfo, &dispc_cinfo);
-        if (r)
-                return r;
+        ok = dpi_dss_clk_calc(pck_req, &ctx);
+        if (!ok)
+                return -EINVAL;
 
-        r = dss_set_clock_div(&dss_cinfo);
+        r = dss_set_clock_div(&ctx.dss_cinfo);
         if (r)
                 return r;
 
-        dpi.mgr_config.clock_info = dispc_cinfo;
+        dpi.mgr_config.clock_info = ctx.dispc_cinfo;
 
-        *fck = dss_cinfo.fck;
-        *lck_div = dispc_cinfo.lck_div;
-        *pck_div = dispc_cinfo.pck_div;
+        *fck = ctx.dss_cinfo.fck;
+        *lck_div = ctx.dispc_cinfo.lck_div;
+        *pck_div = ctx.dispc_cinfo.pck_div;
 
         return 0;
 }
 
-static int dpi_set_mode(struct omap_dss_device *dssdev)
+static int dpi_set_mode(struct omap_overlay_manager *mgr)
 {
         struct omap_video_timings *t = &dpi.timings;
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
         int lck_div = 0, pck_div = 0;
         unsigned long fck = 0;
         unsigned long pck;
         int r = 0;
 
         if (dpi.dsidev)
-                r = dpi_set_dsi_clk(dssdev, t->pixel_clock * 1000, &fck,
+                r = dpi_set_dsi_clk(mgr->id, t->pixel_clock * 1000, &fck,
                                 &lck_div, &pck_div);
         else
-                r = dpi_set_dispc_clk(dssdev, t->pixel_clock * 1000, &fck,
+                r = dpi_set_dispc_clk(t->pixel_clock * 1000, &fck,
                                 &lck_div, &pck_div);
         if (r)
                 return r;
@@ -179,10 +329,8 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
         return 0;
 }
 
-static void dpi_config_lcd_manager(struct omap_dss_device *dssdev)
+static void dpi_config_lcd_manager(struct omap_overlay_manager *mgr)
 {
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
-
         dpi.mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
 
         dpi.mgr_config.stallmode = false;
@@ -197,7 +345,7 @@ static void dpi_config_lcd_manager(struct omap_dss_device *dssdev)
 
 int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
 {
-        struct omap_dss_output *out = dssdev->output;
+        struct omap_dss_output *out = &dpi.output;
         int r;
 
         mutex_lock(&dpi.lock);
@@ -230,7 +378,7 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err_get_dispc;
 
-        r = dss_dpi_select_source(dssdev->channel);
+        r = dss_dpi_select_source(out->manager->id);
         if (r)
                 goto err_src_sel;
 
@@ -244,11 +392,11 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
                         goto err_dsi_pll_init;
         }
 
-        r = dpi_set_mode(dssdev);
+        r = dpi_set_mode(out->manager);
         if (r)
                 goto err_set_mode;
 
-        dpi_config_lcd_manager(dssdev);
+        dpi_config_lcd_manager(out->manager);
 
         mdelay(2);
 
@@ -285,7 +433,7 @@ EXPORT_SYMBOL(omapdss_dpi_display_enable);
 
 void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
 {
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
+        struct omap_overlay_manager *mgr = dpi.output.manager;
 
         mutex_lock(&dpi.lock);
 
@@ -324,12 +472,12 @@ EXPORT_SYMBOL(omapdss_dpi_set_timings);
 int dpi_check_timings(struct omap_dss_device *dssdev,
                         struct omap_video_timings *timings)
 {
-        int r;
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
+        struct omap_overlay_manager *mgr = dpi.output.manager;
         int lck_div, pck_div;
         unsigned long fck;
         unsigned long pck;
-        struct dispc_clock_info dispc_cinfo;
+        struct dpi_clk_calc_ctx ctx;
+        bool ok;
 
         if (mgr && !dispc_mgr_timings_ok(mgr->id, timings))
                 return -EINVAL;
@@ -338,28 +486,21 @@ int dpi_check_timings(struct omap_dss_device *dssdev,
                 return -EINVAL;
 
         if (dpi.dsidev) {
-                struct dsi_clock_info dsi_cinfo;
-                r = dsi_pll_calc_clock_div_pck(dpi.dsidev,
-                                timings->pixel_clock * 1000,
-                                &dsi_cinfo, &dispc_cinfo);
+                ok = dpi_dsi_clk_calc(timings->pixel_clock * 1000, &ctx);
+                if (!ok)
+                        return -EINVAL;
 
-                if (r)
-                        return r;
-
-                fck = dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
+                fck = ctx.dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
         } else {
-                struct dss_clock_info dss_cinfo;
-                r = dss_calc_clock_div(timings->pixel_clock * 1000,
-                                &dss_cinfo, &dispc_cinfo);
+                ok = dpi_dss_clk_calc(timings->pixel_clock * 1000, &ctx);
+                if (!ok)
+                        return -EINVAL;
 
-                if (r)
-                        return r;
-
-                fck = dss_cinfo.fck;
+                fck = ctx.dss_cinfo.fck;
         }
 
-        lck_div = dispc_cinfo.lck_div;
-        pck_div = dispc_cinfo.pck_div;
+        lck_div = ctx.dispc_cinfo.lck_div;
+        pck_div = ctx.dispc_cinfo.pck_div;
 
         pck = fck / lck_div / pck_div / 1000;
 
@@ -379,7 +520,7 @@ void omapdss_dpi_set_data_lines(struct omap_dss_device *dssdev, int data_lines)
 }
 EXPORT_SYMBOL(omapdss_dpi_set_data_lines);
 
-static int __init dpi_verify_dsi_pll(struct platform_device *dsidev)
+static int dpi_verify_dsi_pll(struct platform_device *dsidev)
 {
         int r;
 
@@ -401,7 +542,37 @@ static int __init dpi_verify_dsi_pll(struct platform_device *dsidev)
         return 0;
 }
 
-static int __init dpi_init_display(struct omap_dss_device *dssdev)
+/*
+ * Return a hardcoded channel for the DPI output. This should work for
+ * current use cases, but this can be later expanded to either resolve
+ * the channel in some more dynamic manner, or get the channel as a user
+ * parameter.
+ */
+static enum omap_channel dpi_get_channel(void)
+{
+        switch (omapdss_get_version()) {
+        case OMAPDSS_VER_OMAP24xx:
+        case OMAPDSS_VER_OMAP34xx_ES1:
+        case OMAPDSS_VER_OMAP34xx_ES3:
+        case OMAPDSS_VER_OMAP3630:
+        case OMAPDSS_VER_AM35xx:
+                return OMAP_DSS_CHANNEL_LCD;
+
+        case OMAPDSS_VER_OMAP4430_ES1:
+        case OMAPDSS_VER_OMAP4430_ES2:
+        case OMAPDSS_VER_OMAP4:
+                return OMAP_DSS_CHANNEL_LCD2;
+
+        case OMAPDSS_VER_OMAP5:
+                return OMAP_DSS_CHANNEL_LCD3;
+
+        default:
+                DSSWARN("unsupported DSS version\n");
+                return OMAP_DSS_CHANNEL_LCD;
+        }
+}
+
+static int dpi_init_display(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev;
 
@@ -421,12 +592,7 @@ static int __init dpi_init_display(struct omap_dss_device *dssdev)
                 dpi.vdds_dsi_reg = vdds_dsi;
         }
 
-        /*
-         * XXX We shouldn't need dssdev->channel for this. The dsi pll clock
-         * source for DPI is SoC integration detail, not something that should
-         * be configured in the dssdev
-         */
-        dsidev = dpi_get_dsidev(dssdev->channel);
+        dsidev = dpi_get_dsidev(dpi.output.dispc_channel);
 
         if (dsidev && dpi_verify_dsi_pll(dsidev)) {
                 dsidev = NULL;
@@ -441,7 +607,7 @@ static int __init dpi_init_display(struct omap_dss_device *dssdev)
         return 0;
 }
 
-static struct omap_dss_device * __init dpi_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *dpi_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         const char *def_disp_name = omapdss_get_default_display_name();
@@ -469,7 +635,7 @@ static struct omap_dss_device * __init dpi_find_dssdev(struct platform_device *p
         return def_dssdev;
 }
 
-static void __init dpi_probe_pdata(struct platform_device *dpidev)
+static int dpi_probe_pdata(struct platform_device *dpidev)
 {
         struct omap_dss_device *plat_dssdev;
         struct omap_dss_device *dssdev;
@@ -478,11 +644,11 @@ static void __init dpi_probe_pdata(struct platform_device *dpidev)
         plat_dssdev = dpi_find_dssdev(dpidev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&dpidev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
@@ -490,7 +656,7 @@ static void __init dpi_probe_pdata(struct platform_device *dpidev)
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&dpi.output, dssdev);
@@ -498,7 +664,7 @@ static void __init dpi_probe_pdata(struct platform_device *dpidev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -506,17 +672,21 @@ static void __init dpi_probe_pdata(struct platform_device *dpidev)
                 DSSERR("device %s register failed: %d\n", dssdev->name, r);
                 omapdss_output_unset_device(&dpi.output);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init dpi_init_output(struct platform_device *pdev)
+static void dpi_init_output(struct platform_device *pdev)
 {
         struct omap_dss_output *out = &dpi.output;
 
         out->pdev = pdev;
         out->id = OMAP_DSS_OUTPUT_DPI;
         out->type = OMAP_DISPLAY_TYPE_DPI;
+        out->name = "dpi.0";
+        out->dispc_channel = dpi_get_channel();
 
         dss_register_output(out);
 }
@@ -528,13 +698,19 @@ static void __exit dpi_uninit_output(struct platform_device *pdev)
         dss_unregister_output(out);
 }
 
-static int __init omap_dpi_probe(struct platform_device *pdev)
+static int omap_dpi_probe(struct platform_device *pdev)
 {
+        int r;
+
         mutex_init(&dpi.lock);
 
         dpi_init_output(pdev);
 
-        dpi_probe_pdata(pdev);
+        r = dpi_probe_pdata(pdev);
+        if (r) {
+                dpi_uninit_output(pdev);
+                return r;
+        }
 
         return 0;
 }
@@ -549,6 +725,7 @@ static int __exit omap_dpi_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver omap_dpi_driver = {
+        .probe          = omap_dpi_probe,
         .remove         = __exit_p(omap_dpi_remove),
         .driver         = {
                 .name   = "omapdss_dpi",
@@ -558,7 +735,7 @@ static struct platform_driver omap_dpi_driver = {
 
 int __init dpi_init_platform_driver(void)
 {
-        return platform_driver_probe(&omap_dpi_driver, omap_dpi_probe);
+        return platform_driver_register(&omap_dpi_driver);
 }
 
 void __exit dpi_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index 28d41d16b7be..a73dedc33101 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -200,6 +200,11 @@ struct dsi_reg { u16 idx; };
 
 typedef void (*omap_dsi_isr_t) (void *arg, u32 mask);
 
+static int dsi_display_init_dispc(struct platform_device *dsidev,
+        struct omap_overlay_manager *mgr);
+static void dsi_display_uninit_dispc(struct platform_device *dsidev,
+        struct omap_overlay_manager *mgr);
+
 #define DSI_MAX_NR_ISRS                2
 #define DSI_MAX_NR_LANES        5
 
@@ -250,6 +255,24 @@ struct dsi_isr_tables {
         struct dsi_isr_data isr_table_cio[DSI_MAX_NR_ISRS];
 };
 
+struct dsi_clk_calc_ctx {
+        struct platform_device *dsidev;
+
+        /* inputs */
+
+        const struct omap_dss_dsi_config *config;
+
+        unsigned long req_pck_min, req_pck_nom, req_pck_max;
+
+        /* outputs */
+
+        struct dsi_clock_info dsi_cinfo;
+        struct dispc_clock_info dispc_cinfo;
+
+        struct omap_video_timings dispc_vm;
+        struct omap_dss_dsi_videomode_timings dsi_vm;
+};
+
 struct dsi_data {
         struct platform_device *pdev;
         void __iomem    *base;
@@ -261,6 +284,9 @@ struct dsi_data {
         struct clk *dss_clk;
         struct clk *sys_clk;
 
+        struct dispc_clock_info user_dispc_cinfo;
+        struct dsi_clock_info user_dsi_cinfo;
+
         struct dsi_clock_info current_cinfo;
 
         bool vdds_dsi_enabled;
@@ -324,6 +350,7 @@ struct dsi_data {
         unsigned long lpdiv_max;
 
         unsigned num_lanes_supported;
+        unsigned line_buffer_size;
 
         struct dsi_lane_config lanes[DSI_MAX_NR_LANES];
         unsigned num_lanes_used;
@@ -1192,15 +1219,33 @@ static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
         return r;
 }
 
-static int dsi_set_lp_clk_divisor(struct omap_dss_device *dssdev)
+static int dsi_lp_clock_calc(struct dsi_clock_info *cinfo,
+                unsigned long lp_clk_min, unsigned long lp_clk_max)
+{
+        unsigned long dsi_fclk = cinfo->dsi_pll_hsdiv_dsi_clk;
+        unsigned lp_clk_div;
+        unsigned long lp_clk;
+
+        lp_clk_div = DIV_ROUND_UP(dsi_fclk, lp_clk_max * 2);
+        lp_clk = dsi_fclk / 2 / lp_clk_div;
+
+        if (lp_clk < lp_clk_min || lp_clk > lp_clk_max)
+                return -EINVAL;
+
+        cinfo->lp_clk_div = lp_clk_div;
+        cinfo->lp_clk = lp_clk;
+
+        return 0;
+}
+
+static int dsi_set_lp_clk_divisor(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         unsigned long dsi_fclk;
         unsigned lp_clk_div;
         unsigned long lp_clk;
 
-        lp_clk_div = dssdev->clocks.dsi.lp_clk_div;
+        lp_clk_div = dsi->user_dsi_cinfo.lp_clk_div;
 
         if (lp_clk_div == 0 || lp_clk_div > dsi->lpdiv_max)
                 return -EINVAL;
@@ -1272,6 +1317,75 @@ static int dsi_pll_power(struct platform_device *dsidev,
         return 0;
 }
 
+unsigned long dsi_get_pll_clkin(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        return clk_get_rate(dsi->sys_clk);
+}
+
+bool dsi_hsdiv_calc(struct platform_device *dsidev, unsigned long pll,
+                unsigned long out_min, dsi_hsdiv_calc_func func, void *data)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        int regm, regm_start, regm_stop;
+        unsigned long out_max;
+        unsigned long out;
+
+        out_min = out_min ? out_min : 1;
+        out_max = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
+
+        regm_start = max(DIV_ROUND_UP(pll, out_max), 1ul);
+        regm_stop = min(pll / out_min, dsi->regm_dispc_max);
+
+        for (regm = regm_start; regm <= regm_stop; ++regm) {
+                out = pll / regm;
+
+                if (func(regm, out, data))
+                        return true;
+        }
+
+        return false;
+}
+
+bool dsi_pll_calc(struct platform_device *dsidev, unsigned long clkin,
+                unsigned long pll_min, unsigned long pll_max,
+                dsi_pll_calc_func func, void *data)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        int regn, regn_start, regn_stop;
+        int regm, regm_start, regm_stop;
+        unsigned long fint, pll;
+        const unsigned long pll_hw_max = 1800000000;
+        unsigned long fint_hw_min, fint_hw_max;
+
+        fint_hw_min = dsi->fint_min;
+        fint_hw_max = dsi->fint_max;
+
+        regn_start = max(DIV_ROUND_UP(clkin, fint_hw_max), 1ul);
+        regn_stop = min(clkin / fint_hw_min, dsi->regn_max);
+
+        pll_max = pll_max ? pll_max : ULONG_MAX;
+
+        for (regn = regn_start; regn <= regn_stop; ++regn) {
+                fint = clkin / regn;
+
+                regm_start = max(DIV_ROUND_UP(DIV_ROUND_UP(pll_min, fint), 2),
+                                1ul);
+                regm_stop = min3(pll_max / fint / 2,
+                                pll_hw_max / fint / 2,
+                                dsi->regm_max);
+
+                for (regm = regm_start; regm <= regm_stop; ++regm) {
+                        pll = 2 * regm * fint;
+
+                        if (func(regn, regm, fint, pll, data))
+                                return true;
+                }
+        }
+
+        return false;
+}
+
 /* calculate clock rates using dividers in cinfo */
 static int dsi_calc_clock_rates(struct platform_device *dsidev,
                 struct dsi_clock_info *cinfo)
@@ -1316,192 +1430,7 @@ static int dsi_calc_clock_rates(struct platform_device *dsidev,
         return 0;
 }
 
-int dsi_pll_calc_clock_div_pck(struct platform_device *dsidev,
-                unsigned long req_pck, struct dsi_clock_info *dsi_cinfo,
-                struct dispc_clock_info *dispc_cinfo)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct dsi_clock_info cur, best;
-        struct dispc_clock_info best_dispc;
-        int min_fck_per_pck;
-        int match = 0;
-        unsigned long dss_sys_clk, max_dss_fck;
-
-        dss_sys_clk = clk_get_rate(dsi->sys_clk);
-
-        max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
-
-        if (req_pck == dsi->cache_req_pck &&
-                        dsi->cache_cinfo.clkin == dss_sys_clk) {
-                DSSDBG("DSI clock info found from cache\n");
-                *dsi_cinfo = dsi->cache_cinfo;
-                dispc_find_clk_divs(req_pck, dsi_cinfo->dsi_pll_hsdiv_dispc_clk,
-                        dispc_cinfo);
-                return 0;
-        }
-
-        min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
-
-        if (min_fck_per_pck &&
-                req_pck * min_fck_per_pck > max_dss_fck) {
-                DSSERR("Requested pixel clock not possible with the current "
-                                "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
-                                "the constraint off.\n");
-                min_fck_per_pck = 0;
-        }
-
-        DSSDBG("dsi_pll_calc\n");
-
-retry:
-        memset(&best, 0, sizeof(best));
-        memset(&best_dispc, 0, sizeof(best_dispc));
-
-        memset(&cur, 0, sizeof(cur));
-        cur.clkin = dss_sys_clk;
-
-        /* 0.75MHz < Fint = clkin / regn < 2.1MHz */
-        /* To reduce PLL lock time, keep Fint high (around 2 MHz) */
-        for (cur.regn = 1; cur.regn < dsi->regn_max; ++cur.regn) {
-                cur.fint = cur.clkin / cur.regn;
-
-                if (cur.fint > dsi->fint_max || cur.fint < dsi->fint_min)
-                        continue;
-
-                /* DSIPHY(MHz) = (2 * regm / regn) * clkin */
-                for (cur.regm = 1; cur.regm < dsi->regm_max; ++cur.regm) {
-                        unsigned long a, b;
-
-                        a = 2 * cur.regm * (cur.clkin/1000);
-                        b = cur.regn;
-                        cur.clkin4ddr = a / b * 1000;
-
-                        if (cur.clkin4ddr > 1800 * 1000 * 1000)
-                                break;
-
-                        /* dsi_pll_hsdiv_dispc_clk(MHz) =
-                         * DSIPHY(MHz) / regm_dispc  < 173MHz/186Mhz */
-                        for (cur.regm_dispc = 1; cur.regm_dispc <
-                                        dsi->regm_dispc_max; ++cur.regm_dispc) {
-                                struct dispc_clock_info cur_dispc;
-                                cur.dsi_pll_hsdiv_dispc_clk =
-                                        cur.clkin4ddr / cur.regm_dispc;
-
-                                if (cur.regm_dispc > 1 &&
-                                                cur.regm_dispc % 2 != 0 &&
-                                                req_pck >= 1000000)
-                                        continue;
-
-                                /* this will narrow down the search a bit,
-                                 * but still give pixclocks below what was
-                                 * requested */
-                                if (cur.dsi_pll_hsdiv_dispc_clk  < req_pck)
-                                        break;
-
-                                if (cur.dsi_pll_hsdiv_dispc_clk > max_dss_fck)
-                                        continue;
-
-                                if (min_fck_per_pck &&
-                                        cur.dsi_pll_hsdiv_dispc_clk <
-                                                req_pck * min_fck_per_pck)
-                                        continue;
-
-                                match = 1;
-
-                                dispc_find_clk_divs(req_pck,
-                                                cur.dsi_pll_hsdiv_dispc_clk,
-                                                &cur_dispc);
-
-                                if (abs(cur_dispc.pck - req_pck) <
-                                                abs(best_dispc.pck - req_pck)) {
-                                        best = cur;
-                                        best_dispc = cur_dispc;
-
-                                        if (cur_dispc.pck == req_pck)
-                                                goto found;
-                                }
-                        }
-                }
-        }
-found:
-        if (!match) {
-                if (min_fck_per_pck) {
-                        DSSERR("Could not find suitable clock settings.\n"
-                                        "Turning FCK/PCK constraint off and"
-                                        "trying again.\n");
-                        min_fck_per_pck = 0;
-                        goto retry;
-                }
-
-                DSSERR("Could not find suitable clock settings.\n");
-
-                return -EINVAL;
-        }
-
-        /* dsi_pll_hsdiv_dsi_clk (regm_dsi) is not used */
-        best.regm_dsi = 0;
-        best.dsi_pll_hsdiv_dsi_clk = 0;
-
-        if (dsi_cinfo)
-                *dsi_cinfo = best;
-        if (dispc_cinfo)
-                *dispc_cinfo = best_dispc;
-
-        dsi->cache_req_pck = req_pck;
-        dsi->cache_clk_freq = 0;
-        dsi->cache_cinfo = best;
-
-        return 0;
-}
-
-static int dsi_pll_calc_ddrfreq(struct platform_device *dsidev,
-                unsigned long req_clkin4ddr, struct dsi_clock_info *cinfo)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct dsi_clock_info cur, best;
-
-        DSSDBG("dsi_pll_calc_ddrfreq\n");
-
-        memset(&best, 0, sizeof(best));
-        memset(&cur, 0, sizeof(cur));
-
-        cur.clkin = clk_get_rate(dsi->sys_clk);
-
-        for (cur.regn = 1; cur.regn < dsi->regn_max; ++cur.regn) {
-                cur.fint = cur.clkin / cur.regn;
-
-                if (cur.fint > dsi->fint_max || cur.fint < dsi->fint_min)
-                        continue;
-
-                /* DSIPHY(MHz) = (2 * regm / regn) * clkin */
-                for (cur.regm = 1; cur.regm < dsi->regm_max; ++cur.regm) {
-                        unsigned long a, b;
-
-                        a = 2 * cur.regm * (cur.clkin/1000);
-                        b = cur.regn;
-                        cur.clkin4ddr = a / b * 1000;
-
-                        if (cur.clkin4ddr > 1800 * 1000 * 1000)
-                                break;
-
-                        if (abs(cur.clkin4ddr - req_clkin4ddr) <
-                                        abs(best.clkin4ddr - req_clkin4ddr)) {
-                                best = cur;
-                                DSSDBG("best %ld\n", best.clkin4ddr);
-                        }
-
-                        if (cur.clkin4ddr == req_clkin4ddr)
-                                goto found;
-                }
-        }
-found:
-        if (cinfo)
-                *cinfo = best;
-
-        return 0;
-}
-
-static void dsi_pll_calc_dsi_fck(struct platform_device *dsidev,
-                struct dsi_clock_info *cinfo)
+static void dsi_pll_calc_dsi_fck(struct dsi_clock_info *cinfo)
 {
         unsigned long max_dsi_fck;
 
@@ -1511,90 +1440,6 @@ static void dsi_pll_calc_dsi_fck(struct platform_device *dsidev,
         cinfo->dsi_pll_hsdiv_dsi_clk = cinfo->clkin4ddr / cinfo->regm_dsi;
 }
 
-static int dsi_pll_calc_dispc_fck(struct platform_device *dsidev,
-                unsigned long req_pck, struct dsi_clock_info *cinfo,
-                struct dispc_clock_info *dispc_cinfo)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        unsigned regm_dispc, best_regm_dispc;
-        unsigned long dispc_clk, best_dispc_clk;
-        int min_fck_per_pck;
-        unsigned long max_dss_fck;
-        struct dispc_clock_info best_dispc;
-        bool match;
-
-        max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
-
-        min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
-
-        if (min_fck_per_pck &&
-                        req_pck * min_fck_per_pck > max_dss_fck) {
-                DSSERR("Requested pixel clock not possible with the current "
-                                "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
-                                "the constraint off.\n");
-                min_fck_per_pck = 0;
-        }
-
-retry:
-        best_regm_dispc = 0;
-        best_dispc_clk = 0;
-        memset(&best_dispc, 0, sizeof(best_dispc));
-        match = false;
-
-        for (regm_dispc = 1; regm_dispc < dsi->regm_dispc_max; ++regm_dispc) {
-                struct dispc_clock_info cur_dispc;
-
-                dispc_clk = cinfo->clkin4ddr / regm_dispc;
-
-                /* this will narrow down the search a bit,
-                 * but still give pixclocks below what was
-                 * requested */
-                if (dispc_clk  < req_pck)
-                        break;
-
-                if (dispc_clk > max_dss_fck)
-                        continue;
-
-                if (min_fck_per_pck && dispc_clk < req_pck * min_fck_per_pck)
-                        continue;
-
-                match = true;
-
-                dispc_find_clk_divs(req_pck, dispc_clk, &cur_dispc);
-
-                if (abs(cur_dispc.pck - req_pck) <
-                                abs(best_dispc.pck - req_pck)) {
-                        best_regm_dispc = regm_dispc;
-                        best_dispc_clk = dispc_clk;
-                        best_dispc = cur_dispc;
-
-                        if (cur_dispc.pck == req_pck)
-                                goto found;
-                }
-        }
-
-        if (!match) {
-                if (min_fck_per_pck) {
-                        DSSERR("Could not find suitable clock settings.\n"
-                                        "Turning FCK/PCK constraint off and"
-                                        "trying again.\n");
-                        min_fck_per_pck = 0;
-                        goto retry;
-                }
-
-                DSSERR("Could not find suitable clock settings.\n");
-
-                return -EINVAL;
-        }
-found:
-        cinfo->regm_dispc = best_regm_dispc;
-        cinfo->dsi_pll_hsdiv_dispc_clk = best_dispc_clk;
-
-        *dispc_cinfo = best_dispc;
-
-        return 0;
-}
-
 int dsi_pll_set_clock_div(struct platform_device *dsidev,
                 struct dsi_clock_info *cinfo)
 {
@@ -2783,6 +2628,7 @@ static int dsi_vc_enable(struct platform_device *dsidev, int channel,
 
 static void dsi_vc_initial_config(struct platform_device *dsidev, int channel)
 {
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         u32 r;
 
         DSSDBG("Initial config of virtual channel %d", channel);
@@ -2807,6 +2653,8 @@ static void dsi_vc_initial_config(struct platform_device *dsidev, int channel)
         r = FLD_MOD(r, 4, 23, 21); /* DMA_TX_REQ_NB = no dma */
 
         dsi_write_reg(dsidev, DSI_VC_CTRL(channel), r);
+
+        dsi->vc[channel].source = DSI_VC_SOURCE_L4;
 }
 
 static int dsi_vc_config_source(struct platform_device *dsidev, int channel,
@@ -3777,13 +3625,12 @@ static void dsi_config_vp_num_line_buffers(struct platform_device *dsidev)
 
         if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
                 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
-                unsigned line_buf_size = dsi_get_line_buf_size(dsidev);
                 struct omap_video_timings *timings = &dsi->timings;
                 /*
                  * Don't use line buffers if width is greater than the video
                  * port's line buffer size
                  */
-                if (line_buf_size <= timings->x_res * bpp / 8)
+                if (dsi->line_buffer_size <= timings->x_res * bpp / 8)
                         num_line_buffers = 0;
                 else
                         num_line_buffers = 2;
@@ -3799,18 +3646,22 @@ static void dsi_config_vp_num_line_buffers(struct platform_device *dsidev)
 static void dsi_config_vp_sync_events(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        bool vsync_end = dsi->vm_timings.vp_vsync_end;
-        bool hsync_end = dsi->vm_timings.vp_hsync_end;
+        bool sync_end;
         u32 r;
 
+        if (dsi->vm_timings.trans_mode == OMAP_DSS_DSI_PULSE_MODE)
+                sync_end = true;
+        else
+                sync_end = false;
+
         r = dsi_read_reg(dsidev, DSI_CTRL);
         r = FLD_MOD(r, 1, 9, 9);                /* VP_DE_POL */
         r = FLD_MOD(r, 1, 10, 10);              /* VP_HSYNC_POL */
         r = FLD_MOD(r, 1, 11, 11);              /* VP_VSYNC_POL */
         r = FLD_MOD(r, 1, 15, 15);              /* VP_VSYNC_START */
-        r = FLD_MOD(r, vsync_end, 16, 16);      /* VP_VSYNC_END */
+        r = FLD_MOD(r, sync_end, 16, 16);       /* VP_VSYNC_END */
         r = FLD_MOD(r, 1, 17, 17);              /* VP_HSYNC_START */
-        r = FLD_MOD(r, hsync_end, 18, 18);      /* VP_HSYNC_END */
+        r = FLD_MOD(r, sync_end, 18, 18);       /* VP_HSYNC_END */
         dsi_write_reg(dsidev, DSI_CTRL, r);
 }
 
@@ -3897,9 +3748,8 @@ static int dsi_compute_interleave_lp(int blank, int enter_hs, int exit_hs,
         return max(lp_inter, 0);
 }
 
-static void dsi_config_cmd_mode_interleaving(struct omap_dss_device *dssdev)
+static void dsi_config_cmd_mode_interleaving(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         int blanking_mode;
         int hfp_blanking_mode, hbp_blanking_mode, hsa_blanking_mode;
@@ -3910,7 +3760,7 @@ static void dsi_config_cmd_mode_interleaving(struct omap_dss_device *dssdev)
         struct omap_video_timings *timings = &dsi->timings;
         int bpp = dsi_get_pixel_size(dsi->pix_fmt);
         int ndl = dsi->num_lanes_used - 1;
-        int dsi_fclk_hsdiv = dssdev->clocks.dsi.regm_dsi + 1;
+        int dsi_fclk_hsdiv = dsi->user_dsi_cinfo.regm_dsi + 1;
         int hsa_interleave_hs = 0, hsa_interleave_lp = 0;
         int hfp_interleave_hs = 0, hfp_interleave_lp = 0;
         int hbp_interleave_hs = 0, hbp_interleave_lp = 0;
@@ -4015,9 +3865,8 @@ static void dsi_config_cmd_mode_interleaving(struct omap_dss_device *dssdev)
         dsi_write_reg(dsidev, DSI_VM_TIMING6, r);
 }
 
-static int dsi_proto_config(struct omap_dss_device *dssdev)
+static int dsi_proto_config(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         u32 r;
         int buswidth = 0;
@@ -4075,7 +3924,7 @@ static int dsi_proto_config(struct omap_dss_device *dssdev)
         if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
                 dsi_config_vp_sync_events(dsidev);
                 dsi_config_blanking_modes(dsidev);
-                dsi_config_cmd_mode_interleaving(dssdev);
+                dsi_config_cmd_mode_interleaving(dsidev);
         }
 
         dsi_vc_initial_config(dsidev, 0);
@@ -4159,11 +4008,12 @@ static void dsi_proto_timings(struct platform_device *dsidev)
                 int vfp = dsi->vm_timings.vfp;
                 int vbp = dsi->vm_timings.vbp;
                 int window_sync = dsi->vm_timings.window_sync;
-                bool hsync_end = dsi->vm_timings.vp_hsync_end;
+                bool hsync_end;
                 struct omap_video_timings *timings = &dsi->timings;
                 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
                 int tl, t_he, width_bytes;
 
+                hsync_end = dsi->vm_timings.trans_mode == OMAP_DSS_DSI_PULSE_MODE;
                 t_he = hsync_end ?
                         ((hsa == 0 && ndl == 3) ? 1 : DIV_ROUND_UP(4, ndl)) : 0;
 
@@ -4266,82 +4116,26 @@ int omapdss_dsi_configure_pins(struct omap_dss_device *dssdev,
 }
 EXPORT_SYMBOL(omapdss_dsi_configure_pins);
 
-int omapdss_dsi_set_clocks(struct omap_dss_device *dssdev,
-                unsigned long ddr_clk, unsigned long lp_clk)
-{
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct dsi_clock_info cinfo;
-        struct dispc_clock_info dispc_cinfo;
-        unsigned lp_clk_div;
-        unsigned long dsi_fclk;
-        int bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt);
-        unsigned long pck;
-        int r;
-
-        DSSDBG("Setting DSI clocks: ddr_clk %lu, lp_clk %lu", ddr_clk, lp_clk);
-
-        mutex_lock(&dsi->lock);
-
-        /* Calculate PLL output clock */
-        r = dsi_pll_calc_ddrfreq(dsidev, ddr_clk * 4, &cinfo);
-        if (r)
-                goto err;
-
-        /* Calculate PLL's DSI clock */
-        dsi_pll_calc_dsi_fck(dsidev, &cinfo);
-
-        /* Calculate PLL's DISPC clock and pck & lck divs */
-        pck = cinfo.clkin4ddr / 16 * (dsi->num_lanes_used - 1) * 8 / bpp;
-        DSSDBG("finding dispc dividers for pck %lu\n", pck);
-        r = dsi_pll_calc_dispc_fck(dsidev, pck, &cinfo, &dispc_cinfo);
-        if (r)
-                goto err;
-
-        /* Calculate LP clock */
-        dsi_fclk = cinfo.dsi_pll_hsdiv_dsi_clk;
-        lp_clk_div = DIV_ROUND_UP(dsi_fclk, lp_clk * 2);
-
-        dssdev->clocks.dsi.regn = cinfo.regn;
-        dssdev->clocks.dsi.regm = cinfo.regm;
-        dssdev->clocks.dsi.regm_dispc = cinfo.regm_dispc;
-        dssdev->clocks.dsi.regm_dsi = cinfo.regm_dsi;
-
-        dssdev->clocks.dsi.lp_clk_div = lp_clk_div;
-
-        dssdev->clocks.dispc.channel.lck_div = dispc_cinfo.lck_div;
-        dssdev->clocks.dispc.channel.pck_div = dispc_cinfo.pck_div;
-
-        dssdev->clocks.dispc.dispc_fclk_src = OMAP_DSS_CLK_SRC_FCK;
-
-        dssdev->clocks.dispc.channel.lcd_clk_src =
-                dsi->module_id == 0 ?
-                OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC :
-                OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC;
-
-        dssdev->clocks.dsi.dsi_fclk_src =
-                dsi->module_id == 0 ?
-                OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI :
-                OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI;
-
-        mutex_unlock(&dsi->lock);
-        return 0;
-err:
-        mutex_unlock(&dsi->lock);
-        return r;
-}
-EXPORT_SYMBOL(omapdss_dsi_set_clocks);
-
 int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
+        struct omap_overlay_manager *mgr = dsi->output.manager;
         int bpp = dsi_get_pixel_size(dsi->pix_fmt);
+        struct omap_dss_output *out = &dsi->output;
         u8 data_type;
         u16 word_count;
         int r;
 
+        if (out == NULL || out->manager == NULL) {
+                DSSERR("failed to enable display: no output/manager\n");
+                return -ENODEV;
+        }
+
+        r = dsi_display_init_dispc(dsidev, mgr);
+        if (r)
+                goto err_init_dispc;
+
         if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
                 switch (dsi->pix_fmt) {
                 case OMAP_DSS_DSI_FMT_RGB888:
@@ -4357,8 +4151,8 @@ int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
                         data_type = MIPI_DSI_PACKED_PIXEL_STREAM_16;
                         break;
                 default:
-                        BUG();
-                        return -EINVAL;
+                        r = -EINVAL;
+                        goto err_pix_fmt;
                 };
 
                 dsi_if_enable(dsidev, false);
@@ -4377,16 +4171,20 @@ int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
         }
 
         r = dss_mgr_enable(mgr);
-        if (r) {
-                if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
-                        dsi_if_enable(dsidev, false);
-                        dsi_vc_enable(dsidev, channel, false);
-                }
-
-                return r;
-        }
+        if (r)
+                goto err_mgr_enable;
 
         return 0;
+
+err_mgr_enable:
+        if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
+                dsi_if_enable(dsidev, false);
+                dsi_vc_enable(dsidev, channel, false);
+        }
+err_pix_fmt:
+        dsi_display_uninit_dispc(dsidev, mgr);
+err_init_dispc:
+        return r;
 }
 EXPORT_SYMBOL(dsi_enable_video_output);
 
@@ -4394,7 +4192,7 @@ void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
+        struct omap_overlay_manager *mgr = dsi->output.manager;
 
         if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
                 dsi_if_enable(dsidev, false);
@@ -4408,14 +4206,15 @@ void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel)
         }
 
         dss_mgr_disable(mgr);
+
+        dsi_display_uninit_dispc(dsidev, mgr);
 }
 EXPORT_SYMBOL(dsi_disable_video_output);
 
-static void dsi_update_screen_dispc(struct omap_dss_device *dssdev)
+static void dsi_update_screen_dispc(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
+        struct omap_overlay_manager *mgr = dsi->output.manager;
         unsigned bytespp;
         unsigned bytespl;
         unsigned bytespf;
@@ -4425,7 +4224,7 @@ static void dsi_update_screen_dispc(struct omap_dss_device *dssdev)
         u32 l;
         int r;
         const unsigned channel = dsi->update_channel;
-        const unsigned line_buf_size = dsi_get_line_buf_size(dsidev);
+        const unsigned line_buf_size = dsi->line_buffer_size;
         u16 w = dsi->timings.x_res;
         u16 h = dsi->timings.y_res;
 
@@ -4571,7 +4370,7 @@ int omap_dsi_update(struct omap_dss_device *dssdev, int channel,
         dsi->update_bytes = dw * dh *
                 dsi_get_pixel_size(dsi->pix_fmt) / 8;
 #endif
-        dsi_update_screen_dispc(dssdev);
+        dsi_update_screen_dispc(dsidev);
 
         return 0;
 }
@@ -4579,18 +4378,17 @@ EXPORT_SYMBOL(omap_dsi_update);
 
 /* Display funcs */
 
-static int dsi_configure_dispc_clocks(struct omap_dss_device *dssdev)
+static int dsi_configure_dispc_clocks(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         struct dispc_clock_info dispc_cinfo;
         int r;
-        unsigned long long fck;
+        unsigned long fck;
 
         fck = dsi_get_pll_hsdiv_dispc_rate(dsidev);
 
-        dispc_cinfo.lck_div = dssdev->clocks.dispc.channel.lck_div;
-        dispc_cinfo.pck_div = dssdev->clocks.dispc.channel.pck_div;
+        dispc_cinfo.lck_div = dsi->user_dispc_cinfo.lck_div;
+        dispc_cinfo.pck_div = dsi->user_dispc_cinfo.pck_div;
 
         r = dispc_calc_clock_rates(fck, &dispc_cinfo);
         if (r) {
@@ -4603,21 +4401,17 @@ static int dsi_configure_dispc_clocks(struct omap_dss_device *dssdev)
         return 0;
 }
 
-static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
+static int dsi_display_init_dispc(struct platform_device *dsidev,
+                struct omap_overlay_manager *mgr)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
         int r;
 
-        if (dsi->mode == OMAP_DSS_DSI_CMD_MODE) {
-                dsi->timings.hsw = 1;
-                dsi->timings.hfp = 1;
-                dsi->timings.hbp = 1;
-                dsi->timings.vsw = 1;
-                dsi->timings.vfp = 0;
-                dsi->timings.vbp = 0;
+        dss_select_lcd_clk_source(mgr->id, dsi->module_id == 0 ?
+                        OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC :
+                        OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC);
 
+        if (dsi->mode == OMAP_DSS_DSI_CMD_MODE) {
                 r = dss_mgr_register_framedone_handler(mgr,
                                 dsi_framedone_irq_callback, dsidev);
                 if (r) {
@@ -4645,7 +4439,7 @@ static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
 
         dss_mgr_set_timings(mgr, &dsi->timings);
 
-        r = dsi_configure_dispc_clocks(dssdev);
+        r = dsi_configure_dispc_clocks(dsidev);
         if (r)
                 goto err1;
 
@@ -4662,30 +4456,30 @@ err1:
                 dss_mgr_unregister_framedone_handler(mgr,
                                 dsi_framedone_irq_callback, dsidev);
 err:
+        dss_select_lcd_clk_source(mgr->id, OMAP_DSS_CLK_SRC_FCK);
         return r;
 }
 
-static void dsi_display_uninit_dispc(struct omap_dss_device *dssdev)
+static void dsi_display_uninit_dispc(struct platform_device *dsidev,
+                struct omap_overlay_manager *mgr)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
 
         if (dsi->mode == OMAP_DSS_DSI_CMD_MODE)
                 dss_mgr_unregister_framedone_handler(mgr,
                                 dsi_framedone_irq_callback, dsidev);
+
+        dss_select_lcd_clk_source(mgr->id, OMAP_DSS_CLK_SRC_FCK);
 }
 
-static int dsi_configure_dsi_clocks(struct omap_dss_device *dssdev)
+static int dsi_configure_dsi_clocks(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         struct dsi_clock_info cinfo;
         int r;
 
-        cinfo.regn  = dssdev->clocks.dsi.regn;
-        cinfo.regm  = dssdev->clocks.dsi.regm;
-        cinfo.regm_dispc = dssdev->clocks.dsi.regm_dispc;
-        cinfo.regm_dsi = dssdev->clocks.dsi.regm_dsi;
+        cinfo = dsi->user_dsi_cinfo;
+
         r = dsi_calc_clock_rates(dsidev, &cinfo);
         if (r) {
                 DSSERR("Failed to calc dsi clocks\n");
@@ -4701,24 +4495,22 @@ static int dsi_configure_dsi_clocks(struct omap_dss_device *dssdev)
         return 0;
 }
 
-static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
+static int dsi_display_init_dsi(struct platform_device *dsidev)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
         int r;
 
         r = dsi_pll_init(dsidev, true, true);
         if (r)
                 goto err0;
 
-        r = dsi_configure_dsi_clocks(dssdev);
+        r = dsi_configure_dsi_clocks(dsidev);
         if (r)
                 goto err1;
 
-        dss_select_dsi_clk_source(dsi->module_id, dssdev->clocks.dsi.dsi_fclk_src);
-        dss_select_lcd_clk_source(mgr->id,
-                        dssdev->clocks.dispc.channel.lcd_clk_src);
+        dss_select_dsi_clk_source(dsi->module_id, dsi->module_id == 0 ?
+                        OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI :
+                        OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI);
 
         DSSDBG("PLL OK\n");
 
@@ -4729,12 +4521,12 @@ static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
         _dsi_print_reset_status(dsidev);
 
         dsi_proto_timings(dsidev);
-        dsi_set_lp_clk_divisor(dssdev);
+        dsi_set_lp_clk_divisor(dsidev);
 
         if (1)
                 _dsi_print_reset_status(dsidev);
 
-        r = dsi_proto_config(dssdev);
+        r = dsi_proto_config(dsidev);
         if (r)
                 goto err3;
 
@@ -4751,20 +4543,16 @@ err3:
         dsi_cio_uninit(dsidev);
 err2:
         dss_select_dsi_clk_source(dsi->module_id, OMAP_DSS_CLK_SRC_FCK);
-        dss_select_lcd_clk_source(mgr->id, OMAP_DSS_CLK_SRC_FCK);
-
 err1:
         dsi_pll_uninit(dsidev, true);
 err0:
         return r;
 }
 
-static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev,
+static void dsi_display_uninit_dsi(struct platform_device *dsidev,
                 bool disconnect_lanes, bool enter_ulps)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_overlay_manager *mgr = dssdev->output->manager;
 
         if (enter_ulps && !dsi->ulps_enabled)
                 dsi_enter_ulps(dsidev);
@@ -4777,7 +4565,6 @@ static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev,
         dsi_vc_enable(dsidev, 3, 0);
 
         dss_select_dsi_clk_source(dsi->module_id, OMAP_DSS_CLK_SRC_FCK);
-        dss_select_lcd_clk_source(mgr->id, OMAP_DSS_CLK_SRC_FCK);
         dsi_cio_uninit(dsidev);
         dsi_pll_uninit(dsidev, disconnect_lanes);
 }
@@ -4786,7 +4573,6 @@ int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct omap_dss_output *out = dssdev->output;
         int r = 0;
 
         DSSDBG("dsi_display_enable\n");
@@ -4795,12 +4581,6 @@ int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
 
         mutex_lock(&dsi->lock);
 
-        if (out == NULL || out->manager == NULL) {
-                DSSERR("failed to enable display: no output/manager\n");
-                r = -ENODEV;
-                goto err_start_dev;
-        }
-
         r = omap_dss_start_device(dssdev);
         if (r) {
                 DSSERR("failed to start device\n");
@@ -4815,11 +4595,7 @@ int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
 
         _dsi_initialize_irq(dsidev);
 
-        r = dsi_display_init_dispc(dssdev);
-        if (r)
-                goto err_init_dispc;
-
-        r = dsi_display_init_dsi(dssdev);
+        r = dsi_display_init_dsi(dsidev);
         if (r)
                 goto err_init_dsi;
 
@@ -4828,8 +4604,6 @@ int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
         return 0;
 
 err_init_dsi:
-        dsi_display_uninit_dispc(dssdev);
-err_init_dispc:
         dsi_enable_pll_clock(dsidev, 0);
         dsi_runtime_put(dsidev);
 err_get_dsi:
@@ -4858,9 +4632,7 @@ void omapdss_dsi_display_disable(struct omap_dss_device *dssdev,
         dsi_sync_vc(dsidev, 2);
         dsi_sync_vc(dsidev, 3);
 
-        dsi_display_uninit_dispc(dssdev);
-
-        dsi_display_uninit_dsi(dssdev, disconnect_lanes, enter_ulps);
+        dsi_display_uninit_dsi(dsidev, disconnect_lanes, enter_ulps);
 
         dsi_runtime_put(dsidev);
         dsi_enable_pll_clock(dsidev, 0);
@@ -4881,77 +4653,579 @@ int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable)
 }
 EXPORT_SYMBOL(omapdss_dsi_enable_te);
 
-void omapdss_dsi_set_timings(struct omap_dss_device *dssdev,
-                struct omap_video_timings *timings)
+#ifdef PRINT_VERBOSE_VM_TIMINGS
+static void print_dsi_vm(const char *str,
+                const struct omap_dss_dsi_videomode_timings *t)
+{
+        unsigned long byteclk = t->hsclk / 4;
+        int bl, wc, pps, tot;
+
+        wc = DIV_ROUND_UP(t->hact * t->bitspp, 8);
+        pps = DIV_ROUND_UP(wc + 6, t->ndl); /* pixel packet size */
+        bl = t->hss + t->hsa + t->hse + t->hbp + t->hfp;
+        tot = bl + pps;
+
+#define TO_DSI_T(x) ((u32)div64_u64((u64)x * 1000000000llu, byteclk))
+
+        pr_debug("%s bck %lu, %u/%u/%u/%u/%u/%u = %u+%u = %u, "
+                        "%u/%u/%u/%u/%u/%u = %u + %u = %u\n",
+                        str,
+                        byteclk,
+                        t->hss, t->hsa, t->hse, t->hbp, pps, t->hfp,
+                        bl, pps, tot,
+                        TO_DSI_T(t->hss),
+                        TO_DSI_T(t->hsa),
+                        TO_DSI_T(t->hse),
+                        TO_DSI_T(t->hbp),
+                        TO_DSI_T(pps),
+                        TO_DSI_T(t->hfp),
+
+                        TO_DSI_T(bl),
+                        TO_DSI_T(pps),
+
+                        TO_DSI_T(tot));
+#undef TO_DSI_T
+}
+
+static void print_dispc_vm(const char *str, const struct omap_video_timings *t)
+{
+        unsigned long pck = t->pixel_clock * 1000;
+        int hact, bl, tot;
+
+        hact = t->x_res;
+        bl = t->hsw + t->hbp + t->hfp;
+        tot = hact + bl;
+
+#define TO_DISPC_T(x) ((u32)div64_u64((u64)x * 1000000000llu, pck))
+
+        pr_debug("%s pck %lu, %u/%u/%u/%u = %u+%u = %u, "
+                        "%u/%u/%u/%u = %u + %u = %u\n",
+                        str,
+                        pck,
+                        t->hsw, t->hbp, hact, t->hfp,
+                        bl, hact, tot,
+                        TO_DISPC_T(t->hsw),
+                        TO_DISPC_T(t->hbp),
+                        TO_DISPC_T(hact),
+                        TO_DISPC_T(t->hfp),
+                        TO_DISPC_T(bl),
+                        TO_DISPC_T(hact),
+                        TO_DISPC_T(tot));
+#undef TO_DISPC_T
+}
+
+/* note: this is not quite accurate */
+static void print_dsi_dispc_vm(const char *str,
+                const struct omap_dss_dsi_videomode_timings *t)
+{
+        struct omap_video_timings vm = { 0 };
+        unsigned long byteclk = t->hsclk / 4;
+        unsigned long pck;
+        u64 dsi_tput;
+        int dsi_hact, dsi_htot;
+
+        dsi_tput = (u64)byteclk * t->ndl * 8;
+        pck = (u32)div64_u64(dsi_tput, t->bitspp);
+        dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(t->hact * t->bitspp, 8) + 6, t->ndl);
+        dsi_htot = t->hss + t->hsa + t->hse + t->hbp + dsi_hact + t->hfp;
+
+        vm.pixel_clock = pck / 1000;
+        vm.hsw = div64_u64((u64)(t->hsa + t->hse) * pck, byteclk);
+        vm.hbp = div64_u64((u64)t->hbp * pck, byteclk);
+        vm.hfp = div64_u64((u64)t->hfp * pck, byteclk);
+        vm.x_res = t->hact;
+
+        print_dispc_vm(str, &vm);
+}
+#endif /* PRINT_VERBOSE_VM_TIMINGS */
+
+static bool dsi_cm_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
+                unsigned long pck, void *data)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_clk_calc_ctx *ctx = data;
+        struct omap_video_timings *t = &ctx->dispc_vm;
 
-        mutex_lock(&dsi->lock);
+        ctx->dispc_cinfo.lck_div = lckd;
+        ctx->dispc_cinfo.pck_div = pckd;
+        ctx->dispc_cinfo.lck = lck;
+        ctx->dispc_cinfo.pck = pck;
 
-        dsi->timings = *timings;
+        *t = *ctx->config->timings;
+        t->pixel_clock = pck / 1000;
+        t->x_res = ctx->config->timings->x_res;
+        t->y_res = ctx->config->timings->y_res;
+        t->hsw = t->hfp = t->hbp = t->vsw = 1;
+        t->vfp = t->vbp = 0;
 
-        mutex_unlock(&dsi->lock);
+        return true;
 }
-EXPORT_SYMBOL(omapdss_dsi_set_timings);
 
-void omapdss_dsi_set_size(struct omap_dss_device *dssdev, u16 w, u16 h)
+static bool dsi_cm_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+                void *data)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_clk_calc_ctx *ctx = data;
 
-        mutex_lock(&dsi->lock);
+        ctx->dsi_cinfo.regm_dispc = regm_dispc;
+        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
 
-        dsi->timings.x_res = w;
-        dsi->timings.y_res = h;
+        return dispc_div_calc(dispc, ctx->req_pck_min, ctx->req_pck_max,
+                        dsi_cm_calc_dispc_cb, ctx);
+}
 
-        mutex_unlock(&dsi->lock);
+static bool dsi_cm_calc_pll_cb(int regn, int regm, unsigned long fint,
+                unsigned long pll, void *data)
+{
+        struct dsi_clk_calc_ctx *ctx = data;
+
+        ctx->dsi_cinfo.regn = regn;
+        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.fint = fint;
+        ctx->dsi_cinfo.clkin4ddr = pll;
+
+        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->req_pck_min,
+                        dsi_cm_calc_hsdiv_cb, ctx);
 }
-EXPORT_SYMBOL(omapdss_dsi_set_size);
 
-void omapdss_dsi_set_pixel_format(struct omap_dss_device *dssdev,
-                enum omap_dss_dsi_pixel_format fmt)
+static bool dsi_cm_calc(struct dsi_data *dsi,
+                const struct omap_dss_dsi_config *cfg,
+                struct dsi_clk_calc_ctx *ctx)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        unsigned long clkin;
+        int bitspp, ndl;
+        unsigned long pll_min, pll_max;
+        unsigned long pck, txbyteclk;
 
-        mutex_lock(&dsi->lock);
+        clkin = clk_get_rate(dsi->sys_clk);
+        bitspp = dsi_get_pixel_size(cfg->pixel_format);
+        ndl = dsi->num_lanes_used - 1;
 
-        dsi->pix_fmt = fmt;
+        /*
+         * Here we should calculate minimum txbyteclk to be able to send the
+         * frame in time, and also to handle TE. That's not very simple, though,
+         * especially as we go to LP between each pixel packet due to HW
+         * "feature". So let's just estimate very roughly and multiply by 1.5.
+         */
+        pck = cfg->timings->pixel_clock * 1000;
+        pck = pck * 3 / 2;
+        txbyteclk = pck * bitspp / 8 / ndl;
 
-        mutex_unlock(&dsi->lock);
+        memset(ctx, 0, sizeof(*ctx));
+        ctx->dsidev = dsi->pdev;
+        ctx->config = cfg;
+        ctx->req_pck_min = pck;
+        ctx->req_pck_nom = pck;
+        ctx->req_pck_max = pck * 3 / 2;
+        ctx->dsi_cinfo.clkin = clkin;
+
+        pll_min = max(cfg->hs_clk_min * 4, txbyteclk * 4 * 4);
+        pll_max = cfg->hs_clk_max * 4;
+
+        return dsi_pll_calc(dsi->pdev, clkin,
+                        pll_min, pll_max,
+                        dsi_cm_calc_pll_cb, ctx);
 }
-EXPORT_SYMBOL(omapdss_dsi_set_pixel_format);
 
-void omapdss_dsi_set_operation_mode(struct omap_dss_device *dssdev,
-                enum omap_dss_dsi_mode mode)
+static bool dsi_vm_calc_blanking(struct dsi_clk_calc_ctx *ctx)
 {
-        struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_data *dsi = dsi_get_dsidrv_data(ctx->dsidev);
+        const struct omap_dss_dsi_config *cfg = ctx->config;
+        int bitspp = dsi_get_pixel_size(cfg->pixel_format);
+        int ndl = dsi->num_lanes_used - 1;
+        unsigned long hsclk = ctx->dsi_cinfo.clkin4ddr / 4;
+        unsigned long byteclk = hsclk / 4;
 
-        mutex_lock(&dsi->lock);
+        unsigned long dispc_pck, req_pck_min, req_pck_nom, req_pck_max;
+        int xres;
+        int panel_htot, panel_hbl; /* pixels */
+        int dispc_htot, dispc_hbl; /* pixels */
+        int dsi_htot, dsi_hact, dsi_hbl, hss, hse; /* byteclks */
+        int hfp, hsa, hbp;
+        const struct omap_video_timings *req_vm;
+        struct omap_video_timings *dispc_vm;
+        struct omap_dss_dsi_videomode_timings *dsi_vm;
+        u64 dsi_tput, dispc_tput;
 
-        dsi->mode = mode;
+        dsi_tput = (u64)byteclk * ndl * 8;
 
-        mutex_unlock(&dsi->lock);
+        req_vm = cfg->timings;
+        req_pck_min = ctx->req_pck_min;
+        req_pck_max = ctx->req_pck_max;
+        req_pck_nom = ctx->req_pck_nom;
+
+        dispc_pck = ctx->dispc_cinfo.pck;
+        dispc_tput = (u64)dispc_pck * bitspp;
+
+        xres = req_vm->x_res;
+
+        panel_hbl = req_vm->hfp + req_vm->hbp + req_vm->hsw;
+        panel_htot = xres + panel_hbl;
+
+        dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(xres * bitspp, 8) + 6, ndl);
+
+        /*
+         * When there are no line buffers, DISPC and DSI must have the
+         * same tput. Otherwise DISPC tput needs to be higher than DSI's.
+         */
+        if (dsi->line_buffer_size < xres * bitspp / 8) {
+                if (dispc_tput != dsi_tput)
+                        return false;
+        } else {
+                if (dispc_tput < dsi_tput)
+                        return false;
+        }
+
+        /* DSI tput must be over the min requirement */
+        if (dsi_tput < (u64)bitspp * req_pck_min)
+                return false;
+
+        /* When non-burst mode, DSI tput must be below max requirement. */
+        if (cfg->trans_mode != OMAP_DSS_DSI_BURST_MODE) {
+                if (dsi_tput > (u64)bitspp * req_pck_max)
+                        return false;
+        }
+
+        hss = DIV_ROUND_UP(4, ndl);
+
+        if (cfg->trans_mode == OMAP_DSS_DSI_PULSE_MODE) {
+                if (ndl == 3 && req_vm->hsw == 0)
+                        hse = 1;
+                else
+                        hse = DIV_ROUND_UP(4, ndl);
+        } else {
+                hse = 0;
+        }
+
+        /* DSI htot to match the panel's nominal pck */
+        dsi_htot = div64_u64((u64)panel_htot * byteclk, req_pck_nom);
+
+        /* fail if there would be no time for blanking */
+        if (dsi_htot < hss + hse + dsi_hact)
+                return false;
+
+        /* total DSI blanking needed to achieve panel's TL */
+        dsi_hbl = dsi_htot - dsi_hact;
+
+        /* DISPC htot to match the DSI TL */
+        dispc_htot = div64_u64((u64)dsi_htot * dispc_pck, byteclk);
+
+        /* verify that the DSI and DISPC TLs are the same */
+        if ((u64)dsi_htot * dispc_pck != (u64)dispc_htot * byteclk)
+                return false;
+
+        dispc_hbl = dispc_htot - xres;
+
+        /* setup DSI videomode */
+
+        dsi_vm = &ctx->dsi_vm;
+        memset(dsi_vm, 0, sizeof(*dsi_vm));
+
+        dsi_vm->hsclk = hsclk;
+
+        dsi_vm->ndl = ndl;
+        dsi_vm->bitspp = bitspp;
+
+        if (cfg->trans_mode != OMAP_DSS_DSI_PULSE_MODE) {
+                hsa = 0;
+        } else if (ndl == 3 && req_vm->hsw == 0) {
+                hsa = 0;
+        } else {
+                hsa = div64_u64((u64)req_vm->hsw * byteclk, req_pck_nom);
+                hsa = max(hsa - hse, 1);
+        }
+
+        hbp = div64_u64((u64)req_vm->hbp * byteclk, req_pck_nom);
+        hbp = max(hbp, 1);
+
+        hfp = dsi_hbl - (hss + hsa + hse + hbp);
+        if (hfp < 1) {
+                int t;
+                /* we need to take cycles from hbp */
+
+                t = 1 - hfp;
+                hbp = max(hbp - t, 1);
+                hfp = dsi_hbl - (hss + hsa + hse + hbp);
+
+                if (hfp < 1 && hsa > 0) {
+                        /* we need to take cycles from hsa */
+                        t = 1 - hfp;
+                        hsa = max(hsa - t, 1);
+                        hfp = dsi_hbl - (hss + hsa + hse + hbp);
+                }
+        }
+
+        if (hfp < 1)
+                return false;
+
+        dsi_vm->hss = hss;
+        dsi_vm->hsa = hsa;
+        dsi_vm->hse = hse;
+        dsi_vm->hbp = hbp;
+        dsi_vm->hact = xres;
+        dsi_vm->hfp = hfp;
+
+        dsi_vm->vsa = req_vm->vsw;
+        dsi_vm->vbp = req_vm->vbp;
+        dsi_vm->vact = req_vm->y_res;
+        dsi_vm->vfp = req_vm->vfp;
+
+        dsi_vm->trans_mode = cfg->trans_mode;
+
+        dsi_vm->blanking_mode = 0;
+        dsi_vm->hsa_blanking_mode = 1;
+        dsi_vm->hfp_blanking_mode = 1;
+        dsi_vm->hbp_blanking_mode = 1;
+
+        dsi_vm->ddr_clk_always_on = cfg->ddr_clk_always_on;
+        dsi_vm->window_sync = 4;
+
+        /* setup DISPC videomode */
+
+        dispc_vm = &ctx->dispc_vm;
+        *dispc_vm = *req_vm;
+        dispc_vm->pixel_clock = dispc_pck / 1000;
+
+        if (cfg->trans_mode == OMAP_DSS_DSI_PULSE_MODE) {
+                hsa = div64_u64((u64)req_vm->hsw * dispc_pck,
+                                req_pck_nom);
+                hsa = max(hsa, 1);
+        } else {
+                hsa = 1;
+        }
+
+        hbp = div64_u64((u64)req_vm->hbp * dispc_pck, req_pck_nom);
+        hbp = max(hbp, 1);
+
+        hfp = dispc_hbl - hsa - hbp;
+        if (hfp < 1) {
+                int t;
+                /* we need to take cycles from hbp */
+
+                t = 1 - hfp;
+                hbp = max(hbp - t, 1);
+                hfp = dispc_hbl - hsa - hbp;
+
+                if (hfp < 1) {
+                        /* we need to take cycles from hsa */
+                        t = 1 - hfp;
+                        hsa = max(hsa - t, 1);
+                        hfp = dispc_hbl - hsa - hbp;
+                }
+        }
+
+        if (hfp < 1)
+                return false;
+
+        dispc_vm->hfp = hfp;
+        dispc_vm->hsw = hsa;
+        dispc_vm->hbp = hbp;
+
+        return true;
 }
-EXPORT_SYMBOL(omapdss_dsi_set_operation_mode);
 
-void omapdss_dsi_set_videomode_timings(struct omap_dss_device *dssdev,
-                struct omap_dss_dsi_videomode_timings *timings)
+
+static bool dsi_vm_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
+                unsigned long pck, void *data)
+{
+        struct dsi_clk_calc_ctx *ctx = data;
+
+        ctx->dispc_cinfo.lck_div = lckd;
+        ctx->dispc_cinfo.pck_div = pckd;
+        ctx->dispc_cinfo.lck = lck;
+        ctx->dispc_cinfo.pck = pck;
+
+        if (dsi_vm_calc_blanking(ctx) == false)
+                return false;
+
+#ifdef PRINT_VERBOSE_VM_TIMINGS
+        print_dispc_vm("dispc", &ctx->dispc_vm);
+        print_dsi_vm("dsi  ", &ctx->dsi_vm);
+        print_dispc_vm("req  ", ctx->config->timings);
+        print_dsi_dispc_vm("act  ", &ctx->dsi_vm);
+#endif
+
+        return true;
+}
+
+static bool dsi_vm_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+                void *data)
+{
+        struct dsi_clk_calc_ctx *ctx = data;
+        unsigned long pck_max;
+
+        ctx->dsi_cinfo.regm_dispc = regm_dispc;
+        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
+
+        /*
+         * In burst mode we can let the dispc pck be arbitrarily high, but it
+         * limits our scaling abilities. So for now, don't aim too high.
+         */
+
+        if (ctx->config->trans_mode == OMAP_DSS_DSI_BURST_MODE)
+                pck_max = ctx->req_pck_max + 10000000;
+        else
+                pck_max = ctx->req_pck_max;
+
+        return dispc_div_calc(dispc, ctx->req_pck_min, pck_max,
+                        dsi_vm_calc_dispc_cb, ctx);
+}
+
+static bool dsi_vm_calc_pll_cb(int regn, int regm, unsigned long fint,
+                unsigned long pll, void *data)
+{
+        struct dsi_clk_calc_ctx *ctx = data;
+
+        ctx->dsi_cinfo.regn = regn;
+        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.fint = fint;
+        ctx->dsi_cinfo.clkin4ddr = pll;
+
+        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->req_pck_min,
+                        dsi_vm_calc_hsdiv_cb, ctx);
+}
+
+static bool dsi_vm_calc(struct dsi_data *dsi,
+                const struct omap_dss_dsi_config *cfg,
+                struct dsi_clk_calc_ctx *ctx)
+{
+        const struct omap_video_timings *t = cfg->timings;
+        unsigned long clkin;
+        unsigned long pll_min;
+        unsigned long pll_max;
+        int ndl = dsi->num_lanes_used - 1;
+        int bitspp = dsi_get_pixel_size(cfg->pixel_format);
+        unsigned long byteclk_min;
+
+        clkin = clk_get_rate(dsi->sys_clk);
+
+        memset(ctx, 0, sizeof(*ctx));
+        ctx->dsidev = dsi->pdev;
+        ctx->config = cfg;
+
+        ctx->dsi_cinfo.clkin = clkin;
+
+        /* these limits should come from the panel driver */
+        ctx->req_pck_min = t->pixel_clock * 1000 - 1000;
+        ctx->req_pck_nom = t->pixel_clock * 1000;
+        ctx->req_pck_max = t->pixel_clock * 1000 + 1000;
+
+        byteclk_min = div64_u64((u64)ctx->req_pck_min * bitspp, ndl * 8);
+        pll_min = max(cfg->hs_clk_min * 4, byteclk_min * 4 * 4);
+
+        if (cfg->trans_mode == OMAP_DSS_DSI_BURST_MODE) {
+                pll_max = cfg->hs_clk_max * 4;
+        } else {
+                unsigned long byteclk_max;
+                byteclk_max = div64_u64((u64)ctx->req_pck_max * bitspp,
+                                ndl * 8);
+
+                pll_max = byteclk_max * 4 * 4;
+        }
+
+        return dsi_pll_calc(dsi->pdev, clkin,
+                        pll_min, pll_max,
+                        dsi_vm_calc_pll_cb, ctx);
+}
+
+int omapdss_dsi_set_config(struct omap_dss_device *dssdev,
+                const struct omap_dss_dsi_config *config)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_clk_calc_ctx ctx;
+        bool ok;
+        int r;
 
         mutex_lock(&dsi->lock);
 
-        dsi->vm_timings = *timings;
+        dsi->pix_fmt = config->pixel_format;
+        dsi->mode = config->mode;
+
+        if (config->mode == OMAP_DSS_DSI_VIDEO_MODE)
+                ok = dsi_vm_calc(dsi, config, &ctx);
+        else
+                ok = dsi_cm_calc(dsi, config, &ctx);
+
+        if (!ok) {
+                DSSERR("failed to find suitable DSI clock settings\n");
+                r = -EINVAL;
+                goto err;
+        }
+
+        dsi_pll_calc_dsi_fck(&ctx.dsi_cinfo);
+
+        r = dsi_lp_clock_calc(&ctx.dsi_cinfo, config->lp_clk_min,
+                        config->lp_clk_max);
+        if (r) {
+                DSSERR("failed to find suitable DSI LP clock settings\n");
+                goto err;
+        }
+
+        dsi->user_dsi_cinfo = ctx.dsi_cinfo;
+        dsi->user_dispc_cinfo = ctx.dispc_cinfo;
+
+        dsi->timings = ctx.dispc_vm;
+        dsi->vm_timings = ctx.dsi_vm;
 
         mutex_unlock(&dsi->lock);
+
+        return 0;
+err:
+        mutex_unlock(&dsi->lock);
+
+        return r;
 }
-EXPORT_SYMBOL(omapdss_dsi_set_videomode_timings);
+EXPORT_SYMBOL(omapdss_dsi_set_config);
+
+/*
+ * Return a hardcoded channel for the DSI output. This should work for
+ * current use cases, but this can be later expanded to either resolve
+ * the channel in some more dynamic manner, or get the channel as a user
+ * parameter.
+ */
+static enum omap_channel dsi_get_channel(int module_id)
+{
+        switch (omapdss_get_version()) {
+        case OMAPDSS_VER_OMAP24xx:
+                DSSWARN("DSI not supported\n");
+                return OMAP_DSS_CHANNEL_LCD;
+
+        case OMAPDSS_VER_OMAP34xx_ES1:
+        case OMAPDSS_VER_OMAP34xx_ES3:
+        case OMAPDSS_VER_OMAP3630:
+        case OMAPDSS_VER_AM35xx:
+                return OMAP_DSS_CHANNEL_LCD;
+
+        case OMAPDSS_VER_OMAP4430_ES1:
+        case OMAPDSS_VER_OMAP4430_ES2:
+        case OMAPDSS_VER_OMAP4:
+                switch (module_id) {
+                case 0:
+                        return OMAP_DSS_CHANNEL_LCD;
+                case 1:
+                        return OMAP_DSS_CHANNEL_LCD2;
+                default:
+                        DSSWARN("unsupported module id\n");
+                        return OMAP_DSS_CHANNEL_LCD;
+                }
+
+        case OMAPDSS_VER_OMAP5:
+                switch (module_id) {
+                case 0:
+                        return OMAP_DSS_CHANNEL_LCD;
+                case 1:
+                        return OMAP_DSS_CHANNEL_LCD3;
+                default:
+                        DSSWARN("unsupported module id\n");
+                        return OMAP_DSS_CHANNEL_LCD;
+                }
 
-static int __init dsi_init_display(struct omap_dss_device *dssdev)
+        default:
+                DSSWARN("unsupported DSS version\n");
+                return OMAP_DSS_CHANNEL_LCD;
+        }
+}
+
+static int dsi_init_display(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev =
                         dsi_get_dsidev_from_id(dssdev->phy.dsi.module);
@@ -5073,7 +5347,7 @@ static int dsi_get_clocks(struct platform_device *dsidev)
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         struct clk *clk;
 
-        clk = clk_get(&dsidev->dev, "fck");
+        clk = devm_clk_get(&dsidev->dev, "fck");
         if (IS_ERR(clk)) {
                 DSSERR("can't get fck\n");
                 return PTR_ERR(clk);
@@ -5081,11 +5355,9 @@ static int dsi_get_clocks(struct platform_device *dsidev)
 
         dsi->dss_clk = clk;
 
-        clk = clk_get(&dsidev->dev, "sys_clk");
+        clk = devm_clk_get(&dsidev->dev, "sys_clk");
         if (IS_ERR(clk)) {
                 DSSERR("can't get sys_clk\n");
-                clk_put(dsi->dss_clk);
-                dsi->dss_clk = NULL;
                 return PTR_ERR(clk);
         }
 
@@ -5094,17 +5366,7 @@ static int dsi_get_clocks(struct platform_device *dsidev)
         return 0;
 }
 
-static void dsi_put_clocks(struct platform_device *dsidev)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-
-        if (dsi->dss_clk)
-                clk_put(dsi->dss_clk);
-        if (dsi->sys_clk)
-                clk_put(dsi->sys_clk);
-}
-
-static struct omap_dss_device * __init dsi_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *dsi_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         struct dsi_data *dsi = dsi_get_dsidrv_data(pdev);
@@ -5136,7 +5398,7 @@ static struct omap_dss_device * __init dsi_find_dssdev(struct platform_device *p
         return def_dssdev;
 }
 
-static void __init dsi_probe_pdata(struct platform_device *dsidev)
+static int dsi_probe_pdata(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         struct omap_dss_device *plat_dssdev;
@@ -5146,11 +5408,11 @@ static void __init dsi_probe_pdata(struct platform_device *dsidev)
         plat_dssdev = dsi_find_dssdev(dsidev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&dsidev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
@@ -5158,7 +5420,7 @@ static void __init dsi_probe_pdata(struct platform_device *dsidev)
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&dsi->output, dssdev);
@@ -5166,7 +5428,7 @@ static void __init dsi_probe_pdata(struct platform_device *dsidev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -5174,11 +5436,13 @@ static void __init dsi_probe_pdata(struct platform_device *dsidev)
                 DSSERR("device %s register failed: %d\n", dssdev->name, r);
                 omapdss_output_unset_device(&dsi->output);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init dsi_init_output(struct platform_device *dsidev)
+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;
@@ -5188,11 +5452,13 @@ static void __init dsi_init_output(struct platform_device *dsidev)
                         OMAP_DSS_OUTPUT_DSI1 : OMAP_DSS_OUTPUT_DSI2;
 
         out->type = OMAP_DISPLAY_TYPE_DSI;
+        out->name = dsi->module_id == 0 ? "dsi.0" : "dsi.1";
+        out->dispc_channel = dsi_get_channel(dsi->module_id);
 
         dss_register_output(out);
 }
 
-static void __exit dsi_uninit_output(struct platform_device *dsidev)
+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;
@@ -5201,7 +5467,7 @@ static void __exit dsi_uninit_output(struct platform_device *dsidev)
 }
 
 /* DSI1 HW IP initialisation */
-static int __init omap_dsihw_probe(struct platform_device *dsidev)
+static int omap_dsihw_probe(struct platform_device *dsidev)
 {
         u32 rev;
         int r, i;
@@ -5293,9 +5559,17 @@ static int __init omap_dsihw_probe(struct platform_device *dsidev)
         else
                 dsi->num_lanes_supported = 3;
 
+        dsi->line_buffer_size = dsi_get_line_buf_size(dsidev);
+
         dsi_init_output(dsidev);
 
-        dsi_probe_pdata(dsidev);
+        r = dsi_probe_pdata(dsidev);
+        if (r) {
+                dsi_runtime_put(dsidev);
+                dsi_uninit_output(dsidev);
+                pm_runtime_disable(&dsidev->dev);
+                return r;
+        }
 
         dsi_runtime_put(dsidev);
 
@@ -5314,7 +5588,6 @@ static int __init omap_dsihw_probe(struct platform_device *dsidev)
 
 err_runtime_get:
         pm_runtime_disable(&dsidev->dev);
-        dsi_put_clocks(dsidev);
         return r;
 }
 
@@ -5330,8 +5603,6 @@ static int __exit omap_dsihw_remove(struct platform_device *dsidev)
 
         pm_runtime_disable(&dsidev->dev);
 
-        dsi_put_clocks(dsidev);
-
         if (dsi->vdds_dsi_reg != NULL) {
                 if (dsi->vdds_dsi_enabled) {
                         regulator_disable(dsi->vdds_dsi_reg);
@@ -5369,6 +5640,7 @@ static const struct dev_pm_ops dsi_pm_ops = {
 };
 
 static struct platform_driver omap_dsihw_driver = {
+        .probe          = omap_dsihw_probe,
         .remove         = __exit_p(omap_dsihw_remove),
         .driver         = {
                 .name   = "omapdss_dsi",
@@ -5379,7 +5651,7 @@ static struct platform_driver omap_dsihw_driver = {
 
 int __init dsi_init_platform_driver(void)
 {
-        return platform_driver_probe(&omap_dsihw_driver, omap_dsihw_probe);
+        return platform_driver_register(&omap_dsihw_driver);
 }
 
 void __exit dsi_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 054c2a22b3f1..94f66f9f10a3 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -473,6 +473,47 @@ int dss_calc_clock_rates(struct dss_clock_info *cinfo)
         return 0;
 }
 
+bool dss_div_calc(unsigned long fck_min, dss_div_calc_func func, void *data)
+{
+        int fckd, fckd_start, fckd_stop;
+        unsigned long fck;
+        unsigned long fck_hw_max;
+        unsigned long fckd_hw_max;
+        unsigned long prate;
+        unsigned m;
+
+        if (dss.dpll4_m4_ck == NULL) {
+                /*
+                 * TODO: dss1_fclk can be changed on OMAP2, but the available
+                 * dividers are not continuous. We just use the pre-set rate for
+                 * now.
+                 */
+                fck = clk_get_rate(dss.dss_clk);
+                fckd = 1;
+                return func(fckd, fck, data);
+        }
+
+        fck_hw_max = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
+        fckd_hw_max = dss.feat->fck_div_max;
+
+        m = dss.feat->dss_fck_multiplier;
+        prate = dss_get_dpll4_rate();
+
+        fck_min = fck_min ? fck_min : 1;
+
+        fckd_start = min(prate * m / fck_min, fckd_hw_max);
+        fckd_stop = max(DIV_ROUND_UP(prate * m, fck_hw_max), 1ul);
+
+        for (fckd = fckd_start; fckd >= fckd_stop; --fckd) {
+                fck = prate / fckd * m;
+
+                if (func(fckd, fck, data))
+                        return true;
+        }
+
+        return false;
+}
+
 int dss_set_clock_div(struct dss_clock_info *cinfo)
 {
         if (dss.dpll4_m4_ck) {
@@ -482,7 +523,8 @@ int dss_set_clock_div(struct dss_clock_info *cinfo)
                 prate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
                 DSSDBG("dpll4_m4 = %ld\n", prate);
 
-                r = clk_set_rate(dss.dpll4_m4_ck, prate / cinfo->fck_div);
+                r = clk_set_rate(dss.dpll4_m4_ck,
+                                DIV_ROUND_UP(prate, cinfo->fck_div));
                 if (r)
                         return r;
         } else {
@@ -492,7 +534,9 @@ int dss_set_clock_div(struct dss_clock_info *cinfo)
 
         dss.dss_clk_rate = clk_get_rate(dss.dss_clk);
 
-        WARN_ONCE(dss.dss_clk_rate != cinfo->fck, "clk rate mismatch");
+        WARN_ONCE(dss.dss_clk_rate != cinfo->fck,
+                        "clk rate mismatch: %lu != %lu", dss.dss_clk_rate,
+                        cinfo->fck);
 
         DSSDBG("fck = %ld (%d)\n", cinfo->fck, cinfo->fck_div);
 
@@ -542,121 +586,6 @@ static int dss_setup_default_clock(void)
         return 0;
 }
 
-int dss_calc_clock_div(unsigned long req_pck, struct dss_clock_info *dss_cinfo,
-                struct dispc_clock_info *dispc_cinfo)
-{
-        unsigned long prate;
-        struct dss_clock_info best_dss;
-        struct dispc_clock_info best_dispc;
-
-        unsigned long fck, max_dss_fck;
-
-        u16 fck_div;
-
-        int match = 0;
-        int min_fck_per_pck;
-
-        prate = dss_get_dpll4_rate();
-
-        max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
-
-        fck = clk_get_rate(dss.dss_clk);
-        if (req_pck == dss.cache_req_pck && prate == dss.cache_prate &&
-                dss.cache_dss_cinfo.fck == fck) {
-                DSSDBG("dispc clock info found from cache.\n");
-                *dss_cinfo = dss.cache_dss_cinfo;
-                *dispc_cinfo = dss.cache_dispc_cinfo;
-                return 0;
-        }
-
-        min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
-
-        if (min_fck_per_pck &&
-                req_pck * min_fck_per_pck > max_dss_fck) {
-                DSSERR("Requested pixel clock not possible with the current "
-                                "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
-                                "the constraint off.\n");
-                min_fck_per_pck = 0;
-        }
-
-retry:
-        memset(&best_dss, 0, sizeof(best_dss));
-        memset(&best_dispc, 0, sizeof(best_dispc));
-
-        if (dss.dpll4_m4_ck == NULL) {
-                struct dispc_clock_info cur_dispc;
-                /* XXX can we change the clock on omap2? */
-                fck = clk_get_rate(dss.dss_clk);
-                fck_div = 1;
-
-                dispc_find_clk_divs(req_pck, fck, &cur_dispc);
-                match = 1;
-
-                best_dss.fck = fck;
-                best_dss.fck_div = fck_div;
-
-                best_dispc = cur_dispc;
-
-                goto found;
-        } else {
-                for (fck_div = dss.feat->fck_div_max; fck_div > 0; --fck_div) {
-                        struct dispc_clock_info cur_dispc;
-
-                        fck = prate / fck_div * dss.feat->dss_fck_multiplier;
-
-                        if (fck > max_dss_fck)
-                                continue;
-
-                        if (min_fck_per_pck &&
-                                        fck < req_pck * min_fck_per_pck)
-                                continue;
-
-                        match = 1;
-
-                        dispc_find_clk_divs(req_pck, fck, &cur_dispc);
-
-                        if (abs(cur_dispc.pck - req_pck) <
-                                        abs(best_dispc.pck - req_pck)) {
-
-                                best_dss.fck = fck;
-                                best_dss.fck_div = fck_div;
-
-                                best_dispc = cur_dispc;
-
-                                if (cur_dispc.pck == req_pck)
-                                        goto found;
-                        }
-                }
-        }
-
-found:
-        if (!match) {
-                if (min_fck_per_pck) {
-                        DSSERR("Could not find suitable clock settings.\n"
-                                        "Turning FCK/PCK constraint off and"
-                                        "trying again.\n");
-                        min_fck_per_pck = 0;
-                        goto retry;
-                }
-
-                DSSERR("Could not find suitable clock settings.\n");
-
-                return -EINVAL;
-        }
-
-        if (dss_cinfo)
-                *dss_cinfo = best_dss;
-        if (dispc_cinfo)
-                *dispc_cinfo = best_dispc;
-
-        dss.cache_req_pck = req_pck;
-        dss.cache_prate = prate;
-        dss.cache_dss_cinfo = best_dss;
-        dss.cache_dispc_cinfo = best_dispc;
-
-        return 0;
-}
-
 void dss_set_venc_output(enum omap_dss_venc_type type)
 {
         int l = 0;
@@ -767,13 +696,11 @@ int dss_dpi_select_source(enum omap_channel channel)
 static int dss_get_clocks(void)
 {
         struct clk *clk;
-        int r;
 
-        clk = clk_get(&dss.pdev->dev, "fck");
+        clk = devm_clk_get(&dss.pdev->dev, "fck");
         if (IS_ERR(clk)) {
                 DSSERR("can't get clock fck\n");
-                r = PTR_ERR(clk);
-                goto err;
+                return PTR_ERR(clk);
         }
 
         dss.dss_clk = clk;
@@ -782,8 +709,7 @@ static int dss_get_clocks(void)
                 clk = clk_get(NULL, dss.feat->clk_name);
                 if (IS_ERR(clk)) {
                         DSSERR("Failed to get %s\n", dss.feat->clk_name);
-                        r = PTR_ERR(clk);
-                        goto err;
+                        return PTR_ERR(clk);
                 }
         } else {
                 clk = NULL;
@@ -792,21 +718,12 @@ static int dss_get_clocks(void)
         dss.dpll4_m4_ck = clk;
 
         return 0;
-
-err:
-        if (dss.dss_clk)
-                clk_put(dss.dss_clk);
-        if (dss.dpll4_m4_ck)
-                clk_put(dss.dpll4_m4_ck);
-
-        return r;
 }
 
 static void dss_put_clocks(void)
 {
         if (dss.dpll4_m4_ck)
                 clk_put(dss.dpll4_m4_ck);
-        clk_put(dss.dss_clk);
 }
 
 static int dss_runtime_get(void)
diff --git a/drivers/video/omap2/dss/dss.h b/drivers/video/omap2/dss/dss.h
index 610c8e563daa..84758936429d 100644
--- a/drivers/video/omap2/dss/dss.h
+++ b/drivers/video/omap2/dss/dss.h
@@ -268,14 +268,21 @@ void dss_set_dac_pwrdn_bgz(bool enable);
 unsigned long dss_get_dpll4_rate(void);
 int dss_calc_clock_rates(struct dss_clock_info *cinfo);
 int dss_set_clock_div(struct dss_clock_info *cinfo);
-int dss_calc_clock_div(unsigned long req_pck, struct dss_clock_info *dss_cinfo,
-                struct dispc_clock_info *dispc_cinfo);
+
+typedef bool (*dss_div_calc_func)(int fckd, unsigned long fck, void *data);
+bool dss_div_calc(unsigned long fck_min, dss_div_calc_func func, void *data);
 
 /* SDI */
 int sdi_init_platform_driver(void) __init;
 void sdi_uninit_platform_driver(void) __exit;
 
 /* DSI */
+
+typedef bool (*dsi_pll_calc_func)(int regn, int regm, unsigned long fint,
+                unsigned long pll, void *data);
+typedef bool (*dsi_hsdiv_calc_func)(int regm_dispc, unsigned long dispc,
+                void *data);
+
 #ifdef CONFIG_OMAP2_DSS_DSI
 
 struct dentry;
@@ -292,12 +299,17 @@ void dsi_dump_clocks(struct seq_file *s);
 void dsi_irq_handler(void);
 u8 dsi_get_pixel_size(enum omap_dss_dsi_pixel_format fmt);
 
+unsigned long dsi_get_pll_clkin(struct platform_device *dsidev);
+
+bool dsi_hsdiv_calc(struct platform_device *dsidev, unsigned long pll,
+                unsigned long out_min, dsi_hsdiv_calc_func func, void *data);
+bool dsi_pll_calc(struct platform_device *dsidev, unsigned long clkin,
+                unsigned long pll_min, unsigned long pll_max,
+                dsi_pll_calc_func func, void *data);
+
 unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev);
 int dsi_pll_set_clock_div(struct platform_device *dsidev,
                 struct dsi_clock_info *cinfo);
-int dsi_pll_calc_clock_div_pck(struct platform_device *dsidev,
-                unsigned long req_pck, struct dsi_clock_info *cinfo,
-                struct dispc_clock_info *dispc_cinfo);
 int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
                 bool enable_hsdiv);
 void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes);
@@ -328,14 +340,6 @@ static inline int dsi_pll_set_clock_div(struct platform_device *dsidev,
         WARN("%s: DSI not compiled in\n", __func__);
         return -ENODEV;
 }
-static inline int dsi_pll_calc_clock_div_pck(struct platform_device *dsidev,
-                unsigned long req_pck,
-                struct dsi_clock_info *dsi_cinfo,
-                struct dispc_clock_info *dispc_cinfo)
-{
-        WARN("%s: DSI not compiled in\n", __func__);
-        return -ENODEV;
-}
 static inline int dsi_pll_init(struct platform_device *dsidev,
                 bool enable_hsclk, bool enable_hsdiv)
 {
@@ -356,6 +360,27 @@ static inline struct platform_device *dsi_get_dsidev_from_id(int module)
 {
         return NULL;
 }
+
+static inline unsigned long dsi_get_pll_clkin(struct platform_device *dsidev)
+{
+        return 0;
+}
+
+static inline bool dsi_hsdiv_calc(struct platform_device *dsidev,
+                unsigned long pll, unsigned long out_min,
+                dsi_hsdiv_calc_func func, void *data)
+{
+        return false;
+}
+
+static inline bool dsi_pll_calc(struct platform_device *dsidev,
+                unsigned long clkin,
+                unsigned long pll_min, unsigned long pll_max,
+                dsi_pll_calc_func func, void *data)
+{
+        return false;
+}
+
 #endif
 
 /* DPI */
@@ -376,11 +401,15 @@ void dispc_enable_fifomerge(bool enable);
 void dispc_enable_gamma_table(bool enable);
 void dispc_set_loadmode(enum omap_dss_load_mode mode);
 
+typedef bool (*dispc_div_calc_func)(int lckd, int pckd, unsigned long lck,
+                unsigned long pck, void *data);
+bool dispc_div_calc(unsigned long dispc,
+                unsigned long pck_min, unsigned long pck_max,
+                dispc_div_calc_func func, void *data);
+
 bool dispc_mgr_timings_ok(enum omap_channel channel,
                 const struct omap_video_timings *timings);
 unsigned long dispc_fclk_rate(void);
-void dispc_find_clk_divs(unsigned long req_pck, unsigned long fck,
-                struct dispc_clock_info *cinfo);
 int dispc_calc_clock_rates(unsigned long dispc_fclk_rate,
                 struct dispc_clock_info *cinfo);
 
diff --git a/drivers/video/omap2/dss/dss_features.c b/drivers/video/omap2/dss/dss_features.c
index 7f791aeda4d2..77dbe0cfb34c 100644
--- a/drivers/video/omap2/dss/dss_features.c
+++ b/drivers/video/omap2/dss/dss_features.c
@@ -414,7 +414,7 @@ static const char * const omap5_dss_clk_source_names[] = {
 };
 
 static const struct dss_param_range omap2_dss_param_range[] = {
-        [FEAT_PARAM_DSS_FCK]                    = { 0, 173000000 },
+        [FEAT_PARAM_DSS_FCK]                    = { 0, 133000000 },
         [FEAT_PARAM_DSS_PCD]                    = { 2, 255 },
         [FEAT_PARAM_DSIPLL_REGN]                = { 0, 0 },
         [FEAT_PARAM_DSIPLL_REGM]                = { 0, 0 },
@@ -459,15 +459,15 @@ static const struct dss_param_range omap4_dss_param_range[] = {
 };
 
 static const struct dss_param_range omap5_dss_param_range[] = {
-        [FEAT_PARAM_DSS_FCK]                    = { 0, 200000000 },
+        [FEAT_PARAM_DSS_FCK]                    = { 0, 209250000 },
         [FEAT_PARAM_DSS_PCD]                    = { 1, 255 },
         [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 8) - 1 },
         [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 12) - 1 },
         [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 5) - 1 },
         [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 5) - 1 },
-        [FEAT_PARAM_DSIPLL_FINT]                = { 500000, 2500000 },
+        [FEAT_PARAM_DSIPLL_FINT]                = { 150000, 52000000 },
         [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, (1 << 13) - 1 },
-        [FEAT_PARAM_DSI_FCK]                    = { 0, 170000000 },
+        [FEAT_PARAM_DSI_FCK]                    = { 0, 209250000 },
         [FEAT_PARAM_DOWNSCALE]                  = { 1, 4 },
         [FEAT_PARAM_LINEWIDTH]                  = { 1, 2048 },
 };
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index 72923645dcce..17f4d55c621c 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -328,7 +328,7 @@ static void hdmi_runtime_put(void)
         WARN_ON(r < 0 && r != -ENOSYS);
 }
 
-static int __init hdmi_init_display(struct omap_dss_device *dssdev)
+static int hdmi_init_display(struct omap_dss_device *dssdev)
 {
         int r;
 
@@ -472,17 +472,12 @@ static void hdmi_compute_pll(struct omap_dss_device *dssdev, int phy,
          * Input clock is predivided by N + 1
          * out put of which is reference clk
          */
-        if (dssdev->clocks.hdmi.regn == 0)
-                pi->regn = HDMI_DEFAULT_REGN;
-        else
-                pi->regn = dssdev->clocks.hdmi.regn;
+
+        pi->regn = HDMI_DEFAULT_REGN;
 
         refclk = clkin / pi->regn;
 
-        if (dssdev->clocks.hdmi.regm2 == 0)
-                pi->regm2 = HDMI_DEFAULT_REGM2;
-        else
-                pi->regm2 = dssdev->clocks.hdmi.regm2;
+        pi->regm2 = HDMI_DEFAULT_REGM2;
 
         /*
          * multiplier is pixel_clk/ref_clk
@@ -804,7 +799,7 @@ static int hdmi_get_clocks(struct platform_device *pdev)
 {
         struct clk *clk;
 
-        clk = clk_get(&pdev->dev, "sys_clk");
+        clk = devm_clk_get(&pdev->dev, "sys_clk");
         if (IS_ERR(clk)) {
                 DSSERR("can't get sys_clk\n");
                 return PTR_ERR(clk);
@@ -815,12 +810,6 @@ static int hdmi_get_clocks(struct platform_device *pdev)
         return 0;
 }
 
-static void hdmi_put_clocks(void)
-{
-        if (hdmi.sys_clk)
-                clk_put(hdmi.sys_clk);
-}
-
 #if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
 int hdmi_compute_acr(u32 sample_freq, u32 *n, u32 *cts)
 {
@@ -965,7 +954,7 @@ int hdmi_audio_config(struct omap_dss_audio *audio)
 
 #endif
 
-static struct omap_dss_device * __init hdmi_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *hdmi_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         const char *def_disp_name = omapdss_get_default_display_name();
@@ -993,7 +982,7 @@ static struct omap_dss_device * __init hdmi_find_dssdev(struct platform_device *
         return def_dssdev;
 }
 
-static void __init hdmi_probe_pdata(struct platform_device *pdev)
+static int hdmi_probe_pdata(struct platform_device *pdev)
 {
         struct omap_dss_device *plat_dssdev;
         struct omap_dss_device *dssdev;
@@ -1003,11 +992,11 @@ static void __init hdmi_probe_pdata(struct platform_device *pdev)
         plat_dssdev = hdmi_find_dssdev(pdev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&pdev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
@@ -1017,13 +1006,11 @@ static void __init hdmi_probe_pdata(struct platform_device *pdev)
         hdmi.ls_oe_gpio = priv->ls_oe_gpio;
         hdmi.hpd_gpio = priv->hpd_gpio;
 
-        dssdev->channel = OMAP_DSS_CHANNEL_DIGIT;
-
         r = hdmi_init_display(dssdev);
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&hdmi.output, dssdev);
@@ -1031,7 +1018,7 @@ static void __init hdmi_probe_pdata(struct platform_device *pdev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -1040,17 +1027,21 @@ static void __init hdmi_probe_pdata(struct platform_device *pdev)
                 omapdss_output_unset_device(&hdmi.output);
                 hdmi_uninit_display(dssdev);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init hdmi_init_output(struct platform_device *pdev)
+static void hdmi_init_output(struct platform_device *pdev)
 {
         struct omap_dss_output *out = &hdmi.output;
 
         out->pdev = pdev;
         out->id = OMAP_DSS_OUTPUT_HDMI;
         out->type = OMAP_DISPLAY_TYPE_HDMI;
+        out->name = "hdmi.0";
+        out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
 
         dss_register_output(out);
 }
@@ -1063,7 +1054,7 @@ static void __exit hdmi_uninit_output(struct platform_device *pdev)
 }
 
 /* HDMI HW IP initialisation */
-static int __init omapdss_hdmihw_probe(struct platform_device *pdev)
+static int omapdss_hdmihw_probe(struct platform_device *pdev)
 {
         struct resource *res;
         int r;
@@ -1097,23 +1088,25 @@ static int __init omapdss_hdmihw_probe(struct platform_device *pdev)
         hdmi.ip_data.pll_offset = HDMI_PLLCTRL;
         hdmi.ip_data.phy_offset = HDMI_PHY;
 
+        hdmi_init_output(pdev);
+
         r = hdmi_panel_init();
         if (r) {
                 DSSERR("can't init panel\n");
-                goto err_panel_init;
+                return r;
         }
 
         dss_debugfs_create_file("hdmi", hdmi_dump_regs);
 
-        hdmi_init_output(pdev);
-
-        hdmi_probe_pdata(pdev);
+        r = hdmi_probe_pdata(pdev);
+        if (r) {
+                hdmi_panel_exit();
+                hdmi_uninit_output(pdev);
+                pm_runtime_disable(&pdev->dev);
+                return r;
+        }
 
         return 0;
-
-err_panel_init:
-        hdmi_put_clocks();
-        return r;
 }
 
 static int __exit hdmi_remove_child(struct device *dev, void *data)
@@ -1135,8 +1128,6 @@ static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 
         pm_runtime_disable(&pdev->dev);
 
-        hdmi_put_clocks();
-
         return 0;
 }
 
@@ -1168,6 +1159,7 @@ static const struct dev_pm_ops hdmi_pm_ops = {
 };
 
 static struct platform_driver omapdss_hdmihw_driver = {
+        .probe          = omapdss_hdmihw_probe,
         .remove         = __exit_p(omapdss_hdmihw_remove),
         .driver         = {
                 .name   = "omapdss_hdmi",
@@ -1178,7 +1170,7 @@ static struct platform_driver omapdss_hdmihw_driver = {
 
 int __init hdmi_init_platform_driver(void)
 {
-        return platform_driver_probe(&omapdss_hdmihw_driver, omapdss_hdmihw_probe);
+        return platform_driver_register(&omapdss_hdmihw_driver);
 }
 
 void __exit hdmi_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/dss/output.c b/drivers/video/omap2/dss/output.c
index 79dea1a1a732..5214df63e0a9 100644
--- a/drivers/video/omap2/dss/output.c
+++ b/drivers/video/omap2/dss/output.c
@@ -113,6 +113,7 @@ struct omap_dss_output *omap_dss_get_output(enum omap_dss_output_id id)
 
         return NULL;
 }
+EXPORT_SYMBOL(omap_dss_get_output);
 
 static const struct dss_mgr_ops *dss_mgr_ops;
 
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index e903dd3f54d9..1a17dd1447dc 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -943,13 +943,13 @@ void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev)
 }
 EXPORT_SYMBOL(omapdss_rfbi_display_disable);
 
-static int __init rfbi_init_display(struct omap_dss_device *dssdev)
+static int rfbi_init_display(struct omap_dss_device *dssdev)
 {
         rfbi.dssdev[dssdev->phy.rfbi.channel] = dssdev;
         return 0;
 }
 
-static struct omap_dss_device * __init rfbi_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *rfbi_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         const char *def_disp_name = omapdss_get_default_display_name();
@@ -977,7 +977,7 @@ static struct omap_dss_device * __init rfbi_find_dssdev(struct platform_device *
         return def_dssdev;
 }
 
-static void __init rfbi_probe_pdata(struct platform_device *rfbidev)
+static int rfbi_probe_pdata(struct platform_device *rfbidev)
 {
         struct omap_dss_device *plat_dssdev;
         struct omap_dss_device *dssdev;
@@ -986,11 +986,11 @@ static void __init rfbi_probe_pdata(struct platform_device *rfbidev)
         plat_dssdev = rfbi_find_dssdev(rfbidev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&rfbidev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
@@ -998,7 +998,7 @@ static void __init rfbi_probe_pdata(struct platform_device *rfbidev)
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&rfbi.output, dssdev);
@@ -1006,7 +1006,7 @@ static void __init rfbi_probe_pdata(struct platform_device *rfbidev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -1014,17 +1014,21 @@ static void __init rfbi_probe_pdata(struct platform_device *rfbidev)
                 DSSERR("device %s register failed: %d\n", dssdev->name, r);
                 omapdss_output_unset_device(&rfbi.output);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init rfbi_init_output(struct platform_device *pdev)
+static void rfbi_init_output(struct platform_device *pdev)
 {
         struct omap_dss_output *out = &rfbi.output;
 
         out->pdev = pdev;
         out->id = OMAP_DSS_OUTPUT_DBI;
         out->type = OMAP_DISPLAY_TYPE_DBI;
+        out->name = "rfbi.0";
+        out->dispc_channel = OMAP_DSS_CHANNEL_LCD;
 
         dss_register_output(out);
 }
@@ -1037,7 +1041,7 @@ static void __exit rfbi_uninit_output(struct platform_device *pdev)
 }
 
 /* RFBI HW IP initialisation */
-static int __init omap_rfbihw_probe(struct platform_device *pdev)
+static int omap_rfbihw_probe(struct platform_device *pdev)
 {
         u32 rev;
         struct resource *rfbi_mem;
@@ -1089,7 +1093,12 @@ static int __init omap_rfbihw_probe(struct platform_device *pdev)
 
         rfbi_init_output(pdev);
 
-        rfbi_probe_pdata(pdev);
+        r = rfbi_probe_pdata(pdev);
+        if (r) {
+                rfbi_uninit_output(pdev);
+                pm_runtime_disable(&pdev->dev);
+                return r;
+        }
 
         return 0;
 
@@ -1133,6 +1142,7 @@ static const struct dev_pm_ops rfbi_pm_ops = {
 };
 
 static struct platform_driver omap_rfbihw_driver = {
+        .probe          = omap_rfbihw_probe,
         .remove         = __exit_p(omap_rfbihw_remove),
         .driver         = {
                 .name   = "omapdss_rfbi",
@@ -1143,7 +1153,7 @@ static struct platform_driver omap_rfbihw_driver = {
 
 int __init rfbi_init_platform_driver(void)
 {
-        return platform_driver_probe(&omap_rfbihw_driver, omap_rfbihw_probe);
+        return platform_driver_register(&omap_rfbihw_driver);
 }
 
 void __exit rfbi_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/dss/sdi.c b/drivers/video/omap2/dss/sdi.c
index 62b5374ce438..0bcd30272f69 100644
--- a/drivers/video/omap2/dss/sdi.c
+++ b/drivers/video/omap2/dss/sdi.c
@@ -41,6 +41,72 @@ static struct {
         struct omap_dss_output output;
 } sdi;
 
+struct sdi_clk_calc_ctx {
+        unsigned long pck_min, pck_max;
+
+        struct dss_clock_info dss_cinfo;
+        struct dispc_clock_info dispc_cinfo;
+};
+
+static bool dpi_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
+                unsigned long pck, void *data)
+{
+        struct sdi_clk_calc_ctx *ctx = data;
+
+        ctx->dispc_cinfo.lck_div = lckd;
+        ctx->dispc_cinfo.pck_div = pckd;
+        ctx->dispc_cinfo.lck = lck;
+        ctx->dispc_cinfo.pck = pck;
+
+        return true;
+}
+
+static bool dpi_calc_dss_cb(int fckd, unsigned long fck, void *data)
+{
+        struct sdi_clk_calc_ctx *ctx = data;
+
+        ctx->dss_cinfo.fck = fck;
+        ctx->dss_cinfo.fck_div = fckd;
+
+        return dispc_div_calc(fck, ctx->pck_min, ctx->pck_max,
+                        dpi_calc_dispc_cb, ctx);
+}
+
+static int sdi_calc_clock_div(unsigned long pclk,
+                struct dss_clock_info *dss_cinfo,
+                struct dispc_clock_info *dispc_cinfo)
+{
+        int i;
+        struct sdi_clk_calc_ctx ctx;
+
+        /*
+         * DSS fclk gives us very few possibilities, so finding a good pixel
+         * clock may not be possible. We try multiple times to find the clock,
+         * each time widening the pixel clock range we look for, up to
+         * +/- 1MHz.
+         */
+
+        for (i = 0; i < 10; ++i) {
+                bool ok;
+
+                memset(&ctx, 0, sizeof(ctx));
+                if (pclk > 1000 * i * i * i)
+                        ctx.pck_min = max(pclk - 1000 * i * i * i, 0lu);
+                else
+                        ctx.pck_min = 0;
+                ctx.pck_max = pclk + 1000 * i * i * i;
+
+                ok = dss_div_calc(ctx.pck_min, dpi_calc_dss_cb, &ctx);
+                if (ok) {
+                        *dss_cinfo = ctx.dss_cinfo;
+                        *dispc_cinfo = ctx.dispc_cinfo;
+                        return 0;
+                }
+        }
+
+        return -EINVAL;
+}
+
 static void sdi_config_lcd_manager(struct omap_dss_device *dssdev)
 {
         struct omap_overlay_manager *mgr = dssdev->output->manager;
@@ -88,7 +154,7 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         t->data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
         t->sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
 
-        r = dss_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo);
+        r = sdi_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo);
         if (r)
                 goto err_calc_clock_div;
 
@@ -182,7 +248,7 @@ void omapdss_sdi_set_datapairs(struct omap_dss_device *dssdev, int datapairs)
 }
 EXPORT_SYMBOL(omapdss_sdi_set_datapairs);
 
-static int __init sdi_init_display(struct omap_dss_device *dssdev)
+static int sdi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("SDI init\n");
 
@@ -202,7 +268,7 @@ static int __init sdi_init_display(struct omap_dss_device *dssdev)
         return 0;
 }
 
-static struct omap_dss_device * __init sdi_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *sdi_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         const char *def_disp_name = omapdss_get_default_display_name();
@@ -230,7 +296,7 @@ static struct omap_dss_device * __init sdi_find_dssdev(struct platform_device *p
         return def_dssdev;
 }
 
-static void __init sdi_probe_pdata(struct platform_device *sdidev)
+static int sdi_probe_pdata(struct platform_device *sdidev)
 {
         struct omap_dss_device *plat_dssdev;
         struct omap_dss_device *dssdev;
@@ -239,11 +305,11 @@ static void __init sdi_probe_pdata(struct platform_device *sdidev)
         plat_dssdev = sdi_find_dssdev(sdidev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&sdidev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
@@ -251,7 +317,7 @@ static void __init sdi_probe_pdata(struct platform_device *sdidev)
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&sdi.output, dssdev);
@@ -259,7 +325,7 @@ static void __init sdi_probe_pdata(struct platform_device *sdidev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -267,17 +333,21 @@ static void __init sdi_probe_pdata(struct platform_device *sdidev)
                 DSSERR("device %s register failed: %d\n", dssdev->name, r);
                 omapdss_output_unset_device(&sdi.output);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init sdi_init_output(struct platform_device *pdev)
+static void sdi_init_output(struct platform_device *pdev)
 {
         struct omap_dss_output *out = &sdi.output;
 
         out->pdev = pdev;
         out->id = OMAP_DSS_OUTPUT_SDI;
         out->type = OMAP_DISPLAY_TYPE_SDI;
+        out->name = "sdi.0";
+        out->dispc_channel = OMAP_DSS_CHANNEL_LCD;
 
         dss_register_output(out);
 }
@@ -289,11 +359,17 @@ static void __exit sdi_uninit_output(struct platform_device *pdev)
         dss_unregister_output(out);
 }
 
-static int __init omap_sdi_probe(struct platform_device *pdev)
+static int omap_sdi_probe(struct platform_device *pdev)
 {
+        int r;
+
         sdi_init_output(pdev);
 
-        sdi_probe_pdata(pdev);
+        r = sdi_probe_pdata(pdev);
+        if (r) {
+                sdi_uninit_output(pdev);
+                return r;
+        }
 
         return 0;
 }
@@ -308,6 +384,7 @@ static int __exit omap_sdi_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver omap_sdi_driver = {
+        .probe          = omap_sdi_probe,
         .remove         = __exit_p(omap_sdi_remove),
         .driver         = {
                 .name   = "omapdss_sdi",
@@ -317,7 +394,7 @@ static struct platform_driver omap_sdi_driver = {
 
 int __init sdi_init_platform_driver(void)
 {
-        return platform_driver_probe(&omap_sdi_driver, omap_sdi_probe);
+        return platform_driver_register(&omap_sdi_driver);
 }
 
 void __exit sdi_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 006caf3cb509..74fdb3ee209e 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -519,10 +519,6 @@ int omapdss_venc_display_enable(struct omap_dss_device *dssdev)
                 goto err0;
         }
 
-        if (dssdev->platform_enable)
-                dssdev->platform_enable(dssdev);
-
-
         r = venc_power_on(dssdev);
         if (r)
                 goto err1;
@@ -533,8 +529,6 @@ int omapdss_venc_display_enable(struct omap_dss_device *dssdev)
 
         return 0;
 err1:
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
         omap_dss_stop_device(dssdev);
 err0:
         mutex_unlock(&venc.venc_lock);
@@ -551,9 +545,6 @@ void omapdss_venc_display_disable(struct omap_dss_device *dssdev)
 
         omap_dss_stop_device(dssdev);
 
-        if (dssdev->platform_disable)
-                dssdev->platform_disable(dssdev);
-
         mutex_unlock(&venc.venc_lock);
 }
 
@@ -642,7 +633,7 @@ void omapdss_venc_invert_vid_out_polarity(struct omap_dss_device *dssdev,
         mutex_unlock(&venc.venc_lock);
 }
 
-static int __init venc_init_display(struct omap_dss_device *dssdev)
+static int venc_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
 
@@ -721,7 +712,7 @@ static int venc_get_clocks(struct platform_device *pdev)
         struct clk *clk;
 
         if (dss_has_feature(FEAT_VENC_REQUIRES_TV_DAC_CLK)) {
-                clk = clk_get(&pdev->dev, "tv_dac_clk");
+                clk = devm_clk_get(&pdev->dev, "tv_dac_clk");
                 if (IS_ERR(clk)) {
                         DSSERR("can't get tv_dac_clk\n");
                         return PTR_ERR(clk);
@@ -735,13 +726,7 @@ static int venc_get_clocks(struct platform_device *pdev)
         return 0;
 }
 
-static void venc_put_clocks(void)
-{
-        if (venc.tv_dac_clk)
-                clk_put(venc.tv_dac_clk);
-}
-
-static struct omap_dss_device * __init venc_find_dssdev(struct platform_device *pdev)
+static struct omap_dss_device *venc_find_dssdev(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         const char *def_disp_name = omapdss_get_default_display_name();
@@ -769,7 +754,7 @@ static struct omap_dss_device * __init venc_find_dssdev(struct platform_device *
         return def_dssdev;
 }
 
-static void __init venc_probe_pdata(struct platform_device *vencdev)
+static int venc_probe_pdata(struct platform_device *vencdev)
 {
         struct omap_dss_device *plat_dssdev;
         struct omap_dss_device *dssdev;
@@ -778,21 +763,19 @@ static void __init venc_probe_pdata(struct platform_device *vencdev)
         plat_dssdev = venc_find_dssdev(vencdev);
 
         if (!plat_dssdev)
-                return;
+                return 0;
 
         dssdev = dss_alloc_and_init_device(&vencdev->dev);
         if (!dssdev)
-                return;
+                return -ENOMEM;
 
         dss_copy_device_pdata(dssdev, plat_dssdev);
 
-        dssdev->channel = OMAP_DSS_CHANNEL_DIGIT;
-
         r = venc_init_display(dssdev);
         if (r) {
                 DSSERR("device %s init failed: %d\n", dssdev->name, r);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = omapdss_output_set_device(&venc.output, dssdev);
@@ -800,7 +783,7 @@ static void __init venc_probe_pdata(struct platform_device *vencdev)
                 DSSERR("failed to connect output to new device: %s\n",
                                 dssdev->name);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
 
         r = dss_add_device(dssdev);
@@ -808,17 +791,21 @@ static void __init venc_probe_pdata(struct platform_device *vencdev)
                 DSSERR("device %s register failed: %d\n", dssdev->name, r);
                 omapdss_output_unset_device(&venc.output);
                 dss_put_device(dssdev);
-                return;
+                return r;
         }
+
+        return 0;
 }
 
-static void __init venc_init_output(struct platform_device *pdev)
+static void venc_init_output(struct platform_device *pdev)
 {
         struct omap_dss_output *out = &venc.output;
 
         out->pdev = pdev;
         out->id = OMAP_DSS_OUTPUT_VENC;
         out->type = OMAP_DISPLAY_TYPE_VENC;
+        out->name = "venc.0";
+        out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
 
         dss_register_output(out);
 }
@@ -831,7 +818,7 @@ static void __exit venc_uninit_output(struct platform_device *pdev)
 }
 
 /* VENC HW IP initialisation */
-static int __init omap_venchw_probe(struct platform_device *pdev)
+static int omap_venchw_probe(struct platform_device *pdev)
 {
         u8 rev_id;
         struct resource *venc_mem;
@@ -879,14 +866,19 @@ static int __init omap_venchw_probe(struct platform_device *pdev)
 
         venc_init_output(pdev);
 
-        venc_probe_pdata(pdev);
+        r = venc_probe_pdata(pdev);
+        if (r) {
+                venc_panel_exit();
+                venc_uninit_output(pdev);
+                pm_runtime_disable(&pdev->dev);
+                return r;
+        }
 
         return 0;
 
 err_panel_init:
 err_runtime_get:
         pm_runtime_disable(&pdev->dev);
-        venc_put_clocks();
         return r;
 }
 
@@ -904,7 +896,6 @@ static int __exit omap_venchw_remove(struct platform_device *pdev)
         venc_uninit_output(pdev);
 
         pm_runtime_disable(&pdev->dev);
-        venc_put_clocks();
 
         return 0;
 }
@@ -939,6 +930,7 @@ static const struct dev_pm_ops venc_pm_ops = {
 };
 
 static struct platform_driver omap_venchw_driver = {
+        .probe          = omap_venchw_probe,
         .remove         = __exit_p(omap_venchw_remove),
         .driver         = {
                 .name   = "omapdss_venc",
@@ -949,7 +941,7 @@ static struct platform_driver omap_venchw_driver = {
 
 int __init venc_init_platform_driver(void)
 {
-        return platform_driver_probe(&omap_venchw_driver, omap_venchw_probe);
+        return platform_driver_register(&omap_venchw_driver);
 }
 
 void __exit venc_uninit_platform_driver(void)
diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c
index ca585ef37f25..c84bb8a4d0c4 100644
--- a/drivers/video/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/omap2/omapfb/omapfb-main.c
@@ -1101,41 +1101,25 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
         struct omapfb_info *ofbi = FB2OFB(fbi);
         struct fb_fix_screeninfo *fix = &fbi->fix;
         struct omapfb2_mem_region *rg;
-        unsigned long off;
         unsigned long start;
         u32 len;
-        int r = -EINVAL;
-
-        if (vma->vm_end - vma->vm_start == 0)
-                return 0;
-        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
-                return -EINVAL;
-        off = vma->vm_pgoff << PAGE_SHIFT;
+        int r;
 
         rg = omapfb_get_mem_region(ofbi->region);
 
         start = omapfb_get_region_paddr(ofbi);
         len = fix->smem_len;
-        if (off >= len)
-                goto error;
-        if ((vma->vm_end - vma->vm_start + off) > len)
-                goto error;
 
-        off += start;
+        DBG("user mmap region start %lx, len %d, off %lx\n", start, len,
+                        vma->vm_pgoff << PAGE_SHIFT);
 
-        DBG("user mmap region start %lx, len %d, off %lx\n", start, len, off);
-
-        vma->vm_pgoff = off >> PAGE_SHIFT;
-        /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
         vma->vm_ops = &mmap_user_ops;
         vma->vm_private_data = rg;
-        if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
-                               vma->vm_end - vma->vm_start,
-                               vma->vm_page_prot)) {
-                r = -EAGAIN;
+
+        r = vm_iomap_memory(vma, start, len);
+        if (r)
                 goto error;
-        }
 
         /* vm_ops.open won't be called for mmap itself. */
         atomic_inc(&rg->map_count);
@@ -1144,7 +1128,7 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
 
         return 0;
 
- error:
+error:
         omapfb_put_mem_region(ofbi->region);
 
         return r;
@@ -2388,7 +2372,7 @@ static int omapfb_init_connections(struct omapfb2_device *fbdev,
                 struct omap_dss_device *dssdev = fbdev->displays[i].dssdev;
                 struct omap_dss_output *out = dssdev->output;
 
-                mgr = omap_dss_get_overlay_manager(dssdev->channel);
+                mgr = omap_dss_get_overlay_manager(out->dispc_channel);
 
                 if (!mgr || !out)
                         continue;
@@ -2422,7 +2406,7 @@ static int omapfb_init_connections(struct omapfb2_device *fbdev,
         return 0;
 }
 
-static int __init omapfb_probe(struct platform_device *pdev)
+static int omapfb_probe(struct platform_device *pdev)
 {
         struct omapfb2_device *fbdev = NULL;
         int r = 0;
@@ -2484,7 +2468,7 @@ static int __init omapfb_probe(struct platform_device *pdev)
 
         if (fbdev->num_displays == 0) {
                 dev_err(&pdev->dev, "no displays\n");
-                r = -EINVAL;
+                r = -EPROBE_DEFER;
                 goto cleanup;
         }
 
@@ -2595,6 +2579,7 @@ static int __exit omapfb_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver omapfb_driver = {
+        .probe          = omapfb_probe,
         .remove         = __exit_p(omapfb_remove),
         .driver         = {
                 .name   = "omapfb",
@@ -2602,36 +2587,13 @@ static struct platform_driver omapfb_driver = {
         },
 };
 
-static int __init omapfb_init(void)
-{
-        DBG("omapfb_init\n");
-
-        if (platform_driver_probe(&omapfb_driver, omapfb_probe)) {
-                printk(KERN_ERR "failed to register omapfb driver\n");
-                return -ENODEV;
-        }
-
-        return 0;
-}
-
-static void __exit omapfb_exit(void)
-{
-        DBG("omapfb_exit\n");
-        platform_driver_unregister(&omapfb_driver);
-}
-
 module_param_named(mode, def_mode, charp, 0);
 module_param_named(vram, def_vram, charp, 0);
 module_param_named(rotate, def_rotate, int, 0);
 module_param_named(vrfb, def_vrfb, bool, 0);
 module_param_named(mirror, def_mirror, bool, 0);
 
-/* late_initcall to let panel/ctrl drivers loaded first.
- * I guess better option would be a more dynamic approach,
- * so that omapfb reacts to new panels when they are loaded */
-late_initcall(omapfb_init);
-/*module_init(omapfb_init);*/
-module_exit(omapfb_exit);
+module_platform_driver(omapfb_driver);
 
 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
 MODULE_DESCRIPTION("OMAP2/3 Framebuffer");
diff --git a/drivers/video/omap2/vrfb.c b/drivers/video/omap2/vrfb.c
index 10560efeb35a..5261229c79af 100644
--- a/drivers/video/omap2/vrfb.c
+++ b/drivers/video/omap2/vrfb.c
@@ -397,18 +397,7 @@ static struct platform_driver vrfb_driver = {
         .remove         = __exit_p(vrfb_remove),
 };
 
-static int __init vrfb_init(void)
-{
-        return platform_driver_probe(&vrfb_driver, &vrfb_probe);
-}
-
-static void __exit vrfb_exit(void)
-{
-        platform_driver_unregister(&vrfb_driver);
-}
-
-module_init(vrfb_init);
-module_exit(vrfb_exit);
+module_platform_driver_probe(vrfb_driver, vrfb_probe);
 
 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 MODULE_DESCRIPTION("OMAP VRFB");
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 920c27bf3947..d9f08c653d62 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -705,21 +705,15 @@ static int ps3fb_pan_display(struct fb_var_screeninfo *var,
 
 static int ps3fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
-        unsigned long size, offset;
+        int r;
 
-        size = vma->vm_end - vma->vm_start;
-        offset = vma->vm_pgoff << PAGE_SHIFT;
-        if (offset + size > info->fix.smem_len)
-                return -EINVAL;
-
-        offset += info->fix.smem_start;
-        if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
-                            size, vma->vm_page_prot))
-                return -EAGAIN;
+        r = vm_iomap_memory(vma, info->fix.smem_start, info->fix.smem_len);
 
         dev_dbg(info->device, "ps3fb: mmap framebuffer P(%lx)->V(%lx)\n",
-                offset, vma->vm_start);
-        return 0;
+                info->fix.smem_start + vma->vm_pgoff << PAGE_SHIFT,
+                vma->vm_start);
+
+        return r;
 }
 
     /*
diff --git a/drivers/video/pxa3xx-gcu.c b/drivers/video/pxa3xx-gcu.c
index 6c984eacc7e3..97563c55af63 100644
--- a/drivers/video/pxa3xx-gcu.c
+++ b/drivers/video/pxa3xx-gcu.c
@@ -101,7 +101,6 @@ struct pxa3xx_gcu_priv {
         dma_addr_t                shared_phys;
         struct resource          *resource_mem;
         struct miscdevice         misc_dev;
-        struct file_operations    misc_fops;
         wait_queue_head_t         wait_idle;
         wait_queue_head_t         wait_free;
         spinlock_t                spinlock;
@@ -369,15 +368,20 @@ pxa3xx_gcu_wait_free(struct pxa3xx_gcu_priv *priv)
 
 /* Misc device layer */
 
+static inline struct pxa3xx_gcu_priv *file_dev(struct file *file)
+{
+        struct miscdevice *dev = file->private_data;
+        return container_of(dev, struct pxa3xx_gcu_priv, misc_dev);
+}
+
 static ssize_t
-pxa3xx_gcu_misc_write(struct file *filp, const char *buff,
+pxa3xx_gcu_misc_write(struct file *file, const char *buff,
                       size_t count, loff_t *offp)
 {
         int ret;
         unsigned long flags;
         struct pxa3xx_gcu_batch *buffer;
-        struct pxa3xx_gcu_priv *priv =
-                container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
+        struct pxa3xx_gcu_priv *priv = file_dev(file);
 
         int words = count / 4;
 
@@ -450,11 +454,10 @@ pxa3xx_gcu_misc_write(struct file *filp, const char *buff,
 
 
 static long
-pxa3xx_gcu_misc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+pxa3xx_gcu_misc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         unsigned long flags;
-        struct pxa3xx_gcu_priv *priv =
-                container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
+        struct pxa3xx_gcu_priv *priv = file_dev(file);
 
         switch (cmd) {
         case PXA3XX_GCU_IOCTL_RESET:
@@ -471,11 +474,10 @@ pxa3xx_gcu_misc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 }
 
 static int
-pxa3xx_gcu_misc_mmap(struct file *filp, struct vm_area_struct *vma)
+pxa3xx_gcu_misc_mmap(struct file *file, struct vm_area_struct *vma)
 {
         unsigned int size = vma->vm_end - vma->vm_start;
-        struct pxa3xx_gcu_priv *priv =
-                container_of(filp->f_op, struct pxa3xx_gcu_priv, misc_fops);
+        struct pxa3xx_gcu_priv *priv = file_dev(file);
 
         switch (vma->vm_pgoff) {
         case 0:
@@ -574,6 +576,13 @@ free_buffers(struct platform_device *dev,
         priv->free = NULL;
 }
 
+static const struct file_operations misc_fops = {
+        .owner  = THIS_MODULE,
+        .write  = pxa3xx_gcu_misc_write,
+        .unlocked_ioctl = pxa3xx_gcu_misc_ioctl,
+        .mmap   = pxa3xx_gcu_misc_mmap
+};
+
 static int pxa3xx_gcu_probe(struct platform_device *dev)
 {
         int i, ret, irq;
@@ -601,14 +610,9 @@ static int pxa3xx_gcu_probe(struct platform_device *dev)
          * container_of(). This isn't really necessary as we have a fixed minor
          * number anyway, but this is to avoid statics. */
 
-        priv->misc_fops.owner   = THIS_MODULE;
-        priv->misc_fops.write   = pxa3xx_gcu_misc_write;
-        priv->misc_fops.unlocked_ioctl = pxa3xx_gcu_misc_ioctl;
-        priv->misc_fops.mmap    = pxa3xx_gcu_misc_mmap;
-
         priv->misc_dev.minor    = MISCDEV_MINOR,
         priv->misc_dev.name     = DRV_NAME,
-        priv->misc_dev.fops     = &priv->misc_fops,
+        priv->misc_dev.fops     = &misc_fops,
 
         /* register misc device */
         ret = misc_register(&priv->misc_dev);
diff --git a/drivers/video/s1d13xxxfb.c b/drivers/video/s1d13xxxfb.c
index 76d9053d88c1..05c2dc3d4bc0 100644
--- a/drivers/video/s1d13xxxfb.c
+++ b/drivers/video/s1d13xxxfb.c
@@ -862,7 +862,7 @@ static int s1d13xxxfb_probe(struct platform_device *pdev)
                 printk(KERN_INFO PFX
                         "unknown chip production id %i, revision %i\n",
                         prod_id, revision);
-                printk(KERN_INFO PFX "please contant maintainer\n");
+                printk(KERN_INFO PFX "please contact maintainer\n");
                 goto bail;
         }
 
diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c
index 968a62571df7..2e7991c7ca08 100644
--- a/drivers/video/s3c-fb.c
+++ b/drivers/video/s3c-fb.c
@@ -24,10 +24,9 @@
 #include <linux/uaccess.h>
 #include <linux/interrupt.h>
 #include <linux/pm_runtime.h>
+#include <linux/platform_data/video_s3c.h>
 
 #include <video/samsung_fimd.h>
-#include <mach/map.h>
-#include <plat/fb.h>
 
 /* This driver will export a number of framebuffer interfaces depending
  * on the configuration passed in via the platform data. Each fb instance
diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c
index cfbde5e85cbf..f34c858642e8 100644
--- a/drivers/video/sa1100fb.c
+++ b/drivers/video/sa1100fb.c
@@ -556,7 +556,7 @@ static int sa1100fb_mmap(struct fb_info *info,
                          struct vm_area_struct *vma)
 {
         struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
-        unsigned long start, len, off = vma->vm_pgoff << PAGE_SHIFT;
+        unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
 
         if (off < info->fix.smem_len) {
                 vma->vm_pgoff += 1; /* skip over the palette */
@@ -564,19 +564,9 @@ static int sa1100fb_mmap(struct fb_info *info,
                                              fbi->map_dma, fbi->map_size);
         }
 
-        start = info->fix.mmio_start;
-        len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
-
-        if ((vma->vm_end - vma->vm_start + off) > len)
-                return -EINVAL;
-
-        off += start & PAGE_MASK;
-        vma->vm_pgoff = off >> PAGE_SHIFT;
-        vma->vm_flags |= VM_IO;
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-        return io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
-                                   vma->vm_end - vma->vm_start,
-                                   vma->vm_page_prot);
+
+        return vm_iomap_memory(vma, info->fix.mmio_start, info->fix.mmio_len);
 }
 
 static struct fb_ops sa1100fb_ops = {
diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c
index 2331fadc272b..b2a8912f6435 100644
--- a/drivers/video/sgivwfb.c
+++ b/drivers/video/sgivwfb.c
@@ -705,23 +705,17 @@ static int sgivwfb_setcolreg(u_int regno, u_int red, u_int green,
 static int sgivwfb_mmap(struct fb_info *info,
                         struct vm_area_struct *vma)
 {
-        unsigned long size = vma->vm_end - vma->vm_start;
-        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+        int r;
 
-        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
-                return -EINVAL;
-        if (offset + size > sgivwfb_mem_size)
-                return -EINVAL;
-        offset += sgivwfb_mem_phys;
         pgprot_val(vma->vm_page_prot) =
-            pgprot_val(vma->vm_page_prot) | _PAGE_PCD;
-        vma->vm_flags |= VM_IO;
-        if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
-                                                size, vma->vm_page_prot))
-                return -EAGAIN;
+                pgprot_val(vma->vm_page_prot) | _PAGE_PCD;
+
+        r = vm_iomap_memory(vma, sgivwfb_mem_phys, sgivwfb_mem_size);
+
         printk(KERN_DEBUG "sgivwfb: mmap framebuffer P(%lx)->V(%lx)\n",
                offset, vma->vm_start);
-        return 0;
+
+        return r;
 }
 
 int __init sgivwfb_setup(char *options)
diff --git a/drivers/video/sh_mipi_dsi.c b/drivers/video/sh_mipi_dsi.c
index 701b461cf8a9..6cad53075e99 100644
--- a/drivers/video/sh_mipi_dsi.c
+++ b/drivers/video/sh_mipi_dsi.c
@@ -581,17 +581,7 @@ static struct platform_driver sh_mipi_driver = {
         },
 };
 
-static int __init sh_mipi_init(void)
-{
-        return platform_driver_probe(&sh_mipi_driver, sh_mipi_probe);
-}
-module_init(sh_mipi_init);
-
-static void __exit sh_mipi_exit(void)
-{
-        platform_driver_unregister(&sh_mipi_driver);
-}
-module_exit(sh_mipi_exit);
+module_platform_driver_probe(sh_mipi_driver, sh_mipi_probe);
 
 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
 MODULE_DESCRIPTION("SuperH / ARM-shmobile MIPI DSI driver");
diff --git a/drivers/video/sh_mobile_hdmi.c b/drivers/video/sh_mobile_hdmi.c
index 930e550e752a..bfe4728480fd 100644
--- a/drivers/video/sh_mobile_hdmi.c
+++ b/drivers/video/sh_mobile_hdmi.c
@@ -1445,17 +1445,7 @@ static struct platform_driver sh_hdmi_driver = {
         },
 };
 
-static int __init sh_hdmi_init(void)
-{
-        return platform_driver_probe(&sh_hdmi_driver, sh_hdmi_probe);
-}
-module_init(sh_hdmi_init);
-
-static void __exit sh_hdmi_exit(void)
-{
-        platform_driver_unregister(&sh_hdmi_driver);
-}
-module_exit(sh_hdmi_exit);
+module_platform_driver_probe(sh_hdmi_driver, sh_hdmi_probe);
 
 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
 MODULE_DESCRIPTION("SuperH / ARM-shmobile HDMI driver");
diff --git a/drivers/video/smscufx.c b/drivers/video/smscufx.c
index 97bd6620c364..b2b33fc1ac3f 100644
--- a/drivers/video/smscufx.c
+++ b/drivers/video/smscufx.c
@@ -782,7 +782,11 @@ static int ufx_ops_mmap(struct fb_info *info, struct vm_area_struct *vma)
         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
         unsigned long page, pos;
 
-        if (offset + size > info->fix.smem_len)
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
+                return -EINVAL;
+        if (size > info->fix.smem_len)
+                return -EINVAL;
+        if (offset > info->fix.smem_len - size)
                 return -EINVAL;
 
         pos = (unsigned long)info->fix.smem_start + offset;
diff --git a/drivers/video/ssd1307fb.c b/drivers/video/ssd1307fb.c
index 395cb6a8d8f3..9ef05d3ef68a 100644
--- a/drivers/video/ssd1307fb.c
+++ b/drivers/video/ssd1307fb.c
@@ -1,5 +1,5 @@
 /*
- * Driver for the Solomon SSD1307 OLED controler
+ * Driver for the Solomon SSD1307 OLED controller
  *
  * Copyright 2012 Free Electrons
  *
@@ -392,6 +392,6 @@ static struct i2c_driver ssd1307fb_driver = {
 
 module_i2c_driver(ssd1307fb_driver);
 
-MODULE_DESCRIPTION("FB driver for the Solomon SSD1307 OLED controler");
+MODULE_DESCRIPTION("FB driver for the Solomon SSD1307 OLED controller");
 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/udlfb.c b/drivers/video/udlfb.c
index 86d449ea3169..ec03e726c940 100644
--- a/drivers/video/udlfb.c
+++ b/drivers/video/udlfb.c
@@ -324,7 +324,11 @@ static int dlfb_ops_mmap(struct fb_info *info, struct vm_area_struct *vma)
         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
         unsigned long page, pos;
 
-        if (offset + size > info->fix.smem_len)
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
+                return -EINVAL;
+        if (size > info->fix.smem_len)
+                return -EINVAL;
+        if (offset > info->fix.smem_len - size)
                 return -EINVAL;
 
         pos = (unsigned long)info->fix.smem_start + offset;
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c
index d4284458377e..e328a61b64ba 100644
--- a/drivers/video/uvesafb.c
+++ b/drivers/video/uvesafb.c
@@ -166,7 +166,7 @@ static int uvesafb_exec(struct uvesafb_ktask *task)
         memcpy(&m->id, &uvesafb_cn_id, sizeof(m->id));
         m->seq = seq;
         m->len = len;
-        m->ack = random32();
+        m->ack = prandom_u32();
 
         /* uvesafb_task structure */
         memcpy(m + 1, &task->t, sizeof(task->t));
diff --git a/drivers/video/vermilion/vermilion.c b/drivers/video/vermilion/vermilion.c
index 0aa516fc59cd..09a136633f35 100644
--- a/drivers/video/vermilion/vermilion.c
+++ b/drivers/video/vermilion/vermilion.c
@@ -1003,24 +1003,18 @@ static int vmlfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 static int vmlfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct vml_info *vinfo = container_of(info, struct vml_info, info);
-        unsigned long size = vma->vm_end - vma->vm_start;
         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
         int ret;
 
-        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
-                return -EINVAL;
-        if (offset + size > vinfo->vram_contig_size)
-                return -EINVAL;
         ret = vmlfb_vram_offset(vinfo, offset);
         if (ret)
                 return -EINVAL;
-        offset += vinfo->vram_start;
+
         pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
         pgprot_val(vma->vm_page_prot) &= ~_PAGE_PWT;
-        if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
-                                                size, vma->vm_page_prot))
-                return -EAGAIN;
-        return 0;
+
+        return vm_iomap_memory(vma, vinfo->vram_start,
+                        vinfo->vram_contig_size);
 }
 
 static int vmlfb_sync(struct fb_info *info)
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index 8bc1f9398945..ee5985efa15c 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -420,9 +420,12 @@ static int vfb_mmap(struct fb_info *info,
         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
         unsigned long page, pos;
 
-        if (offset + size > info->fix.smem_len) {
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
+                return -EINVAL;
+        if (size > info->fix.smem_len)
+                return -EINVAL;
+        if (offset > info->fix.smem_len - size)
                 return -EINVAL;
-        }
 
         pos = (unsigned long)info->fix.smem_start + offset;
 
diff --git a/drivers/video/videomode.c b/drivers/video/videomode.c
index 21c47a202afa..df375c96c5d3 100644
--- a/drivers/video/videomode.c
+++ b/drivers/video/videomode.c
@@ -11,7 +11,25 @@
 #include <video/display_timing.h>
 #include <video/videomode.h>
 
-int videomode_from_timing(const struct display_timings *disp,
+void videomode_from_timing(const struct display_timing *dt,
+                          struct videomode *vm)
+{
+        vm->pixelclock = dt->pixelclock.typ;
+        vm->hactive = dt->hactive.typ;
+        vm->hfront_porch = dt->hfront_porch.typ;
+        vm->hback_porch = dt->hback_porch.typ;
+        vm->hsync_len = dt->hsync_len.typ;
+
+        vm->vactive = dt->vactive.typ;
+        vm->vfront_porch = dt->vfront_porch.typ;
+        vm->vback_porch = dt->vback_porch.typ;
+        vm->vsync_len = dt->vsync_len.typ;
+
+        vm->flags = dt->flags;
+}
+EXPORT_SYMBOL_GPL(videomode_from_timing);
+
+int videomode_from_timings(const struct display_timings *disp,
                           struct videomode *vm, unsigned int index)
 {
         struct display_timing *dt;
@@ -20,20 +38,8 @@ int videomode_from_timing(const struct display_timings *disp,
         if (!dt)
                 return -EINVAL;
 
-        vm->pixelclock = display_timing_get_value(&dt->pixelclock, TE_TYP);
-        vm->hactive = display_timing_get_value(&dt->hactive, TE_TYP);
-        vm->hfront_porch = display_timing_get_value(&dt->hfront_porch, TE_TYP);
-        vm->hback_porch = display_timing_get_value(&dt->hback_porch, TE_TYP);
-        vm->hsync_len = display_timing_get_value(&dt->hsync_len, TE_TYP);
-
-        vm->vactive = display_timing_get_value(&dt->vactive, TE_TYP);
-        vm->vfront_porch = display_timing_get_value(&dt->vfront_porch, TE_TYP);
-        vm->vback_porch = display_timing_get_value(&dt->vback_porch, TE_TYP);
-        vm->vsync_len = display_timing_get_value(&dt->vsync_len, TE_TYP);
-
-        vm->dmt_flags = dt->dmt_flags;
-        vm->data_flags = dt->data_flags;
+        videomode_from_timing(dt, vm);
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(videomode_from_timing);
+EXPORT_SYMBOL_GPL(videomode_from_timings);
diff --git a/drivers/video/vt8500lcdfb.c b/drivers/video/vt8500lcdfb.c
index aa2579c2364a..9547e1831e03 100644
--- a/drivers/video/vt8500lcdfb.c
+++ b/drivers/video/vt8500lcdfb.c
@@ -15,22 +15,21 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/errno.h>
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include <linux/dma-mapping.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/string.h>
 #include <linux/wait.h>
-
-#include <linux/platform_data/video-vt8500lcdfb.h>
+#include <video/of_display_timing.h>
 
 #include "vt8500lcdfb.h"
 #include "wmt_ge_rops.h"
@@ -277,11 +276,11 @@ static int vt8500lcd_probe(struct platform_device *pdev)
 {
         struct vt8500lcd_info *fbi;
         struct resource *res;
+        struct display_timings *disp_timing;
         void *addr;
         int irq, ret;
 
         struct fb_videomode     of_mode;
-        struct device_node      *np;
         u32                     bpp;
         dma_addr_t fb_mem_phys;
         unsigned long fb_mem_len;
@@ -346,32 +345,18 @@ static int vt8500lcd_probe(struct platform_device *pdev)
                 goto failed_free_res;
         }
 
-        np = of_parse_phandle(pdev->dev.of_node, "default-mode", 0);
-        if (!np) {
-                pr_err("%s: No display description in Device Tree\n", __func__);
-                ret = -EINVAL;
-                goto failed_free_res;
-        }
+        disp_timing = of_get_display_timings(pdev->dev.of_node);
+        if (!disp_timing)
+                return -EINVAL;
 
-        /*
-         * This code is copied from Sascha Hauer's of_videomode helper
-         * and can be replaced with a call to the helper once mainlined
-         */
-        ret = 0;
-        ret |= of_property_read_u32(np, "hactive", &of_mode.xres);
-        ret |= of_property_read_u32(np, "vactive", &of_mode.yres);
-        ret |= of_property_read_u32(np, "hback-porch", &of_mode.left_margin);
-        ret |= of_property_read_u32(np, "hfront-porch", &of_mode.right_margin);
-        ret |= of_property_read_u32(np, "hsync-len", &of_mode.hsync_len);
-        ret |= of_property_read_u32(np, "vback-porch", &of_mode.upper_margin);
-        ret |= of_property_read_u32(np, "vfront-porch", &of_mode.lower_margin);
-        ret |= of_property_read_u32(np, "vsync-len", &of_mode.vsync_len);
-        ret |= of_property_read_u32(np, "bpp", &bpp);
-        if (ret) {
-                pr_err("%s: Unable to read display properties\n", __func__);
-                goto failed_free_res;
-        }
-        of_mode.vmode = FB_VMODE_NONINTERLACED;
+        ret = of_get_fb_videomode(pdev->dev.of_node, &of_mode,
+                                                        OF_USE_NATIVE_MODE);
+        if (ret)
+                return ret;
+
+        ret = of_property_read_u32(pdev->dev.of_node, "bits-per-pixel", &bpp);
+        if (ret)
+                return ret;
 
         /* try allocating the framebuffer */
         fb_mem_len = of_mode.xres * of_mode.yres * 2 * (bpp / 8);
diff --git a/drivers/video/wm8505fb.c b/drivers/video/wm8505fb.c
index 4dd0580f96fd..01f9ace068e2 100644
--- a/drivers/video/wm8505fb.c
+++ b/drivers/video/wm8505fb.c
@@ -14,25 +14,25 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
 #include <linux/fb.h>
+#include <linux/errno.h>
+#include <linux/err.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include <linux/dma-mapping.h>
-#include <linux/platform_device.h>
-#include <linux/wait.h>
+#include <linux/kernel.h>
+#include <linux/memblock.h>
+#include <linux/mm.h>
+#include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_fdt.h>
-#include <linux/memblock.h>
-
-#include <linux/platform_data/video-vt8500lcdfb.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/wait.h>
+#include <video/of_display_timing.h>
 
 #include "wm8505fb_regs.h"
 #include "wmt_ge_rops.h"
@@ -263,26 +263,22 @@ static struct fb_ops wm8505fb_ops = {
 static int wm8505fb_probe(struct platform_device *pdev)
 {
         struct wm8505fb_info    *fbi;
-        struct resource         *res;
+        struct resource *res;
+        struct display_timings *disp_timing;
         void                    *addr;
         int ret;
 
-        struct fb_videomode     of_mode;
-        struct device_node      *np;
+        struct fb_videomode     mode;
         u32                     bpp;
         dma_addr_t fb_mem_phys;
         unsigned long fb_mem_len;
         void *fb_mem_virt;
 
-        ret = -ENOMEM;
-        fbi = NULL;
-
         fbi = devm_kzalloc(&pdev->dev, sizeof(struct wm8505fb_info) +
                         sizeof(u32) * 16, GFP_KERNEL);
         if (!fbi) {
                 dev_err(&pdev->dev, "Failed to initialize framebuffer device\n");
-                ret = -ENOMEM;
-                goto failed;
+                return -ENOMEM;
         }
 
         strcpy(fbi->fb.fix.id, DRIVER_NAME);
@@ -308,54 +304,23 @@ static int wm8505fb_probe(struct platform_device *pdev)
         fbi->fb.pseudo_palette  = addr;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
-                dev_err(&pdev->dev, "no I/O memory resource defined\n");
-                ret = -ENODEV;
-                goto failed_fbi;
-        }
+        fbi->regbase = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(fbi->regbase))
+                return PTR_ERR(fbi->regbase);
 
-        res = request_mem_region(res->start, resource_size(res), DRIVER_NAME);
-        if (res == NULL) {
-                dev_err(&pdev->dev, "failed to request I/O memory\n");
-                ret = -EBUSY;
-                goto failed_fbi;
-        }
-
-        fbi->regbase = ioremap(res->start, resource_size(res));
-        if (fbi->regbase == NULL) {
-                dev_err(&pdev->dev, "failed to map I/O memory\n");
-                ret = -EBUSY;
-                goto failed_free_res;
-        }
+        disp_timing = of_get_display_timings(pdev->dev.of_node);
+        if (!disp_timing)
+                return -EINVAL;
 
-        np = of_parse_phandle(pdev->dev.of_node, "default-mode", 0);
-        if (!np) {
-                pr_err("%s: No display description in Device Tree\n", __func__);
-                ret = -EINVAL;
-                goto failed_free_res;
-        }
+        ret = of_get_fb_videomode(pdev->dev.of_node, &mode, OF_USE_NATIVE_MODE);
+        if (ret)
+                return ret;
 
-        /*
-         * This code is copied from Sascha Hauer's of_videomode helper
-         * and can be replaced with a call to the helper once mainlined
-         */
-        ret = 0;
-        ret |= of_property_read_u32(np, "hactive", &of_mode.xres);
-        ret |= of_property_read_u32(np, "vactive", &of_mode.yres);
-        ret |= of_property_read_u32(np, "hback-porch", &of_mode.left_margin);
-        ret |= of_property_read_u32(np, "hfront-porch", &of_mode.right_margin);
-        ret |= of_property_read_u32(np, "hsync-len", &of_mode.hsync_len);
-        ret |= of_property_read_u32(np, "vback-porch", &of_mode.upper_margin);
-        ret |= of_property_read_u32(np, "vfront-porch", &of_mode.lower_margin);
-        ret |= of_property_read_u32(np, "vsync-len", &of_mode.vsync_len);
-        ret |= of_property_read_u32(np, "bpp", &bpp);
-        if (ret) {
-                pr_err("%s: Unable to read display properties\n", __func__);
-                goto failed_free_res;
-        }
+        ret = of_property_read_u32(pdev->dev.of_node, "bits-per-pixel", &bpp);
+        if (ret)
+                return ret;
 
-        of_mode.vmode = FB_VMODE_NONINTERLACED;
-        fb_videomode_to_var(&fbi->fb.var, &of_mode);
+        fb_videomode_to_var(&fbi->fb.var, &mode);
 
         fbi->fb.var.nonstd              = 0;
         fbi->fb.var.activate            = FB_ACTIVATE_NOW;
@@ -364,16 +329,16 @@ static int wm8505fb_probe(struct platform_device *pdev)
         fbi->fb.var.width               = -1;
 
         /* try allocating the framebuffer */
-        fb_mem_len = of_mode.xres * of_mode.yres * 2 * (bpp / 8);
-        fb_mem_virt = dma_alloc_coherent(&pdev->dev, fb_mem_len, &fb_mem_phys,
+        fb_mem_len = mode.xres * mode.yres * 2 * (bpp / 8);
+        fb_mem_virt = dmam_alloc_coherent(&pdev->dev, fb_mem_len, &fb_mem_phys,
                                 GFP_KERNEL);
         if (!fb_mem_virt) {
                 pr_err("%s: Failed to allocate framebuffer\n", __func__);
                 return -ENOMEM;
-        };
+        }
 
-        fbi->fb.var.xres_virtual        = of_mode.xres;
-        fbi->fb.var.yres_virtual        = of_mode.yres * 2;
+        fbi->fb.var.xres_virtual        = mode.xres;
+        fbi->fb.var.yres_virtual        = mode.yres * 2;
         fbi->fb.var.bits_per_pixel      = bpp;
 
         fbi->fb.fix.smem_start          = fb_mem_phys;
@@ -381,28 +346,29 @@ static int wm8505fb_probe(struct platform_device *pdev)
         fbi->fb.screen_base             = fb_mem_virt;
         fbi->fb.screen_size             = fb_mem_len;
 
+        fbi->contrast = 0x10;
+        ret = wm8505fb_set_par(&fbi->fb);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to set parameters\n");
+                return ret;
+        }
+
         if (fb_alloc_cmap(&fbi->fb.cmap, 256, 0) < 0) {
                 dev_err(&pdev->dev, "Failed to allocate color map\n");
-                ret = -ENOMEM;
-                goto failed_free_io;
+                return -ENOMEM;
         }
 
         wm8505fb_init_hw(&fbi->fb);
 
-        fbi->contrast = 0x80;
-        ret = wm8505fb_set_par(&fbi->fb);
-        if (ret) {
-                dev_err(&pdev->dev, "Failed to set parameters\n");
-                goto failed_free_cmap;
-        }
-
         platform_set_drvdata(pdev, fbi);
 
         ret = register_framebuffer(&fbi->fb);
         if (ret < 0) {
                 dev_err(&pdev->dev,
                         "Failed to register framebuffer device: %d\n", ret);
-                goto failed_free_cmap;
+                if (fbi->fb.cmap.len)
+                        fb_dealloc_cmap(&fbi->fb.cmap);
+                return ret;
         }
 
         ret = device_create_file(&pdev->dev, &dev_attr_contrast);
@@ -416,25 +382,11 @@ static int wm8505fb_probe(struct platform_device *pdev)
                fbi->fb.fix.smem_start + fbi->fb.fix.smem_len - 1);
 
         return 0;
-
-failed_free_cmap:
-        if (fbi->fb.cmap.len)
-                fb_dealloc_cmap(&fbi->fb.cmap);
-failed_free_io:
-        iounmap(fbi->regbase);
-failed_free_res:
-        release_mem_region(res->start, resource_size(res));
-failed_fbi:
-        platform_set_drvdata(pdev, NULL);
-        kfree(fbi);
-failed:
-        return ret;
 }
 
 static int wm8505fb_remove(struct platform_device *pdev)
 {
         struct wm8505fb_info *fbi = platform_get_drvdata(pdev);
-        struct resource *res;
 
         device_remove_file(&pdev->dev, &dev_attr_contrast);
 
@@ -445,13 +397,6 @@ static int wm8505fb_remove(struct platform_device *pdev)
         if (fbi->fb.cmap.len)
                 fb_dealloc_cmap(&fbi->fb.cmap);
 
-        iounmap(fbi->regbase);
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, resource_size(res));
-
-        kfree(fbi);
-
         return 0;
 }
 
diff --git a/drivers/video/wmt_ge_rops.h b/drivers/video/wmt_ge_rops.h
index 87380751a443..f73ec6377a46 100644
--- a/drivers/video/wmt_ge_rops.h
+++ b/drivers/video/wmt_ge_rops.h
@@ -1,5 +1,28 @@
+#ifdef CONFIG_FB_WMT_GE_ROPS
+
 extern void wmt_ge_fillrect(struct fb_info *info,
                             const struct fb_fillrect *rect);
 extern void wmt_ge_copyarea(struct fb_info *info,
                             const struct fb_copyarea *area);
 extern int wmt_ge_sync(struct fb_info *info);
+
+#else
+
+static inline int wmt_ge_sync(struct fb_info *p)
+{
+        return 0;
+}
+
+static inline void wmt_ge_fillrect(struct fb_info *p,
+                                    const struct fb_fillrect *rect)
+{
+        sys_fillrect(p, rect);
+}
+
+static inline void wmt_ge_copyarea(struct fb_info *p,
+                                     const struct fb_copyarea *area)
+{
+        sys_copyarea(p, area);
+}
+
+#endif