Merge tag 'v3.6-rc4'

Merge 3.6-rc4 to get latest OMAP and device tree fixes.

50 files changed, 1721 insertions, 633 deletions

diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index c22e8d39a2cb..a1d58e9d3073 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -336,8 +336,8 @@ static void arcfb_lcd_update_horiz(struct arcfb_par *par, unsigned int left,
 }
 
 /*
- * here we start the process of spliting out the fb update into
- * individual blocks of pixels. we end up spliting into 64x64 blocks
+ * here we start the process of splitting out the fb update into
+ * individual blocks of pixels. we end up splitting into 64x64 blocks
  * and finally down to 64x8 pages.
  */
 static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index d99505b16374..15055395cd95 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -939,7 +939,7 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                  * up a splash image.
                  */
         } else {
-                /* alocate memory buffer */
+                /* allocate memory buffer */
                 ret = atmel_lcdfb_alloc_video_memory(sinfo);
                 if (ret < 0) {
                         dev_err(dev, "cannot allocate framebuffer: %d\n", ret);
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index b0b2ac335347..747442d2c0f6 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -90,7 +90,8 @@
 #undef DEBUG
 
 #ifdef DEBUG
-#define DBG(fmt, args...)               printk(KERN_DEBUG "aty128fb: %s " fmt, __func__, ##args);
+#define DBG(fmt, args...) \
+        printk(KERN_DEBUG "aty128fb: %s " fmt, __func__, ##args);
 #else
 #define DBG(fmt, args...)
 #endif
@@ -449,8 +450,9 @@ static int aty128_decode_var(struct fb_var_screeninfo *var,
                              struct aty128fb_par *par);
 #if 0
 static void __devinit aty128_get_pllinfo(struct aty128fb_par *par,
-                                      void __iomem *bios);
-static void __devinit __iomem *aty128_map_ROM(struct pci_dev *pdev, const struct aty128fb_par *par);
+                                         void __iomem *bios);
+static void __devinit __iomem *aty128_map_ROM(struct pci_dev *pdev,
+                                              const struct aty128fb_par *par);
 #endif
 static void aty128_timings(struct aty128fb_par *par);
 static void aty128_init_engine(struct aty128fb_par *par);
@@ -779,7 +781,8 @@ static u32 depth_to_dst(u32 depth)
 
 
 #ifndef __sparc__
-static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, struct pci_dev *dev)
+static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par,
+                                               struct pci_dev *dev)
 {
         u16 dptr;
         u8 rom_type;
@@ -811,13 +814,14 @@ static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, s
         /* Look for the PCI data to check the ROM type */
         dptr = BIOS_IN16(0x18);
 
-        /* Check the PCI data signature. If it's wrong, we still assume a normal x86 ROM
-         * for now, until I've verified this works everywhere. The goal here is more
-         * to phase out Open Firmware images.
+        /* Check the PCI data signature. If it's wrong, we still assume a normal
+         * x86 ROM for now, until I've verified this works everywhere.
+         * The goal here is more to phase out Open Firmware images.
          *
-         * Currently, we only look at the first PCI data, we could iteratre and deal with
-         * them all, and we should use fb_bios_start relative to start of image and not
-         * relative start of ROM, but so far, I never found a dual-image ATI card
+         * Currently, we only look at the first PCI data, we could iteratre and
+         * deal with them all, and we should use fb_bios_start relative to start
+         * of image and not relative start of ROM, but so far, I never found a
+         * dual-image ATI card.
          *
          * typedef struct {
          *      u32     signature;      + 0x00
@@ -852,7 +856,8 @@ static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, s
                 printk(KERN_INFO "aty128fb: Found HP PA-RISC ROM Image\n");
                 goto failed;
         default:
-                printk(KERN_INFO "aty128fb: Found unknown type %d ROM Image\n", rom_type);
+                printk(KERN_INFO "aty128fb: Found unknown type %d ROM Image\n",
+                       rom_type);
                 goto failed;
         }
  anyway:
@@ -863,7 +868,8 @@ static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, s
         return NULL;
 }
 
-static void __devinit aty128_get_pllinfo(struct aty128fb_par *par, unsigned char __iomem *bios)
+static void __devinit aty128_get_pllinfo(struct aty128fb_par *par,
+                                         unsigned char __iomem *bios)
 {
         unsigned int bios_hdr;
         unsigned int bios_pll;
@@ -1247,10 +1253,13 @@ static int aty128_crtc_to_var(const struct aty128_crtc *crtc,
 static void aty128_set_crt_enable(struct aty128fb_par *par, int on)
 {
         if (on) {
-                aty_st_le32(CRTC_EXT_CNTL, aty_ld_le32(CRTC_EXT_CNTL) | CRT_CRTC_ON);
-                aty_st_le32(DAC_CNTL, (aty_ld_le32(DAC_CNTL) | DAC_PALETTE2_SNOOP_EN));
+                aty_st_le32(CRTC_EXT_CNTL, aty_ld_le32(CRTC_EXT_CNTL) |
+                            CRT_CRTC_ON);
+                aty_st_le32(DAC_CNTL, (aty_ld_le32(DAC_CNTL) |
+                            DAC_PALETTE2_SNOOP_EN));
         } else
-                aty_st_le32(CRTC_EXT_CNTL, aty_ld_le32(CRTC_EXT_CNTL) & ~CRT_CRTC_ON);
+                aty_st_le32(CRTC_EXT_CNTL, aty_ld_le32(CRTC_EXT_CNTL) &
+                            ~CRT_CRTC_ON);
 }
 
 static void aty128_set_lcd_enable(struct aty128fb_par *par, int on)
@@ -1281,7 +1290,8 @@ static void aty128_set_lcd_enable(struct aty128fb_par *par, int on)
         }
 }
 
-static void aty128_set_pll(struct aty128_pll *pll, const struct aty128fb_par *par)
+static void aty128_set_pll(struct aty128_pll *pll,
+                           const struct aty128fb_par *par)
 {
         u32 div3;
 
@@ -1366,7 +1376,8 @@ static int aty128_var_to_pll(u32 period_in_ps, struct aty128_pll *pll,
 }
 
 
-static int aty128_pll_to_var(const struct aty128_pll *pll, struct fb_var_screeninfo *var)
+static int aty128_pll_to_var(const struct aty128_pll *pll,
+                             struct fb_var_screeninfo *var)
 {
         var->pixclock = 100000000 / pll->vclk;
 
@@ -1512,7 +1523,8 @@ static int aty128fb_set_par(struct fb_info *info)
  *  encode/decode the User Defined Part of the Display
  */
 
-static int aty128_decode_var(struct fb_var_screeninfo *var, struct aty128fb_par *par)
+static int aty128_decode_var(struct fb_var_screeninfo *var,
+                             struct aty128fb_par *par)
 {
         int err;
         struct aty128_crtc crtc;
@@ -1559,7 +1571,8 @@ static int aty128_encode_var(struct fb_var_screeninfo *var,
 }           
 
 
-static int aty128fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+static int aty128fb_check_var(struct fb_var_screeninfo *var,
+                              struct fb_info *info)
 {
         struct aty128fb_par par;
         int err;
@@ -1575,7 +1588,8 @@ static int aty128fb_check_var(struct fb_var_screeninfo *var, struct fb_info *inf
 /*
  *  Pan or Wrap the Display
  */
-static int aty128fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fb) 
+static int aty128fb_pan_display(struct fb_var_screeninfo *var,
+                                struct fb_info *fb)
 {
         struct aty128fb_par *par = fb->par;
         u32 xoffset, yoffset;
@@ -1594,7 +1608,8 @@ static int aty128fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *f
         par->crtc.xoffset = xoffset;
         par->crtc.yoffset = yoffset;
 
-        offset = ((yoffset * par->crtc.vxres + xoffset)*(par->crtc.bpp >> 3)) & ~7;
+        offset = ((yoffset * par->crtc.vxres + xoffset) * (par->crtc.bpp >> 3))
+                                                                          & ~7;
 
         if (par->crtc.bpp == 24)
                 offset += 8 * (offset % 3); /* Must be multiple of 8 and 3 */
@@ -1620,11 +1635,13 @@ static void aty128_st_pal(u_int regno, u_int red, u_int green, u_int blue,
                  * do mirroring
                  */
 
-                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) | DAC_PALETTE_ACCESS_CNTL);
+                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) |
+                            DAC_PALETTE_ACCESS_CNTL);
                 aty_st_8(PALETTE_INDEX, regno);
                 aty_st_le32(PALETTE_DATA, (red<<16)|(green<<8)|blue);
 #endif
-                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) & ~DAC_PALETTE_ACCESS_CNTL);
+                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) &
+                            ~DAC_PALETTE_ACCESS_CNTL);
         }
 
         aty_st_8(PALETTE_INDEX, regno);
@@ -1753,7 +1770,8 @@ static int aty128_bl_update_status(struct backlight_device *bd)
                         aty_st_le32(LVDS_GEN_CNTL, reg);
                 }
                 reg &= ~LVDS_BL_MOD_LEVEL_MASK;
-                reg |= (aty128_bl_get_level_brightness(par, level) << LVDS_BL_MOD_LEVEL_SHIFT);
+                reg |= (aty128_bl_get_level_brightness(par, level) <<
+                        LVDS_BL_MOD_LEVEL_SHIFT);
 #ifdef BACKLIGHT_LVDS_OFF
                 reg |= LVDS_ON | LVDS_EN;
                 reg &= ~LVDS_DISPLAY_DIS;
@@ -1764,7 +1782,8 @@ static int aty128_bl_update_status(struct backlight_device *bd)
 #endif
         } else {
                 reg &= ~LVDS_BL_MOD_LEVEL_MASK;
-                reg |= (aty128_bl_get_level_brightness(par, 0) << LVDS_BL_MOD_LEVEL_SHIFT);
+                reg |= (aty128_bl_get_level_brightness(par, 0) <<
+                        LVDS_BL_MOD_LEVEL_SHIFT);
 #ifdef BACKLIGHT_LVDS_OFF
                 reg |= LVDS_DISPLAY_DIS;
                 aty_st_le32(LVDS_GEN_CNTL, reg);
@@ -1869,7 +1888,8 @@ static void aty128_early_resume(void *data)
 }
 #endif /* CONFIG_PPC_PMAC */
 
-static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit aty128_init(struct pci_dev *pdev,
+                                 const struct pci_device_id *ent)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
         struct aty128fb_par *par = info->par;
@@ -1887,7 +1907,8 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
 
         /* range check to make sure */
         if (ent->driver_data < ARRAY_SIZE(r128_family))
-            strlcat(video_card, r128_family[ent->driver_data], sizeof(video_card));
+                strlcat(video_card, r128_family[ent->driver_data],
+                        sizeof(video_card));
 
         printk(KERN_INFO "aty128fb: %s [chip rev 0x%x] ", video_card, chip_rev);
 
@@ -1911,11 +1932,11 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
                 /* Indicate sleep capability */
                 if (par->chip_gen == rage_M3) {
                         pmac_call_feature(PMAC_FTR_DEVICE_CAN_WAKE, NULL, 0, 1);
-#if 0 /* Disable the early video resume hack for now as it's causing problems, among
-       * others we now rely on the PCI core restoring the config space for us, which
-       * isn't the case with that hack, and that code path causes various things to
-       * be called with interrupts off while they shouldn't. I'm leaving the code in
-       * as it can be useful for debugging purposes
+#if 0 /* Disable the early video resume hack for now as it's causing problems,
+       * among others we now rely on the PCI core restoring the config space
+       * for us, which isn't the case with that hack, and that code path causes
+       * various things to be called with interrupts off while they shouldn't.
+       * I'm leaving the code in as it can be useful for debugging purposes
        */
                         pmac_set_early_video_resume(aty128_early_resume, par);
 #endif
@@ -1953,11 +1974,11 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
                                 default_vmode = VMODE_1152_768_60;
         
                         if (default_cmode > 16) 
-                            default_cmode = CMODE_32;
+                                default_cmode = CMODE_32;
                         else if (default_cmode > 8) 
-                            default_cmode = CMODE_16;
+                                default_cmode = CMODE_16;
                         else 
-                            default_cmode = CMODE_8;
+                                default_cmode = CMODE_8;
 
                         if (mac_vmode_to_var(default_vmode, default_cmode, &var))
                                 var = default_var;
@@ -2018,7 +2039,8 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
 
 #ifdef CONFIG_PCI
 /* register a card    ++ajoshi */
-static int __devinit aty128_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit aty128_probe(struct pci_dev *pdev,
+                                  const struct pci_device_id *ent)
 {
         unsigned long fb_addr, reg_addr;
         struct aty128fb_par *par;
@@ -2318,39 +2340,39 @@ static inline void aty128_rectcopy(int srcx, int srcy, int dstx, int dsty,
                                    u_int width, u_int height,
                                    struct fb_info_aty128 *par)
 {
-    u32 save_dp_datatype, save_dp_cntl, dstval;
-
-    if (!width || !height)
-        return;
-
-    dstval = depth_to_dst(par->current_par.crtc.depth);
-    if (dstval == DST_24BPP) {
-        srcx *= 3;
-        dstx *= 3;
-        width *= 3;
-    } else if (dstval == -EINVAL) {
-        printk("aty128fb: invalid depth or RGBA\n");
-        return;
-    }
-
-    wait_for_fifo(2, par);
-    save_dp_datatype = aty_ld_le32(DP_DATATYPE);
-    save_dp_cntl     = aty_ld_le32(DP_CNTL);
-
-    wait_for_fifo(6, par);
-    aty_st_le32(SRC_Y_X, (srcy << 16) | srcx);
-    aty_st_le32(DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT);
-    aty_st_le32(DP_CNTL, DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM);
-    aty_st_le32(DP_DATATYPE, save_dp_datatype | dstval | SRC_DSTCOLOR);
-
-    aty_st_le32(DST_Y_X, (dsty << 16) | dstx);
-    aty_st_le32(DST_HEIGHT_WIDTH, (height << 16) | width);
-
-    par->blitter_may_be_busy = 1;
-
-    wait_for_fifo(2, par);
-    aty_st_le32(DP_DATATYPE, save_dp_datatype);
-    aty_st_le32(DP_CNTL, save_dp_cntl); 
+        u32 save_dp_datatype, save_dp_cntl, dstval;
+
+        if (!width || !height)
+                return;
+
+        dstval = depth_to_dst(par->current_par.crtc.depth);
+        if (dstval == DST_24BPP) {
+                srcx *= 3;
+                dstx *= 3;
+                width *= 3;
+        } else if (dstval == -EINVAL) {
+                printk("aty128fb: invalid depth or RGBA\n");
+                return;
+        }
+
+        wait_for_fifo(2, par);
+        save_dp_datatype = aty_ld_le32(DP_DATATYPE);
+        save_dp_cntl     = aty_ld_le32(DP_CNTL);
+
+        wait_for_fifo(6, par);
+        aty_st_le32(SRC_Y_X, (srcy << 16) | srcx);
+        aty_st_le32(DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT);
+        aty_st_le32(DP_CNTL, DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM);
+        aty_st_le32(DP_DATATYPE, save_dp_datatype | dstval | SRC_DSTCOLOR);
+
+        aty_st_le32(DST_Y_X, (dsty << 16) | dstx);
+        aty_st_le32(DST_HEIGHT_WIDTH, (height << 16) | width);
+
+        par->blitter_may_be_busy = 1;
+
+        wait_for_fifo(2, par);
+        aty_st_le32(DP_DATATYPE, save_dp_datatype);
+        aty_st_le32(DP_CNTL, save_dp_cntl);
 }
 
 
@@ -2358,17 +2380,17 @@ static inline void aty128_rectcopy(int srcx, int srcy, int dstx, int dsty,
      * Text mode accelerated functions
      */
 
-static void fbcon_aty128_bmove(struct display *p, int sy, int sx, int dy, int dx,
-                        int height, int width)
+static void fbcon_aty128_bmove(struct display *p, int sy, int sx, int dy,
+                               int dx, int height, int width)
 {
-    sx     *= fontwidth(p);
-    sy     *= fontheight(p);
-    dx     *= fontwidth(p);
-    dy     *= fontheight(p);
-    width  *= fontwidth(p);
-    height *= fontheight(p);
-
-    aty128_rectcopy(sx, sy, dx, dy, width, height,
+        sx     *= fontwidth(p);
+        sy     *= fontheight(p);
+        dx     *= fontwidth(p);
+        dy     *= fontheight(p);
+        width  *= fontwidth(p);
+        height *= fontheight(p);
+
+        aty128_rectcopy(sx, sy, dx, dy, width, height,
                         (struct fb_info_aty128 *)p->fb_info);
 }
 #endif /* 0 */
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 622f12b62a47..3f2e8c13f1ca 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -863,7 +863,7 @@ static int aty_var_to_crtc(const struct fb_info *info,
 
         if ((xres > 1600) || (yres > 1200)) {
                 FAIL("MACH64 chips are designed for max 1600x1200\n"
-                     "select anoter resolution.");
+                     "select another resolution.");
         }
         h_sync_strt = h_disp + var->right_margin;
         h_sync_end = h_sync_strt + var->hsync_len;
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index ce1506b75adf..9e279ee38da8 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -2018,7 +2018,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
           if ((rinfo->family == CHIP_FAMILY_RS100) ||
               (rinfo->family == CHIP_FAMILY_RS200)) {
              /* This is to workaround the asic bug for RMX, some versions
-                of BIOS dosen't have this register initialized correctly.
+                of BIOS doesn't have this register initialized correctly.
              */
              OUTREGP(CRTC_MORE_CNTL, CRTC_H_CUTOFF_ACTIVE_EN,
                      ~CRTC_H_CUTOFF_ACTIVE_EN);
diff --git a/drivers/video/aty/radeon_monitor.c b/drivers/video/aty/radeon_monitor.c
index 9261c918fde8..5c23eac0eb9a 100644
--- a/drivers/video/aty/radeon_monitor.c
+++ b/drivers/video/aty/radeon_monitor.c
@@ -730,6 +730,25 @@ static void radeon_videomode_to_var(struct fb_var_screeninfo *var,
         var->vmode = mode->vmode;
 }
 
+#ifdef CONFIG_PPC_PSERIES
+static int is_powerblade(const char *model)
+{
+        struct device_node *root;
+        const char* cp;
+        int len, l, rc = 0;
+
+        root = of_find_node_by_path("/");
+        if (root && model) {
+                l = strlen(model);
+                cp = of_get_property(root, "model", &len);
+                if (cp)
+                        rc = memcmp(model, cp, min(len, l)) == 0;
+                of_node_put(root);
+        }
+        return rc;
+}
+#endif
+
 /*
  * Build the modedb for head 1 (head 2 will come later), check panel infos
  * from either BIOS or EDID, and pick up the default mode
@@ -865,6 +884,22 @@ void __devinit radeon_check_modes(struct radeonfb_info *rinfo, const char *mode_
                         has_default_mode = 1;
         }
 
+#ifdef CONFIG_PPC_PSERIES
+        if (!has_default_mode && (
+                is_powerblade("IBM,8842") || /* JS20 */
+                is_powerblade("IBM,8844") || /* JS21 */
+                is_powerblade("IBM,7998") || /* JS12/JS21/JS22 */
+                is_powerblade("IBM,0792") || /* QS21 */
+                is_powerblade("IBM,0793")    /* QS22 */
+            )) {
+                printk("Falling back to 800x600 on JSxx hardware\n");
+                if (fb_find_mode(&info->var, info, "800x600@60",
+                                 info->monspecs.modedb,
+                                 info->monspecs.modedb_len, NULL, 8) != 0)
+                        has_default_mode = 1;
+        }
+#endif
+
         /*
          * Still no mode, let's pick up a default from the db
          */
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index f49181c73113..f75da8758adc 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -228,6 +228,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         data->port = pdata->flags;
         if (data->port < 0) {
                 dev_err(&pdev->dev, "wrong platform data is assigned");
+                kfree(data);
                 return -EINVAL;
         }
 
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index fa2b03750316..cf282763a8dc 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -88,7 +88,7 @@ config LCD_PLATFORM
 
 config LCD_TOSA
         tristate "Sharp SL-6000 LCD Driver"
-        depends on SPI && MACH_TOSA
+        depends on I2C && SPI && MACH_TOSA
         help
           If you have an Sharp SL-6000 Zaurus say Y to enable a driver
           for its LCD.
@@ -245,7 +245,7 @@ config BACKLIGHT_CARILLO_RANCH
 
 config BACKLIGHT_PWM
         tristate "Generic PWM based Backlight Driver"
-        depends on HAVE_PWM
+        depends on PWM
         help
           If you have a LCD backlight adjustable by PWM, say Y to enable
           this driver.
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index 0443a4f71858..df1cbb7ef6ca 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -127,7 +127,8 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
         struct atmel_pwm_bl *pwmbl;
         int retval;
 
-        pwmbl = kzalloc(sizeof(struct atmel_pwm_bl), GFP_KERNEL);
+        pwmbl = devm_kzalloc(&pdev->dev, sizeof(struct atmel_pwm_bl),
+                                GFP_KERNEL);
         if (!pwmbl)
                 return -ENOMEM;
 
@@ -154,7 +155,8 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                 goto err_free_mem;
 
         if (pwmbl->gpio_on != -1) {
-                retval = gpio_request(pwmbl->gpio_on, "gpio_atmel_pwm_bl");
+                retval = devm_gpio_request(&pdev->dev, pwmbl->gpio_on,
+                                        "gpio_atmel_pwm_bl");
                 if (retval) {
                         pwmbl->gpio_on = -1;
                         goto err_free_pwm;
@@ -164,7 +166,7 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                 retval = gpio_direction_output(pwmbl->gpio_on,
                                 0 ^ pdata->on_active_low);
                 if (retval)
-                        goto err_free_gpio;
+                        goto err_free_pwm;
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -174,7 +176,7 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                                           &atmel_pwm_bl_ops, &props);
         if (IS_ERR(bldev)) {
                 retval = PTR_ERR(bldev);
-                goto err_free_gpio;
+                goto err_free_pwm;
         }
 
         pwmbl->bldev = bldev;
@@ -196,13 +198,9 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
 err_free_bl_dev:
         platform_set_drvdata(pdev, NULL);
         backlight_device_unregister(bldev);
-err_free_gpio:
-        if (pwmbl->gpio_on != -1)
-                gpio_free(pwmbl->gpio_on);
 err_free_pwm:
         pwm_channel_free(&pwmbl->pwmc);
 err_free_mem:
-        kfree(pwmbl);
         return retval;
 }
 
@@ -210,15 +208,12 @@ static int __exit atmel_pwm_bl_remove(struct platform_device *pdev)
 {
         struct atmel_pwm_bl *pwmbl = platform_get_drvdata(pdev);
 
-        if (pwmbl->gpio_on != -1) {
+        if (pwmbl->gpio_on != -1)
                 gpio_set_value(pwmbl->gpio_on, 0);
-                gpio_free(pwmbl->gpio_on);
-        }
         pwm_channel_disable(&pwmbl->pwmc);
         pwm_channel_free(&pwmbl->pwmc);
         backlight_device_unregister(pwmbl->bldev);
         platform_set_drvdata(pdev, NULL);
-        kfree(pwmbl);
 
         return 0;
 }
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index 23d732677ba1..c781768ba892 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -492,7 +492,8 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
         lcd->gpio_backlight_cont = -1;
 
         if (gpio_is_valid(pdata->gpio_backlight_on)) {
-                err = gpio_request(pdata->gpio_backlight_on, "BL_ON");
+                err = devm_gpio_request(&spi->dev, pdata->gpio_backlight_on,
+                                        "BL_ON");
                 if (err) {
                         dev_err(&spi->dev, "failed to request GPIO%d for "
                                 "backlight_on\n", pdata->gpio_backlight_on);
@@ -504,11 +505,12 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
         }
 
         if (gpio_is_valid(pdata->gpio_backlight_cont)) {
-                err = gpio_request(pdata->gpio_backlight_cont, "BL_CONT");
+                err = devm_gpio_request(&spi->dev, pdata->gpio_backlight_cont,
+                                        "BL_CONT");
                 if (err) {
                         dev_err(&spi->dev, "failed to request GPIO%d for "
                                 "backlight_cont\n", pdata->gpio_backlight_cont);
-                        goto err_free_backlight_on;
+                        return err;
                 }
 
                 lcd->gpio_backlight_cont = pdata->gpio_backlight_cont;
@@ -525,11 +527,6 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
                 }
         }
         return 0;
-
-err_free_backlight_on:
-        if (gpio_is_valid(lcd->gpio_backlight_on))
-                gpio_free(lcd->gpio_backlight_on);
-        return err;
 }
 
 static int __devinit corgi_lcd_probe(struct spi_device *spi)
@@ -602,12 +599,6 @@ static int __devexit corgi_lcd_remove(struct spi_device *spi)
         backlight_update_status(lcd->bl_dev);
         backlight_device_unregister(lcd->bl_dev);
 
-        if (gpio_is_valid(lcd->gpio_backlight_on))
-                gpio_free(lcd->gpio_backlight_on);
-
-        if (gpio_is_valid(lcd->gpio_backlight_cont))
-                gpio_free(lcd->gpio_backlight_cont);
-
         corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
         lcd_device_unregister(lcd->lcd_dev);
 
diff --git a/drivers/video/backlight/ili9320.c b/drivers/video/backlight/ili9320.c
index 6c9399341bcf..9327cd1b3143 100644
--- a/drivers/video/backlight/ili9320.c
+++ b/drivers/video/backlight/ili9320.c
@@ -263,7 +263,7 @@ int __devinit ili9320_probe_spi(struct spi_device *spi,
 
 EXPORT_SYMBOL_GPL(ili9320_probe_spi);
 
-int __devexit ili9320_remove(struct ili9320 *ili)
+int ili9320_remove(struct ili9320 *ili)
 {
         ili9320_power(ili, FB_BLANK_POWERDOWN);
 
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index 40f606a86093..2d90c0648aa0 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -175,28 +175,27 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
 
         priv->spi = spi;
 
-        ret = gpio_request_one(pdata->reset_gpio, GPIOF_OUT_INIT_HIGH,
-                                                "lcd l4f00242t03 reset");
+        ret = devm_gpio_request_one(&spi->dev, pdata->reset_gpio,
+                        GPIOF_OUT_INIT_HIGH, "lcd l4f00242t03 reset");
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 reset gpio.\n");
                 return ret;
         }
 
-        ret = gpio_request_one(pdata->data_enable_gpio, GPIOF_OUT_INIT_LOW,
-                                                "lcd l4f00242t03 data enable");
+        ret = devm_gpio_request_one(&spi->dev, pdata->data_enable_gpio,
+                        GPIOF_OUT_INIT_LOW, "lcd l4f00242t03 data enable");
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 data en gpio.\n");
-                goto err;
+                return ret;
         }
 
         priv->io_reg = regulator_get(&spi->dev, "vdd");
         if (IS_ERR(priv->io_reg)) {
-                ret = PTR_ERR(priv->io_reg);
                 dev_err(&spi->dev, "%s: Unable to get the IO regulator\n",
                        __func__);
-                goto err2;
+                return PTR_ERR(priv->io_reg);
         }
 
         priv->core_reg = regulator_get(&spi->dev, "vcore");
@@ -204,14 +203,14 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
                 ret = PTR_ERR(priv->core_reg);
                 dev_err(&spi->dev, "%s: Unable to get the core regulator\n",
                        __func__);
-                goto err3;
+                goto err1;
         }
 
         priv->ld = lcd_device_register("l4f00242t03",
                                         &spi->dev, priv, &l4f_ops);
         if (IS_ERR(priv->ld)) {
                 ret = PTR_ERR(priv->ld);
-                goto err4;
+                goto err2;
         }
 
         /* Init the LCD */
@@ -223,14 +222,10 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
 
         return 0;
 
-err4:
+err2:
         regulator_put(priv->core_reg);
-err3:
+err1:
         regulator_put(priv->io_reg);
-err2:
-        gpio_free(pdata->data_enable_gpio);
-err:
-        gpio_free(pdata->reset_gpio);
 
         return ret;
 }
@@ -238,16 +233,12 @@ err:
 static int __devexit l4f00242t03_remove(struct spi_device *spi)
 {
         struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
-        struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
 
         l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
         lcd_device_unregister(priv->ld);
 
         dev_set_drvdata(&spi->dev, NULL);
 
-        gpio_free(pdata->data_enable_gpio);
-        gpio_free(pdata->reset_gpio);
-
         regulator_put(priv->io_reg);
         regulator_put(priv->core_reg);
 
diff --git a/drivers/video/backlight/lm3533_bl.c b/drivers/video/backlight/lm3533_bl.c
index bebeb63607db..18dca0c29c68 100644
--- a/drivers/video/backlight/lm3533_bl.c
+++ b/drivers/video/backlight/lm3533_bl.c
@@ -295,7 +295,7 @@ static int __devinit lm3533_bl_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        bl = kzalloc(sizeof(*bl), GFP_KERNEL);
+        bl = devm_kzalloc(&pdev->dev, sizeof(*bl), GFP_KERNEL);
         if (!bl) {
                 dev_err(&pdev->dev,
                                 "failed to allocate memory for backlight\n");
@@ -317,8 +317,7 @@ static int __devinit lm3533_bl_probe(struct platform_device *pdev)
                                                 &lm3533_bl_ops, &props);
         if (IS_ERR(bd)) {
                 dev_err(&pdev->dev, "failed to register backlight device\n");
-                ret = PTR_ERR(bd);
-                goto err_free;
+                return PTR_ERR(bd);
         }
 
         bl->bd = bd;
@@ -348,8 +347,6 @@ err_sysfs_remove:
         sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
 err_unregister:
         backlight_device_unregister(bd);
-err_free:
-        kfree(bl);
 
         return ret;
 }
@@ -367,7 +364,6 @@ static int __devexit lm3533_bl_remove(struct platform_device *pdev)
         lm3533_ctrlbank_disable(&bl->cb);
         sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
         backlight_device_unregister(bd);
-        kfree(bl);
 
         return 0;
 }
diff --git a/drivers/video/backlight/lms283gf05.c b/drivers/video/backlight/lms283gf05.c
index a9f2c36966f1..ea43f2254196 100644
--- a/drivers/video/backlight/lms283gf05.c
+++ b/drivers/video/backlight/lms283gf05.c
@@ -158,29 +158,27 @@ static int __devinit lms283gf05_probe(struct spi_device *spi)
         int ret = 0;
 
         if (pdata != NULL) {
-                ret = gpio_request(pdata->reset_gpio, "LMS285GF05 RESET");
+                ret = devm_gpio_request(&spi->dev, pdata->reset_gpio,
+                                        "LMS285GF05 RESET");
                 if (ret)
                         return ret;
 
                 ret = gpio_direction_output(pdata->reset_gpio,
                                                 !pdata->reset_inverted);
                 if (ret)
-                        goto err;
+                        return ret;
         }
 
         st = devm_kzalloc(&spi->dev, sizeof(struct lms283gf05_state),
                                 GFP_KERNEL);
         if (st == NULL) {
                 dev_err(&spi->dev, "No memory for device state\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         ld = lcd_device_register("lms283gf05", &spi->dev, st, &lms_ops);
-        if (IS_ERR(ld)) {
-                ret = PTR_ERR(ld);
-                goto err;
-        }
+        if (IS_ERR(ld))
+                return PTR_ERR(ld);
 
         st->spi = spi;
         st->ld = ld;
@@ -193,24 +191,14 @@ static int __devinit lms283gf05_probe(struct spi_device *spi)
         lms283gf05_toggle(spi, disp_initseq, ARRAY_SIZE(disp_initseq));
 
         return 0;
-
-err:
-        if (pdata != NULL)
-                gpio_free(pdata->reset_gpio);
-
-        return ret;
 }
 
 static int __devexit lms283gf05_remove(struct spi_device *spi)
 {
         struct lms283gf05_state *st = dev_get_drvdata(&spi->dev);
-        struct lms283gf05_pdata *pdata = st->spi->dev.platform_data;
 
         lcd_device_unregister(st->ld);
 
-        if (pdata != NULL)
-                gpio_free(pdata->reset_gpio);
-
         return 0;
 }
 
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c
index 72a0e0c917cf..aa6d4f71131f 100644
--- a/drivers/video/backlight/lp855x_bl.c
+++ b/drivers/video/backlight/lp855x_bl.c
@@ -14,11 +14,15 @@
 #include <linux/i2c.h>
 #include <linux/backlight.h>
 #include <linux/err.h>
-#include <linux/lp855x.h>
+#include <linux/platform_data/lp855x.h>
 
 /* Registers */
-#define BRIGHTNESS_CTRL         (0x00)
-#define DEVICE_CTRL             (0x01)
+#define BRIGHTNESS_CTRL         0x00
+#define DEVICE_CTRL             0x01
+#define EEPROM_START            0xA0
+#define EEPROM_END              0xA7
+#define EPROM_START             0xA0
+#define EPROM_END               0xAF
 
 #define BUF_SIZE                20
 #define DEFAULT_BL_NAME         "lcd-backlight"
diff --git a/drivers/video/backlight/ot200_bl.c b/drivers/video/backlight/ot200_bl.c
index f519d55a294c..469cf0f109d2 100644
--- a/drivers/video/backlight/ot200_bl.c
+++ b/drivers/video/backlight/ot200_bl.c
@@ -84,7 +84,8 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         int retval = 0;
 
         /* request gpio */
-        if (gpio_request(GPIO_DIMM, "ot200 backlight dimmer") < 0) {
+        if (devm_gpio_request(&pdev->dev, GPIO_DIMM,
+                                "ot200 backlight dimmer") < 0) {
                 dev_err(&pdev->dev, "failed to request GPIO %d\n", GPIO_DIMM);
                 return -ENODEV;
         }
@@ -93,14 +94,13 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         pwm_timer = cs5535_mfgpt_alloc_timer(7, MFGPT_DOMAIN_ANY);
         if (!pwm_timer) {
                 dev_err(&pdev->dev, "MFGPT 7 not available\n");
-                retval = -ENODEV;
-                goto error_mfgpt_alloc;
+                return -ENODEV;
         }
 
-        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
         if (!data) {
                 retval = -ENOMEM;
-                goto error_kzalloc;
+                goto error_devm_kzalloc;
         }
 
         /* setup gpio */
@@ -122,26 +122,21 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 retval = PTR_ERR(bl);
-                goto error_backlight_device_register;
+                goto error_devm_kzalloc;
         }
 
         platform_set_drvdata(pdev, bl);
 
         return 0;
 
-error_backlight_device_register:
-        kfree(data);
-error_kzalloc:
+error_devm_kzalloc:
         cs5535_mfgpt_free_timer(pwm_timer);
-error_mfgpt_alloc:
-        gpio_free(GPIO_DIMM);
         return retval;
 }
 
 static int ot200_backlight_remove(struct platform_device *pdev)
 {
         struct backlight_device *bl = platform_get_drvdata(pdev);
-        struct ot200_backlight_data *data = bl_get_data(bl);
 
         backlight_device_unregister(bl);
 
@@ -152,9 +147,7 @@ static int ot200_backlight_remove(struct platform_device *pdev)
                 MAX_COMP2 - dim_table[100]);
 
         cs5535_mfgpt_free_timer(pwm_timer);
-        gpio_free(GPIO_DIMM);
 
-        kfree(data);
         return 0;
 }
 
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 342b7d7cbb63..995f0164c9b0 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -26,11 +26,13 @@ struct pwm_bl_data {
         struct device           *dev;
         unsigned int            period;
         unsigned int            lth_brightness;
+        unsigned int            *levels;
         int                     (*notify)(struct device *,
                                           int brightness);
         void                    (*notify_after)(struct device *,
                                         int brightness);
         int                     (*check_fb)(struct device *, struct fb_info *);
+        void                    (*exit)(struct device *);
 };
 
 static int pwm_backlight_update_status(struct backlight_device *bl)
@@ -52,9 +54,18 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
                 pwm_config(pb->pwm, 0, pb->period);
                 pwm_disable(pb->pwm);
         } else {
-                brightness = pb->lth_brightness +
-                        (brightness * (pb->period - pb->lth_brightness) / max);
-                pwm_config(pb->pwm, brightness, pb->period);
+                int duty_cycle;
+
+                if (pb->levels) {
+                        duty_cycle = pb->levels[brightness];
+                        max = pb->levels[max];
+                } else {
+                        duty_cycle = brightness;
+                }
+
+                duty_cycle = pb->lth_brightness +
+                     (duty_cycle * (pb->period - pb->lth_brightness) / max);
+                pwm_config(pb->pwm, duty_cycle, pb->period);
                 pwm_enable(pb->pwm);
         }
 
@@ -83,17 +94,98 @@ static const struct backlight_ops pwm_backlight_ops = {
         .check_fb       = pwm_backlight_check_fb,
 };
 
+#ifdef CONFIG_OF
+static int pwm_backlight_parse_dt(struct device *dev,
+                                  struct platform_pwm_backlight_data *data)
+{
+        struct device_node *node = dev->of_node;
+        struct property *prop;
+        int length;
+        u32 value;
+        int ret;
+
+        if (!node)
+                return -ENODEV;
+
+        memset(data, 0, sizeof(*data));
+
+        /* determine the number of brightness levels */
+        prop = of_find_property(node, "brightness-levels", &length);
+        if (!prop)
+                return -EINVAL;
+
+        data->max_brightness = length / sizeof(u32);
+
+        /* read brightness levels from DT property */
+        if (data->max_brightness > 0) {
+                size_t size = sizeof(*data->levels) * data->max_brightness;
+
+                data->levels = devm_kzalloc(dev, size, GFP_KERNEL);
+                if (!data->levels)
+                        return -ENOMEM;
+
+                ret = of_property_read_u32_array(node, "brightness-levels",
+                                                 data->levels,
+                                                 data->max_brightness);
+                if (ret < 0)
+                        return ret;
+
+                ret = of_property_read_u32(node, "default-brightness-level",
+                                           &value);
+                if (ret < 0)
+                        return ret;
+
+                if (value >= data->max_brightness) {
+                        dev_warn(dev, "invalid default brightness level: %u, using %u\n",
+                                 value, data->max_brightness - 1);
+                        value = data->max_brightness - 1;
+                }
+
+                data->dft_brightness = value;
+                data->max_brightness--;
+        }
+
+        /*
+         * TODO: Most users of this driver use a number of GPIOs to control
+         *       backlight power. Support for specifying these needs to be
+         *       added.
+         */
+
+        return 0;
+}
+
+static struct of_device_id pwm_backlight_of_match[] = {
+        { .compatible = "pwm-backlight" },
+        { }
+};
+
+MODULE_DEVICE_TABLE(of, pwm_backlight_of_match);
+#else
+static int pwm_backlight_parse_dt(struct device *dev,
+                                  struct platform_pwm_backlight_data *data)
+{
+        return -ENODEV;
+}
+#endif
+
 static int pwm_backlight_probe(struct platform_device *pdev)
 {
-        struct backlight_properties props;
         struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
+        struct platform_pwm_backlight_data defdata;
+        struct backlight_properties props;
         struct backlight_device *bl;
         struct pwm_bl_data *pb;
+        unsigned int max;
         int ret;
 
         if (!data) {
-                dev_err(&pdev->dev, "failed to find platform data\n");
-                return -EINVAL;
+                ret = pwm_backlight_parse_dt(&pdev->dev, &defdata);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "failed to find platform data\n");
+                        return ret;
+                }
+
+                data = &defdata;
         }
 
         if (data->init) {
@@ -109,21 +201,42 @@ static int pwm_backlight_probe(struct platform_device *pdev)
                 goto err_alloc;
         }
 
-        pb->period = data->pwm_period_ns;
+        if (data->levels) {
+                max = data->levels[data->max_brightness];
+                pb->levels = data->levels;
+        } else
+                max = data->max_brightness;
+
         pb->notify = data->notify;
         pb->notify_after = data->notify_after;
         pb->check_fb = data->check_fb;
-        pb->lth_brightness = data->lth_brightness *
-                (data->pwm_period_ns / data->max_brightness);
+        pb->exit = data->exit;
         pb->dev = &pdev->dev;
 
-        pb->pwm = pwm_request(data->pwm_id, "backlight");
+        pb->pwm = pwm_get(&pdev->dev, NULL);
         if (IS_ERR(pb->pwm)) {
-                dev_err(&pdev->dev, "unable to request PWM for backlight\n");
-                ret = PTR_ERR(pb->pwm);
-                goto err_alloc;
-        } else
-                dev_dbg(&pdev->dev, "got pwm for backlight\n");
+                dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
+
+                pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
+                if (IS_ERR(pb->pwm)) {
+                        dev_err(&pdev->dev, "unable to request legacy PWM\n");
+                        ret = PTR_ERR(pb->pwm);
+                        goto err_alloc;
+                }
+        }
+
+        dev_dbg(&pdev->dev, "got pwm for backlight\n");
+
+        /*
+         * The DT case will set the pwm_period_ns field to 0 and store the
+         * period, parsed from the DT, in the PWM device. For the non-DT case,
+         * set the period from platform data.
+         */
+        if (data->pwm_period_ns > 0)
+                pwm_set_period(pb->pwm, data->pwm_period_ns);
+
+        pb->period = pwm_get_period(pb->pwm);
+        pb->lth_brightness = data->lth_brightness * (pb->period / max);
 
         memset(&props, 0, sizeof(struct backlight_properties));
         props.type = BACKLIGHT_RAW;
@@ -143,7 +256,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         return 0;
 
 err_bl:
-        pwm_free(pb->pwm);
+        pwm_put(pb->pwm);
 err_alloc:
         if (data->exit)
                 data->exit(&pdev->dev);
@@ -152,16 +265,15 @@ err_alloc:
 
 static int pwm_backlight_remove(struct platform_device *pdev)
 {
-        struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
         struct backlight_device *bl = platform_get_drvdata(pdev);
         struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
 
         backlight_device_unregister(bl);
         pwm_config(pb->pwm, 0, pb->period);
         pwm_disable(pb->pwm);
-        pwm_free(pb->pwm);
-        if (data->exit)
-                data->exit(&pdev->dev);
+        pwm_put(pb->pwm);
+        if (pb->exit)
+                pb->exit(&pdev->dev);
         return 0;
 }
 
@@ -195,11 +307,12 @@ static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops, pwm_backlight_suspend,
 
 static struct platform_driver pwm_backlight_driver = {
         .driver         = {
-                .name   = "pwm-backlight",
-                .owner  = THIS_MODULE,
+                .name           = "pwm-backlight",
+                .owner          = THIS_MODULE,
 #ifdef CONFIG_PM
-                .pm     = &pwm_backlight_pm_ops,
+                .pm             = &pwm_backlight_pm_ops,
 #endif
+                .of_match_table = of_match_ptr(pwm_backlight_of_match),
         },
         .probe          = pwm_backlight_probe,
         .remove         = pwm_backlight_remove,
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index 0d54e607e82d..49342e1d20be 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -92,14 +92,14 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
 
         data->comadj = sharpsl_param.comadj == -1 ? COMADJ_DEFAULT : sharpsl_param.comadj;
 
-        ret = gpio_request(TOSA_GPIO_BL_C20MA, "backlight");
+        ret = devm_gpio_request(&client->dev, TOSA_GPIO_BL_C20MA, "backlight");
         if (ret) {
                 dev_dbg(&data->bl->dev, "Unable to request gpio!\n");
                 return ret;
         }
         ret = gpio_direction_output(TOSA_GPIO_BL_C20MA, 0);
         if (ret)
-                goto err_gpio_dir;
+                return ret;
 
         i2c_set_clientdata(client, data);
         data->i2c = client;
@@ -123,8 +123,6 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
 
 err_reg:
         data->bl = NULL;
-err_gpio_dir:
-        gpio_free(TOSA_GPIO_BL_C20MA);
         return ret;
 }
 
@@ -135,8 +133,6 @@ static int __devexit tosa_bl_remove(struct i2c_client *client)
         backlight_device_unregister(data->bl);
         data->bl = NULL;
 
-        gpio_free(TOSA_GPIO_BL_C20MA);
-
         return 0;
 }
 
diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c
index 47823b8efff0..33047a66cc24 100644
--- a/drivers/video/backlight/tosa_lcd.c
+++ b/drivers/video/backlight/tosa_lcd.c
@@ -193,7 +193,7 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
         data->spi = spi;
         dev_set_drvdata(&spi->dev, data);
 
-        ret = gpio_request(TOSA_GPIO_TG_ON, "tg #pwr");
+        ret = devm_gpio_request(&spi->dev, TOSA_GPIO_TG_ON, "tg #pwr");
         if (ret < 0)
                 goto err_gpio_tg;
 
@@ -201,7 +201,7 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
 
         ret = gpio_direction_output(TOSA_GPIO_TG_ON, 0);
         if (ret < 0)
-                goto err_gpio_dir;
+                goto err_gpio_tg;
 
         mdelay(60);
         tosa_lcd_tg_init(data);
@@ -221,8 +221,6 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
 
 err_register:
         tosa_lcd_tg_off(data);
-err_gpio_dir:
-        gpio_free(TOSA_GPIO_TG_ON);
 err_gpio_tg:
         dev_set_drvdata(&spi->dev, NULL);
         return ret;
@@ -239,7 +237,6 @@ static int __devexit tosa_lcd_remove(struct spi_device *spi)
 
         tosa_lcd_tg_off(data);
 
-        gpio_free(TOSA_GPIO_TG_ON);
         dev_set_drvdata(&spi->dev, NULL);
 
         return 0;
diff --git a/drivers/video/bfin_adv7393fb.c b/drivers/video/bfin_adv7393fb.c
index 33ea874c87d2..d0f121bd8b25 100644
--- a/drivers/video/bfin_adv7393fb.c
+++ b/drivers/video/bfin_adv7393fb.c
@@ -58,7 +58,7 @@ static const unsigned short ppi_pins[] = {
  */
 
 static struct bfin_adv7393_fb_par {
-        /* structure holding blackfin / adv7393 paramters when
+        /* structure holding blackfin / adv7393 parameters when
            screen is blanked */
         struct {
                 u8 Mode;        /* ntsc/pal/? */
@@ -353,18 +353,16 @@ adv7393_read_proc(char *page, char **start, off_t off,
 
 static int
 adv7393_write_proc(struct file *file, const char __user * buffer,
-                   unsigned long count, void *data)
+                   size_t count, void *data)
 {
         struct adv7393fb_device *fbdev = data;
-        char line[8];
         unsigned int val;
         int ret;
 
-        ret = copy_from_user(line, buffer, count);
+        ret = kstrtouint_from_user(buffer, count, 0, &val);
         if (ret)
                 return -EFAULT;
 
-        val = simple_strtoul(line, NULL, 0);
         adv7393_write(fbdev->client, val >> 8, val & 0xff);
 
         return count;
diff --git a/drivers/video/broadsheetfb.c b/drivers/video/broadsheetfb.c
index 377dde3d5bfc..c95b417d0d41 100644
--- a/drivers/video/broadsheetfb.c
+++ b/drivers/video/broadsheetfb.c
@@ -1211,7 +1211,7 @@ static int __devexit broadsheetfb_remove(struct platform_device *dev)
 
 static struct platform_driver broadsheetfb_driver = {
         .probe  = broadsheetfb_probe,
-        .remove = broadsheetfb_remove,
+        .remove = __devexit_p(broadsheetfb_remove),
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "broadsheetfb",
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index 738c8ce7d132..bc67d05cad60 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -1611,7 +1611,7 @@ static void init_vgachip(struct fb_info *info)
         /* ext. display controls: ext.adr. wrap */
         vga_wcrt(cinfo->regbase, CL_CRT1B, 0x02);
 
-        /* Set/Reset registes: - */
+        /* Set/Reset registers: - */
         vga_wgfx(cinfo->regbase, VGA_GFX_SR_VALUE, 0x00);
         /* Set/Reset enable: - */
         vga_wgfx(cinfo->regbase, VGA_GFX_SR_ENABLE, 0x00);
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index c2d11fef114b..e2c96d01d8f5 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -224,5 +224,19 @@ config FONT_10x18
           big letters. It fits between the sun 12x22 and the normal 8x16 font.
           If other fonts are too big or too small for you, say Y, otherwise say N.
 
+config FONT_AUTOSELECT
+        def_bool y
+        depends on FRAMEBUFFER_CONSOLE || SGI_NEWPORT_CONSOLE || STI_CONSOLE || USB_SISUSBVGA_CON
+        depends on !FONT_8x8
+        depends on !FONT_6x11
+        depends on !FONT_7x14
+        depends on !FONT_PEARL_8x8
+        depends on !FONT_ACORN_8x8
+        depends on !FONT_MINI_4x6
+        depends on !FONT_SUN8x16
+        depends on !FONT_SUN12x22
+        depends on !FONT_10x18
+        select FONT_8x16
+
 endmenu
 
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 2e471c22abf5..88e92041d8f0 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -372,8 +372,15 @@ static void fb_flashcursor(struct work_struct *work)
         struct vc_data *vc = NULL;
         int c;
         int mode;
+        int ret;
+
+        /* FIXME: we should sort out the unbind locking instead */
+        /* instead we just fail to flash the cursor if we can't get
+         * the lock instead of blocking fbcon deinit */
+        ret = console_trylock();
+        if (ret == 0)
+                return;
 
-        console_lock();
         if (ops && ops->currcon != -1)
                 vc = vc_cons[ops->currcon].d;
 
diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c
index 47118c75a4c0..7ae9d53f2bf1 100644
--- a/drivers/video/da8xx-fb.c
+++ b/drivers/video/da8xx-fb.c
@@ -30,7 +30,10 @@
 #include <linux/clk.h>
 #include <linux/cpufreq.h>
 #include <linux/console.h>
+#include <linux/spinlock.h>
 #include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/lcm.h>
 #include <video/da8xx-fb.h>
 #include <asm/div64.h>
 
@@ -160,6 +163,13 @@ struct da8xx_fb_par {
         wait_queue_head_t       vsync_wait;
         int                     vsync_flag;
         int                     vsync_timeout;
+        spinlock_t              lock_for_chan_update;
+
+        /*
+         * LCDC has 2 ping pong DMA channels, channel 0
+         * and channel 1.
+         */
+        unsigned int            which_dma_channel_done;
 #ifdef CONFIG_CPU_FREQ
         struct notifier_block   freq_transition;
         unsigned int            lcd_fck_rate;
@@ -260,10 +270,18 @@ static inline void lcd_enable_raster(void)
 {
         u32 reg;
 
+        /* Put LCDC in reset for several cycles */
+        if (lcd_revision == LCD_VERSION_2)
+                /* Write 1 to reset LCDC */
+                lcdc_write(LCD_CLK_MAIN_RESET, LCD_CLK_RESET_REG);
+        mdelay(1);
+
         /* Bring LCDC out of reset */
         if (lcd_revision == LCD_VERSION_2)
                 lcdc_write(0, LCD_CLK_RESET_REG);
+        mdelay(1);
 
+        /* Above reset sequence doesnot reset register context */
         reg = lcdc_read(LCD_RASTER_CTRL_REG);
         if (!(reg & LCD_RASTER_ENABLE))
                 lcdc_write(reg | LCD_RASTER_ENABLE, LCD_RASTER_CTRL_REG);
@@ -277,10 +295,6 @@ static inline void lcd_disable_raster(void)
         reg = lcdc_read(LCD_RASTER_CTRL_REG);
         if (reg & LCD_RASTER_ENABLE)
                 lcdc_write(reg & ~LCD_RASTER_ENABLE, LCD_RASTER_CTRL_REG);
-
-        if (lcd_revision == LCD_VERSION_2)
-                /* Write 1 to reset LCDC */
-                lcdc_write(LCD_CLK_MAIN_RESET, LCD_CLK_RESET_REG);
 }
 
 static void lcd_blit(int load_mode, struct da8xx_fb_par *par)
@@ -344,8 +358,8 @@ static void lcd_blit(int load_mode, struct da8xx_fb_par *par)
         lcd_enable_raster();
 }
 
-/* Configure the Burst Size of DMA */
-static int lcd_cfg_dma(int burst_size)
+/* Configure the Burst Size and fifo threhold of DMA */
+static int lcd_cfg_dma(int burst_size, int fifo_th)
 {
         u32 reg;
 
@@ -369,6 +383,9 @@ static int lcd_cfg_dma(int burst_size)
         default:
                 return -EINVAL;
         }
+
+        reg |= (fifo_th << 8);
+
         lcdc_write(reg, LCD_DMA_CTRL_REG);
 
         return 0;
@@ -670,8 +687,8 @@ static int lcd_init(struct da8xx_fb_par *par, const struct lcd_ctrl_config *cfg,
                 lcdc_write((lcdc_read(LCD_RASTER_TIMING_2_REG) &
                         ~LCD_INVERT_PIXEL_CLOCK), LCD_RASTER_TIMING_2_REG);
 
-        /* Configure the DMA burst size. */
-        ret = lcd_cfg_dma(cfg->dma_burst_sz);
+        /* Configure the DMA burst size and fifo threshold. */
+        ret = lcd_cfg_dma(cfg->dma_burst_sz, cfg->fifo_th);
         if (ret < 0)
                 return ret;
 
@@ -715,7 +732,6 @@ static irqreturn_t lcdc_irq_handler_rev02(int irq, void *arg)
 {
         struct da8xx_fb_par *par = arg;
         u32 stat = lcdc_read(LCD_MASKED_STAT_REG);
-        u32 reg_int;
 
         if ((stat & LCD_SYNC_LOST) && (stat & LCD_FIFO_UNDERFLOW)) {
                 lcd_disable_raster();
@@ -732,10 +748,8 @@ static irqreturn_t lcdc_irq_handler_rev02(int irq, void *arg)
 
                 lcdc_write(stat, LCD_MASKED_STAT_REG);
 
-                /* Disable PL completion inerrupt */
-                reg_int = lcdc_read(LCD_INT_ENABLE_CLR_REG) |
-                       (LCD_V2_PL_INT_ENA);
-                lcdc_write(reg_int, LCD_INT_ENABLE_CLR_REG);
+                /* Disable PL completion interrupt */
+                lcdc_write(LCD_V2_PL_INT_ENA, LCD_INT_ENABLE_CLR_REG);
 
                 /* Setup and start data loading mode */
                 lcd_blit(LOAD_DATA, par);
@@ -743,6 +757,7 @@ static irqreturn_t lcdc_irq_handler_rev02(int irq, void *arg)
                 lcdc_write(stat, LCD_MASKED_STAT_REG);
 
                 if (stat & LCD_END_OF_FRAME0) {
+                        par->which_dma_channel_done = 0;
                         lcdc_write(par->dma_start,
                                    LCD_DMA_FRM_BUF_BASE_ADDR_0_REG);
                         lcdc_write(par->dma_end,
@@ -752,6 +767,7 @@ static irqreturn_t lcdc_irq_handler_rev02(int irq, void *arg)
                 }
 
                 if (stat & LCD_END_OF_FRAME1) {
+                        par->which_dma_channel_done = 1;
                         lcdc_write(par->dma_start,
                                    LCD_DMA_FRM_BUF_BASE_ADDR_1_REG);
                         lcdc_write(par->dma_end,
@@ -798,6 +814,7 @@ static irqreturn_t lcdc_irq_handler_rev01(int irq, void *arg)
                 lcdc_write(stat, LCD_STAT_REG);
 
                 if (stat & LCD_END_OF_FRAME0) {
+                        par->which_dma_channel_done = 0;
                         lcdc_write(par->dma_start,
                                    LCD_DMA_FRM_BUF_BASE_ADDR_0_REG);
                         lcdc_write(par->dma_end,
@@ -807,6 +824,7 @@ static irqreturn_t lcdc_irq_handler_rev01(int irq, void *arg)
                 }
 
                 if (stat & LCD_END_OF_FRAME1) {
+                        par->which_dma_channel_done = 1;
                         lcdc_write(par->dma_start,
                                    LCD_DMA_FRM_BUF_BASE_ADDR_1_REG);
                         lcdc_write(par->dma_end,
@@ -1021,11 +1039,14 @@ static int cfb_blank(int blank, struct fb_info *info)
         par->blank = blank;
         switch (blank) {
         case FB_BLANK_UNBLANK:
+                lcd_enable_raster();
+
                 if (par->panel_power_ctrl)
                         par->panel_power_ctrl(1);
-
-                lcd_enable_raster();
                 break;
+        case FB_BLANK_NORMAL:
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
         case FB_BLANK_POWERDOWN:
                 if (par->panel_power_ctrl)
                         par->panel_power_ctrl(0);
@@ -1052,6 +1073,7 @@ static int da8xx_pan_display(struct fb_var_screeninfo *var,
         struct fb_fix_screeninfo    *fix = &fbi->fix;
         unsigned int end;
         unsigned int start;
+        unsigned long irq_flags;
 
         if (var->xoffset != fbi->var.xoffset ||
                         var->yoffset != fbi->var.yoffset) {
@@ -1069,6 +1091,21 @@ static int da8xx_pan_display(struct fb_var_screeninfo *var,
                         end     = start + fbi->var.yres * fix->line_length - 1;
                         par->dma_start  = start;
                         par->dma_end    = end;
+                        spin_lock_irqsave(&par->lock_for_chan_update,
+                                        irq_flags);
+                        if (par->which_dma_channel_done == 0) {
+                                lcdc_write(par->dma_start,
+                                           LCD_DMA_FRM_BUF_BASE_ADDR_0_REG);
+                                lcdc_write(par->dma_end,
+                                           LCD_DMA_FRM_BUF_CEILING_ADDR_0_REG);
+                        } else if (par->which_dma_channel_done == 1) {
+                                lcdc_write(par->dma_start,
+                                           LCD_DMA_FRM_BUF_BASE_ADDR_1_REG);
+                                lcdc_write(par->dma_end,
+                                           LCD_DMA_FRM_BUF_CEILING_ADDR_1_REG);
+                        }
+                        spin_unlock_irqrestore(&par->lock_for_chan_update,
+                                        irq_flags);
                 }
         }
 
@@ -1114,6 +1151,7 @@ static int __devinit fb_probe(struct platform_device *device)
         struct da8xx_fb_par *par;
         resource_size_t len;
         int ret, i;
+        unsigned long ulcm;
 
         if (fb_pdata == NULL) {
                 dev_err(&device->dev, "Can not get platform data\n");
@@ -1209,7 +1247,8 @@ static int __devinit fb_probe(struct platform_device *device)
 
         /* allocate frame buffer */
         par->vram_size = lcdc_info->width * lcdc_info->height * lcd_cfg->bpp;
-        par->vram_size = PAGE_ALIGN(par->vram_size/8);
+        ulcm = lcm((lcdc_info->width * lcd_cfg->bpp)/8, PAGE_SIZE);
+        par->vram_size = roundup(par->vram_size/8, ulcm);
         par->vram_size = par->vram_size * LCD_NUM_BUFFERS;
 
         par->vram_virt = dma_alloc_coherent(NULL,
@@ -1296,6 +1335,8 @@ static int __devinit fb_probe(struct platform_device *device)
         /* initialize the vsync wait queue */
         init_waitqueue_head(&par->vsync_wait);
         par->vsync_timeout = HZ / 5;
+        par->which_dma_channel_done = -1;
+        spin_lock_init(&par->lock_for_chan_update);
 
         /* Register the Frame Buffer  */
         if (register_framebuffer(da8xx_fb_info) < 0) {
@@ -1382,11 +1423,12 @@ static int fb_resume(struct platform_device *dev)
         struct da8xx_fb_par *par = info->par;
 
         console_lock();
+        clk_enable(par->lcdc_clk);
+        lcd_enable_raster();
+
         if (par->panel_power_ctrl)
                 par->panel_power_ctrl(1);
 
-        clk_enable(par->lcdc_clk);
-        lcd_enable_raster();
         fb_set_suspend(info, 0);
         console_unlock();
 
diff --git a/drivers/video/epson1355fb.c b/drivers/video/epson1355fb.c
index a268cbf1cbea..68b9b511ce80 100644
--- a/drivers/video/epson1355fb.c
+++ b/drivers/video/epson1355fb.c
@@ -477,11 +477,11 @@ static __init unsigned int get_fb_size(struct fb_info *info)
         return size;
 }
 
-static int epson1355_width_tab[2][4] __initdata =
+static int epson1355_width_tab[2][4] __devinitdata =
     { {4, 8, 16, -1}, {9, 12, 16, -1} };
-static int epson1355_bpp_tab[8] __initdata = { 1, 2, 4, 8, 15, 16 };
+static int epson1355_bpp_tab[8] __devinitdata = { 1, 2, 4, 8, 15, 16 };
 
-static void __init fetch_hw_state(struct fb_info *info, struct epson1355_par *par)
+static void __devinit fetch_hw_state(struct fb_info *info, struct epson1355_par *par)
 {
         struct fb_var_screeninfo *var = &info->var;
         struct fb_fix_screeninfo *fix = &info->fix;
@@ -601,7 +601,7 @@ static int epson1355fb_remove(struct platform_device *dev)
         return 0;
 }
 
-int __devinit epson1355fb_probe(struct platform_device *dev)
+static int __devinit epson1355fb_probe(struct platform_device *dev)
 {
         struct epson1355_par *default_par;
         struct fb_info *info;
diff --git a/drivers/video/exynos/exynos_dp_core.c b/drivers/video/exynos/exynos_dp_core.c
index a36b2d28280e..c6c016a506ce 100644
--- a/drivers/video/exynos/exynos_dp_core.c
+++ b/drivers/video/exynos/exynos_dp_core.c
@@ -47,7 +47,7 @@ static int exynos_dp_detect_hpd(struct exynos_dp_device *dp)
 
         exynos_dp_init_hpd(dp);
 
-        udelay(200);
+        usleep_range(200, 210);
 
         while (exynos_dp_get_plug_in_status(dp) != 0) {
                 timeout_loop++;
@@ -55,7 +55,7 @@ static int exynos_dp_detect_hpd(struct exynos_dp_device *dp)
                         dev_err(dp->dev, "failed to get hpd plug status\n");
                         return -ETIMEDOUT;
                 }
-                udelay(10);
+                usleep_range(10, 11);
         }
 
         return 0;
@@ -304,7 +304,7 @@ static void exynos_dp_link_start(struct exynos_dp_device *dp)
                 buf[lane] = DPCD_PRE_EMPHASIS_PATTERN2_LEVEL0 |
                             DPCD_VOLTAGE_SWING_PATTERN1_LEVEL0;
         exynos_dp_write_bytes_to_dpcd(dp,
-                DPCD_ADDR_TRAINING_PATTERN_SET,
+                DPCD_ADDR_TRAINING_LANE0_SET,
                 lane_count, buf);
 }
 
@@ -336,7 +336,7 @@ static int exynos_dp_channel_eq_ok(u8 link_status[6], int lane_count)
         u8 lane_status;
 
         lane_align = link_status[2];
-        if ((lane_align == DPCD_INTERLANE_ALIGN_DONE) == 0)
+        if ((lane_align & DPCD_INTERLANE_ALIGN_DONE) == 0)
                 return -EINVAL;
 
         for (lane = 0; lane < lane_count; lane++) {
@@ -407,6 +407,9 @@ static unsigned int exynos_dp_get_lane_link_training(
         case 3:
                 reg = exynos_dp_get_lane3_link_training(dp);
                 break;
+        default:
+                WARN_ON(1);
+                return 0;
         }
 
         return reg;
@@ -483,7 +486,7 @@ static int exynos_dp_process_clock_recovery(struct exynos_dp_device *dp)
         u8 pre_emphasis;
         u8 training_lane;
 
-        udelay(100);
+        usleep_range(100, 101);
 
         exynos_dp_read_bytes_from_dpcd(dp, DPCD_ADDR_LANE0_1_STATUS,
                                 6, link_status);
@@ -501,7 +504,7 @@ static int exynos_dp_process_clock_recovery(struct exynos_dp_device *dp)
                 buf[0] = DPCD_SCRAMBLING_DISABLED |
                          DPCD_TRAINING_PATTERN_2;
                 exynos_dp_write_byte_to_dpcd(dp,
-                        DPCD_ADDR_TRAINING_LANE0_SET,
+                        DPCD_ADDR_TRAINING_PATTERN_SET,
                         buf[0]);
 
                 for (lane = 0; lane < lane_count; lane++) {
@@ -568,7 +571,7 @@ static int exynos_dp_process_equalizer_training(struct exynos_dp_device *dp)
 
         u8 adjust_request[2];
 
-        udelay(400);
+        usleep_range(400, 401);
 
         exynos_dp_read_bytes_from_dpcd(dp, DPCD_ADDR_LANE0_1_STATUS,
                                 6, link_status);
@@ -736,7 +739,7 @@ static int exynos_dp_set_link_train(struct exynos_dp_device *dp,
                 if (retval == 0)
                         break;
 
-                udelay(100);
+                usleep_range(100, 110);
         }
 
         return retval;
@@ -770,7 +773,7 @@ static int exynos_dp_config_video(struct exynos_dp_device *dp,
                         return -ETIMEDOUT;
                 }
 
-                udelay(1);
+                usleep_range(1, 2);
         }
 
         /* Set to use the register calculated M/N video */
@@ -804,7 +807,7 @@ static int exynos_dp_config_video(struct exynos_dp_device *dp,
                         return -ETIMEDOUT;
                 }
 
-                mdelay(1);
+                usleep_range(1000, 1001);
         }
 
         if (retval != 0)
diff --git a/drivers/video/exynos/exynos_dp_core.h b/drivers/video/exynos/exynos_dp_core.h
index 1e0f998e0c9f..8526e548c385 100644
--- a/drivers/video/exynos/exynos_dp_core.h
+++ b/drivers/video/exynos/exynos_dp_core.h
@@ -85,10 +85,6 @@ void exynos_dp_set_link_bandwidth(struct exynos_dp_device *dp, u32 bwtype);
 void exynos_dp_get_link_bandwidth(struct exynos_dp_device *dp, u32 *bwtype);
 void exynos_dp_set_lane_count(struct exynos_dp_device *dp, u32 count);
 void exynos_dp_get_lane_count(struct exynos_dp_device *dp, u32 *count);
-void exynos_dp_set_link_bandwidth(struct exynos_dp_device *dp, u32 bwtype);
-void exynos_dp_get_link_bandwidth(struct exynos_dp_device *dp, u32 *bwtype);
-void exynos_dp_set_lane_count(struct exynos_dp_device *dp, u32 count);
-void exynos_dp_get_lane_count(struct exynos_dp_device *dp, u32 *count);
 void exynos_dp_enable_enhanced_mode(struct exynos_dp_device *dp, bool enable);
 void exynos_dp_set_training_pattern(struct exynos_dp_device *dp,
                                  enum pattern_set pattern);
diff --git a/drivers/video/exynos/exynos_dp_reg.c b/drivers/video/exynos/exynos_dp_reg.c
index 6ce76d56c3a1..2db5b9aa250a 100644
--- a/drivers/video/exynos/exynos_dp_reg.c
+++ b/drivers/video/exynos/exynos_dp_reg.c
@@ -122,7 +122,7 @@ void exynos_dp_reset(struct exynos_dp_device *dp)
                 LS_CLK_DOMAIN_FUNC_EN_N;
         writel(reg, dp->reg_base + EXYNOS_DP_FUNC_EN_2);
 
-        udelay(20);
+        usleep_range(20, 30);
 
         exynos_dp_lane_swap(dp, 0);
 
@@ -752,7 +752,7 @@ int exynos_dp_read_bytes_from_i2c(struct exynos_dp_device *dp,
 
                         /*
                          * If Rx sends defer, Tx sends only reads
-                         * request without sending addres
+                         * request without sending address
                          */
                         if (!defer)
                                 retval = exynos_dp_select_i2c_device(dp,
@@ -988,7 +988,7 @@ void exynos_dp_reset_macro(struct exynos_dp_device *dp)
         writel(reg, dp->reg_base + EXYNOS_DP_PHY_TEST);
 
         /* 10 us is the minimum reset time. */
-        udelay(10);
+        usleep_range(10, 20);
 
         reg &= ~MACRO_RST;
         writel(reg, dp->reg_base + EXYNOS_DP_PHY_TEST);
diff --git a/drivers/video/exynos/exynos_mipi_dsi.c b/drivers/video/exynos/exynos_mipi_dsi.c
index 6c1f5c314a42..4bc2b8a5dd8b 100644
--- a/drivers/video/exynos/exynos_mipi_dsi.c
+++ b/drivers/video/exynos/exynos_mipi_dsi.c
@@ -106,7 +106,7 @@ static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
 
         /*
          * data from Display controller(FIMD) is transferred in video mode
-         * but in case of command mode, all settigs is updated to registers.
+         * but in case of command mode, all settings are updated to registers.
          */
         exynos_mipi_dsi_stand_by(dsim, 1);
 }
@@ -154,7 +154,7 @@ static int exynos_mipi_dsi_blank_mode(struct mipi_dsim_device *dsim, int power)
                 if (client_drv && client_drv->power_on)
                         client_drv->power_on(client_dev, 1);
 
-                exynos_mipi_regulator_disable(dsim);
+                exynos_mipi_regulator_enable(dsim);
 
                 /* enable MIPI-DSI PHY. */
                 if (dsim->pd->phy_enable)
diff --git a/drivers/video/exynos/s6e8ax0.h b/drivers/video/exynos/s6e8ax0.h
deleted file mode 100644
index 1f1b270484b0..000000000000
--- a/drivers/video/exynos/s6e8ax0.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/* linux/drivers/video/backlight/s6e8ax0.h
- *
- * MIPI-DSI based s6e8ax0 AMOLED LCD Panel definitions.
- *
- * Copyright (c) 2011 Samsung Electronics
- *
- * Inki Dae, <inki.dae@samsung.com>
- * Donghwa Lee <dh09.lee@samsung.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.
-*/
-
-#ifndef _S6E8AX0_H
-#define _S6E8AX0_H
-
-extern void s6e8ax0_init(void);
-
-#endif
-
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 1ddeb11659d4..64cda560c488 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -104,6 +104,8 @@ static int fb_deferred_io_mkwrite(struct vm_area_struct *vma,
         deferred framebuffer IO. then if userspace touches a page
         again, we repeat the same scheme */
 
+        file_update_time(vma->vm_file);
+
         /* protect against the workqueue changing the page list */
         mutex_lock(&fbdefio->lock);
 
diff --git a/drivers/video/fb_draw.h b/drivers/video/fb_draw.h
index 04c01faaf772..624ee115f129 100644
--- a/drivers/video/fb_draw.h
+++ b/drivers/video/fb_draw.h
@@ -3,6 +3,7 @@
 
 #include <asm/types.h>
 #include <linux/fb.h>
+#include <linux/bug.h>
 
     /*
      *  Compose two values, using a bitmask as decision value
@@ -41,7 +42,8 @@ pixel_to_pat( u32 bpp, u32 pixel)
         case 32:
                 return 0x0000000100000001ul*pixel;
         default:
-                panic("pixel_to_pat(): unsupported pixelformat\n");
+                WARN(1, "pixel_to_pat(): unsupported pixelformat %d\n", bpp);
+                return 0;
     }
 }
 #else
@@ -66,7 +68,8 @@ pixel_to_pat( u32 bpp, u32 pixel)
         case 32:
                 return 0x00000001ul*pixel;
         default:
-                panic("pixel_to_pat(): unsupported pixelformat\n");
+                WARN(1, "pixel_to_pat(): unsupported pixelformat %d\n", bpp);
+                return 0;
     }
 }
 #endif
diff --git a/drivers/video/grvga.c b/drivers/video/grvga.c
index da066c210923..5245f9a71892 100644
--- a/drivers/video/grvga.c
+++ b/drivers/video/grvga.c
@@ -354,7 +354,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
          */
         if (fb_get_options("grvga", &options)) {
                 retval = -ENODEV;
-                goto err;
+                goto free_fb;
         }
 
         if (!options || !*options)
@@ -370,7 +370,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
                         if (grvga_parse_custom(this_opt, &info->var) < 0) {
                                 dev_err(&dev->dev, "Failed to parse custom mode (%s).\n", this_opt);
                                 retval = -EINVAL;
-                                goto err1;
+                                goto free_fb;
                         }
                 } else if (!strncmp(this_opt, "addr", 4))
                         grvga_fix_addr = simple_strtoul(this_opt + 5, NULL, 16);
@@ -387,10 +387,11 @@ static int __devinit grvga_probe(struct platform_device *dev)
         info->flags = FBINFO_DEFAULT | FBINFO_PARTIAL_PAN_OK | FBINFO_HWACCEL_YPAN;
         info->fix.smem_len = grvga_mem_size;
 
-        if (!request_mem_region(dev->resource[0].start, resource_size(&dev->resource[0]), "grlib-svgactrl regs")) {
+        if (!devm_request_mem_region(&dev->dev, dev->resource[0].start,
+                    resource_size(&dev->resource[0]), "grlib-svgactrl regs")) {
                 dev_err(&dev->dev, "registers already mapped\n");
                 retval = -EBUSY;
-                goto err;
+                goto free_fb;
         }
 
         par->regs = of_ioremap(&dev->resource[0], 0,
@@ -400,14 +401,14 @@ static int __devinit grvga_probe(struct platform_device *dev)
         if (!par->regs) {
                 dev_err(&dev->dev, "failed to map registers\n");
                 retval = -ENOMEM;
-                goto err1;
+                goto free_fb;
         }
 
         retval = fb_alloc_cmap(&info->cmap, 256, 0);
         if (retval < 0) {
                 dev_err(&dev->dev, "failed to allocate mem with fb_alloc_cmap\n");
                 retval = -ENOMEM;
-                goto err2;
+                goto unmap_regs;
         }
 
         if (mode_opt) {
@@ -415,7 +416,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
                                       grvga_modedb, sizeof(grvga_modedb), &grvga_modedb[0], 8);
                 if (!retval || retval == 4) {
                         retval = -EINVAL;
-                        goto err3;
+                        goto dealloc_cmap;
                 }
         }
 
@@ -427,10 +428,11 @@ static int __devinit grvga_probe(struct platform_device *dev)
 
                 physical_start = grvga_fix_addr;
 
-                if (!request_mem_region(physical_start, grvga_mem_size, dev->name)) {
+                if (!devm_request_mem_region(&dev->dev, physical_start,
+                                             grvga_mem_size, dev->name)) {
                         dev_err(&dev->dev, "failed to request memory region\n");
                         retval = -ENOMEM;
-                        goto err3;
+                        goto dealloc_cmap;
                 }
 
                 virtual_start = (unsigned long) ioremap(physical_start, grvga_mem_size);
@@ -438,7 +440,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
                 if (!virtual_start) {
                         dev_err(&dev->dev, "error mapping framebuffer memory\n");
                         retval = -ENOMEM;
-                        goto err4;
+                        goto dealloc_cmap;
                 }
         } else {        /* Allocate frambuffer memory */
 
@@ -451,7 +453,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
                                 "unable to allocate framebuffer memory (%lu bytes)\n",
                                 grvga_mem_size);
                         retval = -ENOMEM;
-                        goto err3;
+                        goto dealloc_cmap;
                 }
 
                 physical_start = dma_map_single(&dev->dev, (void *)virtual_start, grvga_mem_size, DMA_TO_DEVICE);
@@ -484,7 +486,7 @@ static int __devinit grvga_probe(struct platform_device *dev)
         retval = register_framebuffer(info);
         if (retval < 0) {
                 dev_err(&dev->dev, "failed to register framebuffer\n");
-                goto err4;
+                goto free_mem;
         }
 
         __raw_writel(physical_start, &par->regs->fb_pos);
@@ -493,21 +495,18 @@ static int __devinit grvga_probe(struct platform_device *dev)
 
         return 0;
 
-err4:
+free_mem:
         dev_set_drvdata(&dev->dev, NULL);
-        if (grvga_fix_addr) {
-                release_mem_region(physical_start, grvga_mem_size);
+        if (grvga_fix_addr)
                 iounmap((void *)virtual_start);
-        } else
+        else
                 kfree((void *)virtual_start);
-err3:
+dealloc_cmap:
         fb_dealloc_cmap(&info->cmap);
-err2:
+unmap_regs:
         of_iounmap(&dev->resource[0], par->regs,
                    resource_size(&dev->resource[0]));
-err1:
-        release_mem_region(dev->resource[0].start, resource_size(&dev->resource[0]));
-err:
+free_fb:
         framebuffer_release(info);
 
         return retval;
@@ -524,12 +523,10 @@ static int __devexit grvga_remove(struct platform_device *device)
 
                 of_iounmap(&device->resource[0], par->regs,
                            resource_size(&device->resource[0]));
-                release_mem_region(device->resource[0].start, resource_size(&device->resource[0]));
 
-                if (!par->fb_alloced) {
-                        release_mem_region(info->fix.smem_start, info->fix.smem_len);
+                if (!par->fb_alloced)
                         iounmap(info->screen_base);
-                } else
+                else
                         kfree((void *)info->screen_base);
 
                 framebuffer_release(info);
diff --git a/drivers/video/i740fb.c b/drivers/video/i740fb.c
index fe574d84ed99..ff3f8808e4e9 100644
--- a/drivers/video/i740fb.c
+++ b/drivers/video/i740fb.c
@@ -497,7 +497,7 @@ static int i740fb_decode_var(const struct fb_var_screeninfo *var,
 
         mem = vxres * vyres * ((bpp + 1) / 8);
         if (mem > info->screen_size) {
-                dev_err(info->device, "not enough video memory (%d KB requested, %ld KB avaliable)\n",
+                dev_err(info->device, "not enough video memory (%d KB requested, %ld KB available)\n",
                         mem >> 10, info->screen_size >> 10);
                 return -ENOMEM;
         }
@@ -728,7 +728,7 @@ static void vga_protect(struct i740fb_par *par)
         i740outreg_mask(par, VGA_SEQ_I, VGA_SEQ_CLOCK_MODE, 0x20, 0x20);
 
         i740inb(par, 0x3DA);
-        i740outb(par, VGA_ATT_W, 0x00); /* enable pallete access */
+        i740outb(par, VGA_ATT_W, 0x00); /* enable palette access */
 }
 
 static void vga_unprotect(struct i740fb_par *par)
@@ -737,7 +737,7 @@ static void vga_unprotect(struct i740fb_par *par)
         i740outreg_mask(par, VGA_SEQ_I, VGA_SEQ_CLOCK_MODE, 0, 0x20);
 
         i740inb(par, 0x3DA);
-        i740outb(par, VGA_ATT_W, 0x20); /* disable pallete access */
+        i740outb(par, VGA_ATT_W, 0x20); /* disable palette access */
 }
 
 static int i740fb_set_par(struct fb_info *info)
diff --git a/drivers/video/mbx/mbxfb.c b/drivers/video/mbx/mbxfb.c
index ab0a8e527333..85e4f44bfa61 100644
--- a/drivers/video/mbx/mbxfb.c
+++ b/drivers/video/mbx/mbxfb.c
@@ -1045,7 +1045,7 @@ static int __devexit mbxfb_remove(struct platform_device *dev)
 
 static struct platform_driver mbxfb_driver = {
         .probe = mbxfb_probe,
-        .remove = mbxfb_remove,
+        .remove = __devexit_p(mbxfb_remove),
         .suspend = mbxfb_suspend,
         .resume = mbxfb_resume,
         .driver = {
diff --git a/drivers/video/mx3fb.c b/drivers/video/mx3fb.c
index eec0d7b748eb..c89f8a8d36d2 100644
--- a/drivers/video/mx3fb.c
+++ b/drivers/video/mx3fb.c
@@ -269,7 +269,7 @@ struct mx3fb_info {
         dma_cookie_t                    cookie;
         struct scatterlist              sg[2];
 
-        u32                             sync;   /* preserve var->sync flags */
+        struct fb_var_screeninfo        cur_var; /* current var info */
 };
 
 static void mx3fb_dma_done(void *);
@@ -698,9 +698,29 @@ static void mx3fb_dma_done(void *arg)
         complete(&mx3_fbi->flip_cmpl);
 }
 
+static bool mx3fb_must_set_par(struct fb_info *fbi)
+{
+        struct mx3fb_info *mx3_fbi = fbi->par;
+        struct fb_var_screeninfo old_var = mx3_fbi->cur_var;
+        struct fb_var_screeninfo new_var = fbi->var;
+
+        if ((fbi->var.activate & FB_ACTIVATE_FORCE) &&
+            (fbi->var.activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW)
+                return true;
+
+        /*
+         * Ignore xoffset and yoffset update,
+         * because pan display handles this case.
+         */
+        old_var.xoffset = new_var.xoffset;
+        old_var.yoffset = new_var.yoffset;
+
+        return !!memcmp(&old_var, &new_var, sizeof(struct fb_var_screeninfo));
+}
+
 static int __set_par(struct fb_info *fbi, bool lock)
 {
-        u32 mem_len;
+        u32 mem_len, cur_xoffset, cur_yoffset;
         struct ipu_di_signal_cfg sig_cfg;
         enum ipu_panel mode = IPU_PANEL_TFT;
         struct mx3fb_info *mx3_fbi = fbi->par;
@@ -780,8 +800,25 @@ static int __set_par(struct fb_info *fbi, bool lock)
         video->out_height       = fbi->var.yres;
         video->out_stride       = fbi->var.xres_virtual;
 
-        if (mx3_fbi->blank == FB_BLANK_UNBLANK)
+        if (mx3_fbi->blank == FB_BLANK_UNBLANK) {
                 sdc_enable_channel(mx3_fbi);
+                /*
+                 * sg[0] points to fb smem_start address
+                 * and is actually active in controller.
+                 */
+                mx3_fbi->cur_var.xoffset = 0;
+                mx3_fbi->cur_var.yoffset = 0;
+        }
+
+        /*
+         * Preserve xoffset and yoffest in case they are
+         * inactive in controller as fb is blanked.
+         */
+        cur_xoffset = mx3_fbi->cur_var.xoffset;
+        cur_yoffset = mx3_fbi->cur_var.yoffset;
+        mx3_fbi->cur_var = fbi->var;
+        mx3_fbi->cur_var.xoffset = cur_xoffset;
+        mx3_fbi->cur_var.yoffset = cur_yoffset;
 
         return 0;
 }
@@ -802,7 +839,7 @@ static int mx3fb_set_par(struct fb_info *fbi)
 
         mutex_lock(&mx3_fbi->mutex);
 
-        ret = __set_par(fbi, true);
+        ret = mx3fb_must_set_par(fbi) ? __set_par(fbi, true) : 0;
 
         mutex_unlock(&mx3_fbi->mutex);
 
@@ -901,8 +938,8 @@ static int mx3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
         var->grayscale = 0;
 
         /* Preserve sync flags */
-        var->sync |= mx3_fbi->sync;
-        mx3_fbi->sync |= var->sync;
+        var->sync |= mx3_fbi->cur_var.sync;
+        mx3_fbi->cur_var.sync |= var->sync;
 
         return 0;
 }
@@ -1043,8 +1080,8 @@ static int mx3fb_pan_display(struct fb_var_screeninfo *var,
                 return -EINVAL;
         }
 
-        if (fbi->var.xoffset == var->xoffset &&
-            fbi->var.yoffset == var->yoffset)
+        if (mx3_fbi->cur_var.xoffset == var->xoffset &&
+            mx3_fbi->cur_var.yoffset == var->yoffset)
                 return 0;       /* No change, do nothing */
 
         y_bottom = var->yoffset;
@@ -1127,6 +1164,8 @@ static int mx3fb_pan_display(struct fb_var_screeninfo *var,
         else
                 fbi->var.vmode &= ~FB_VMODE_YWRAP;
 
+        mx3_fbi->cur_var = fbi->var;
+
         mutex_unlock(&mx3_fbi->mutex);
 
         dev_dbg(fbi->device, "Update complete\n");
diff --git a/drivers/video/mxsfb.c b/drivers/video/mxsfb.c
index abbe691047bd..49619b441500 100644
--- a/drivers/video/mxsfb.c
+++ b/drivers/video/mxsfb.c
@@ -41,12 +41,14 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/pinctrl/consumer.h>
-#include <mach/mxsfb.h>
+#include <linux/mxsfb.h>
 
 #define REG_SET 4
 #define REG_CLR 8
@@ -750,16 +752,43 @@ static void __devexit mxsfb_free_videomem(struct mxsfb_info *host)
         }
 }
 
+static struct platform_device_id mxsfb_devtype[] = {
+        {
+                .name = "imx23-fb",
+                .driver_data = MXSFB_V3,
+        }, {
+                .name = "imx28-fb",
+                .driver_data = MXSFB_V4,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(platform, mxsfb_devtype);
+
+static const struct of_device_id mxsfb_dt_ids[] = {
+        { .compatible = "fsl,imx23-lcdif", .data = &mxsfb_devtype[0], },
+        { .compatible = "fsl,imx28-lcdif", .data = &mxsfb_devtype[1], },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxsfb_dt_ids);
+
 static int __devinit mxsfb_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                        of_match_device(mxsfb_dt_ids, &pdev->dev);
         struct mxsfb_platform_data *pdata = pdev->dev.platform_data;
         struct resource *res;
         struct mxsfb_info *host;
         struct fb_info *fb_info;
         struct fb_modelist *modelist;
         struct pinctrl *pinctrl;
+        int panel_enable;
+        enum of_gpio_flags flags;
         int i, ret;
 
+        if (of_id)
+                pdev->id_entry = of_id->data;
+
         if (!pdata) {
                 dev_err(&pdev->dev, "No platformdata. Giving up\n");
                 return -ENODEV;
@@ -807,6 +836,22 @@ static int __devinit mxsfb_probe(struct platform_device *pdev)
                 goto error_getclock;
         }
 
+        panel_enable = of_get_named_gpio_flags(pdev->dev.of_node,
+                                               "panel-enable-gpios", 0, &flags);
+        if (gpio_is_valid(panel_enable)) {
+                unsigned long f = GPIOF_OUT_INIT_HIGH;
+                if (flags == OF_GPIO_ACTIVE_LOW)
+                        f = GPIOF_OUT_INIT_LOW;
+                ret = devm_gpio_request_one(&pdev->dev, panel_enable,
+                                            f, "panel-enable");
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "failed to request gpio %d: %d\n",
+                                panel_enable, ret);
+                        goto error_panel_enable;
+                }
+        }
+
         fb_info->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
         if (!fb_info->pseudo_palette) {
                 ret = -ENOMEM;
@@ -854,6 +899,7 @@ error_register:
 error_init_fb:
         kfree(fb_info->pseudo_palette);
 error_pseudo_pallette:
+error_panel_enable:
         clk_put(host->clk);
 error_getclock:
 error_getpin:
@@ -901,19 +947,6 @@ static void mxsfb_shutdown(struct platform_device *pdev)
         writel(CTRL_RUN, host->base + LCDC_CTRL + REG_CLR);
 }
 
-static struct platform_device_id mxsfb_devtype[] = {
-        {
-                .name = "imx23-fb",
-                .driver_data = MXSFB_V3,
-        }, {
-                .name = "imx28-fb",
-                .driver_data = MXSFB_V4,
-        }, {
-                /* sentinel */
-        }
-};
-MODULE_DEVICE_TABLE(platform, mxsfb_devtype);
-
 static struct platform_driver mxsfb_driver = {
         .probe = mxsfb_probe,
         .remove = __devexit_p(mxsfb_remove),
@@ -921,6 +954,7 @@ static struct platform_driver mxsfb_driver = {
         .id_table = mxsfb_devtype,
         .driver = {
                    .name = DRIVER_NAME,
+                   .of_match_table = mxsfb_dt_ids,
         },
 };
 
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index c35a248c5e35..58bd9c27369d 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -206,8 +206,7 @@ static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
 {
         DSSDBG("pm notif %lu\n", v);
 
-        switch (v)
-        {
+        switch (v) {
         case PM_SUSPEND_PREPARE:
                 DSSDBG("suspending displays\n");
                 return dss_suspend_all_devices();
@@ -221,8 +220,7 @@ static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
         }
 }
 
-static struct notifier_block omap_dss_pm_notif_block =
-{
+static struct notifier_block omap_dss_pm_notif_block = {
         .notifier_call = omap_dss_pm_notif,
 };
 
diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c
index 5f9d8e69029e..69bf9d07c237 100644
--- a/drivers/video/s3c-fb.c
+++ b/drivers/video/s3c-fb.c
@@ -189,7 +189,7 @@ struct s3c_fb_vsync {
 
 /**
  * struct s3c_fb - overall hardware state of the hardware
- * @slock: The spinlock protection for this data sturcture.
+ * @slock: The spinlock protection for this data sturucture.
  * @dev: The device that we bound to, for printing, etc.
  * @bus_clk: The clk (hclk) feeding our interface and possibly pixclk.
  * @lcd_clk: The clk (sclk) feeding pixclk.
@@ -361,7 +361,7 @@ static int s3c_fb_calc_pixclk(struct s3c_fb *sfb, unsigned int pixclk)
         result = (unsigned int)tmp / 1000;
 
         dev_dbg(sfb->dev, "pixclk=%u, clk=%lu, div=%d (%lu)\n",
-                pixclk, clk, result, clk / result);
+                pixclk, clk, result, result ? clk / result : clk);
 
         return result;
 }
@@ -1348,8 +1348,14 @@ static void s3c_fb_clear_win(struct s3c_fb *sfb, int win)
         writel(0, regs + VIDOSD_A(win, sfb->variant));
         writel(0, regs + VIDOSD_B(win, sfb->variant));
         writel(0, regs + VIDOSD_C(win, sfb->variant));
-        reg = readl(regs + SHADOWCON);
-        writel(reg & ~SHADOWCON_WINx_PROTECT(win), regs + SHADOWCON);
+
+        if (sfb->variant.has_shadowcon) {
+                reg = readl(sfb->regs + SHADOWCON);
+                reg &= ~(SHADOWCON_WINx_PROTECT(win) |
+                        SHADOWCON_CHx_ENABLE(win) |
+                        SHADOWCON_CHx_LOCAL_ENABLE(win));
+                writel(reg, sfb->regs + SHADOWCON);
+        }
 }
 
 static int __devinit s3c_fb_probe(struct platform_device *pdev)
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index 2c80246b18b8..1d007366b917 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -84,7 +84,7 @@ static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64",
                         "S3 Virge/VX", "S3 Virge/DX", "S3 Virge/GX",
                         "S3 Virge/GX2", "S3 Virge/GX2+", "",
                         "S3 Trio3D/1X", "S3 Trio3D/2X", "S3 Trio3D/2X",
-                        "S3 Trio3D"};
+                        "S3 Trio3D", "S3 Virge/MX"};
 
 #define CHIP_UNKNOWN            0x00
 #define CHIP_732_TRIO32         0x01
@@ -105,6 +105,7 @@ static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64",
 #define CHIP_362_TRIO3D_2X      0x11
 #define CHIP_368_TRIO3D_2X      0x12
 #define CHIP_365_TRIO3D         0x13
+#define CHIP_260_VIRGE_MX       0x14
 
 #define CHIP_XXX_TRIO           0x80
 #define CHIP_XXX_TRIO64V2_DXGX  0x81
@@ -280,7 +281,8 @@ static int __devinit s3fb_setup_ddc_bus(struct fb_info *info)
          */
 /*      vga_wseq(par->state.vgabase, 0x08, 0x06); - not needed, already unlocked */
         if (par->chip == CHIP_357_VIRGE_GX2 ||
-            par->chip == CHIP_359_VIRGE_GX2P)
+            par->chip == CHIP_359_VIRGE_GX2P ||
+            par->chip == CHIP_260_VIRGE_MX)
                 svga_wseq_mask(par->state.vgabase, 0x0d, 0x01, 0x03);
         else
                 svga_wseq_mask(par->state.vgabase, 0x0d, 0x00, 0x03);
@@ -487,7 +489,8 @@ static void s3_set_pixclock(struct fb_info *info, u32 pixclock)
             par->chip == CHIP_359_VIRGE_GX2P ||
             par->chip == CHIP_360_TRIO3D_1X ||
             par->chip == CHIP_362_TRIO3D_2X ||
-            par->chip == CHIP_368_TRIO3D_2X) {
+            par->chip == CHIP_368_TRIO3D_2X ||
+            par->chip == CHIP_260_VIRGE_MX) {
                 vga_wseq(par->state.vgabase, 0x12, (n - 2) | ((r & 3) << 6));   /* n and two bits of r */
                 vga_wseq(par->state.vgabase, 0x29, r >> 2); /* remaining highest bit of r */
         } else
@@ -690,7 +693,8 @@ static int s3fb_set_par(struct fb_info *info)
             par->chip != CHIP_359_VIRGE_GX2P &&
             par->chip != CHIP_360_TRIO3D_1X &&
             par->chip != CHIP_362_TRIO3D_2X &&
-            par->chip != CHIP_368_TRIO3D_2X) {
+            par->chip != CHIP_368_TRIO3D_2X &&
+            par->chip != CHIP_260_VIRGE_MX) {
                 vga_wcrt(par->state.vgabase, 0x54, 0x18); /* M parameter */
                 vga_wcrt(par->state.vgabase, 0x60, 0xff); /* N parameter */
                 vga_wcrt(par->state.vgabase, 0x61, 0xff); /* L parameter */
@@ -739,7 +743,8 @@ static int s3fb_set_par(struct fb_info *info)
             par->chip == CHIP_368_TRIO3D_2X ||
             par->chip == CHIP_365_TRIO3D    ||
             par->chip == CHIP_375_VIRGE_DX  ||
-            par->chip == CHIP_385_VIRGE_GX) {
+            par->chip == CHIP_385_VIRGE_GX  ||
+            par->chip == CHIP_260_VIRGE_MX) {
                 dbytes = info->var.xres * ((bpp+7)/8);
                 vga_wcrt(par->state.vgabase, 0x91, (dbytes + 7) / 8);
                 vga_wcrt(par->state.vgabase, 0x90, (((dbytes + 7) / 8) >> 8) | 0x80);
@@ -751,7 +756,8 @@ static int s3fb_set_par(struct fb_info *info)
             par->chip == CHIP_359_VIRGE_GX2P ||
             par->chip == CHIP_360_TRIO3D_1X ||
             par->chip == CHIP_362_TRIO3D_2X ||
-            par->chip == CHIP_368_TRIO3D_2X)
+            par->chip == CHIP_368_TRIO3D_2X ||
+            par->chip == CHIP_260_VIRGE_MX)
                 vga_wcrt(par->state.vgabase, 0x34, 0x00);
         else    /* enable Data Transfer Position Control (DTPC) */
                 vga_wcrt(par->state.vgabase, 0x34, 0x10);
@@ -807,7 +813,8 @@ static int s3fb_set_par(struct fb_info *info)
                     par->chip == CHIP_359_VIRGE_GX2P ||
                     par->chip == CHIP_360_TRIO3D_1X ||
                     par->chip == CHIP_362_TRIO3D_2X ||
-                    par->chip == CHIP_368_TRIO3D_2X)
+                    par->chip == CHIP_368_TRIO3D_2X ||
+                    par->chip == CHIP_260_VIRGE_MX)
                         svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0xF0);
                 else {
                         svga_wcrt_mask(par->state.vgabase, 0x67, 0x10, 0xF0);
@@ -837,7 +844,8 @@ static int s3fb_set_par(struct fb_info *info)
                             par->chip != CHIP_359_VIRGE_GX2P &&
                             par->chip != CHIP_360_TRIO3D_1X &&
                             par->chip != CHIP_362_TRIO3D_2X &&
-                            par->chip != CHIP_368_TRIO3D_2X)
+                            par->chip != CHIP_368_TRIO3D_2X &&
+                            par->chip != CHIP_260_VIRGE_MX)
                                 hmul = 2;
                 }
                 break;
@@ -864,7 +872,8 @@ static int s3fb_set_par(struct fb_info *info)
                             par->chip != CHIP_359_VIRGE_GX2P &&
                             par->chip != CHIP_360_TRIO3D_1X &&
                             par->chip != CHIP_362_TRIO3D_2X &&
-                            par->chip != CHIP_368_TRIO3D_2X)
+                            par->chip != CHIP_368_TRIO3D_2X &&
+                            par->chip != CHIP_260_VIRGE_MX)
                                 hmul = 2;
                 }
                 break;
@@ -1208,7 +1217,8 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
                         break;
                 }
         } else if (par->chip == CHIP_357_VIRGE_GX2 ||
-                   par->chip == CHIP_359_VIRGE_GX2P) {
+                   par->chip == CHIP_359_VIRGE_GX2P ||
+                   par->chip == CHIP_260_VIRGE_MX) {
                 switch ((regval & 0xC0) >> 6) {
                 case 1: /* 4MB */
                         info->screen_size = 4 << 20;
@@ -1515,6 +1525,7 @@ static struct pci_device_id s3_devices[] __devinitdata = {
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A12), .driver_data = CHIP_359_VIRGE_GX2P},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A13), .driver_data = CHIP_36X_TRIO3D_1X_2X},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8904), .driver_data = CHIP_365_TRIO3D},
+        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8C01), .driver_data = CHIP_260_VIRGE_MX},
 
         {0, 0, 0, 0, 0, 0, 0}
 };
diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c
index cee7803a0a1c..0d0f52c18fd8 100644
--- a/drivers/video/savage/savagefb_driver.c
+++ b/drivers/video/savage/savagefb_driver.c
@@ -662,7 +662,7 @@ static void savage_get_default_par(struct savagefb_par *par, struct savage_reg *
         vga_out8(0x3c4, 0x18, par);
         reg->SR18 = vga_in8(0x3c5, par);
 
-        /* Save flat panel expansion regsters. */
+        /* Save flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
@@ -815,7 +815,7 @@ static void savage_set_default_par(struct savagefb_par *par,
         vga_out8(0x3c4, 0x18, par);
         vga_out8(0x3c5, reg->SR18, par);
 
-        /* Save flat panel expansion regsters. */
+        /* Save flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
@@ -1318,7 +1318,7 @@ static void savagefb_set_par_int(struct savagefb_par  *par, struct savage_reg *r
         vga_out8(0x3c4, 0x15, par);
         vga_out8(0x3c5, reg->SR15, par);
 
-        /* Restore flat panel expansion regsters. */
+        /* Restore flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
@@ -1351,7 +1351,7 @@ static void savagefb_set_par_int(struct savagefb_par  *par, struct savage_reg *r
         /* following part not present in X11 driver */
         cr67 = vga_in8(0x3d5, par) & 0xf;
         vga_out8(0x3d5, 0x50 | cr67, par);
-        udelay(10000);
+        mdelay(10);
         vga_out8(0x3d4, 0x67, par);
         /* end of part */
         vga_out8(0x3d5, reg->CR67 & ~0x0c, par);
@@ -1904,11 +1904,11 @@ static int savage_init_hw(struct savagefb_par *par)
         vga_out8(0x3d4, 0x66, par);
         cr66 = vga_in8(0x3d5, par);
         vga_out8(0x3d5, cr66 | 0x02, par);
-        udelay(10000);
+        mdelay(10);
 
         vga_out8(0x3d4, 0x66, par);
         vga_out8(0x3d5, cr66 & ~0x02, par);     /* clear reset flag */
-        udelay(10000);
+        mdelay(10);
 
 
         /*
@@ -1918,11 +1918,11 @@ static int savage_init_hw(struct savagefb_par *par)
         vga_out8(0x3d4, 0x3f, par);
         cr3f = vga_in8(0x3d5, par);
         vga_out8(0x3d5, cr3f | 0x08, par);
-        udelay(10000);
+        mdelay(10);
 
         vga_out8(0x3d4, 0x3f, par);
         vga_out8(0x3d5, cr3f & ~0x08, par);     /* clear reset flags */
-        udelay(10000);
+        mdelay(10);
 
         /* Savage ramdac speeds */
         par->numClocks = 4;
diff --git a/drivers/video/sh_mipi_dsi.c b/drivers/video/sh_mipi_dsi.c
index 4c6b84488561..3951fdae5f68 100644
--- a/drivers/video/sh_mipi_dsi.c
+++ b/drivers/video/sh_mipi_dsi.c
@@ -127,8 +127,7 @@ static void sh_mipi_shutdown(struct platform_device *pdev)
         sh_mipi_dsi_enable(mipi, false);
 }
 
-static int __init sh_mipi_setup(struct sh_mipi *mipi,
-                                struct sh_mipi_dsi_info *pdata)
+static int sh_mipi_setup(struct sh_mipi *mipi, struct sh_mipi_dsi_info *pdata)
 {
         void __iomem *base = mipi->base;
         struct sh_mobile_lcdc_chan_cfg *ch = pdata->lcd_chan;
@@ -551,7 +550,7 @@ efindslot:
         return ret;
 }
 
-static int __exit sh_mipi_remove(struct platform_device *pdev)
+static int __devexit sh_mipi_remove(struct platform_device *pdev)
 {
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         struct resource *res2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
@@ -592,7 +591,7 @@ static int __exit sh_mipi_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver sh_mipi_driver = {
-        .remove         = __exit_p(sh_mipi_remove),
+        .remove         = __devexit_p(sh_mipi_remove),
         .shutdown       = sh_mipi_shutdown,
         .driver = {
                 .name   = "sh-mipi-dsi",
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index e672698bd820..699487c287b2 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -12,6 +12,7 @@
 #include <linux/backlight.h>
 #include <linux/clk.h>
 #include <linux/console.h>
+#include <linux/ctype.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
 #include <linux/gpio.h>
@@ -32,12 +33,176 @@
 
 #include "sh_mobile_lcdcfb.h"
 
+/* ----------------------------------------------------------------------------
+ * Overlay register definitions
+ */
+
+#define LDBCR                   0xb00
+#define LDBCR_UPC(n)            (1 << ((n) + 16))
+#define LDBCR_UPF(n)            (1 << ((n) + 8))
+#define LDBCR_UPD(n)            (1 << ((n) + 0))
+#define LDBnBSIFR(n)            (0xb20 + (n) * 0x20 + 0x00)
+#define LDBBSIFR_EN             (1 << 31)
+#define LDBBSIFR_VS             (1 << 29)
+#define LDBBSIFR_BRSEL          (1 << 28)
+#define LDBBSIFR_MX             (1 << 27)
+#define LDBBSIFR_MY             (1 << 26)
+#define LDBBSIFR_CV3            (3 << 24)
+#define LDBBSIFR_CV2            (2 << 24)
+#define LDBBSIFR_CV1            (1 << 24)
+#define LDBBSIFR_CV0            (0 << 24)
+#define LDBBSIFR_CV_MASK        (3 << 24)
+#define LDBBSIFR_LAY_MASK       (0xff << 16)
+#define LDBBSIFR_LAY_SHIFT      16
+#define LDBBSIFR_ROP3_MASK      (0xff << 16)
+#define LDBBSIFR_ROP3_SHIFT     16
+#define LDBBSIFR_AL_PL8         (3 << 14)
+#define LDBBSIFR_AL_PL1         (2 << 14)
+#define LDBBSIFR_AL_PK          (1 << 14)
+#define LDBBSIFR_AL_1           (0 << 14)
+#define LDBBSIFR_AL_MASK        (3 << 14)
+#define LDBBSIFR_SWPL           (1 << 10)
+#define LDBBSIFR_SWPW           (1 << 9)
+#define LDBBSIFR_SWPB           (1 << 8)
+#define LDBBSIFR_RY             (1 << 7)
+#define LDBBSIFR_CHRR_420       (2 << 0)
+#define LDBBSIFR_CHRR_422       (1 << 0)
+#define LDBBSIFR_CHRR_444       (0 << 0)
+#define LDBBSIFR_RPKF_ARGB32    (0x00 << 0)
+#define LDBBSIFR_RPKF_RGB16     (0x03 << 0)
+#define LDBBSIFR_RPKF_RGB24     (0x0b << 0)
+#define LDBBSIFR_RPKF_MASK      (0x1f << 0)
+#define LDBnBSSZR(n)            (0xb20 + (n) * 0x20 + 0x04)
+#define LDBBSSZR_BVSS_MASK      (0xfff << 16)
+#define LDBBSSZR_BVSS_SHIFT     16
+#define LDBBSSZR_BHSS_MASK      (0xfff << 0)
+#define LDBBSSZR_BHSS_SHIFT     0
+#define LDBnBLOCR(n)            (0xb20 + (n) * 0x20 + 0x08)
+#define LDBBLOCR_CVLC_MASK      (0xfff << 16)
+#define LDBBLOCR_CVLC_SHIFT     16
+#define LDBBLOCR_CHLC_MASK      (0xfff << 0)
+#define LDBBLOCR_CHLC_SHIFT     0
+#define LDBnBSMWR(n)            (0xb20 + (n) * 0x20 + 0x0c)
+#define LDBBSMWR_BSMWA_MASK     (0xffff << 16)
+#define LDBBSMWR_BSMWA_SHIFT    16
+#define LDBBSMWR_BSMW_MASK      (0xffff << 0)
+#define LDBBSMWR_BSMW_SHIFT     0
+#define LDBnBSAYR(n)            (0xb20 + (n) * 0x20 + 0x10)
+#define LDBBSAYR_FG1A_MASK      (0xff << 24)
+#define LDBBSAYR_FG1A_SHIFT     24
+#define LDBBSAYR_FG1R_MASK      (0xff << 16)
+#define LDBBSAYR_FG1R_SHIFT     16
+#define LDBBSAYR_FG1G_MASK      (0xff << 8)
+#define LDBBSAYR_FG1G_SHIFT     8
+#define LDBBSAYR_FG1B_MASK      (0xff << 0)
+#define LDBBSAYR_FG1B_SHIFT     0
+#define LDBnBSACR(n)            (0xb20 + (n) * 0x20 + 0x14)
+#define LDBBSACR_FG2A_MASK      (0xff << 24)
+#define LDBBSACR_FG2A_SHIFT     24
+#define LDBBSACR_FG2R_MASK      (0xff << 16)
+#define LDBBSACR_FG2R_SHIFT     16
+#define LDBBSACR_FG2G_MASK      (0xff << 8)
+#define LDBBSACR_FG2G_SHIFT     8
+#define LDBBSACR_FG2B_MASK      (0xff << 0)
+#define LDBBSACR_FG2B_SHIFT     0
+#define LDBnBSAAR(n)            (0xb20 + (n) * 0x20 + 0x18)
+#define LDBBSAAR_AP_MASK        (0xff << 24)
+#define LDBBSAAR_AP_SHIFT       24
+#define LDBBSAAR_R_MASK         (0xff << 16)
+#define LDBBSAAR_R_SHIFT        16
+#define LDBBSAAR_GY_MASK        (0xff << 8)
+#define LDBBSAAR_GY_SHIFT       8
+#define LDBBSAAR_B_MASK         (0xff << 0)
+#define LDBBSAAR_B_SHIFT        0
+#define LDBnBPPCR(n)            (0xb20 + (n) * 0x20 + 0x1c)
+#define LDBBPPCR_AP_MASK        (0xff << 24)
+#define LDBBPPCR_AP_SHIFT       24
+#define LDBBPPCR_R_MASK         (0xff << 16)
+#define LDBBPPCR_R_SHIFT        16
+#define LDBBPPCR_GY_MASK        (0xff << 8)
+#define LDBBPPCR_GY_SHIFT       8
+#define LDBBPPCR_B_MASK         (0xff << 0)
+#define LDBBPPCR_B_SHIFT        0
+#define LDBnBBGCL(n)            (0xb10 + (n) * 0x04)
+#define LDBBBGCL_BGA_MASK       (0xff << 24)
+#define LDBBBGCL_BGA_SHIFT      24
+#define LDBBBGCL_BGR_MASK       (0xff << 16)
+#define LDBBBGCL_BGR_SHIFT      16
+#define LDBBBGCL_BGG_MASK       (0xff << 8)
+#define LDBBBGCL_BGG_SHIFT      8
+#define LDBBBGCL_BGB_MASK       (0xff << 0)
+#define LDBBBGCL_BGB_SHIFT      0
+
 #define SIDE_B_OFFSET 0x1000
 #define MIRROR_OFFSET 0x2000
 
 #define MAX_XRES 1920
 #define MAX_YRES 1080
 
+enum sh_mobile_lcdc_overlay_mode {
+        LCDC_OVERLAY_BLEND,
+        LCDC_OVERLAY_ROP3,
+};
+
+/*
+ * struct sh_mobile_lcdc_overlay - LCDC display overlay
+ *
+ * @channel: LCDC channel this overlay belongs to
+ * @cfg: Overlay configuration
+ * @info: Frame buffer device
+ * @index: Overlay index (0-3)
+ * @base: Overlay registers base address
+ * @enabled: True if the overlay is enabled
+ * @mode: Overlay blending mode (alpha blend or ROP3)
+ * @alpha: Global alpha blending value (0-255, for alpha blending mode)
+ * @rop3: Raster operation (for ROP3 mode)
+ * @fb_mem: Frame buffer virtual memory address
+ * @fb_size: Frame buffer size in bytes
+ * @dma_handle: Frame buffer DMA address
+ * @base_addr_y: Overlay base address (RGB or luma component)
+ * @base_addr_c: Overlay base address (chroma component)
+ * @pan_y_offset: Panning linear offset in bytes (luma component)
+ * @format: Current pixelf format
+ * @xres: Horizontal visible resolution
+ * @xres_virtual: Horizontal total resolution
+ * @yres: Vertical visible resolution
+ * @yres_virtual: Vertical total resolution
+ * @pitch: Overlay line pitch
+ * @pos_x: Horizontal overlay position
+ * @pos_y: Vertical overlay position
+ */
+struct sh_mobile_lcdc_overlay {
+        struct sh_mobile_lcdc_chan *channel;
+
+        const struct sh_mobile_lcdc_overlay_cfg *cfg;
+        struct fb_info *info;
+
+        unsigned int index;
+        unsigned long base;
+
+        bool enabled;
+        enum sh_mobile_lcdc_overlay_mode mode;
+        unsigned int alpha;
+        unsigned int rop3;
+
+        void *fb_mem;
+        unsigned long fb_size;
+
+        dma_addr_t dma_handle;
+        unsigned long base_addr_y;
+        unsigned long base_addr_c;
+        unsigned long pan_y_offset;
+
+        const struct sh_mobile_lcdc_format_info *format;
+        unsigned int xres;
+        unsigned int xres_virtual;
+        unsigned int yres;
+        unsigned int yres_virtual;
+        unsigned int pitch;
+        int pos_x;
+        int pos_y;
+};
+
 struct sh_mobile_lcdc_priv {
         void __iomem *base;
         int irq;
@@ -45,7 +210,10 @@ struct sh_mobile_lcdc_priv {
         struct device *dev;
         struct clk *dot_clk;
         unsigned long lddckr;
+
         struct sh_mobile_lcdc_chan ch[2];
+        struct sh_mobile_lcdc_overlay overlays[4];
+
         struct notifier_block notifier;
         int started;
         int forced_fourcc; /* 2 channel LCDC must share fourcc setting */
@@ -141,6 +309,13 @@ static unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan *chan,
         return ioread32(chan->lcdc->base + chan->reg_offs[reg_nr]);
 }
 
+static void lcdc_write_overlay(struct sh_mobile_lcdc_overlay *ovl,
+                               int reg, unsigned long data)
+{
+        iowrite32(data, ovl->channel->lcdc->base + reg);
+        iowrite32(data, ovl->channel->lcdc->base + reg + SIDE_B_OFFSET);
+}
+
 static void lcdc_write(struct sh_mobile_lcdc_priv *priv,
                        unsigned long reg_offs, unsigned long data)
 {
@@ -384,8 +559,8 @@ sh_mobile_lcdc_must_reconfigure(struct sh_mobile_lcdc_chan *ch,
         return true;
 }
 
-static int sh_mobile_check_var(struct fb_var_screeninfo *var,
-                               struct fb_info *info);
+static int sh_mobile_lcdc_check_var(struct fb_var_screeninfo *var,
+                                    struct fb_info *info);
 
 static int sh_mobile_lcdc_display_notify(struct sh_mobile_lcdc_chan *ch,
                                          enum sh_mobile_lcdc_entity_event event,
@@ -439,7 +614,7 @@ static int sh_mobile_lcdc_display_notify(struct sh_mobile_lcdc_chan *ch,
                 fb_videomode_to_var(&var, mode);
                 var.bits_per_pixel = info->var.bits_per_pixel;
                 var.grayscale = info->var.grayscale;
-                ret = sh_mobile_check_var(&var, info);
+                ret = sh_mobile_lcdc_check_var(&var, info);
                 break;
         }
 
@@ -585,7 +760,7 @@ static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static int sh_mobile_wait_for_vsync(struct sh_mobile_lcdc_chan *ch)
+static int sh_mobile_lcdc_wait_for_vsync(struct sh_mobile_lcdc_chan *ch)
 {
         unsigned long ldintr;
         int ret;
@@ -685,8 +860,98 @@ static void sh_mobile_lcdc_geometry(struct sh_mobile_lcdc_chan *ch)
         lcdc_write_chan(ch, LDHAJR, tmp);
 }
 
+static void sh_mobile_lcdc_overlay_setup(struct sh_mobile_lcdc_overlay *ovl)
+{
+        u32 format = 0;
+
+        if (!ovl->enabled) {
+                lcdc_write(ovl->channel->lcdc, LDBCR, LDBCR_UPC(ovl->index));
+                lcdc_write_overlay(ovl, LDBnBSIFR(ovl->index), 0);
+                lcdc_write(ovl->channel->lcdc, LDBCR,
+                           LDBCR_UPF(ovl->index) | LDBCR_UPD(ovl->index));
+                return;
+        }
+
+        ovl->base_addr_y = ovl->dma_handle;
+        ovl->base_addr_c = ovl->dma_handle
+                         + ovl->xres_virtual * ovl->yres_virtual;
+
+        switch (ovl->mode) {
+        case LCDC_OVERLAY_BLEND:
+                format = LDBBSIFR_EN | (ovl->alpha << LDBBSIFR_LAY_SHIFT);
+                break;
+
+        case LCDC_OVERLAY_ROP3:
+                format = LDBBSIFR_EN | LDBBSIFR_BRSEL
+                       | (ovl->rop3 << LDBBSIFR_ROP3_SHIFT);
+                break;
+        }
+
+        switch (ovl->format->fourcc) {
+        case V4L2_PIX_FMT_RGB565:
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV61:
+        case V4L2_PIX_FMT_NV42:
+                format |= LDBBSIFR_SWPL | LDBBSIFR_SWPW;
+                break;
+        case V4L2_PIX_FMT_BGR24:
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV24:
+                format |= LDBBSIFR_SWPL | LDBBSIFR_SWPW | LDBBSIFR_SWPB;
+                break;
+        case V4L2_PIX_FMT_BGR32:
+        default:
+                format |= LDBBSIFR_SWPL;
+                break;
+        }
+
+        switch (ovl->format->fourcc) {
+        case V4L2_PIX_FMT_RGB565:
+                format |= LDBBSIFR_AL_1 | LDBBSIFR_RY | LDBBSIFR_RPKF_RGB16;
+                break;
+        case V4L2_PIX_FMT_BGR24:
+                format |= LDBBSIFR_AL_1 | LDBBSIFR_RY | LDBBSIFR_RPKF_RGB24;
+                break;
+        case V4L2_PIX_FMT_BGR32:
+                format |= LDBBSIFR_AL_PK | LDBBSIFR_RY | LDDFR_PKF_ARGB32;
+                break;
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
+                format |= LDBBSIFR_AL_1 | LDBBSIFR_CHRR_420;
+                break;
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV61:
+                format |= LDBBSIFR_AL_1 | LDBBSIFR_CHRR_422;
+                break;
+        case V4L2_PIX_FMT_NV24:
+        case V4L2_PIX_FMT_NV42:
+                format |= LDBBSIFR_AL_1 | LDBBSIFR_CHRR_444;
+                break;
+        }
+
+        lcdc_write(ovl->channel->lcdc, LDBCR, LDBCR_UPC(ovl->index));
+
+        lcdc_write_overlay(ovl, LDBnBSIFR(ovl->index), format);
+
+        lcdc_write_overlay(ovl, LDBnBSSZR(ovl->index),
+                (ovl->yres << LDBBSSZR_BVSS_SHIFT) |
+                (ovl->xres << LDBBSSZR_BHSS_SHIFT));
+        lcdc_write_overlay(ovl, LDBnBLOCR(ovl->index),
+                (ovl->pos_y << LDBBLOCR_CVLC_SHIFT) |
+                (ovl->pos_x << LDBBLOCR_CHLC_SHIFT));
+        lcdc_write_overlay(ovl, LDBnBSMWR(ovl->index),
+                ovl->pitch << LDBBSMWR_BSMW_SHIFT);
+
+        lcdc_write_overlay(ovl, LDBnBSAYR(ovl->index), ovl->base_addr_y);
+        lcdc_write_overlay(ovl, LDBnBSACR(ovl->index), ovl->base_addr_c);
+
+        lcdc_write(ovl->channel->lcdc, LDBCR,
+                   LDBCR_UPF(ovl->index) | LDBCR_UPD(ovl->index));
+}
+
 /*
- * __sh_mobile_lcdc_start - Configure and tart the LCDC
+ * __sh_mobile_lcdc_start - Configure and start the LCDC
  * @priv: LCDC device
  *
  * Configure all enabled channels and start the LCDC device. All external
@@ -839,27 +1104,25 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
         /* Compute frame buffer base address and pitch for each channel. */
         for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
                 int pixelformat;
-                void *meram;
+                void *cache;
 
                 ch = &priv->ch[k];
                 if (!ch->enabled)
                         continue;
 
                 ch->base_addr_y = ch->dma_handle;
-                ch->base_addr_c = ch->base_addr_y + ch->xres * ch->yres_virtual;
+                ch->base_addr_c = ch->dma_handle
+                                + ch->xres_virtual * ch->yres_virtual;
                 ch->line_size = ch->pitch;
 
                 /* Enable MERAM if possible. */
-                if (mdev == NULL || mdev->ops == NULL ||
-                    ch->cfg->meram_cfg == NULL)
+                if (mdev == NULL || ch->cfg->meram_cfg == NULL)
                         continue;
 
-                /* we need to de-init configured ICBs before we can
-                 * re-initialize them.
-                 */
-                if (ch->meram) {
-                        mdev->ops->meram_unregister(mdev, ch->meram);
-                        ch->meram = NULL;
+                /* Free the allocated MERAM cache. */
+                if (ch->cache) {
+                        sh_mobile_meram_cache_free(mdev, ch->cache);
+                        ch->cache = NULL;
                 }
 
                 switch (ch->format->fourcc) {
@@ -881,17 +1144,22 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
                         break;
                 }
 
-                meram = mdev->ops->meram_register(mdev, ch->cfg->meram_cfg,
+                cache = sh_mobile_meram_cache_alloc(mdev, ch->cfg->meram_cfg,
                                         ch->pitch, ch->yres, pixelformat,
                                         &ch->line_size);
-                if (!IS_ERR(meram)) {
-                        mdev->ops->meram_update(mdev, meram,
+                if (!IS_ERR(cache)) {
+                        sh_mobile_meram_cache_update(mdev, cache,
                                         ch->base_addr_y, ch->base_addr_c,
                                         &ch->base_addr_y, &ch->base_addr_c);
-                        ch->meram = meram;
+                        ch->cache = cache;
                 }
         }
 
+        for (k = 0; k < ARRAY_SIZE(priv->overlays); ++k) {
+                struct sh_mobile_lcdc_overlay *ovl = &priv->overlays[k];
+                sh_mobile_lcdc_overlay_setup(ovl);
+        }
+
         /* Start the LCDC. */
         __sh_mobile_lcdc_start(priv);
 
@@ -953,12 +1221,10 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
 
                 sh_mobile_lcdc_display_off(ch);
 
-                /* disable the meram */
-                if (ch->meram) {
-                        struct sh_mobile_meram_info *mdev;
-                        mdev = priv->meram_dev;
-                        mdev->ops->meram_unregister(mdev, ch->meram);
-                        ch->meram = 0;
+                /* Free the MERAM cache. */
+                if (ch->cache) {
+                        sh_mobile_meram_cache_free(priv->meram_dev, ch->cache);
+                        ch->cache = 0;
                 }
 
         }
@@ -975,8 +1241,511 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
                         sh_mobile_lcdc_clk_off(priv);
 }
 
+static int __sh_mobile_lcdc_check_var(struct fb_var_screeninfo *var,
+                                      struct fb_info *info)
+{
+        if (var->xres > MAX_XRES || var->yres > MAX_YRES)
+                return -EINVAL;
+
+        /* Make sure the virtual resolution is at least as big as the visible
+         * resolution.
+         */
+        if (var->xres_virtual < var->xres)
+                var->xres_virtual = var->xres;
+        if (var->yres_virtual < var->yres)
+                var->yres_virtual = var->yres;
+
+        if (sh_mobile_format_is_fourcc(var)) {
+                const struct sh_mobile_lcdc_format_info *format;
+
+                format = sh_mobile_format_info(var->grayscale);
+                if (format == NULL)
+                        return -EINVAL;
+                var->bits_per_pixel = format->bpp;
+
+                /* Default to RGB and JPEG color-spaces for RGB and YUV formats
+                 * respectively.
+                 */
+                if (!format->yuv)
+                        var->colorspace = V4L2_COLORSPACE_SRGB;
+                else if (var->colorspace != V4L2_COLORSPACE_REC709)
+                        var->colorspace = V4L2_COLORSPACE_JPEG;
+        } else {
+                if (var->bits_per_pixel <= 16) {                /* RGB 565 */
+                        var->bits_per_pixel = 16;
+                        var->red.offset = 11;
+                        var->red.length = 5;
+                        var->green.offset = 5;
+                        var->green.length = 6;
+                        var->blue.offset = 0;
+                        var->blue.length = 5;
+                        var->transp.offset = 0;
+                        var->transp.length = 0;
+                } else if (var->bits_per_pixel <= 24) {         /* RGB 888 */
+                        var->bits_per_pixel = 24;
+                        var->red.offset = 16;
+                        var->red.length = 8;
+                        var->green.offset = 8;
+                        var->green.length = 8;
+                        var->blue.offset = 0;
+                        var->blue.length = 8;
+                        var->transp.offset = 0;
+                        var->transp.length = 0;
+                } else if (var->bits_per_pixel <= 32) {         /* RGBA 888 */
+                        var->bits_per_pixel = 32;
+                        var->red.offset = 16;
+                        var->red.length = 8;
+                        var->green.offset = 8;
+                        var->green.length = 8;
+                        var->blue.offset = 0;
+                        var->blue.length = 8;
+                        var->transp.offset = 24;
+                        var->transp.length = 8;
+                } else
+                        return -EINVAL;
+
+                var->red.msb_right = 0;
+                var->green.msb_right = 0;
+                var->blue.msb_right = 0;
+                var->transp.msb_right = 0;
+        }
+
+        /* Make sure we don't exceed our allocated memory. */
+        if (var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8 >
+            info->fix.smem_len)
+                return -EINVAL;
+
+        return 0;
+}
+
 /* -----------------------------------------------------------------------------
- * Frame buffer operations
+ * Frame buffer operations - Overlays
+ */
+
+static ssize_t
+overlay_alpha_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        return scnprintf(buf, PAGE_SIZE, "%u\n", ovl->alpha);
+}
+
+static ssize_t
+overlay_alpha_store(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+        unsigned int alpha;
+        char *endp;
+
+        alpha = simple_strtoul(buf, &endp, 10);
+        if (isspace(*endp))
+                endp++;
+
+        if (endp - buf != count)
+                return -EINVAL;
+
+        if (alpha > 255)
+                return -EINVAL;
+
+        if (ovl->alpha != alpha) {
+                ovl->alpha = alpha;
+
+                if (ovl->mode == LCDC_OVERLAY_BLEND && ovl->enabled)
+                        sh_mobile_lcdc_overlay_setup(ovl);
+        }
+
+        return count;
+}
+
+static ssize_t
+overlay_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        return scnprintf(buf, PAGE_SIZE, "%u\n", ovl->mode);
+}
+
+static ssize_t
+overlay_mode_store(struct device *dev, struct device_attribute *attr,
+                   const char *buf, size_t count)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+        unsigned int mode;
+        char *endp;
+
+        mode = simple_strtoul(buf, &endp, 10);
+        if (isspace(*endp))
+                endp++;
+
+        if (endp - buf != count)
+                return -EINVAL;
+
+        if (mode != LCDC_OVERLAY_BLEND && mode != LCDC_OVERLAY_ROP3)
+                return -EINVAL;
+
+        if (ovl->mode != mode) {
+                ovl->mode = mode;
+
+                if (ovl->enabled)
+                        sh_mobile_lcdc_overlay_setup(ovl);
+        }
+
+        return count;
+}
+
+static ssize_t
+overlay_position_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        return scnprintf(buf, PAGE_SIZE, "%d,%d\n", ovl->pos_x, ovl->pos_y);
+}
+
+static ssize_t
+overlay_position_store(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+        char *endp;
+        int pos_x;
+        int pos_y;
+
+        pos_x = simple_strtol(buf, &endp, 10);
+        if (*endp != ',')
+                return -EINVAL;
+
+        pos_y = simple_strtol(endp + 1, &endp, 10);
+        if (isspace(*endp))
+                endp++;
+
+        if (endp - buf != count)
+                return -EINVAL;
+
+        if (ovl->pos_x != pos_x || ovl->pos_y != pos_y) {
+                ovl->pos_x = pos_x;
+                ovl->pos_y = pos_y;
+
+                if (ovl->enabled)
+                        sh_mobile_lcdc_overlay_setup(ovl);
+        }
+
+        return count;
+}
+
+static ssize_t
+overlay_rop3_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        return scnprintf(buf, PAGE_SIZE, "%u\n", ovl->rop3);
+}
+
+static ssize_t
+overlay_rop3_store(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+        unsigned int rop3;
+        char *endp;
+
+        rop3 = !!simple_strtoul(buf, &endp, 10);
+        if (isspace(*endp))
+                endp++;
+
+        if (endp - buf != count)
+                return -EINVAL;
+
+        if (rop3 > 255)
+                return -EINVAL;
+
+        if (ovl->rop3 != rop3) {
+                ovl->rop3 = rop3;
+
+                if (ovl->mode == LCDC_OVERLAY_ROP3 && ovl->enabled)
+                        sh_mobile_lcdc_overlay_setup(ovl);
+        }
+
+        return count;
+}
+
+static const struct device_attribute overlay_sysfs_attrs[] = {
+        __ATTR(ovl_alpha, S_IRUGO|S_IWUSR,
+               overlay_alpha_show, overlay_alpha_store),
+        __ATTR(ovl_mode, S_IRUGO|S_IWUSR,
+               overlay_mode_show, overlay_mode_store),
+        __ATTR(ovl_position, S_IRUGO|S_IWUSR,
+               overlay_position_show, overlay_position_store),
+        __ATTR(ovl_rop3, S_IRUGO|S_IWUSR,
+               overlay_rop3_show, overlay_rop3_store),
+};
+
+static const struct fb_fix_screeninfo sh_mobile_lcdc_overlay_fix  = {
+        .id =           "SH Mobile LCDC",
+        .type =         FB_TYPE_PACKED_PIXELS,
+        .visual =       FB_VISUAL_TRUECOLOR,
+        .accel =        FB_ACCEL_NONE,
+        .xpanstep =     1,
+        .ypanstep =     1,
+        .ywrapstep =    0,
+        .capabilities = FB_CAP_FOURCC,
+};
+
+static int sh_mobile_lcdc_overlay_pan(struct fb_var_screeninfo *var,
+                                    struct fb_info *info)
+{
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+        unsigned long base_addr_y;
+        unsigned long base_addr_c;
+        unsigned long y_offset;
+        unsigned long c_offset;
+
+        if (!ovl->format->yuv) {
+                y_offset = (var->yoffset * ovl->xres_virtual + var->xoffset)
+                         * ovl->format->bpp / 8;
+                c_offset = 0;
+        } else {
+                unsigned int xsub = ovl->format->bpp < 24 ? 2 : 1;
+                unsigned int ysub = ovl->format->bpp < 16 ? 2 : 1;
+
+                y_offset = var->yoffset * ovl->xres_virtual + var->xoffset;
+                c_offset = var->yoffset / ysub * ovl->xres_virtual * 2 / xsub
+                         + var->xoffset * 2 / xsub;
+        }
+
+        /* If the Y offset hasn't changed, the C offset hasn't either. There's
+         * nothing to do in that case.
+         */
+        if (y_offset == ovl->pan_y_offset)
+                return 0;
+
+        /* Set the source address for the next refresh */
+        base_addr_y = ovl->dma_handle + y_offset;
+        base_addr_c = ovl->dma_handle + ovl->xres_virtual * ovl->yres_virtual
+                    + c_offset;
+
+        ovl->base_addr_y = base_addr_y;
+        ovl->base_addr_c = base_addr_c;
+        ovl->pan_y_offset = y_offset;
+
+        lcdc_write(ovl->channel->lcdc, LDBCR, LDBCR_UPC(ovl->index));
+
+        lcdc_write_overlay(ovl, LDBnBSAYR(ovl->index), ovl->base_addr_y);
+        lcdc_write_overlay(ovl, LDBnBSACR(ovl->index), ovl->base_addr_c);
+
+        lcdc_write(ovl->channel->lcdc, LDBCR,
+                   LDBCR_UPF(ovl->index) | LDBCR_UPD(ovl->index));
+
+        return 0;
+}
+
+static int sh_mobile_lcdc_overlay_ioctl(struct fb_info *info, unsigned int cmd,
+                                      unsigned long arg)
+{
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        switch (cmd) {
+        case FBIO_WAITFORVSYNC:
+                return sh_mobile_lcdc_wait_for_vsync(ovl->channel);
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
+static int sh_mobile_lcdc_overlay_check_var(struct fb_var_screeninfo *var,
+                                          struct fb_info *info)
+{
+        return __sh_mobile_lcdc_check_var(var, info);
+}
+
+static int sh_mobile_lcdc_overlay_set_par(struct fb_info *info)
+{
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        ovl->format =
+                sh_mobile_format_info(sh_mobile_format_fourcc(&info->var));
+
+        ovl->xres = info->var.xres;
+        ovl->xres_virtual = info->var.xres_virtual;
+        ovl->yres = info->var.yres;
+        ovl->yres_virtual = info->var.yres_virtual;
+
+        if (ovl->format->yuv)
+                ovl->pitch = info->var.xres_virtual;
+        else
+                ovl->pitch = info->var.xres_virtual * ovl->format->bpp / 8;
+
+        sh_mobile_lcdc_overlay_setup(ovl);
+
+        info->fix.line_length = ovl->pitch;
+
+        if (sh_mobile_format_is_fourcc(&info->var)) {
+                info->fix.type = FB_TYPE_FOURCC;
+                info->fix.visual = FB_VISUAL_FOURCC;
+        } else {
+                info->fix.type = FB_TYPE_PACKED_PIXELS;
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+        }
+
+        return 0;
+}
+
+/* Overlay blanking. Disable the overlay when blanked. */
+static int sh_mobile_lcdc_overlay_blank(int blank, struct fb_info *info)
+{
+        struct sh_mobile_lcdc_overlay *ovl = info->par;
+
+        ovl->enabled = !blank;
+        sh_mobile_lcdc_overlay_setup(ovl);
+
+        /* Prevent the backlight from receiving a blanking event by returning
+         * a non-zero value.
+         */
+        return 1;
+}
+
+static struct fb_ops sh_mobile_lcdc_overlay_ops = {
+        .owner          = THIS_MODULE,
+        .fb_read        = fb_sys_read,
+        .fb_write       = fb_sys_write,
+        .fb_fillrect    = sys_fillrect,
+        .fb_copyarea    = sys_copyarea,
+        .fb_imageblit   = sys_imageblit,
+        .fb_blank       = sh_mobile_lcdc_overlay_blank,
+        .fb_pan_display = sh_mobile_lcdc_overlay_pan,
+        .fb_ioctl       = sh_mobile_lcdc_overlay_ioctl,
+        .fb_check_var   = sh_mobile_lcdc_overlay_check_var,
+        .fb_set_par     = sh_mobile_lcdc_overlay_set_par,
+};
+
+static void
+sh_mobile_lcdc_overlay_fb_unregister(struct sh_mobile_lcdc_overlay *ovl)
+{
+        struct fb_info *info = ovl->info;
+
+        if (info == NULL || info->dev == NULL)
+                return;
+
+        unregister_framebuffer(ovl->info);
+}
+
+static int __devinit
+sh_mobile_lcdc_overlay_fb_register(struct sh_mobile_lcdc_overlay *ovl)
+{
+        struct sh_mobile_lcdc_priv *lcdc = ovl->channel->lcdc;
+        struct fb_info *info = ovl->info;
+        unsigned int i;
+        int ret;
+
+        if (info == NULL)
+                return 0;
+
+        ret = register_framebuffer(info);
+        if (ret < 0)
+                return ret;
+
+        dev_info(lcdc->dev, "registered %s/overlay %u as %dx%d %dbpp.\n",
+                 dev_name(lcdc->dev), ovl->index, info->var.xres,
+                 info->var.yres, info->var.bits_per_pixel);
+
+        for (i = 0; i < ARRAY_SIZE(overlay_sysfs_attrs); ++i) {
+                ret = device_create_file(info->dev, &overlay_sysfs_attrs[i]);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void
+sh_mobile_lcdc_overlay_fb_cleanup(struct sh_mobile_lcdc_overlay *ovl)
+{
+        struct fb_info *info = ovl->info;
+
+        if (info == NULL || info->device == NULL)
+                return;
+
+        framebuffer_release(info);
+}
+
+static int __devinit
+sh_mobile_lcdc_overlay_fb_init(struct sh_mobile_lcdc_overlay *ovl)
+{
+        struct sh_mobile_lcdc_priv *priv = ovl->channel->lcdc;
+        struct fb_var_screeninfo *var;
+        struct fb_info *info;
+
+        /* Allocate and initialize the frame buffer device. */
+        info = framebuffer_alloc(0, priv->dev);
+        if (info == NULL) {
+                dev_err(priv->dev, "unable to allocate fb_info\n");
+                return -ENOMEM;
+        }
+
+        ovl->info = info;
+
+        info->flags = FBINFO_FLAG_DEFAULT;
+        info->fbops = &sh_mobile_lcdc_overlay_ops;
+        info->device = priv->dev;
+        info->screen_base = ovl->fb_mem;
+        info->par = ovl;
+
+        /* Initialize fixed screen information. Restrict pan to 2 lines steps
+         * for NV12 and NV21.
+         */
+        info->fix = sh_mobile_lcdc_overlay_fix;
+        snprintf(info->fix.id, sizeof(info->fix.id),
+                 "SH Mobile LCDC Overlay %u", ovl->index);
+        info->fix.smem_start = ovl->dma_handle;
+        info->fix.smem_len = ovl->fb_size;
+        info->fix.line_length = ovl->pitch;
+
+        if (ovl->format->yuv)
+                info->fix.visual = FB_VISUAL_FOURCC;
+        else
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+
+        switch (ovl->format->fourcc) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
+                info->fix.ypanstep = 2;
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV61:
+                info->fix.xpanstep = 2;
+        }
+
+        /* Initialize variable screen information. */
+        var = &info->var;
+        memset(var, 0, sizeof(*var));
+        var->xres = ovl->xres;
+        var->yres = ovl->yres;
+        var->xres_virtual = ovl->xres_virtual;
+        var->yres_virtual = ovl->yres_virtual;
+        var->activate = FB_ACTIVATE_NOW;
+
+        /* Use the legacy API by default for RGB formats, and the FOURCC API
+         * for YUV formats.
+         */
+        if (!ovl->format->yuv)
+                var->bits_per_pixel = ovl->format->bpp;
+        else
+                var->grayscale = ovl->format->fourcc;
+
+        return sh_mobile_lcdc_overlay_check_var(var, info);
+}
+
+/* -----------------------------------------------------------------------------
+ * Frame buffer operations - main frame buffer
  */
 
 static int sh_mobile_lcdc_setcolreg(u_int regno,
@@ -1003,12 +1772,12 @@ static int sh_mobile_lcdc_setcolreg(u_int regno,
         return 0;
 }
 
-static struct fb_fix_screeninfo sh_mobile_lcdc_fix  = {
+static const struct fb_fix_screeninfo sh_mobile_lcdc_fix  = {
         .id =           "SH Mobile LCDC",
         .type =         FB_TYPE_PACKED_PIXELS,
         .visual =       FB_VISUAL_TRUECOLOR,
         .accel =        FB_ACCEL_NONE,
-        .xpanstep =     0,
+        .xpanstep =     1,
         .ypanstep =     1,
         .ywrapstep =    0,
         .capabilities = FB_CAP_FOURCC,
@@ -1035,78 +1804,74 @@ static void sh_mobile_lcdc_imageblit(struct fb_info *info,
         sh_mobile_lcdc_deferred_io_touch(info);
 }
 
-static int sh_mobile_fb_pan_display(struct fb_var_screeninfo *var,
-                                     struct fb_info *info)
+static int sh_mobile_lcdc_pan(struct fb_var_screeninfo *var,
+                              struct fb_info *info)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
         struct sh_mobile_lcdc_priv *priv = ch->lcdc;
         unsigned long ldrcntr;
-        unsigned long new_pan_offset;
         unsigned long base_addr_y, base_addr_c;
+        unsigned long y_offset;
         unsigned long c_offset;
 
-        if (!ch->format->yuv)
-                new_pan_offset = var->yoffset * ch->pitch
-                               + var->xoffset * (ch->format->bpp / 8);
-        else
-                new_pan_offset = var->yoffset * ch->pitch + var->xoffset;
+        if (!ch->format->yuv) {
+                y_offset = (var->yoffset * ch->xres_virtual + var->xoffset)
+                         * ch->format->bpp / 8;
+                c_offset = 0;
+        } else {
+                unsigned int xsub = ch->format->bpp < 24 ? 2 : 1;
+                unsigned int ysub = ch->format->bpp < 16 ? 2 : 1;
 
-        if (new_pan_offset == ch->pan_offset)
-                return 0;       /* No change, do nothing */
+                y_offset = var->yoffset * ch->xres_virtual + var->xoffset;
+                c_offset = var->yoffset / ysub * ch->xres_virtual * 2 / xsub
+                         + var->xoffset * 2 / xsub;
+        }
 
-        ldrcntr = lcdc_read(priv, _LDRCNTR);
+        /* If the Y offset hasn't changed, the C offset hasn't either. There's
+         * nothing to do in that case.
+         */
+        if (y_offset == ch->pan_y_offset)
+                return 0;
 
         /* Set the source address for the next refresh */
-        base_addr_y = ch->dma_handle + new_pan_offset;
-        if (ch->format->yuv) {
-                /* Set y offset */
-                c_offset = var->yoffset * ch->pitch
-                         * (ch->format->bpp - 8) / 8;
-                base_addr_c = ch->dma_handle + ch->xres * ch->yres_virtual
-                            + c_offset;
-                /* Set x offset */
-                if (ch->format->fourcc == V4L2_PIX_FMT_NV24)
-                        base_addr_c += 2 * var->xoffset;
-                else
-                        base_addr_c += var->xoffset;
-        }
+        base_addr_y = ch->dma_handle + y_offset;
+        base_addr_c = ch->dma_handle + ch->xres_virtual * ch->yres_virtual
+                    + c_offset;
 
-        if (ch->meram) {
-                struct sh_mobile_meram_info *mdev;
-
-                mdev = priv->meram_dev;
-                mdev->ops->meram_update(mdev, ch->meram,
-                                        base_addr_y, base_addr_c,
-                                        &base_addr_y, &base_addr_c);
-        }
+        if (ch->cache)
+                sh_mobile_meram_cache_update(priv->meram_dev, ch->cache,
+                                             base_addr_y, base_addr_c,
+                                             &base_addr_y, &base_addr_c);
 
         ch->base_addr_y = base_addr_y;
         ch->base_addr_c = base_addr_c;
+        ch->pan_y_offset = y_offset;
 
         lcdc_write_chan_mirror(ch, LDSA1R, base_addr_y);
         if (ch->format->yuv)
                 lcdc_write_chan_mirror(ch, LDSA2R, base_addr_c);
 
+        ldrcntr = lcdc_read(priv, _LDRCNTR);
         if (lcdc_chan_is_sublcd(ch))
                 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_SRS);
         else
                 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_MRS);
 
-        ch->pan_offset = new_pan_offset;
 
         sh_mobile_lcdc_deferred_io_touch(info);
 
         return 0;
 }
 
-static int sh_mobile_ioctl(struct fb_info *info, unsigned int cmd,
-                       unsigned long arg)
+static int sh_mobile_lcdc_ioctl(struct fb_info *info, unsigned int cmd,
+                                unsigned long arg)
 {
+        struct sh_mobile_lcdc_chan *ch = info->par;
         int retval;
 
         switch (cmd) {
         case FBIO_WAITFORVSYNC:
-                retval = sh_mobile_wait_for_vsync(info->par);
+                retval = sh_mobile_lcdc_wait_for_vsync(ch);
                 break;
 
         default:
@@ -1158,7 +1923,7 @@ static void sh_mobile_fb_reconfig(struct fb_info *info)
  * Locking: both .fb_release() and .fb_open() are called with info->lock held if
  * user == 1, or with console sem held, if user == 0.
  */
-static int sh_mobile_release(struct fb_info *info, int user)
+static int sh_mobile_lcdc_release(struct fb_info *info, int user)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
 
@@ -1179,7 +1944,7 @@ static int sh_mobile_release(struct fb_info *info, int user)
         return 0;
 }
 
-static int sh_mobile_open(struct fb_info *info, int user)
+static int sh_mobile_lcdc_open(struct fb_info *info, int user)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
 
@@ -1192,7 +1957,8 @@ static int sh_mobile_open(struct fb_info *info, int user)
         return 0;
 }
 
-static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+static int sh_mobile_lcdc_check_var(struct fb_var_screeninfo *var,
+                                    struct fb_info *info)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
         struct sh_mobile_lcdc_priv *p = ch->lcdc;
@@ -1200,9 +1966,7 @@ static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *in
         unsigned int best_xres = 0;
         unsigned int best_yres = 0;
         unsigned int i;
-
-        if (var->xres > MAX_XRES || var->yres > MAX_YRES)
-                return -EINVAL;
+        int ret;
 
         /* If board code provides us with a list of available modes, make sure
          * we use one of them. Find the mode closest to the requested one. The
@@ -1237,73 +2001,9 @@ static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *in
                 var->yres = best_yres;
         }
 
-        /* Make sure the virtual resolution is at least as big as the visible
-         * resolution.
-         */
-        if (var->xres_virtual < var->xres)
-                var->xres_virtual = var->xres;
-        if (var->yres_virtual < var->yres)
-                var->yres_virtual = var->yres;
-
-        if (sh_mobile_format_is_fourcc(var)) {
-                const struct sh_mobile_lcdc_format_info *format;
-
-                format = sh_mobile_format_info(var->grayscale);
-                if (format == NULL)
-                        return -EINVAL;
-                var->bits_per_pixel = format->bpp;
-
-                /* Default to RGB and JPEG color-spaces for RGB and YUV formats
-                 * respectively.
-                 */
-                if (!format->yuv)
-                        var->colorspace = V4L2_COLORSPACE_SRGB;
-                else if (var->colorspace != V4L2_COLORSPACE_REC709)
-                        var->colorspace = V4L2_COLORSPACE_JPEG;
-        } else {
-                if (var->bits_per_pixel <= 16) {                /* RGB 565 */
-                        var->bits_per_pixel = 16;
-                        var->red.offset = 11;
-                        var->red.length = 5;
-                        var->green.offset = 5;
-                        var->green.length = 6;
-                        var->blue.offset = 0;
-                        var->blue.length = 5;
-                        var->transp.offset = 0;
-                        var->transp.length = 0;
-                } else if (var->bits_per_pixel <= 24) {         /* RGB 888 */
-                        var->bits_per_pixel = 24;
-                        var->red.offset = 16;
-                        var->red.length = 8;
-                        var->green.offset = 8;
-                        var->green.length = 8;
-                        var->blue.offset = 0;
-                        var->blue.length = 8;
-                        var->transp.offset = 0;
-                        var->transp.length = 0;
-                } else if (var->bits_per_pixel <= 32) {         /* RGBA 888 */
-                        var->bits_per_pixel = 32;
-                        var->red.offset = 16;
-                        var->red.length = 8;
-                        var->green.offset = 8;
-                        var->green.length = 8;
-                        var->blue.offset = 0;
-                        var->blue.length = 8;
-                        var->transp.offset = 24;
-                        var->transp.length = 8;
-                } else
-                        return -EINVAL;
-
-                var->red.msb_right = 0;
-                var->green.msb_right = 0;
-                var->blue.msb_right = 0;
-                var->transp.msb_right = 0;
-        }
-
-        /* Make sure we don't exceed our allocated memory. */
-        if (var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8 >
-            info->fix.smem_len)
-                return -EINVAL;
+        ret = __sh_mobile_lcdc_check_var(var, info);
+        if (ret < 0)
+                return ret;
 
         /* only accept the forced_fourcc for dual channel configurations */
         if (p->forced_fourcc &&
@@ -1313,7 +2013,7 @@ static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *in
         return 0;
 }
 
-static int sh_mobile_set_par(struct fb_info *info)
+static int sh_mobile_lcdc_set_par(struct fb_info *info)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
         int ret;
@@ -1329,9 +2029,9 @@ static int sh_mobile_set_par(struct fb_info *info)
         ch->yres_virtual = info->var.yres_virtual;
 
         if (ch->format->yuv)
-                ch->pitch = info->var.xres;
+                ch->pitch = info->var.xres_virtual;
         else
-                ch->pitch = info->var.xres * ch->format->bpp / 8;
+                ch->pitch = info->var.xres_virtual * ch->format->bpp / 8;
 
         ret = sh_mobile_lcdc_start(ch->lcdc);
         if (ret < 0)
@@ -1383,8 +2083,8 @@ static int sh_mobile_lcdc_blank(int blank, struct fb_info *info)
                  * mode will reenable the clocks and update the screen in time,
                  * so it does not need this. */
                 if (!info->fbdefio) {
-                        sh_mobile_wait_for_vsync(ch);
-                        sh_mobile_wait_for_vsync(ch);
+                        sh_mobile_lcdc_wait_for_vsync(ch);
+                        sh_mobile_lcdc_wait_for_vsync(ch);
                 }
                 sh_mobile_lcdc_clk_off(p);
         }
@@ -1402,12 +2102,12 @@ static struct fb_ops sh_mobile_lcdc_ops = {
         .fb_copyarea    = sh_mobile_lcdc_copyarea,
         .fb_imageblit   = sh_mobile_lcdc_imageblit,
         .fb_blank       = sh_mobile_lcdc_blank,
-        .fb_pan_display = sh_mobile_fb_pan_display,
-        .fb_ioctl       = sh_mobile_ioctl,
-        .fb_open        = sh_mobile_open,
-        .fb_release     = sh_mobile_release,
-        .fb_check_var   = sh_mobile_check_var,
-        .fb_set_par     = sh_mobile_set_par,
+        .fb_pan_display = sh_mobile_lcdc_pan,
+        .fb_ioctl       = sh_mobile_lcdc_ioctl,
+        .fb_open        = sh_mobile_lcdc_open,
+        .fb_release     = sh_mobile_lcdc_release,
+        .fb_check_var   = sh_mobile_lcdc_check_var,
+        .fb_set_par     = sh_mobile_lcdc_set_par,
 };
 
 static void
@@ -1514,19 +2214,24 @@ sh_mobile_lcdc_channel_fb_init(struct sh_mobile_lcdc_chan *ch,
         else
                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 
-        if (ch->format->fourcc == V4L2_PIX_FMT_NV12 ||
-            ch->format->fourcc == V4L2_PIX_FMT_NV21)
+        switch (ch->format->fourcc) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
                 info->fix.ypanstep = 2;
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV61:
+                info->fix.xpanstep = 2;
+        }
 
         /* Initialize variable screen information using the first mode as
-         * default. The default Y virtual resolution is twice the panel size to
-         * allow for double-buffering.
+         * default.
          */
         var = &info->var;
         fb_videomode_to_var(var, mode);
         var->width = ch->cfg->panel_cfg.width;
         var->height = ch->cfg->panel_cfg.height;
-        var->yres_virtual = var->yres * 2;
+        var->xres_virtual = ch->xres_virtual;
+        var->yres_virtual = ch->yres_virtual;
         var->activate = FB_ACTIVATE_NOW;
 
         /* Use the legacy API by default for RGB formats, and the FOURCC API
@@ -1537,7 +2242,7 @@ sh_mobile_lcdc_channel_fb_init(struct sh_mobile_lcdc_chan *ch,
         else
                 var->grayscale = ch->format->fourcc;
 
-        ret = sh_mobile_check_var(var, info);
+        ret = sh_mobile_lcdc_check_var(var, info);
         if (ret)
                 return ret;
 
@@ -1712,15 +2417,27 @@ static const struct fb_videomode default_720p __devinitconst = {
 static int sh_mobile_lcdc_remove(struct platform_device *pdev)
 {
         struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev);
-        int i;
+        unsigned int i;
 
         fb_unregister_client(&priv->notifier);
 
+        for (i = 0; i < ARRAY_SIZE(priv->overlays); i++)
+                sh_mobile_lcdc_overlay_fb_unregister(&priv->overlays[i]);
         for (i = 0; i < ARRAY_SIZE(priv->ch); i++)
                 sh_mobile_lcdc_channel_fb_unregister(&priv->ch[i]);
 
         sh_mobile_lcdc_stop(priv);
 
+        for (i = 0; i < ARRAY_SIZE(priv->overlays); i++) {
+                struct sh_mobile_lcdc_overlay *ovl = &priv->overlays[i];
+
+                sh_mobile_lcdc_overlay_fb_cleanup(ovl);
+
+                if (ovl->fb_mem)
+                        dma_free_coherent(&pdev->dev, ovl->fb_size,
+                                          ovl->fb_mem, ovl->dma_handle);
+        }
+
         for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
                 struct sh_mobile_lcdc_chan *ch = &priv->ch[i];
 
@@ -1737,8 +2454,11 @@ static int sh_mobile_lcdc_remove(struct platform_device *pdev)
         }
 
         for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
-                if (priv->ch[i].bl)
-                        sh_mobile_lcdc_bl_remove(priv->ch[i].bl);
+                struct sh_mobile_lcdc_chan *ch = &priv->ch[i];
+
+                if (ch->bl)
+                        sh_mobile_lcdc_bl_remove(ch->bl);
+                mutex_destroy(&ch->open_lock);
         }
 
         if (priv->dot_clk) {
@@ -1796,6 +2516,61 @@ static int __devinit sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *
 }
 
 static int __devinit
+sh_mobile_lcdc_overlay_init(struct sh_mobile_lcdc_priv *priv,
+                          struct sh_mobile_lcdc_overlay *ovl)
+{
+        const struct sh_mobile_lcdc_format_info *format;
+        int ret;
+
+        if (ovl->cfg->fourcc == 0)
+                return 0;
+
+        /* Validate the format. */
+        format = sh_mobile_format_info(ovl->cfg->fourcc);
+        if (format == NULL) {
+                dev_err(priv->dev, "Invalid FOURCC %08x\n", ovl->cfg->fourcc);
+                return -EINVAL;
+        }
+
+        ovl->enabled = false;
+        ovl->mode = LCDC_OVERLAY_BLEND;
+        ovl->alpha = 255;
+        ovl->rop3 = 0;
+        ovl->pos_x = 0;
+        ovl->pos_y = 0;
+
+        /* The default Y virtual resolution is twice the panel size to allow for
+         * double-buffering.
+         */
+        ovl->format = format;
+        ovl->xres = ovl->cfg->max_xres;
+        ovl->xres_virtual = ovl->xres;
+        ovl->yres = ovl->cfg->max_yres;
+        ovl->yres_virtual = ovl->yres * 2;
+
+        if (!format->yuv)
+                ovl->pitch = ovl->xres_virtual * format->bpp / 8;
+        else
+                ovl->pitch = ovl->xres_virtual;
+
+        /* Allocate frame buffer memory. */
+        ovl->fb_size = ovl->cfg->max_xres * ovl->cfg->max_yres
+                       * format->bpp / 8 * 2;
+        ovl->fb_mem = dma_alloc_coherent(priv->dev, ovl->fb_size,
+                                           &ovl->dma_handle, GFP_KERNEL);
+        if (!ovl->fb_mem) {
+                dev_err(priv->dev, "unable to allocate buffer\n");
+                return -ENOMEM;
+        }
+
+        ret = sh_mobile_lcdc_overlay_fb_init(ovl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int __devinit
 sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv,
                             struct sh_mobile_lcdc_chan *ch)
 {
@@ -1854,7 +2629,9 @@ sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv,
                 num_modes = cfg->num_modes;
         }
 
-        /* Use the first mode as default. */
+        /* Use the first mode as default. The default Y virtual resolution is
+         * twice the panel size to allow for double-buffering.
+         */
         ch->format = format;
         ch->xres = mode->xres;
         ch->xres_virtual = mode->xres;
@@ -1863,10 +2640,10 @@ sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv,
 
         if (!format->yuv) {
                 ch->colorspace = V4L2_COLORSPACE_SRGB;
-                ch->pitch = ch->xres * format->bpp / 8;
+                ch->pitch = ch->xres_virtual * format->bpp / 8;
         } else {
                 ch->colorspace = V4L2_COLORSPACE_REC709;
-                ch->pitch = ch->xres;
+                ch->pitch = ch->xres_virtual;
         }
 
         ch->display.width = cfg->panel_cfg.width;
@@ -1952,7 +2729,6 @@ static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev)
                 }
                 init_waitqueue_head(&ch->frame_end_wait);
                 init_completion(&ch->vsync_completion);
-                ch->pan_offset = 0;
 
                 /* probe the backlight is there is one defined */
                 if (ch->cfg->bl_info.max_brightness)
@@ -2003,6 +2779,17 @@ static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev)
                         goto err1;
         }
 
+        for (i = 0; i < ARRAY_SIZE(pdata->overlays); i++) {
+                struct sh_mobile_lcdc_overlay *ovl = &priv->overlays[i];
+
+                ovl->cfg = &pdata->overlays[i];
+                ovl->channel = &priv->ch[0];
+
+                error = sh_mobile_lcdc_overlay_init(priv, ovl);
+                if (error)
+                        goto err1;
+        }
+
         error = sh_mobile_lcdc_start(priv);
         if (error) {
                 dev_err(&pdev->dev, "unable to start hardware\n");
@@ -2017,6 +2804,14 @@ static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev)
                         goto err1;
         }
 
+        for (i = 0; i < ARRAY_SIZE(pdata->overlays); i++) {
+                struct sh_mobile_lcdc_overlay *ovl = &priv->overlays[i];
+
+                error = sh_mobile_lcdc_overlay_fb_register(ovl);
+                if (error)
+                        goto err1;
+        }
+
         /* Failure ignored */
         priv->notifier.notifier_call = sh_mobile_lcdc_notify;
         fb_register_client(&priv->notifier);
diff --git a/drivers/video/sh_mobile_lcdcfb.h b/drivers/video/sh_mobile_lcdcfb.h
index 5c3bddd2cb72..0f92f6544b94 100644
--- a/drivers/video/sh_mobile_lcdcfb.h
+++ b/drivers/video/sh_mobile_lcdcfb.h
@@ -47,6 +47,7 @@ struct sh_mobile_lcdc_entity {
 /*
  * struct sh_mobile_lcdc_chan - LCDC display channel
  *
+ * @pan_y_offset: Panning linear offset in bytes (luma component)
  * @base_addr_y: Frame buffer viewport base address (luma component)
  * @base_addr_c: Frame buffer viewport base address (chroma component)
  * @pitch: Frame buffer line pitch
@@ -59,7 +60,7 @@ struct sh_mobile_lcdc_chan {
         unsigned long *reg_offs;
         unsigned long ldmt1r_value;
         unsigned long enabled; /* ME and SE in LDCNT2R */
-        void *meram;
+        void *cache;
 
         struct mutex open_lock;         /* protects the use counter */
         int use_count;
@@ -68,7 +69,7 @@ struct sh_mobile_lcdc_chan {
         unsigned long fb_size;
 
         dma_addr_t dma_handle;
-        unsigned long pan_offset;
+        unsigned long pan_y_offset;
 
         unsigned long frame_end;
         wait_queue_head_t frame_end_wait;
diff --git a/drivers/video/sh_mobile_meram.c b/drivers/video/sh_mobile_meram.c
index 82ba830bf95d..7a0ba8bb3fbe 100644
--- a/drivers/video/sh_mobile_meram.c
+++ b/drivers/video/sh_mobile_meram.c
@@ -11,6 +11,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/export.h>
 #include <linux/genalloc.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
@@ -194,13 +195,28 @@ static inline unsigned long meram_read_reg(void __iomem *base, unsigned int off)
 }
 
 /* -----------------------------------------------------------------------------
- * Allocation
+ * MERAM allocation and free
+ */
+
+static unsigned long meram_alloc(struct sh_mobile_meram_priv *priv, size_t size)
+{
+        return gen_pool_alloc(priv->pool, size);
+}
+
+static void meram_free(struct sh_mobile_meram_priv *priv, unsigned long mem,
+                       size_t size)
+{
+        gen_pool_free(priv->pool, mem, size);
+}
+
+/* -----------------------------------------------------------------------------
+ * LCDC cache planes allocation, init, cleanup and free
  */
 
 /* Allocate ICBs and MERAM for a plane. */
-static int __meram_alloc(struct sh_mobile_meram_priv *priv,
-                         struct sh_mobile_meram_fb_plane *plane,
-                         size_t size)
+static int meram_plane_alloc(struct sh_mobile_meram_priv *priv,
+                             struct sh_mobile_meram_fb_plane *plane,
+                             size_t size)
 {
         unsigned long mem;
         unsigned long idx;
@@ -215,7 +231,7 @@ static int __meram_alloc(struct sh_mobile_meram_priv *priv,
                 return -ENOMEM;
         plane->marker = &priv->icbs[idx];
 
-        mem = gen_pool_alloc(priv->pool, size * 1024);
+        mem = meram_alloc(priv, size * 1024);
         if (mem == 0)
                 return -ENOMEM;
 
@@ -229,11 +245,11 @@ static int __meram_alloc(struct sh_mobile_meram_priv *priv,
 }
 
 /* Free ICBs and MERAM for a plane. */
-static void __meram_free(struct sh_mobile_meram_priv *priv,
-                         struct sh_mobile_meram_fb_plane *plane)
+static void meram_plane_free(struct sh_mobile_meram_priv *priv,
+                             struct sh_mobile_meram_fb_plane *plane)
 {
-        gen_pool_free(priv->pool, priv->meram + plane->marker->offset,
-                      plane->marker->size * 1024);
+        meram_free(priv, priv->meram + plane->marker->offset,
+                   plane->marker->size * 1024);
 
         __clear_bit(plane->marker->index, &priv->used_icb);
         __clear_bit(plane->cache->index, &priv->used_icb);
@@ -248,62 +264,6 @@ static int is_nvcolor(int cspace)
         return 0;
 }
 
-/* Allocate memory for the ICBs and mark them as used. */
-static struct sh_mobile_meram_fb_cache *
-meram_alloc(struct sh_mobile_meram_priv *priv,
-            const struct sh_mobile_meram_cfg *cfg,
-            int pixelformat)
-{
-        struct sh_mobile_meram_fb_cache *cache;
-        unsigned int nplanes = is_nvcolor(pixelformat) ? 2 : 1;
-        int ret;
-
-        if (cfg->icb[0].meram_size == 0)
-                return ERR_PTR(-EINVAL);
-
-        if (nplanes == 2 && cfg->icb[1].meram_size == 0)
-                return ERR_PTR(-EINVAL);
-
-        cache = kzalloc(sizeof(*cache), GFP_KERNEL);
-        if (cache == NULL)
-                return ERR_PTR(-ENOMEM);
-
-        cache->nplanes = nplanes;
-
-        ret = __meram_alloc(priv, &cache->planes[0], cfg->icb[0].meram_size);
-        if (ret < 0)
-                goto error;
-
-        cache->planes[0].marker->current_reg = 1;
-        cache->planes[0].marker->pixelformat = pixelformat;
-
-        if (cache->nplanes == 1)
-                return cache;
-
-        ret = __meram_alloc(priv, &cache->planes[1], cfg->icb[1].meram_size);
-        if (ret < 0) {
-                __meram_free(priv, &cache->planes[0]);
-                goto error;
-        }
-
-        return cache;
-
-error:
-        kfree(cache);
-        return ERR_PTR(-ENOMEM);
-}
-
-/* Unmark the specified ICB as used. */
-static void meram_free(struct sh_mobile_meram_priv *priv,
-                       struct sh_mobile_meram_fb_cache *cache)
-{
-        __meram_free(priv, &cache->planes[0]);
-        if (cache->nplanes == 2)
-                __meram_free(priv, &cache->planes[1]);
-
-        kfree(cache);
-}
-
 /* Set the next address to fetch. */
 static void meram_set_next_addr(struct sh_mobile_meram_priv *priv,
                                 struct sh_mobile_meram_fb_cache *cache,
@@ -355,10 +315,10 @@ meram_get_next_icb_addr(struct sh_mobile_meram_info *pdata,
         (((x) * (y) + (MERAM_LINE_WIDTH - 1)) & ~(MERAM_LINE_WIDTH - 1))
 
 /* Initialize MERAM. */
-static int meram_init(struct sh_mobile_meram_priv *priv,
-                      struct sh_mobile_meram_fb_plane *plane,
-                      unsigned int xres, unsigned int yres,
-                      unsigned int *out_pitch)
+static int meram_plane_init(struct sh_mobile_meram_priv *priv,
+                            struct sh_mobile_meram_fb_plane *plane,
+                            unsigned int xres, unsigned int yres,
+                            unsigned int *out_pitch)
 {
         struct sh_mobile_meram_icb *marker = plane->marker;
         unsigned long total_byte_count = MERAM_CALC_BYTECOUNT(xres, yres);
@@ -427,8 +387,8 @@ static int meram_init(struct sh_mobile_meram_priv *priv,
         return 0;
 }
 
-static void meram_deinit(struct sh_mobile_meram_priv *priv,
-                         struct sh_mobile_meram_fb_plane *plane)
+static void meram_plane_cleanup(struct sh_mobile_meram_priv *priv,
+                                struct sh_mobile_meram_fb_plane *plane)
 {
         /* disable ICB */
         meram_write_icb(priv->base, plane->cache->index,  MExxCTL,
@@ -441,20 +401,82 @@ static void meram_deinit(struct sh_mobile_meram_priv *priv,
 }
 
 /* -----------------------------------------------------------------------------
- * Registration/unregistration
+ * MERAM operations
  */
 
-static void *sh_mobile_meram_register(struct sh_mobile_meram_info *pdata,
-                                      const struct sh_mobile_meram_cfg *cfg,
-                                      unsigned int xres, unsigned int yres,
-                                      unsigned int pixelformat,
-                                      unsigned int *pitch)
+unsigned long sh_mobile_meram_alloc(struct sh_mobile_meram_info *pdata,
+                                    size_t size)
+{
+        struct sh_mobile_meram_priv *priv = pdata->priv;
+
+        return meram_alloc(priv, size);
+}
+EXPORT_SYMBOL_GPL(sh_mobile_meram_alloc);
+
+void sh_mobile_meram_free(struct sh_mobile_meram_info *pdata, unsigned long mem,
+                          size_t size)
+{
+        struct sh_mobile_meram_priv *priv = pdata->priv;
+
+        meram_free(priv, mem, size);
+}
+EXPORT_SYMBOL_GPL(sh_mobile_meram_free);
+
+/* Allocate memory for the ICBs and mark them as used. */
+static struct sh_mobile_meram_fb_cache *
+meram_cache_alloc(struct sh_mobile_meram_priv *priv,
+                  const struct sh_mobile_meram_cfg *cfg,
+                  int pixelformat)
+{
+        unsigned int nplanes = is_nvcolor(pixelformat) ? 2 : 1;
+        struct sh_mobile_meram_fb_cache *cache;
+        int ret;
+
+        cache = kzalloc(sizeof(*cache), GFP_KERNEL);
+        if (cache == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        cache->nplanes = nplanes;
+
+        ret = meram_plane_alloc(priv, &cache->planes[0],
+                                cfg->icb[0].meram_size);
+        if (ret < 0)
+                goto error;
+
+        cache->planes[0].marker->current_reg = 1;
+        cache->planes[0].marker->pixelformat = pixelformat;
+
+        if (cache->nplanes == 1)
+                return cache;
+
+        ret = meram_plane_alloc(priv, &cache->planes[1],
+                                cfg->icb[1].meram_size);
+        if (ret < 0) {
+                meram_plane_free(priv, &cache->planes[0]);
+                goto error;
+        }
+
+        return cache;
+
+error:
+        kfree(cache);
+        return ERR_PTR(-ENOMEM);
+}
+
+void *sh_mobile_meram_cache_alloc(struct sh_mobile_meram_info *pdata,
+                                  const struct sh_mobile_meram_cfg *cfg,
+                                  unsigned int xres, unsigned int yres,
+                                  unsigned int pixelformat, unsigned int *pitch)
 {
         struct sh_mobile_meram_fb_cache *cache;
         struct sh_mobile_meram_priv *priv = pdata->priv;
         struct platform_device *pdev = pdata->pdev;
+        unsigned int nplanes = is_nvcolor(pixelformat) ? 2 : 1;
         unsigned int out_pitch;
 
+        if (priv == NULL)
+                return ERR_PTR(-ENODEV);
+
         if (pixelformat != SH_MOBILE_MERAM_PF_NV &&
             pixelformat != SH_MOBILE_MERAM_PF_NV24 &&
             pixelformat != SH_MOBILE_MERAM_PF_RGB)
@@ -469,10 +491,16 @@ static void *sh_mobile_meram_register(struct sh_mobile_meram_info *pdata,
                 return ERR_PTR(-EINVAL);
         }
 
+        if (cfg->icb[0].meram_size == 0)
+                return ERR_PTR(-EINVAL);
+
+        if (nplanes == 2 && cfg->icb[1].meram_size == 0)
+                return ERR_PTR(-EINVAL);
+
         mutex_lock(&priv->lock);
 
         /* We now register the ICBs and allocate the MERAM regions. */
-        cache = meram_alloc(priv, cfg, pixelformat);
+        cache = meram_cache_alloc(priv, cfg, pixelformat);
         if (IS_ERR(cache)) {
                 dev_err(&pdev->dev, "MERAM allocation failed (%ld).",
                         PTR_ERR(cache));
@@ -480,42 +508,50 @@ static void *sh_mobile_meram_register(struct sh_mobile_meram_info *pdata,
         }
 
         /* initialize MERAM */
-        meram_init(priv, &cache->planes[0], xres, yres, &out_pitch);
+        meram_plane_init(priv, &cache->planes[0], xres, yres, &out_pitch);
         *pitch = out_pitch;
         if (pixelformat == SH_MOBILE_MERAM_PF_NV)
-                meram_init(priv, &cache->planes[1], xres, (yres + 1) / 2,
-                        &out_pitch);
+                meram_plane_init(priv, &cache->planes[1],
+                                 xres, (yres + 1) / 2, &out_pitch);
         else if (pixelformat == SH_MOBILE_MERAM_PF_NV24)
-                meram_init(priv, &cache->planes[1], 2 * xres, (yres + 1) / 2,
-                        &out_pitch);
+                meram_plane_init(priv, &cache->planes[1],
+                                 2 * xres, (yres + 1) / 2, &out_pitch);
 
 err:
         mutex_unlock(&priv->lock);
         return cache;
 }
+EXPORT_SYMBOL_GPL(sh_mobile_meram_cache_alloc);
 
-static void
-sh_mobile_meram_unregister(struct sh_mobile_meram_info *pdata, void *data)
+void
+sh_mobile_meram_cache_free(struct sh_mobile_meram_info *pdata, void *data)
 {
         struct sh_mobile_meram_fb_cache *cache = data;
         struct sh_mobile_meram_priv *priv = pdata->priv;
 
         mutex_lock(&priv->lock);
 
-        /* deinit & free */
-        meram_deinit(priv, &cache->planes[0]);
-        if (cache->nplanes == 2)
-                meram_deinit(priv, &cache->planes[1]);
+        /* Cleanup and free. */
+        meram_plane_cleanup(priv, &cache->planes[0]);
+        meram_plane_free(priv, &cache->planes[0]);
+
+        if (cache->nplanes == 2) {
+                meram_plane_cleanup(priv, &cache->planes[1]);
+                meram_plane_free(priv, &cache->planes[1]);
+        }
 
-        meram_free(priv, cache);
+        kfree(cache);
 
         mutex_unlock(&priv->lock);
 }
-
-static void
-sh_mobile_meram_update(struct sh_mobile_meram_info *pdata, void *data,
-                       unsigned long base_addr_y, unsigned long base_addr_c,
-                       unsigned long *icb_addr_y, unsigned long *icb_addr_c)
+EXPORT_SYMBOL_GPL(sh_mobile_meram_cache_free);
+
+void
+sh_mobile_meram_cache_update(struct sh_mobile_meram_info *pdata, void *data,
+                             unsigned long base_addr_y,
+                             unsigned long base_addr_c,
+                             unsigned long *icb_addr_y,
+                             unsigned long *icb_addr_c)
 {
         struct sh_mobile_meram_fb_cache *cache = data;
         struct sh_mobile_meram_priv *priv = pdata->priv;
@@ -527,13 +563,7 @@ sh_mobile_meram_update(struct sh_mobile_meram_info *pdata, void *data,
 
         mutex_unlock(&priv->lock);
 }
-
-static struct sh_mobile_meram_ops sh_mobile_meram_ops = {
-        .module                 = THIS_MODULE,
-        .meram_register         = sh_mobile_meram_register,
-        .meram_unregister       = sh_mobile_meram_unregister,
-        .meram_update           = sh_mobile_meram_update,
-};
+EXPORT_SYMBOL_GPL(sh_mobile_meram_cache_update);
 
 /* -----------------------------------------------------------------------------
  * Power management
@@ -624,7 +654,6 @@ static int __devinit sh_mobile_meram_probe(struct platform_device *pdev)
         for (i = 0; i < MERAM_ICB_NUM; ++i)
                 priv->icbs[i].index = i;
 
-        pdata->ops = &sh_mobile_meram_ops;
         pdata->priv = priv;
         pdata->pdev = pdev;
 
diff --git a/drivers/video/sis/init.c b/drivers/video/sis/init.c
index 66de832361cc..f082ae55c0c9 100644
--- a/drivers/video/sis/init.c
+++ b/drivers/video/sis/init.c
@@ -2628,7 +2628,8 @@ SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
       else if(VCLK >= 135) data = 0x02;
 
       if(SiS_Pr->ChipType == SIS_540) {
-         if((VCLK == 203) || (VCLK < 234)) data = 0x02;
+         /* Was == 203 or < 234 which made no sense */
+         if (VCLK < 234) data = 0x02;
       }
 
       if(SiS_Pr->ChipType < SIS_315H) {
diff --git a/drivers/video/smscufx.c b/drivers/video/smscufx.c
index af3ef27ad36c..5533a32c6ca1 100644
--- a/drivers/video/smscufx.c
+++ b/drivers/video/smscufx.c
@@ -1,7 +1,7 @@
 /*
  * smscufx.c -- Framebuffer driver for SMSC UFX USB controller
  *
- * Copyright (C) 2011 Steve Glendinning <steve.glendinning@smsc.com>
+ * Copyright (C) 2011 Steve Glendinning <steve.glendinning@shawell.net>
  * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
  * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
  * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
@@ -904,7 +904,7 @@ static ssize_t ufx_ops_write(struct fb_info *info, const char __user *buf,
         result = fb_sys_write(info, buf, count, ppos);
 
         if (result > 0) {
-                int start = max((int)(offset / info->fix.line_length) - 1, 0);
+                int start = max((int)(offset / info->fix.line_length), 0);
                 int lines = min((u32)((result / info->fix.line_length) + 1),
                                 (u32)info->var.yres);
 
@@ -1002,7 +1002,7 @@ static int ufx_ops_ioctl(struct fb_info *info, unsigned int cmd,
         /* TODO: Help propose a standard fb.h ioctl to report mmap damage */
         if (cmd == UFX_IOCTL_REPORT_DAMAGE) {
                 /* If we have a damage-aware client, turn fb_defio "off"
-                 * To avoid perf imact of unecessary page fault handling.
+                 * To avoid perf imact of unnecessary page fault handling.
                  * Done by resetting the delay for this fb_info to a very
                  * long period. Pages will become writable and stay that way.
                  * Reset to normal value when all clients have closed this fb.
@@ -1466,7 +1466,7 @@ static int ufx_read_edid(struct ufx_data *dev, u8 *edid, int edid_len)
         /* all FF's in the first 16 bytes indicates nothing is connected */
         for (i = 0; i < 16; i++) {
                 if (edid[i] != 0xFF) {
-                        pr_debug("edid data read succesfully");
+                        pr_debug("edid data read successfully");
                         return EDID_LENGTH;
                 }
         }
@@ -1972,6 +1972,6 @@ MODULE_PARM_DESC(console, "Allow fbcon to be used on this display");
 module_param(fb_defio, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
 MODULE_PARM_DESC(fb_defio, "Enable fb_defio mmap support");
 
-MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
+MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
 MODULE_DESCRIPTION("SMSC UFX kernel framebuffer driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/sunxvr500.c b/drivers/video/sunxvr500.c
index b9c2b948d34d..eb931b8626fa 100644
--- a/drivers/video/sunxvr500.c
+++ b/drivers/video/sunxvr500.c
@@ -12,7 +12,7 @@
 
 #include <asm/io.h>
 
-/* XXX This device has a 'dev-comm' property which aparently is
+/* XXX This device has a 'dev-comm' property which apparently is
  * XXX a pointer into the openfirmware's address space which is
  * XXX a shared area the kernel driver can use to keep OBP
  * XXX informed about the current resolution setting.  The idea
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index 90a2e30272ad..2f6b2b835f88 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -1567,6 +1567,18 @@ static void w100_suspend(u32 mode)
                 val = readl(remapped_regs + mmPLL_CNTL);
                 val |= 0x00000004;  /* bit2=1 */
                 writel(val, remapped_regs + mmPLL_CNTL);
+
+                writel(0x00000000, remapped_regs + mmLCDD_CNTL1);
+                writel(0x00000000, remapped_regs + mmLCDD_CNTL2);
+                writel(0x00000000, remapped_regs + mmGENLCD_CNTL1);
+                writel(0x00000000, remapped_regs + mmGENLCD_CNTL2);
+                writel(0x00000000, remapped_regs + mmGENLCD_CNTL3);
+
+                val = readl(remapped_regs + mmMEM_EXT_CNTL);
+                val |= 0xF0000000;
+                val &= ~(0x00000001);
+                writel(val, remapped_regs + mmMEM_EXT_CNTL);
+
                 writel(0x0000001d, remapped_regs + mmPWRMGT_CNTL);
         }
 }