Merge branch 'master' into for-next

Fast-forwarded to current state of Linus' tree as there are patches to be
applied for files that didn't exist on the old branch.

143 files changed, 7412 insertions, 2569 deletions

diff --git a/drivers/video/amba-clcd.c b/drivers/video/amba-clcd.c
index 013c8ce57205..5fc983c5b92c 100644
--- a/drivers/video/amba-clcd.c
+++ b/drivers/video/amba-clcd.c
@@ -120,8 +120,23 @@ static void clcdfb_enable(struct clcd_fb *fb, u32 cntl)
 static int
 clcdfb_set_bitfields(struct clcd_fb *fb, struct fb_var_screeninfo *var)
 {
+        u32 caps;
         int ret = 0;
 
+        if (fb->panel->caps && fb->board->caps)
+                caps = fb->panel->caps & fb->board->caps;
+        else {
+                /* Old way of specifying what can be used */
+                caps = fb->panel->cntl & CNTL_BGR ?
+                        CLCD_CAP_BGR : CLCD_CAP_RGB;
+                /* But mask out 444 modes as they weren't supported */
+                caps &= ~CLCD_CAP_444;
+        }
+
+        /* Only TFT panels can do RGB888/BGR888 */
+        if (!(fb->panel->cntl & CNTL_LCDTFT))
+                caps &= ~CLCD_CAP_888;
+
         memset(&var->transp, 0, sizeof(var->transp));
 
         var->red.msb_right = 0;
@@ -133,6 +148,13 @@ clcdfb_set_bitfields(struct clcd_fb *fb, struct fb_var_screeninfo *var)
         case 2:
         case 4:
         case 8:
+                /* If we can't do 5551, reject */
+                caps &= CLCD_CAP_5551;
+                if (!caps) {
+                        ret = -EINVAL;
+                        break;
+                }
+
                 var->red.length         = var->bits_per_pixel;
                 var->red.offset         = 0;
                 var->green.length       = var->bits_per_pixel;
@@ -140,23 +162,61 @@ clcdfb_set_bitfields(struct clcd_fb *fb, struct fb_var_screeninfo *var)
                 var->blue.length        = var->bits_per_pixel;
                 var->blue.offset        = 0;
                 break;
+
         case 16:
-                var->red.length = 5;
-                var->blue.length = 5;
+                /* If we can't do 444, 5551 or 565, reject */
+                if (!(caps & (CLCD_CAP_444 | CLCD_CAP_5551 | CLCD_CAP_565))) {
+                        ret = -EINVAL;
+                        break;
+                }
+
                 /*
-                 * Green length can be 5 or 6 depending whether
-                 * we're operating in RGB555 or RGB565 mode.
+                 * Green length can be 4, 5 or 6 depending whether
+                 * we're operating in 444, 5551 or 565 mode.
                  */
-                if (var->green.length != 5 && var->green.length != 6)
-                        var->green.length = 6;
+                if (var->green.length == 4 && caps & CLCD_CAP_444)
+                        caps &= CLCD_CAP_444;
+                if (var->green.length == 5 && caps & CLCD_CAP_5551)
+                        caps &= CLCD_CAP_5551;
+                else if (var->green.length == 6 && caps & CLCD_CAP_565)
+                        caps &= CLCD_CAP_565;
+                else {
+                        /*
+                         * PL110 officially only supports RGB555,
+                         * but may be wired up to allow RGB565.
+                         */
+                        if (caps & CLCD_CAP_565) {
+                                var->green.length = 6;
+                                caps &= CLCD_CAP_565;
+                        } else if (caps & CLCD_CAP_5551) {
+                                var->green.length = 5;
+                                caps &= CLCD_CAP_5551;
+                        } else {
+                                var->green.length = 4;
+                                caps &= CLCD_CAP_444;
+                        }
+                }
+
+                if (var->green.length >= 5) {
+                        var->red.length = 5;
+                        var->blue.length = 5;
+                } else {
+                        var->red.length = 4;
+                        var->blue.length = 4;
+                }
                 break;
         case 32:
-                if (fb->panel->cntl & CNTL_LCDTFT) {
-                        var->red.length         = 8;
-                        var->green.length       = 8;
-                        var->blue.length        = 8;
+                /* If we can't do 888, reject */
+                caps &= CLCD_CAP_888;
+                if (!caps) {
+                        ret = -EINVAL;
                         break;
                 }
+
+                var->red.length = 8;
+                var->green.length = 8;
+                var->blue.length = 8;
+                break;
         default:
                 ret = -EINVAL;
                 break;
@@ -168,7 +228,20 @@ clcdfb_set_bitfields(struct clcd_fb *fb, struct fb_var_screeninfo *var)
          * the bitfield length defined above.
          */
         if (ret == 0 && var->bits_per_pixel >= 16) {
-                if (fb->panel->cntl & CNTL_BGR) {
+                bool bgr, rgb;
+
+                bgr = caps & CLCD_CAP_BGR && var->blue.offset == 0;
+                rgb = caps & CLCD_CAP_RGB && var->red.offset == 0;
+
+                if (!bgr && !rgb)
+                        /*
+                         * The requested format was not possible, try just
+                         * our capabilities.  One of BGR or RGB must be
+                         * supported.
+                         */
+                        bgr = caps & CLCD_CAP_BGR;
+
+                if (bgr) {
                         var->blue.offset = 0;
                         var->green.offset = var->blue.offset + var->blue.length;
                         var->red.offset = var->green.offset + var->green.length;
@@ -443,8 +516,8 @@ static int clcdfb_register(struct clcd_fb *fb)
 
         fb_set_var(&fb->fb, &fb->fb.var);
 
-        printk(KERN_INFO "CLCD: %s hardware, %s display\n",
-               fb->board->name, fb->panel->mode.name);
+        dev_info(&fb->dev->dev, "%s hardware, %s display\n",
+                 fb->board->name, fb->panel->mode.name);
 
         ret = register_framebuffer(&fb->fb);
         if (ret == 0)
@@ -486,6 +559,10 @@ static int clcdfb_probe(struct amba_device *dev, const struct amba_id *id)
         fb->dev = dev;
         fb->board = board;
 
+        dev_info(&fb->dev->dev, "PL%03x rev%u at 0x%08llx\n",
+                amba_part(dev), amba_rev(dev),
+                (unsigned long long)dev->res.start);
+
         ret = fb->board->setup(fb);
         if (ret)
                 goto free_fb;
diff --git a/drivers/video/arkfb.c b/drivers/video/arkfb.c
index 391ac939f011..8686429cbdf0 100644
--- a/drivers/video/arkfb.c
+++ b/drivers/video/arkfb.c
@@ -158,12 +158,19 @@ static void arkfb_settile(struct fb_info *info, struct fb_tilemap *map)
         }
 }
 
+static void arkfb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
+{
+        struct arkfb_info *par = info->par;
+
+        svga_tilecursor(par->state.vgabase, info, cursor);
+}
+
 static struct fb_tile_ops arkfb_tile_ops = {
         .fb_settile     = arkfb_settile,
         .fb_tilecopy    = svga_tilecopy,
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
-        .fb_tilecursor  = svga_tilecursor,
+        .fb_tilecursor  = arkfb_tilecursor,
         .fb_get_tilemax = svga_get_tilemax,
 };
 
@@ -466,32 +473,40 @@ static unsigned short dac_regs[4] = {0x3c8, 0x3c9, 0x3c6, 0x3c7};
 
 static void ark_dac_read_regs(void *data, u8 *code, int count)
 {
-        u8 regval = vga_rseq(NULL, 0x1C);
+        struct fb_info *info = data;
+        struct arkfb_info *par;
+        u8 regval;
 
+        par = info->par;
+        regval = vga_rseq(par->state.vgabase, 0x1C);
         while (count != 0)
         {
-                vga_wseq(NULL, 0x1C, regval | (code[0] & 4 ? 0x80 : 0));
-                code[1] = vga_r(NULL, dac_regs[code[0] & 3]);
+                vga_wseq(par->state.vgabase, 0x1C, regval | (code[0] & 4 ? 0x80 : 0));
+                code[1] = vga_r(par->state.vgabase, dac_regs[code[0] & 3]);
                 count--;
                 code += 2;
         }
 
-        vga_wseq(NULL, 0x1C, regval);
+        vga_wseq(par->state.vgabase, 0x1C, regval);
 }
 
 static void ark_dac_write_regs(void *data, u8 *code, int count)
 {
-        u8 regval = vga_rseq(NULL, 0x1C);
+        struct fb_info *info = data;
+        struct arkfb_info *par;
+        u8 regval;
 
+        par = info->par;
+        regval = vga_rseq(par->state.vgabase, 0x1C);
         while (count != 0)
         {
-                vga_wseq(NULL, 0x1C, regval | (code[0] & 4 ? 0x80 : 0));
-                vga_w(NULL, dac_regs[code[0] & 3], code[1]);
+                vga_wseq(par->state.vgabase, 0x1C, regval | (code[0] & 4 ? 0x80 : 0));
+                vga_w(par->state.vgabase, dac_regs[code[0] & 3], code[1]);
                 count--;
                 code += 2;
         }
 
-        vga_wseq(NULL, 0x1C, regval);
+        vga_wseq(par->state.vgabase, 0x1C, regval);
 }
 
 
@@ -507,8 +522,8 @@ static void ark_set_pixclock(struct fb_info *info, u32 pixclock)
         }
 
         /* Set VGA misc register  */
-        regval = vga_r(NULL, VGA_MIS_R);
-        vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
+        regval = vga_r(par->state.vgabase, VGA_MIS_R);
+        vga_w(par->state.vgabase, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
 }
 
 
@@ -520,7 +535,10 @@ static int arkfb_open(struct fb_info *info, int user)
 
         mutex_lock(&(par->open_lock));
         if (par->ref_count == 0) {
+                void __iomem *vgabase = par->state.vgabase;
+
                 memset(&(par->state), 0, sizeof(struct vgastate));
+                par->state.vgabase = vgabase;
                 par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS | VGA_SAVE_CMAP;
                 par->state.num_crtc = 0x60;
                 par->state.num_seq = 0x30;
@@ -646,50 +664,50 @@ static int arkfb_set_par(struct fb_info *info)
         info->var.activate = FB_ACTIVATE_NOW;
 
         /* Unlock registers */
-        svga_wcrt_mask(0x11, 0x00, 0x80);
+        svga_wcrt_mask(par->state.vgabase, 0x11, 0x00, 0x80);
 
         /* Blank screen and turn off sync */
-        svga_wseq_mask(0x01, 0x20, 0x20);
-        svga_wcrt_mask(0x17, 0x00, 0x80);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x00, 0x80);
 
         /* Set default values */
-        svga_set_default_gfx_regs();
-        svga_set_default_atc_regs();
-        svga_set_default_seq_regs();
-        svga_set_default_crt_regs();
-        svga_wcrt_multi(ark_line_compare_regs, 0xFFFFFFFF);
-        svga_wcrt_multi(ark_start_address_regs, 0);
+        svga_set_default_gfx_regs(par->state.vgabase);
+        svga_set_default_atc_regs(par->state.vgabase);
+        svga_set_default_seq_regs(par->state.vgabase);
+        svga_set_default_crt_regs(par->state.vgabase);
+        svga_wcrt_multi(par->state.vgabase, ark_line_compare_regs, 0xFFFFFFFF);
+        svga_wcrt_multi(par->state.vgabase, ark_start_address_regs, 0);
 
         /* ARK specific initialization */
-        svga_wseq_mask(0x10, 0x1F, 0x1F); /* enable linear framebuffer and full memory access */
-        svga_wseq_mask(0x12, 0x03, 0x03); /* 4 MB linear framebuffer size */
+        svga_wseq_mask(par->state.vgabase, 0x10, 0x1F, 0x1F); /* enable linear framebuffer and full memory access */
+        svga_wseq_mask(par->state.vgabase, 0x12, 0x03, 0x03); /* 4 MB linear framebuffer size */
 
-        vga_wseq(NULL, 0x13, info->fix.smem_start >> 16);
-        vga_wseq(NULL, 0x14, info->fix.smem_start >> 24);
-        vga_wseq(NULL, 0x15, 0);
-        vga_wseq(NULL, 0x16, 0);
+        vga_wseq(par->state.vgabase, 0x13, info->fix.smem_start >> 16);
+        vga_wseq(par->state.vgabase, 0x14, info->fix.smem_start >> 24);
+        vga_wseq(par->state.vgabase, 0x15, 0);
+        vga_wseq(par->state.vgabase, 0x16, 0);
 
         /* Set the FIFO threshold register */
         /* It is fascinating way to store 5-bit value in 8-bit register */
         regval = 0x10 | ((threshold & 0x0E) >> 1) | (threshold & 0x01) << 7 | (threshold & 0x10) << 1;
-        vga_wseq(NULL, 0x18, regval);
+        vga_wseq(par->state.vgabase, 0x18, regval);
 
         /* Set the offset register */
         pr_debug("fb%d: offset register       : %d\n", info->node, offset_value);
-        svga_wcrt_multi(ark_offset_regs, offset_value);
+        svga_wcrt_multi(par->state.vgabase, ark_offset_regs, offset_value);
 
         /* fix for hi-res textmode */
-        svga_wcrt_mask(0x40, 0x08, 0x08);
+        svga_wcrt_mask(par->state.vgabase, 0x40, 0x08, 0x08);
 
         if (info->var.vmode & FB_VMODE_DOUBLE)
-                svga_wcrt_mask(0x09, 0x80, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x80, 0x80);
         else
-                svga_wcrt_mask(0x09, 0x00, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x00, 0x80);
 
         if (info->var.vmode & FB_VMODE_INTERLACED)
-                svga_wcrt_mask(0x44, 0x04, 0x04);
+                svga_wcrt_mask(par->state.vgabase, 0x44, 0x04, 0x04);
         else
-                svga_wcrt_mask(0x44, 0x00, 0x04);
+                svga_wcrt_mask(par->state.vgabase, 0x44, 0x00, 0x04);
 
         hmul = 1;
         hdiv = 1;
@@ -699,40 +717,40 @@ static int arkfb_set_par(struct fb_info *info)
         switch (mode) {
         case 0:
                 pr_debug("fb%d: text mode\n", info->node);
-                svga_set_textmode_vga_regs();
+                svga_set_textmode_vga_regs(par->state.vgabase);
 
-                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
-                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x00, 0x04); /* 8bit pixel path */
                 dac_set_mode(par->dac, DAC_PSEUDO8_8);
 
                 break;
         case 1:
                 pr_debug("fb%d: 4 bit pseudocolor\n", info->node);
-                vga_wgfx(NULL, VGA_GFX_MODE, 0x40);
+                vga_wgfx(par->state.vgabase, VGA_GFX_MODE, 0x40);
 
-                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
-                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x00, 0x04); /* 8bit pixel path */
                 dac_set_mode(par->dac, DAC_PSEUDO8_8);
                 break;
         case 2:
                 pr_debug("fb%d: 4 bit pseudocolor, planar\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
-                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x00, 0x04); /* 8bit pixel path */
                 dac_set_mode(par->dac, DAC_PSEUDO8_8);
                 break;
         case 3:
                 pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x16); /* 8bpp accel mode */
+                vga_wseq(par->state.vgabase, 0x11, 0x16); /* 8bpp accel mode */
 
                 if (info->var.pixclock > 20000) {
                         pr_debug("fb%d: not using multiplex\n", info->node);
-                        svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                        svga_wcrt_mask(par->state.vgabase, 0x46, 0x00, 0x04); /* 8bit pixel path */
                         dac_set_mode(par->dac, DAC_PSEUDO8_8);
                 } else {
                         pr_debug("fb%d: using multiplex\n", info->node);
-                        svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                        svga_wcrt_mask(par->state.vgabase, 0x46, 0x04, 0x04); /* 16bit pixel path */
                         dac_set_mode(par->dac, DAC_PSEUDO8_16);
                         hdiv = 2;
                 }
@@ -740,22 +758,22 @@ static int arkfb_set_par(struct fb_info *info)
         case 4:
                 pr_debug("fb%d: 5/5/5 truecolor\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x1A); /* 16bpp accel mode */
-                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x1A); /* 16bpp accel mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x04, 0x04); /* 16bit pixel path */
                 dac_set_mode(par->dac, DAC_RGB1555_16);
                 break;
         case 5:
                 pr_debug("fb%d: 5/6/5 truecolor\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x1A); /* 16bpp accel mode */
-                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x1A); /* 16bpp accel mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x04, 0x04); /* 16bit pixel path */
                 dac_set_mode(par->dac, DAC_RGB0565_16);
                 break;
         case 6:
                 pr_debug("fb%d: 8/8/8 truecolor\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x16); /* 8bpp accel mode ??? */
-                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x16); /* 8bpp accel mode ??? */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x04, 0x04); /* 16bit pixel path */
                 dac_set_mode(par->dac, DAC_RGB0888_16);
                 hmul = 3;
                 hdiv = 2;
@@ -763,8 +781,8 @@ static int arkfb_set_par(struct fb_info *info)
         case 7:
                 pr_debug("fb%d: 8/8/8/8 truecolor\n", info->node);
 
-                vga_wseq(NULL, 0x11, 0x1E); /* 32bpp accel mode */
-                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                vga_wseq(par->state.vgabase, 0x11, 0x1E); /* 32bpp accel mode */
+                svga_wcrt_mask(par->state.vgabase, 0x46, 0x04, 0x04); /* 16bit pixel path */
                 dac_set_mode(par->dac, DAC_RGB8888_16);
                 hmul = 2;
                 break;
@@ -774,7 +792,7 @@ static int arkfb_set_par(struct fb_info *info)
         }
 
         ark_set_pixclock(info, (hdiv * info->var.pixclock) / hmul);
-        svga_set_timings(&ark_timing_regs, &(info->var), hmul, hdiv,
+        svga_set_timings(par->state.vgabase, &ark_timing_regs, &(info->var), hmul, hdiv,
                          (info->var.vmode & FB_VMODE_DOUBLE)     ? 2 : 1,
                          (info->var.vmode & FB_VMODE_INTERLACED) ? 2 : 1,
                           hmul, info->node);
@@ -782,12 +800,12 @@ static int arkfb_set_par(struct fb_info *info)
         /* Set interlaced mode start/end register */
         value = info->var.xres + info->var.left_margin + info->var.right_margin + info->var.hsync_len;
         value = ((value * hmul / hdiv) / 8) - 5;
-        vga_wcrt(NULL, 0x42, (value + 1) / 2);
+        vga_wcrt(par->state.vgabase, 0x42, (value + 1) / 2);
 
         memset_io(info->screen_base, 0x00, screen_size);
         /* Device and screen back on */
-        svga_wcrt_mask(0x17, 0x80, 0x80);
-        svga_wseq_mask(0x01, 0x00, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x80, 0x80);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
 
         return 0;
 }
@@ -857,23 +875,25 @@ static int arkfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 
 static int arkfb_blank(int blank_mode, struct fb_info *info)
 {
+        struct arkfb_info *par = info->par;
+
         switch (blank_mode) {
         case FB_BLANK_UNBLANK:
                 pr_debug("fb%d: unblank\n", info->node);
-                svga_wseq_mask(0x01, 0x00, 0x20);
-                svga_wcrt_mask(0x17, 0x80, 0x80);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x17, 0x80, 0x80);
                 break;
         case FB_BLANK_NORMAL:
                 pr_debug("fb%d: blank\n", info->node);
-                svga_wseq_mask(0x01, 0x20, 0x20);
-                svga_wcrt_mask(0x17, 0x80, 0x80);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x17, 0x80, 0x80);
                 break;
         case FB_BLANK_POWERDOWN:
         case FB_BLANK_HSYNC_SUSPEND:
         case FB_BLANK_VSYNC_SUSPEND:
                 pr_debug("fb%d: sync down\n", info->node);
-                svga_wseq_mask(0x01, 0x20, 0x20);
-                svga_wcrt_mask(0x17, 0x00, 0x80);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x17, 0x00, 0x80);
                 break;
         }
         return 0;
@@ -884,6 +904,7 @@ static int arkfb_blank(int blank_mode, struct fb_info *info)
 
 static int arkfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 {
+        struct arkfb_info *par = info->par;
         unsigned int offset;
 
         /* Calculate the offset */
@@ -897,7 +918,7 @@ static int arkfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info
         }
 
         /* Set the offset */
-        svga_wcrt_multi(ark_start_address_regs, offset);
+        svga_wcrt_multi(par->state.vgabase, ark_start_address_regs, offset);
 
         return 0;
 }
@@ -930,6 +951,8 @@ static struct fb_ops arkfb_ops = {
 /* PCI probe */
 static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
+        struct pci_bus_region bus_reg;
+        struct resource vga_res;
         struct fb_info *info;
         struct arkfb_info *par;
         int rc;
@@ -985,8 +1008,17 @@ static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_
                 goto err_iomap;
         }
 
+        bus_reg.start = 0;
+        bus_reg.end = 64 * 1024;
+
+        vga_res.flags = IORESOURCE_IO;
+
+        pcibios_bus_to_resource(dev, &vga_res, &bus_reg);
+
+        par->state.vgabase = (void __iomem *) vga_res.start;
+
         /* FIXME get memsize */
-        regval = vga_rseq(NULL, 0x10);
+        regval = vga_rseq(par->state.vgabase, 0x10);
         info->screen_size = (1 << (regval >> 6)) << 20;
         info->fix.smem_len = info->screen_size;
 
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index bac163450216..4484c721f0f9 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -68,7 +68,7 @@ static void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info *sinfo,
 }
 #endif
 
-static const u32 contrast_ctr = ATMEL_LCDC_PS_DIV8
+static u32 contrast_ctr = ATMEL_LCDC_PS_DIV8
                 | ATMEL_LCDC_POL_POSITIVE
                 | ATMEL_LCDC_ENA_PWMENABLE;
 
@@ -127,6 +127,7 @@ static void init_backlight(struct atmel_lcdfb_info *sinfo)
                 return;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 0xff;
         bl = backlight_device_register("backlight", &sinfo->pdev->dev, sinfo,
                                        &atmel_lcdc_bl_ops, &props);
@@ -163,6 +164,10 @@ static void exit_backlight(struct atmel_lcdfb_info *sinfo)
 
 static void init_contrast(struct atmel_lcdfb_info *sinfo)
 {
+        /* contrast pwm can be 'inverted' */
+        if (sinfo->lcdcon_pol_negative)
+                        contrast_ctr &= ~(ATMEL_LCDC_POL_POSITIVE);
+
         /* have some default contrast/backlight settings */
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, contrast_ctr);
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_VAL, ATMEL_LCDC_CVAL_DEFAULT);
@@ -632,7 +637,7 @@ static inline unsigned int chan_to_field(unsigned int chan, const struct fb_bitf
  *      magnitude which needs to be scaled in this function for the hardware.
  *      Things to take into consideration are how many color registers, if
  *      any, are supported with the current color visual. With truecolor mode
- *      no color palettes are supported. Here a psuedo palette is created
+ *      no color palettes are supported. Here a pseudo palette is created
  *      which we store the value in pseudo_palette in struct fb_info. For
  *      pseudocolor mode we have a limited color palette. To deal with this
  *      we can program what color is displayed for a particular pixel value.
@@ -710,11 +715,35 @@ static int atmel_lcdfb_pan_display(struct fb_var_screeninfo *var,
         return 0;
 }
 
+static int atmel_lcdfb_blank(int blank_mode, struct fb_info *info)
+{
+        struct atmel_lcdfb_info *sinfo = info->par;
+
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+        case FB_BLANK_NORMAL:
+                atmel_lcdfb_start(sinfo);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+                break;
+        case FB_BLANK_POWERDOWN:
+                atmel_lcdfb_stop(sinfo);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* let fbcon do a soft blank for us */
+        return ((blank_mode == FB_BLANK_NORMAL) ? 1 : 0);
+}
+
 static struct fb_ops atmel_lcdfb_ops = {
         .owner          = THIS_MODULE,
         .fb_check_var   = atmel_lcdfb_check_var,
         .fb_set_par     = atmel_lcdfb_set_par,
         .fb_setcolreg   = atmel_lcdfb_setcolreg,
+        .fb_blank       = atmel_lcdfb_blank,
         .fb_pan_display = atmel_lcdfb_pan_display,
         .fb_fillrect    = cfb_fillrect,
         .fb_copyarea    = cfb_copyarea,
@@ -816,6 +845,7 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                 sinfo->guard_time = pdata_sinfo->guard_time;
                 sinfo->smem_len = pdata_sinfo->smem_len;
                 sinfo->lcdcon_is_backlight = pdata_sinfo->lcdcon_is_backlight;
+                sinfo->lcdcon_pol_negative = pdata_sinfo->lcdcon_pol_negative;
                 sinfo->lcd_wiring_mode = pdata_sinfo->lcd_wiring_mode;
         } else {
                 dev_err(dev, "cannot get default configuration\n");
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 4cb6a576c567..b0b2ac335347 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1818,6 +1818,7 @@ static void aty128_bl_init(struct aty128fb_par *par)
         snprintf(name, sizeof(name), "aty128bl%d", info->node);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, info->dev, par, &aty128_bl_data,
                                        &props);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 94e293fce1d2..ebb893c49e90 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2241,6 +2241,7 @@ static void aty_bl_init(struct atyfb_par *par)
         snprintf(name, sizeof(name), "atybl%d", info->node);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, info->dev, par, &aty_bl_data,
                                        &props);
@@ -3123,12 +3124,12 @@ static int __devinit atyfb_setup_sparc(struct pci_dev *pdev,
                 M = pll_regs[2];
 
                 /*
-                 * PLL Feedback Divider N (Dependant on CLOCK_CNTL):
+                 * PLL Feedback Divider N (Dependent on CLOCK_CNTL):
                  */
                 N = pll_regs[7 + (clock_cntl & 3)];
 
                 /*
-                 * PLL Post Divider P (Dependant on CLOCK_CNTL):
+                 * PLL Post Divider P (Dependent on CLOCK_CNTL):
                  */
                 P = 1 << (pll_regs[6] >> ((clock_cntl & 3) << 1));
 
diff --git a/drivers/video/aty/mach64_cursor.c b/drivers/video/aty/mach64_cursor.c
index 2ba8b3c421a1..46f72ed53510 100644
--- a/drivers/video/aty/mach64_cursor.c
+++ b/drivers/video/aty/mach64_cursor.c
@@ -51,7 +51,7 @@
  * to a larger number and saturate CUR_HORZ_POSN to zero.
  *
  * if Y becomes negative, CUR_VERT_OFFSET must be adjusted to a larger number,
- * CUR_OFFSET must be adjusted to a point to the appropraite line in the cursor
+ * CUR_OFFSET must be adjusted to a point to the appropriate line in the cursor
  * definitation and CUR_VERT_POSN must be saturated to zero.
  */
 
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 9b811ddbce83..db572df7e1ef 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -158,6 +158,7 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
         snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, rinfo->info->dev, pdata,
                                        &radeon_bl_data, &props);
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 3c1e13ed1cba..32f8cf6200a7 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -1248,7 +1248,7 @@ static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_reg
 
         /* Workaround from XFree */
         if (rinfo->is_mobility) {
-                /* A temporal workaround for the occational blanking on certain laptop
+                /* A temporal workaround for the occasional blanking on certain laptop
                  * panels. This appears to related to the PLL divider registers
                  * (fail to lock?). It occurs even when all dividers are the same
                  * with their old settings. In this case we really don't need to
diff --git a/drivers/video/aty/radeon_i2c.c b/drivers/video/aty/radeon_i2c.c
index 78d1f4cd1fe0..ab1d0fd76316 100644
--- a/drivers/video/aty/radeon_i2c.c
+++ b/drivers/video/aty/radeon_i2c.c
@@ -100,6 +100,9 @@ void radeon_create_i2c_busses(struct radeonfb_info *rinfo)
 {
         rinfo->i2c[0].rinfo     = rinfo;
         rinfo->i2c[0].ddc_reg   = GPIO_MONID;
+#ifndef CONFIG_PPC
+        rinfo->i2c[0].adapter.class = I2C_CLASS_HWMON;
+#endif
         radeon_setup_i2c_bus(&rinfo->i2c[0], "monid");
 
         rinfo->i2c[1].rinfo     = rinfo;
diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c
index 4ea187d93768..5dff32ac8044 100644
--- a/drivers/video/au1200fb.c
+++ b/drivers/video/au1200fb.c
@@ -1572,7 +1572,7 @@ static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
         /* Copy monitor specs from panel data */
         /* fixme: we're setting up LCD controller windows, so these dont give a
         damn as to what the monitor specs are (the panel itself does, but that
-        isnt done here...so maybe need a generic catchall monitor setting??? */
+        isn't done here...so maybe need a generic catchall monitor setting??? */
         memcpy(&fbi->monspecs, &panel->monspecs, sizeof(struct fb_monspecs));
 
         /* We first try the user mode passed in argument. If that failed,
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index b224396b86d5..c8b520e9a11a 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -12,11 +12,12 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/fb.h>
 #include <linux/i2c.h>
 #include <linux/backlight.h>
+#include <linux/mfd/core.h>
 #include <linux/mfd/88pm860x.h>
-#include <linux/slab.h>
 
 #define MAX_BRIGHTNESS          (0xFF)
 #define MIN_BRIGHTNESS          (0)
@@ -161,32 +162,13 @@ static const struct backlight_ops pm860x_backlight_ops = {
         .get_brightness = pm860x_backlight_get_brightness,
 };
 
-static int __check_device(struct pm860x_backlight_pdata *pdata, char *name)
-{
-        struct pm860x_backlight_pdata *p = pdata;
-        int ret = -EINVAL;
-
-        while (p && p->id) {
-                if ((p->id != PM8606_ID_BACKLIGHT) || (p->flags < 0))
-                        break;
-
-                if (!strncmp(name, pm860x_backlight_name[p->flags],
-                        MFD_NAME_SIZE)) {
-                        ret = (int)p->flags;
-                        break;
-                }
-                p++;
-        }
-        return ret;
-}
-
 static int pm860x_backlight_probe(struct platform_device *pdev)
 {
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-        struct pm860x_platform_data *pm860x_pdata;
         struct pm860x_backlight_pdata *pdata = NULL;
         struct pm860x_backlight_data *data;
         struct backlight_device *bl;
+        struct mfd_cell *cell;
         struct resource *res;
         struct backlight_properties props;
         unsigned char value;
@@ -199,10 +181,10 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        if (pdev->dev.parent->platform_data) {
-                pm860x_pdata = pdev->dev.parent->platform_data;
-                pdata = pm860x_pdata->backlight;
-        }
+        cell = pdev->dev.platform_data;
+        if (cell == NULL)
+                return -ENODEV;
+        pdata = cell->mfd_data;
         if (pdata == NULL) {
                 dev_err(&pdev->dev, "platform data isn't assigned to "
                         "backlight\n");
@@ -219,7 +201,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         data->current_brightness = MAX_BRIGHTNESS;
         data->pwm = pdata->pwm;
         data->iset = pdata->iset;
-        data->port = __check_device(pdata, name);
+        data->port = pdata->flags;
         if (data->port < 0) {
                 dev_err(&pdev->dev, "wrong platform data is assigned");
                 kfree(data);
@@ -227,6 +209,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = MAX_BRIGHTNESS;
         bl = backlight_device_register(name, &pdev->dev, data,
                                         &pm860x_backlight_ops, &props);
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index e54a337227ea..0c9373bedd1f 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -109,6 +109,14 @@ config LCD_S6E63M0
           If you have an S6E63M0 LCD Panel, say Y to enable its
           LCD control driver.
 
+config LCD_LD9040
+        tristate "LD9040 AMOLED LCD Driver"
+        depends on SPI && BACKLIGHT_CLASS_DEVICE
+        default n
+        help
+          If you have an LD9040 Panel, say Y to enable its
+          control driver.
+
 endif # LCD_CLASS_DEVICE
 
 #
@@ -236,12 +244,12 @@ config BACKLIGHT_MAX8925
           If you have a LCD backlight connected to the WLED output of MAX8925
           WLED output, say Y here to enable this driver.
 
-config BACKLIGHT_MBP_NVIDIA
-       tristate "MacBook Pro Nvidia Backlight Driver"
-       depends on X86
+config BACKLIGHT_APPLE
+       tristate "Apple Backlight Driver"
+       depends on X86 && ACPI
        help
-         If you have an Apple Macbook Pro with Nvidia graphics hardware say Y
-         to enable a driver for its backlight
+         If you have an Intel-based Apple say Y to enable a driver for its
+         backlight.
 
 config BACKLIGHT_TOSA
         tristate "Sharp SL-6000 Backlight Driver"
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 44c0f81ad85d..b9ca8490df87 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_LCD_VGG2432A4)	   += vgg2432a4.o
 obj-$(CONFIG_LCD_TDO24M)           += tdo24m.o
 obj-$(CONFIG_LCD_TOSA)             += tosa_lcd.o
 obj-$(CONFIG_LCD_S6E63M0)       += s6e63m0.o
+obj-$(CONFIG_LCD_LD9040)        += ld9040.o
 
 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
 obj-$(CONFIG_BACKLIGHT_ATMEL_PWM)    += atmel-pwm-bl.o
@@ -26,7 +27,7 @@ obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
 obj-$(CONFIG_BACKLIGHT_PWM)     += pwm_bl.o
 obj-$(CONFIG_BACKLIGHT_DA903X)  += da903x_bl.o
 obj-$(CONFIG_BACKLIGHT_MAX8925) += max8925_bl.o
-obj-$(CONFIG_BACKLIGHT_MBP_NVIDIA) += mbp_nvidia_bl.o
+obj-$(CONFIG_BACKLIGHT_APPLE)   += apple_bl.o
 obj-$(CONFIG_BACKLIGHT_TOSA)    += tosa_bl.o
 obj-$(CONFIG_BACKLIGHT_SAHARA)  += kb3886_bl.o
 obj-$(CONFIG_BACKLIGHT_WM831X)  += wm831x_bl.o
diff --git a/drivers/video/backlight/adp5520_bl.c b/drivers/video/backlight/adp5520_bl.c
index 9f436e014f85..af3119707dbf 100644
--- a/drivers/video/backlight/adp5520_bl.c
+++ b/drivers/video/backlight/adp5520_bl.c
@@ -303,6 +303,7 @@ static int __devinit adp5520_bl_probe(struct platform_device *pdev)
         mutex_init(&data->lock);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = ADP5020_MAX_BRIGHTNESS;
         bl = backlight_device_register(pdev->name, data->master, data,
                                        &adp5520_bl_ops, &props);
diff --git a/drivers/video/backlight/adp8860_bl.c b/drivers/video/backlight/adp8860_bl.c
index 734c650a47c4..d2a96a421ffd 100644
--- a/drivers/video/backlight/adp8860_bl.c
+++ b/drivers/video/backlight/adp8860_bl.c
@@ -709,6 +709,7 @@ static int __devinit adp8860_probe(struct i2c_client *client,
         i2c_set_clientdata(client, data);
 
         memset(&props, 0, sizeof(props));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = ADP8860_MAX_BRIGHTNESS;
 
         mutex_init(&data->lock);
diff --git a/drivers/video/backlight/adx_bl.c b/drivers/video/backlight/adx_bl.c
index fe9af129c5dd..c861c41af442 100644
--- a/drivers/video/backlight/adx_bl.c
+++ b/drivers/video/backlight/adx_bl.c
@@ -104,6 +104,7 @@ static int __devinit adx_backlight_probe(struct platform_device *pdev)
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 0xff;
         bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
                                           bl, &adx_backlight_ops, &props);
diff --git a/drivers/video/backlight/apple_bl.c b/drivers/video/backlight/apple_bl.c
new file mode 100644
index 000000000000..be98d152b7fd
--- /dev/null
+++ b/drivers/video/backlight/apple_bl.c
@@ -0,0 +1,241 @@
+/*
+ *  Backlight Driver for Intel-based Apples
+ *
+ *  Copyright (c) Red Hat <mjg@redhat.com>
+ *  Based on code from Pommed:
+ *  Copyright (C) 2006 Nicolas Boichat <nicolas @boichat.ch>
+ *  Copyright (C) 2006 Felipe Alfaro Solana <felipe_alfaro @linuxmail.org>
+ *  Copyright (C) 2007 Julien BLACHE <jb@jblache.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This driver triggers SMIs which cause the firmware to change the
+ *  backlight brightness. This is icky in many ways, but it's impractical to
+ *  get at the firmware code in order to figure out what it's actually doing.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/pci.h>
+#include <linux/acpi.h>
+
+static struct backlight_device *apple_backlight_device;
+
+struct hw_data {
+        /* I/O resource to allocate. */
+        unsigned long iostart;
+        unsigned long iolen;
+        /* Backlight operations structure. */
+        const struct backlight_ops backlight_ops;
+        void (*set_brightness)(int);
+};
+
+static const struct hw_data *hw_data;
+
+#define DRIVER "apple_backlight: "
+
+/* Module parameters. */
+static int debug;
+module_param_named(debug, debug, int, 0644);
+MODULE_PARM_DESC(debug, "Set to one to enable debugging messages.");
+
+/*
+ * Implementation for machines with Intel chipset.
+ */
+static void intel_chipset_set_brightness(int intensity)
+{
+        outb(0x04 | (intensity << 4), 0xb3);
+        outb(0xbf, 0xb2);
+}
+
+static int intel_chipset_send_intensity(struct backlight_device *bd)
+{
+        int intensity = bd->props.brightness;
+
+        if (debug)
+                printk(KERN_DEBUG DRIVER "setting brightness to %d\n",
+                       intensity);
+
+        intel_chipset_set_brightness(intensity);
+        return 0;
+}
+
+static int intel_chipset_get_intensity(struct backlight_device *bd)
+{
+        int intensity;
+
+        outb(0x03, 0xb3);
+        outb(0xbf, 0xb2);
+        intensity = inb(0xb3) >> 4;
+
+        if (debug)
+                printk(KERN_DEBUG DRIVER "read brightness of %d\n",
+                       intensity);
+
+        return intensity;
+}
+
+static const struct hw_data intel_chipset_data = {
+        .iostart = 0xb2,
+        .iolen = 2,
+        .backlight_ops  = {
+                .options        = BL_CORE_SUSPENDRESUME,
+                .get_brightness = intel_chipset_get_intensity,
+                .update_status  = intel_chipset_send_intensity,
+        },
+        .set_brightness = intel_chipset_set_brightness,
+};
+
+/*
+ * Implementation for machines with Nvidia chipset.
+ */
+static void nvidia_chipset_set_brightness(int intensity)
+{
+        outb(0x04 | (intensity << 4), 0x52f);
+        outb(0xbf, 0x52e);
+}
+
+static int nvidia_chipset_send_intensity(struct backlight_device *bd)
+{
+        int intensity = bd->props.brightness;
+
+        if (debug)
+                printk(KERN_DEBUG DRIVER "setting brightness to %d\n",
+                       intensity);
+
+        nvidia_chipset_set_brightness(intensity);
+        return 0;
+}
+
+static int nvidia_chipset_get_intensity(struct backlight_device *bd)
+{
+        int intensity;
+
+        outb(0x03, 0x52f);
+        outb(0xbf, 0x52e);
+        intensity = inb(0x52f) >> 4;
+
+        if (debug)
+                printk(KERN_DEBUG DRIVER "read brightness of %d\n",
+                       intensity);
+
+        return intensity;
+}
+
+static const struct hw_data nvidia_chipset_data = {
+        .iostart = 0x52e,
+        .iolen = 2,
+        .backlight_ops          = {
+                .options        = BL_CORE_SUSPENDRESUME,
+                .get_brightness = nvidia_chipset_get_intensity,
+                .update_status  = nvidia_chipset_send_intensity
+        },
+        .set_brightness = nvidia_chipset_set_brightness,
+};
+
+static int __devinit apple_bl_add(struct acpi_device *dev)
+{
+        struct backlight_properties props;
+        struct pci_dev *host;
+        int intensity;
+
+        host = pci_get_bus_and_slot(0, 0);
+
+        if (!host) {
+                printk(KERN_ERR DRIVER "unable to find PCI host\n");
+                return -ENODEV;
+        }
+
+        if (host->vendor == PCI_VENDOR_ID_INTEL)
+                hw_data = &intel_chipset_data;
+        else if (host->vendor == PCI_VENDOR_ID_NVIDIA)
+                hw_data = &nvidia_chipset_data;
+
+        pci_dev_put(host);
+
+        if (!hw_data) {
+                printk(KERN_ERR DRIVER "unknown hardware\n");
+                return -ENODEV;
+        }
+
+        /* Check that the hardware responds - this may not work under EFI */
+
+        intensity = hw_data->backlight_ops.get_brightness(NULL);
+
+        if (!intensity) {
+                hw_data->set_brightness(1);
+                if (!hw_data->backlight_ops.get_brightness(NULL))
+                        return -ENODEV;
+
+                hw_data->set_brightness(0);
+        }
+
+        if (!request_region(hw_data->iostart, hw_data->iolen,
+                            "Apple backlight"))
+                return -ENXIO;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = 15;
+        apple_backlight_device = backlight_device_register("apple_backlight",
+                                  NULL, NULL, &hw_data->backlight_ops, &props);
+
+        if (IS_ERR(apple_backlight_device)) {
+                release_region(hw_data->iostart, hw_data->iolen);
+                return PTR_ERR(apple_backlight_device);
+        }
+
+        apple_backlight_device->props.brightness =
+                hw_data->backlight_ops.get_brightness(apple_backlight_device);
+        backlight_update_status(apple_backlight_device);
+
+        return 0;
+}
+
+static int __devexit apple_bl_remove(struct acpi_device *dev, int type)
+{
+        backlight_device_unregister(apple_backlight_device);
+
+        release_region(hw_data->iostart, hw_data->iolen);
+        hw_data = NULL;
+        return 0;
+}
+
+static const struct acpi_device_id apple_bl_ids[] = {
+        {"APP0002", 0},
+        {"", 0},
+};
+
+static struct acpi_driver apple_bl_driver = {
+        .name = "Apple backlight",
+        .ids = apple_bl_ids,
+        .ops = {
+                .add = apple_bl_add,
+                .remove = apple_bl_remove,
+        },
+};
+
+static int __init apple_bl_init(void)
+{
+        return acpi_bus_register_driver(&apple_bl_driver);
+}
+
+static void __exit apple_bl_exit(void)
+{
+        acpi_bus_unregister_driver(&apple_bl_driver);
+}
+
+module_init(apple_bl_init);
+module_exit(apple_bl_exit);
+
+MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
+MODULE_DESCRIPTION("Apple Backlight Driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(acpi, apple_bl_ids);
+MODULE_ALIAS("mbp_nvidia_bl");
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index e6a66dab088c..0443a4f71858 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -168,6 +168,7 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
         bldev = backlight_device_register("atmel-pwm-bl", &pdev->dev, pwmbl,
                                           &atmel_pwm_bl_ops, &props);
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 08703299ef61..80d292fb92d8 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -19,6 +19,12 @@
 #include <asm/backlight.h>
 #endif
 
+static const char const *backlight_types[] = {
+        [BACKLIGHT_RAW] = "raw",
+        [BACKLIGHT_PLATFORM] = "platform",
+        [BACKLIGHT_FIRMWARE] = "firmware",
+};
+
 #if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
                            defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
 /* This callback gets called when something important happens inside a
@@ -169,6 +175,14 @@ static ssize_t backlight_store_brightness(struct device *dev,
         return rc;
 }
 
+static ssize_t backlight_show_type(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct backlight_device *bd = to_backlight_device(dev);
+
+        return sprintf(buf, "%s\n", backlight_types[bd->props.type]);
+}
+
 static ssize_t backlight_show_max_brightness(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
@@ -234,6 +248,7 @@ static struct device_attribute bl_device_attributes[] = {
         __ATTR(actual_brightness, 0444, backlight_show_actual_brightness,
                      NULL),
         __ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL),
+        __ATTR(type, 0444, backlight_show_type, NULL),
         __ATTR_NULL,
 };
 
@@ -292,9 +307,16 @@ struct backlight_device *backlight_device_register(const char *name,
         dev_set_drvdata(&new_bd->dev, devdata);
 
         /* Set default properties */
-        if (props)
+        if (props) {
                 memcpy(&new_bd->props, props,
                        sizeof(struct backlight_properties));
+                if (props->type <= 0 || props->type >= BACKLIGHT_TYPE_MAX) {
+                        WARN(1, "%s: invalid backlight type", name);
+                        new_bd->props.type = BACKLIGHT_RAW;
+                }
+        } else {
+                new_bd->props.type = BACKLIGHT_RAW;
+        }
 
         rc = device_register(&new_bd->dev);
         if (rc) {
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index 1e71c35083bb..c6533bad26f8 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -109,7 +109,7 @@ static unsigned long corgibl_flags;
 #define CORGIBL_BATTLOW       0x02
 
 /*
- * This is only a psuedo I2C interface. We can't use the standard kernel
+ * This is only a pseudo I2C interface. We can't use the standard kernel
  * routines as the interface is write only. We just assume the data is acked...
  */
 static void lcdtg_ssp_i2c_send(struct corgi_lcd *lcd, uint8_t data)
@@ -562,6 +562,7 @@ static int __devinit corgi_lcd_probe(struct spi_device *spi)
         lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = pdata->max_intensity;
         lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev, lcd,
                                                 &corgi_bl_ops, &props);
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
index 397d15eb1ea8..6c8c54041fae 100644
--- a/drivers/video/backlight/cr_bllcd.c
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -193,6 +193,7 @@ static int cr_backlight_probe(struct platform_device *pdev)
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         bdp = backlight_device_register("cr-backlight", &pdev->dev, NULL,
                                         &cr_backlight_ops, &props);
         if (IS_ERR(bdp)) {
diff --git a/drivers/video/backlight/da903x_bl.c b/drivers/video/backlight/da903x_bl.c
index 87659ed79bd7..62043f12a5a4 100644
--- a/drivers/video/backlight/da903x_bl.c
+++ b/drivers/video/backlight/da903x_bl.c
@@ -136,6 +136,7 @@ static int da903x_backlight_probe(struct platform_device *pdev)
                 da903x_write(data->da903x_dev, DA9034_WLED_CONTROL2,
                                 DA9034_WLED_ISET(pdata->output_current));
 
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = max_brightness;
         bl = backlight_device_register(pdev->name, data->da903x_dev, data,
                                        &da903x_backlight_ops, &props);
diff --git a/drivers/video/backlight/ep93xx_bl.c b/drivers/video/backlight/ep93xx_bl.c
index b0cc49184803..9f1e389d51d2 100644
--- a/drivers/video/backlight/ep93xx_bl.c
+++ b/drivers/video/backlight/ep93xx_bl.c
@@ -87,6 +87,7 @@ static int __init ep93xxbl_probe(struct platform_device *dev)
         ep93xxbl->mmio = EP93XX_RASTER_BRIGHTNESS;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = EP93XX_MAX_BRIGHT;
         bl = backlight_device_register(dev->name, &dev->dev, ep93xxbl,
                                        &ep93xxbl_ops, &props);
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
index 312ca619735d..8c6befd65a33 100644
--- a/drivers/video/backlight/generic_bl.c
+++ b/drivers/video/backlight/generic_bl.c
@@ -91,6 +91,7 @@ static int genericbl_probe(struct platform_device *pdev)
                 name = machinfo->name;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = machinfo->max_intensity;
         bd = backlight_device_register(name, &pdev->dev, NULL, &genericbl_ops,
                                        &props);
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index 267d23f8d645..38aa00272141 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -109,6 +109,7 @@ static int __devinit hp680bl_probe(struct platform_device *pdev)
         struct backlight_device *bd;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = HP680_MAX_INTENSITY;
         bd = backlight_device_register("hp680-bl", &pdev->dev, NULL,
                                        &hp680bl_ops, &props);
diff --git a/drivers/video/backlight/jornada720_bl.c b/drivers/video/backlight/jornada720_bl.c
index 2f177b3a4885..de65d80159be 100644
--- a/drivers/video/backlight/jornada720_bl.c
+++ b/drivers/video/backlight/jornada720_bl.c
@@ -106,6 +106,7 @@ static int jornada_bl_probe(struct platform_device *pdev)
         struct backlight_device *bd;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = BL_MAX_BRIGHT;
         bd = backlight_device_register(S1D_DEVICENAME, &pdev->dev, NULL,
                                        &jornada_bl_ops, &props);
@@ -146,12 +147,12 @@ static struct platform_driver jornada_bl_driver = {
         },
 };
 
-int __init jornada_bl_init(void)
+static int __init jornada_bl_init(void)
 {
         return platform_driver_register(&jornada_bl_driver);
 }
 
-void __exit jornada_bl_exit(void)
+static void __exit jornada_bl_exit(void)
 {
         platform_driver_unregister(&jornada_bl_driver);
 }
diff --git a/drivers/video/backlight/jornada720_lcd.c b/drivers/video/backlight/jornada720_lcd.c
index cbbb167fd268..d2ff658b4144 100644
--- a/drivers/video/backlight/jornada720_lcd.c
+++ b/drivers/video/backlight/jornada720_lcd.c
@@ -135,12 +135,12 @@ static struct platform_driver jornada_lcd_driver = {
         },
 };
 
-int __init jornada_lcd_init(void)
+static int __init jornada_lcd_init(void)
 {
         return platform_driver_register(&jornada_lcd_driver);
 }
 
-void __exit jornada_lcd_exit(void)
+static void __exit jornada_lcd_exit(void)
 {
         platform_driver_unregister(&jornada_lcd_driver);
 }
diff --git a/drivers/video/backlight/kb3886_bl.c b/drivers/video/backlight/kb3886_bl.c
index f439a8632287..72dd5556a35b 100644
--- a/drivers/video/backlight/kb3886_bl.c
+++ b/drivers/video/backlight/kb3886_bl.c
@@ -149,6 +149,7 @@ static int kb3886bl_probe(struct platform_device *pdev)
                 machinfo->limit_mask = -1;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = machinfo->max_intensity;
         kb3886_backlight_device = backlight_device_register("kb3886-bl",
                                                             &pdev->dev, NULL,
diff --git a/drivers/video/backlight/ld9040.c b/drivers/video/backlight/ld9040.c
new file mode 100644
index 000000000000..7281b2506a67
--- /dev/null
+++ b/drivers/video/backlight/ld9040.c
@@ -0,0 +1,819 @@
+/*
+ * ld9040 AMOLED LCD panel driver.
+ *
+ * Copyright (c) 2011 Samsung Electronics
+ * Author: Donghwa Lee  <dh09.lee@samsung.com>
+ * Derived from drivers/video/backlight/s6e63m0.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include <linux/wait.h>
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/lcd.h>
+#include <linux/backlight.h>
+
+#include "ld9040_gamma.h"
+
+#define SLEEPMSEC               0x1000
+#define ENDDEF                  0x2000
+#define DEFMASK                 0xFF00
+#define COMMAND_ONLY            0xFE
+#define DATA_ONLY               0xFF
+
+#define MIN_BRIGHTNESS          0
+#define MAX_BRIGHTNESS          24
+#define power_is_on(pwr)        ((pwr) <= FB_BLANK_NORMAL)
+
+struct ld9040 {
+        struct device                   *dev;
+        struct spi_device               *spi;
+        unsigned int                    power;
+        unsigned int                    current_brightness;
+
+        struct lcd_device               *ld;
+        struct backlight_device         *bd;
+        struct lcd_platform_data        *lcd_pd;
+};
+
+static const unsigned short seq_swreset[] = {
+        0x01, COMMAND_ONLY,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_user_setting[] = {
+        0xF0, 0x5A,
+
+        DATA_ONLY, 0x5A,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_elvss_on[] = {
+        0xB1, 0x0D,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x16,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gtcon[] = {
+        0xF7, 0x09,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_panel_condition[] = {
+        0xF8, 0x05,
+
+        DATA_ONLY, 0x65,
+        DATA_ONLY, 0x96,
+        DATA_ONLY, 0x71,
+        DATA_ONLY, 0x7D,
+        DATA_ONLY, 0x19,
+        DATA_ONLY, 0x3B,
+        DATA_ONLY, 0x0D,
+        DATA_ONLY, 0x19,
+        DATA_ONLY, 0x7E,
+        DATA_ONLY, 0x0D,
+        DATA_ONLY, 0xE2,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x7E,
+        DATA_ONLY, 0x7D,
+        DATA_ONLY, 0x07,
+        DATA_ONLY, 0x07,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x02,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gamma_set1[] = {
+        0xF9, 0x00,
+
+        DATA_ONLY, 0xA7,
+        DATA_ONLY, 0xB4,
+        DATA_ONLY, 0xAE,
+        DATA_ONLY, 0xBF,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x91,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0xB2,
+        DATA_ONLY, 0xB4,
+        DATA_ONLY, 0xAA,
+        DATA_ONLY, 0xBB,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0xAC,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0xB3,
+        DATA_ONLY, 0xB1,
+        DATA_ONLY, 0xAA,
+        DATA_ONLY, 0xBC,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0xB3,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gamma_ctrl[] = {
+        0xFB, 0x02,
+
+        DATA_ONLY, 0x5A,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gamma_start[] = {
+        0xF9, COMMAND_ONLY,
+
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_apon[] = {
+        0xF3, 0x00,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x0A,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_display_ctrl[] = {
+        0xF2, 0x02,
+
+        DATA_ONLY, 0x08,
+        DATA_ONLY, 0x08,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x10,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_manual_pwr[] = {
+        0xB0, 0x04,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_pwr_ctrl[] = {
+        0xF4, 0x0A,
+
+        DATA_ONLY, 0x87,
+        DATA_ONLY, 0x25,
+        DATA_ONLY, 0x6A,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x02,
+        DATA_ONLY, 0x88,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_sleep_out[] = {
+        0x11, COMMAND_ONLY,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_sleep_in[] = {
+        0x10, COMMAND_ONLY,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_display_on[] = {
+        0x29, COMMAND_ONLY,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_display_off[] = {
+        0x28, COMMAND_ONLY,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vci1_1st_en[] = {
+        0xF3, 0x10,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vl1_en[] = {
+        0xF3, 0x11,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vl2_en[] = {
+        0xF3, 0x13,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vci1_2nd_en[] = {
+        0xF3, 0x33,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vl3_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vreg1_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0x01,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vgh_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0x11,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vgl_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0x31,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x02,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vmos_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xB1,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vint_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xF1,
+        /* DATA_ONLY, 0x71,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vbh_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xF9,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_vbl_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFD,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gam_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFF,
+        /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_sd_amp_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFF,
+        /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x80,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_gls_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFF,
+        /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x81,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_els_en[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFF,
+        /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x83,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static const unsigned short seq_el_on[] = {
+        0xF3, 0x37,
+
+        DATA_ONLY, 0xFF,
+        /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
+        DATA_ONLY, 0x87,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
+        ENDDEF, 0x00
+};
+
+static int ld9040_spi_write_byte(struct ld9040 *lcd, int addr, int data)
+{
+        u16 buf[1];
+        struct spi_message msg;
+
+        struct spi_transfer xfer = {
+                .len            = 2,
+                .tx_buf         = buf,
+        };
+
+        buf[0] = (addr << 8) | data;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        return spi_sync(lcd->spi, &msg);
+}
+
+static int ld9040_spi_write(struct ld9040 *lcd, unsigned char address,
+        unsigned char command)
+{
+        int ret = 0;
+
+        if (address != DATA_ONLY)
+                ret = ld9040_spi_write_byte(lcd, 0x0, address);
+        if (command != COMMAND_ONLY)
+                ret = ld9040_spi_write_byte(lcd, 0x1, command);
+
+        return ret;
+}
+
+static int ld9040_panel_send_sequence(struct ld9040 *lcd,
+        const unsigned short *wbuf)
+{
+        int ret = 0, i = 0;
+
+        while ((wbuf[i] & DEFMASK) != ENDDEF) {
+                if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
+                        ret = ld9040_spi_write(lcd, wbuf[i], wbuf[i+1]);
+                        if (ret)
+                                break;
+                } else
+                        udelay(wbuf[i+1]*1000);
+                i += 2;
+        }
+
+        return ret;
+}
+
+static int _ld9040_gamma_ctl(struct ld9040 *lcd, const unsigned int *gamma)
+{
+        unsigned int i = 0;
+        int ret = 0;
+
+        /* start gamma table updating. */
+        ret = ld9040_panel_send_sequence(lcd, seq_gamma_start);
+        if (ret) {
+                dev_err(lcd->dev, "failed to disable gamma table updating.\n");
+                goto gamma_err;
+        }
+
+        for (i = 0 ; i < GAMMA_TABLE_COUNT; i++) {
+                ret = ld9040_spi_write(lcd, DATA_ONLY, gamma[i]);
+                if (ret) {
+                        dev_err(lcd->dev, "failed to set gamma table.\n");
+                        goto gamma_err;
+                }
+        }
+
+        /* update gamma table. */
+        ret = ld9040_panel_send_sequence(lcd, seq_gamma_ctrl);
+        if (ret)
+                dev_err(lcd->dev, "failed to update gamma table.\n");
+
+gamma_err:
+        return ret;
+}
+
+static int ld9040_gamma_ctl(struct ld9040 *lcd, int gamma)
+{
+        int ret = 0;
+
+        ret = _ld9040_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
+
+        return ret;
+}
+
+
+static int ld9040_ldi_init(struct ld9040 *lcd)
+{
+        int ret, i;
+        static const unsigned short *init_seq[] = {
+                seq_user_setting,
+                seq_panel_condition,
+                seq_display_ctrl,
+                seq_manual_pwr,
+                seq_elvss_on,
+                seq_gtcon,
+                seq_gamma_set1,
+                seq_gamma_ctrl,
+                seq_sleep_out,
+        };
+
+        for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
+                ret = ld9040_panel_send_sequence(lcd, init_seq[i]);
+                /* workaround: minimum delay time for transferring CMD */
+                udelay(300);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int ld9040_ldi_enable(struct ld9040 *lcd)
+{
+        int ret = 0;
+
+        ret = ld9040_panel_send_sequence(lcd, seq_display_on);
+
+        return ret;
+}
+
+static int ld9040_ldi_disable(struct ld9040 *lcd)
+{
+        int ret;
+
+        ret = ld9040_panel_send_sequence(lcd, seq_display_off);
+        ret = ld9040_panel_send_sequence(lcd, seq_sleep_in);
+
+        return ret;
+}
+
+static int ld9040_power_on(struct ld9040 *lcd)
+{
+        int ret = 0;
+        struct lcd_platform_data *pd = NULL;
+        pd = lcd->lcd_pd;
+        if (!pd) {
+                dev_err(lcd->dev, "platform data is NULL.\n");
+                return -EFAULT;
+        }
+
+        if (!pd->power_on) {
+                dev_err(lcd->dev, "power_on is NULL.\n");
+                return -EFAULT;
+        } else {
+                pd->power_on(lcd->ld, 1);
+                mdelay(pd->power_on_delay);
+        }
+
+        if (!pd->reset) {
+                dev_err(lcd->dev, "reset is NULL.\n");
+                return -EFAULT;
+        } else {
+                pd->reset(lcd->ld);
+                mdelay(pd->reset_delay);
+        }
+
+        ret = ld9040_ldi_init(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "failed to initialize ldi.\n");
+                return ret;
+        }
+
+        ret = ld9040_ldi_enable(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "failed to enable ldi.\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int ld9040_power_off(struct ld9040 *lcd)
+{
+        int ret = 0;
+        struct lcd_platform_data *pd = NULL;
+
+        pd = lcd->lcd_pd;
+        if (!pd) {
+                dev_err(lcd->dev, "platform data is NULL.\n");
+                return -EFAULT;
+        }
+
+        ret = ld9040_ldi_disable(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "lcd setting failed.\n");
+                return -EIO;
+        }
+
+        mdelay(pd->power_off_delay);
+
+        if (!pd->power_on) {
+                dev_err(lcd->dev, "power_on is NULL.\n");
+                return -EFAULT;
+        } else
+                pd->power_on(lcd->ld, 0);
+
+        return 0;
+}
+
+static int ld9040_power(struct ld9040 *lcd, int power)
+{
+        int ret = 0;
+
+        if (power_is_on(power) && !power_is_on(lcd->power))
+                ret = ld9040_power_on(lcd);
+        else if (!power_is_on(power) && power_is_on(lcd->power))
+                ret = ld9040_power_off(lcd);
+
+        if (!ret)
+                lcd->power = power;
+
+        return ret;
+}
+
+static int ld9040_set_power(struct lcd_device *ld, int power)
+{
+        struct ld9040 *lcd = lcd_get_data(ld);
+
+        if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
+                power != FB_BLANK_NORMAL) {
+                dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
+                return -EINVAL;
+        }
+
+        return ld9040_power(lcd, power);
+}
+
+static int ld9040_get_power(struct lcd_device *ld)
+{
+        struct ld9040 *lcd = lcd_get_data(ld);
+
+        return lcd->power;
+}
+
+static int ld9040_get_brightness(struct backlight_device *bd)
+{
+        return bd->props.brightness;
+}
+
+static int ld9040_set_brightness(struct backlight_device *bd)
+{
+        int ret = 0, brightness = bd->props.brightness;
+        struct ld9040 *lcd = bl_get_data(bd);
+
+        if (brightness < MIN_BRIGHTNESS ||
+                brightness > bd->props.max_brightness) {
+                dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
+                        MIN_BRIGHTNESS, MAX_BRIGHTNESS);
+                return -EINVAL;
+        }
+
+        ret = ld9040_gamma_ctl(lcd, bd->props.brightness);
+        if (ret) {
+                dev_err(&bd->dev, "lcd brightness setting failed.\n");
+                return -EIO;
+        }
+
+        return ret;
+}
+
+static struct lcd_ops ld9040_lcd_ops = {
+        .set_power = ld9040_set_power,
+        .get_power = ld9040_get_power,
+};
+
+static const struct backlight_ops ld9040_backlight_ops  = {
+        .get_brightness = ld9040_get_brightness,
+        .update_status = ld9040_set_brightness,
+};
+
+
+static int ld9040_probe(struct spi_device *spi)
+{
+        int ret = 0;
+        struct ld9040 *lcd = NULL;
+        struct lcd_device *ld = NULL;
+        struct backlight_device *bd = NULL;
+
+        lcd = kzalloc(sizeof(struct ld9040), GFP_KERNEL);
+        if (!lcd)
+                return -ENOMEM;
+
+        /* ld9040 lcd panel uses 3-wire 9bits SPI Mode. */
+        spi->bits_per_word = 9;
+
+        ret = spi_setup(spi);
+        if (ret < 0) {
+                dev_err(&spi->dev, "spi setup failed.\n");
+                goto out_free_lcd;
+        }
+
+        lcd->spi = spi;
+        lcd->dev = &spi->dev;
+
+        lcd->lcd_pd = spi->dev.platform_data;
+        if (!lcd->lcd_pd) {
+                dev_err(&spi->dev, "platform data is NULL.\n");
+                goto out_free_lcd;
+        }
+
+        ld = lcd_device_register("ld9040", &spi->dev, lcd, &ld9040_lcd_ops);
+        if (IS_ERR(ld)) {
+                ret = PTR_ERR(ld);
+                goto out_free_lcd;
+        }
+
+        lcd->ld = ld;
+
+        bd = backlight_device_register("ld9040-bl", &spi->dev,
+                lcd, &ld9040_backlight_ops, NULL);
+        if (IS_ERR(ld)) {
+                ret = PTR_ERR(ld);
+                goto out_free_lcd;
+        }
+
+        bd->props.max_brightness = MAX_BRIGHTNESS;
+        bd->props.brightness = MAX_BRIGHTNESS;
+        lcd->bd = bd;
+
+        /*
+         * if lcd panel was on from bootloader like u-boot then
+         * do not lcd on.
+         */
+        if (!lcd->lcd_pd->lcd_enabled) {
+                /*
+                 * if lcd panel was off from bootloader then
+                 * current lcd status is powerdown and then
+                 * it enables lcd panel.
+                 */
+                lcd->power = FB_BLANK_POWERDOWN;
+
+                ld9040_power(lcd, FB_BLANK_UNBLANK);
+        } else
+                lcd->power = FB_BLANK_UNBLANK;
+
+        dev_set_drvdata(&spi->dev, lcd);
+
+        dev_info(&spi->dev, "ld9040 panel driver has been probed.\n");
+        return 0;
+
+out_free_lcd:
+        kfree(lcd);
+        return ret;
+}
+
+static int __devexit ld9040_remove(struct spi_device *spi)
+{
+        struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
+
+        ld9040_power(lcd, FB_BLANK_POWERDOWN);
+        lcd_device_unregister(lcd->ld);
+        kfree(lcd);
+
+        return 0;
+}
+
+#if defined(CONFIG_PM)
+static int ld9040_suspend(struct spi_device *spi, pm_message_t mesg)
+{
+        int ret = 0;
+        struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
+
+        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+
+        /*
+         * when lcd panel is suspend, lcd panel becomes off
+         * regardless of status.
+         */
+        ret = ld9040_power(lcd, FB_BLANK_POWERDOWN);
+
+        return ret;
+}
+
+static int ld9040_resume(struct spi_device *spi)
+{
+        int ret = 0;
+        struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
+
+        lcd->power = FB_BLANK_POWERDOWN;
+
+        ret = ld9040_power(lcd, FB_BLANK_UNBLANK);
+
+        return ret;
+}
+#else
+#define ld9040_suspend          NULL
+#define ld9040_resume           NULL
+#endif
+
+/* Power down all displays on reboot, poweroff or halt. */
+static void ld9040_shutdown(struct spi_device *spi)
+{
+        struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
+
+        ld9040_power(lcd, FB_BLANK_POWERDOWN);
+}
+
+static struct spi_driver ld9040_driver = {
+        .driver = {
+                .name   = "ld9040",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ld9040_probe,
+        .remove         = __devexit_p(ld9040_remove),
+        .shutdown       = ld9040_shutdown,
+        .suspend        = ld9040_suspend,
+        .resume         = ld9040_resume,
+};
+
+static int __init ld9040_init(void)
+{
+        return spi_register_driver(&ld9040_driver);
+}
+
+static void __exit ld9040_exit(void)
+{
+        spi_unregister_driver(&ld9040_driver);
+}
+
+module_init(ld9040_init);
+module_exit(ld9040_exit);
+
+MODULE_AUTHOR("Donghwa Lee <dh09.lee@samsung.com>");
+MODULE_DESCRIPTION("ld9040 LCD Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/backlight/ld9040_gamma.h b/drivers/video/backlight/ld9040_gamma.h
new file mode 100644
index 000000000000..038d9c86ec03
--- /dev/null
+++ b/drivers/video/backlight/ld9040_gamma.h
@@ -0,0 +1,200 @@
+/*
+ * Gamma level 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 _LD9040_BRIGHTNESS_H
+#define _LD9040_BRIGHTNESS_H
+
+#define MAX_GAMMA_LEVEL         25
+#define GAMMA_TABLE_COUNT       21
+
+/* gamma value: 2.2 */
+static const unsigned int ld9040_22_300[] = {
+        0x00, 0xa7, 0xb4, 0xae, 0xbf, 0x00, 0x91,
+        0x00, 0xb2, 0xb4, 0xaa, 0xbb, 0x00, 0xac,
+        0x00, 0xb3, 0xb1, 0xaa, 0xbc, 0x00, 0xb3
+};
+
+static const unsigned int ld9040_22_290[] = {
+        0x00, 0xa9, 0xb7, 0xae, 0xbd, 0x00, 0x89,
+        0x00, 0xb7, 0xb6, 0xa8, 0xba, 0x00, 0xa4,
+        0x00, 0xb1, 0xb4, 0xaa, 0xbb, 0x00, 0xaa
+};
+
+static const unsigned int ld9040_22_280[] = {
+        0x00, 0xa9, 0xb6, 0xad, 0xbf, 0x00, 0x86,
+        0x00, 0xb8, 0xb5, 0xa8, 0xbc, 0x00, 0xa0,
+        0x00, 0xb3, 0xb3, 0xa9, 0xbc, 0x00, 0xa7
+};
+
+static const unsigned int ld9040_22_270[] = {
+        0x00, 0xa8, 0xb8, 0xae, 0xbe, 0x00, 0x84,
+        0x00, 0xb9, 0xb7, 0xa8, 0xbc, 0x00, 0x9d,
+        0x00, 0xb2, 0xb5, 0xaa, 0xbc, 0x00, 0xa4
+
+};
+static const unsigned int ld9040_22_260[] = {
+        0x00, 0xa4, 0xb8, 0xb0, 0xbf, 0x00, 0x80,
+        0x00, 0xb8, 0xb6, 0xaa, 0xbc, 0x00, 0x9a,
+        0x00, 0xb0, 0xb5, 0xab, 0xbd, 0x00, 0xa0
+};
+
+static const unsigned int ld9040_22_250[] = {
+        0x00, 0xa4, 0xb9, 0xaf, 0xc1, 0x00, 0x7d,
+        0x00, 0xb9, 0xb6, 0xaa, 0xbb, 0x00, 0x97,
+        0x00, 0xb1, 0xb5, 0xaa, 0xbf, 0x00, 0x9d
+};
+
+static const unsigned int ld9040_22_240[] = {
+        0x00, 0xa2, 0xb9, 0xaf, 0xc2, 0x00, 0x7a,
+        0x00, 0xb9, 0xb7, 0xaa, 0xbd, 0x00, 0x94,
+        0x00, 0xb0, 0xb5, 0xab, 0xbf, 0x00, 0x9a
+};
+
+static const unsigned int ld9040_22_230[] = {
+        0x00, 0xa0, 0xb9, 0xaf, 0xc3, 0x00, 0x77,
+        0x00, 0xb9, 0xb7, 0xab, 0xbe, 0x00, 0x90,
+        0x00, 0xb0, 0xb6, 0xab, 0xbf, 0x00, 0x97
+};
+
+static const unsigned int ld9040_22_220[] = {
+        0x00, 0x9e, 0xba, 0xb0, 0xc2, 0x00, 0x75,
+        0x00, 0xb9, 0xb8, 0xab, 0xbe, 0x00, 0x8e,
+        0x00, 0xb0, 0xb6, 0xac, 0xbf, 0x00, 0x94
+};
+
+static const unsigned int ld9040_22_210[] = {
+        0x00, 0x9c, 0xb9, 0xb0, 0xc4, 0x00, 0x72,
+        0x00, 0xb8, 0xb8, 0xac, 0xbf, 0x00, 0x8a,
+        0x00, 0xb0, 0xb6, 0xac, 0xc0, 0x00, 0x91
+};
+
+static const unsigned int ld9040_22_200[] = {
+        0x00, 0x9a, 0xba, 0xb1, 0xc4, 0x00, 0x6f,
+        0x00, 0xb8, 0xb8, 0xad, 0xc0, 0x00, 0x86,
+        0x00, 0xb0, 0xb7, 0xad, 0xc0, 0x00, 0x8d
+};
+
+static const unsigned int ld9040_22_190[] = {
+        0x00, 0x97, 0xba, 0xb2, 0xc5, 0x00, 0x6c,
+        0x00, 0xb8, 0xb8, 0xae, 0xc1, 0x00, 0x82,
+        0x00, 0xb0, 0xb6, 0xae, 0xc2, 0x00, 0x89
+};
+
+static const unsigned int ld9040_22_180[] = {
+        0x00, 0x93, 0xba, 0xb3, 0xc5, 0x00, 0x69,
+        0x00, 0xb8, 0xb9, 0xae, 0xc1, 0x00, 0x7f,
+        0x00, 0xb0, 0xb6, 0xae, 0xc3, 0x00, 0x85
+};
+
+static const unsigned int ld9040_22_170[] = {
+        0x00, 0x8b, 0xb9, 0xb3, 0xc7, 0x00, 0x65,
+        0x00, 0xb7, 0xb8, 0xaf, 0xc3, 0x00, 0x7a,
+        0x00, 0x80, 0xb6, 0xae, 0xc4, 0x00, 0x81
+};
+
+static const unsigned int ld9040_22_160[] = {
+        0x00, 0x89, 0xba, 0xb3, 0xc8, 0x00, 0x62,
+        0x00, 0xb6, 0xba, 0xaf, 0xc3, 0x00, 0x76,
+        0x00, 0xaf, 0xb7, 0xae, 0xc4, 0x00, 0x7e
+};
+
+static const unsigned int ld9040_22_150[] = {
+        0x00, 0x82, 0xba, 0xb4, 0xc7, 0x00, 0x5f,
+        0x00, 0xb5, 0xba, 0xb0, 0xc3, 0x00, 0x72,
+        0x00, 0xae, 0xb8, 0xb0, 0xc3, 0x00, 0x7a
+};
+
+static const unsigned int ld9040_22_140[] = {
+        0x00, 0x7b, 0xbb, 0xb4, 0xc8, 0x00, 0x5b,
+        0x00, 0xb5, 0xba, 0xb1, 0xc4, 0x00, 0x6e,
+        0x00, 0xae, 0xb9, 0xb0, 0xc5, 0x00, 0x75
+};
+
+static const unsigned int ld9040_22_130[] = {
+        0x00, 0x71, 0xbb, 0xb5, 0xc8, 0x00, 0x57,
+        0x00, 0xb5, 0xbb, 0xb0, 0xc5, 0x00, 0x6a,
+        0x00, 0xae, 0xb9, 0xb1, 0xc6, 0x00, 0x70
+};
+
+static const unsigned int ld9040_22_120[] = {
+        0x00, 0x47, 0xba, 0xb6, 0xca, 0x00, 0x53,
+        0x00, 0xb5, 0xbb, 0xb3, 0xc6, 0x00, 0x65,
+        0x00, 0xae, 0xb8, 0xb3, 0xc7, 0x00, 0x6c
+};
+
+static const unsigned int ld9040_22_110[] = {
+        0x00, 0x13, 0xbb, 0xb7, 0xca, 0x00, 0x4f,
+        0x00, 0xb4, 0xbb, 0xb3, 0xc7, 0x00, 0x60,
+        0x00, 0xad, 0xb8, 0xb4, 0xc7, 0x00, 0x67
+};
+
+static const unsigned int ld9040_22_100[] = {
+        0x00, 0x13, 0xba, 0xb8, 0xcb, 0x00, 0x4b,
+        0x00, 0xb3, 0xbc, 0xb4, 0xc7, 0x00, 0x5c,
+        0x00, 0xac, 0xb8, 0xb4, 0xc8, 0x00, 0x62
+};
+
+static const unsigned int ld9040_22_90[] = {
+        0x00, 0x13, 0xb9, 0xb8, 0xcd, 0x00, 0x46,
+        0x00, 0xb1, 0xbc, 0xb5, 0xc8, 0x00, 0x56,
+        0x00, 0xaa, 0xb8, 0xb4, 0xc9, 0x00, 0x5d
+};
+
+static const unsigned int ld9040_22_80[] = {
+        0x00, 0x13, 0xba, 0xb9, 0xcd, 0x00, 0x41,
+        0x00, 0xb0, 0xbe, 0xb5, 0xc9, 0x00, 0x51,
+        0x00, 0xa9, 0xb9, 0xb5, 0xca, 0x00, 0x57
+};
+
+static const unsigned int ld9040_22_70[] = {
+        0x00, 0x13, 0xb9, 0xb9, 0xd0, 0x00, 0x3c,
+        0x00, 0xaf, 0xbf, 0xb6, 0xcb, 0x00, 0x4b,
+        0x00, 0xa8, 0xb9, 0xb5, 0xcc, 0x00, 0x52
+};
+
+static const unsigned int ld9040_22_50[] = {
+        0x00, 0x13, 0xb2, 0xba, 0xd2, 0x00, 0x30,
+        0x00, 0xaf, 0xc0, 0xb8, 0xcd, 0x00, 0x3d,
+        0x00, 0xa8, 0xb8, 0xb7, 0xcd, 0x00, 0x44
+};
+
+struct ld9040_gamma {
+        unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
+} gamma_table = {
+        .gamma_22_table[0] = (unsigned int *)&ld9040_22_50,
+        .gamma_22_table[1] = (unsigned int *)&ld9040_22_70,
+        .gamma_22_table[2] = (unsigned int *)&ld9040_22_80,
+        .gamma_22_table[3] = (unsigned int *)&ld9040_22_90,
+        .gamma_22_table[4] = (unsigned int *)&ld9040_22_100,
+        .gamma_22_table[5] = (unsigned int *)&ld9040_22_110,
+        .gamma_22_table[6] = (unsigned int *)&ld9040_22_120,
+        .gamma_22_table[7] = (unsigned int *)&ld9040_22_130,
+        .gamma_22_table[8] = (unsigned int *)&ld9040_22_140,
+        .gamma_22_table[9] = (unsigned int *)&ld9040_22_150,
+        .gamma_22_table[10] = (unsigned int *)&ld9040_22_160,
+        .gamma_22_table[11] = (unsigned int *)&ld9040_22_170,
+        .gamma_22_table[12] = (unsigned int *)&ld9040_22_180,
+        .gamma_22_table[13] = (unsigned int *)&ld9040_22_190,
+        .gamma_22_table[14] = (unsigned int *)&ld9040_22_200,
+        .gamma_22_table[15] = (unsigned int *)&ld9040_22_210,
+        .gamma_22_table[16] = (unsigned int *)&ld9040_22_220,
+        .gamma_22_table[17] = (unsigned int *)&ld9040_22_230,
+        .gamma_22_table[18] = (unsigned int *)&ld9040_22_240,
+        .gamma_22_table[19] = (unsigned int *)&ld9040_22_250,
+        .gamma_22_table[20] = (unsigned int *)&ld9040_22_260,
+        .gamma_22_table[21] = (unsigned int *)&ld9040_22_270,
+        .gamma_22_table[22] = (unsigned int *)&ld9040_22_280,
+        .gamma_22_table[23] = (unsigned int *)&ld9040_22_290,
+        .gamma_22_table[24] = (unsigned int *)&ld9040_22_300,
+};
+
+#endif
diff --git a/drivers/video/backlight/locomolcd.c b/drivers/video/backlight/locomolcd.c
index d2f59015d517..be20b5cbe26c 100644
--- a/drivers/video/backlight/locomolcd.c
+++ b/drivers/video/backlight/locomolcd.c
@@ -6,7 +6,7 @@
  * GPL v2
  *
  * This driver assumes single CPU. That's okay, because collie is
- * slightly old hardware, and noone is going to retrofit second CPU to
+ * slightly old hardware, and no one is going to retrofit second CPU to
  * old PDA.
  */
 
@@ -184,6 +184,7 @@ static int locomolcd_probe(struct locomo_dev *ldev)
         local_irq_restore(flags);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 4;
         locomolcd_bl_device = backlight_device_register("locomo-bl",
                                                         &ldev->dev, NULL,
diff --git a/drivers/video/backlight/max8925_bl.c b/drivers/video/backlight/max8925_bl.c
index 209acc105cbc..07e8e273ced0 100644
--- a/drivers/video/backlight/max8925_bl.c
+++ b/drivers/video/backlight/max8925_bl.c
@@ -136,6 +136,7 @@ static int __devinit max8925_backlight_probe(struct platform_device *pdev)
         data->current_brightness = 0;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = MAX_BRIGHTNESS;
         bl = backlight_device_register(name, &pdev->dev, data,
                                         &max8925_backlight_ops, &props);
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
deleted file mode 100644
index 1485f7345f49..000000000000
--- a/drivers/video/backlight/mbp_nvidia_bl.c
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- *  Backlight Driver for Nvidia 8600 in Macbook Pro
- *
- *  Copyright (c) Red Hat <mjg@redhat.com>
- *  Based on code from Pommed:
- *  Copyright (C) 2006 Nicolas Boichat <nicolas @boichat.ch>
- *  Copyright (C) 2006 Felipe Alfaro Solana <felipe_alfaro @linuxmail.org>
- *  Copyright (C) 2007 Julien BLACHE <jb@jblache.org>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- *  This driver triggers SMIs which cause the firmware to change the
- *  backlight brightness. This is icky in many ways, but it's impractical to
- *  get at the firmware code in order to figure out what it's actually doing.
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/backlight.h>
-#include <linux/err.h>
-#include <linux/dmi.h>
-#include <linux/io.h>
-
-static struct backlight_device *mbp_backlight_device;
-
-/* Structure to be passed to the DMI_MATCH function. */
-struct dmi_match_data {
-        /* I/O resource to allocate. */
-        unsigned long iostart;
-        unsigned long iolen;
-        /* Backlight operations structure. */
-        const struct backlight_ops backlight_ops;
-};
-
-/* Module parameters. */
-static int debug;
-module_param_named(debug, debug, int, 0644);
-MODULE_PARM_DESC(debug, "Set to one to enable debugging messages.");
-
-/*
- * Implementation for MacBooks with Intel chipset.
- */
-static int intel_chipset_send_intensity(struct backlight_device *bd)
-{
-        int intensity = bd->props.brightness;
-
-        if (debug)
-                printk(KERN_DEBUG "mbp_nvidia_bl: setting brightness to %d\n",
-                       intensity);
-
-        outb(0x04 | (intensity << 4), 0xb3);
-        outb(0xbf, 0xb2);
-        return 0;
-}
-
-static int intel_chipset_get_intensity(struct backlight_device *bd)
-{
-        int intensity;
-
-        outb(0x03, 0xb3);
-        outb(0xbf, 0xb2);
-        intensity = inb(0xb3) >> 4;
-
-        if (debug)
-                printk(KERN_DEBUG "mbp_nvidia_bl: read brightness of %d\n",
-                       intensity);
-
-        return intensity;
-}
-
-static const struct dmi_match_data intel_chipset_data = {
-        .iostart = 0xb2,
-        .iolen = 2,
-        .backlight_ops  = {
-                .options        = BL_CORE_SUSPENDRESUME,
-                .get_brightness = intel_chipset_get_intensity,
-                .update_status  = intel_chipset_send_intensity,
-        }
-};
-
-/*
- * Implementation for MacBooks with Nvidia chipset.
- */
-static int nvidia_chipset_send_intensity(struct backlight_device *bd)
-{
-        int intensity = bd->props.brightness;
-
-        if (debug)
-                printk(KERN_DEBUG "mbp_nvidia_bl: setting brightness to %d\n",
-                       intensity);
-
-        outb(0x04 | (intensity << 4), 0x52f);
-        outb(0xbf, 0x52e);
-        return 0;
-}
-
-static int nvidia_chipset_get_intensity(struct backlight_device *bd)
-{
-        int intensity;
-
-        outb(0x03, 0x52f);
-        outb(0xbf, 0x52e);
-        intensity = inb(0x52f) >> 4;
-
-        if (debug)
-                printk(KERN_DEBUG "mbp_nvidia_bl: read brightness of %d\n",
-                       intensity);
-
-        return intensity;
-}
-
-static const struct dmi_match_data nvidia_chipset_data = {
-        .iostart = 0x52e,
-        .iolen = 2,
-        .backlight_ops          = {
-                .options        = BL_CORE_SUSPENDRESUME,
-                .get_brightness = nvidia_chipset_get_intensity,
-                .update_status  = nvidia_chipset_send_intensity
-        }
-};
-
-/*
- * DMI matching.
- */
-static /* const */ struct dmi_match_data *driver_data;
-
-static int mbp_dmi_match(const struct dmi_system_id *id)
-{
-        driver_data = id->driver_data;
-
-        printk(KERN_INFO "mbp_nvidia_bl: %s detected\n", id->ident);
-        return 1;
-}
-
-static const struct dmi_system_id __initdata mbp_device_table[] = {
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 1,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Computer, Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 2,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook2,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 3,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook3,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 4,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 4,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,2"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 1,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro1,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 1,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro1,2"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 2,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro2,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 2,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro2,2"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 3,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 3,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3,2"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 4,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookAir 1,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir1,1"),
-                },
-                .driver_data    = (void *)&intel_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 5,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5,1"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 5,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5,2"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBook 6,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook6,1"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookAir 2,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir2,1"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 5,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,1"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 5,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,2"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 5,3",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,3"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 5,4",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,4"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookPro 5,5",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,5"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookAir 3,1",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir3,1"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        {
-                .callback       = mbp_dmi_match,
-                .ident          = "MacBookAir 3,2",
-                .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir3,2"),
-                },
-                .driver_data    = (void *)&nvidia_chipset_data,
-        },
-        { }
-};
-
-static int __init mbp_init(void)
-{
-        struct backlight_properties props;
-        if (!dmi_check_system(mbp_device_table))
-                return -ENODEV;
-
-        if (!request_region(driver_data->iostart, driver_data->iolen, 
-                                                "Macbook Pro backlight"))
-                return -ENXIO;
-
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = 15;
-        mbp_backlight_device = backlight_device_register("mbp_backlight", NULL,
-                                                         NULL,
-                                                         &driver_data->backlight_ops,
-                                                         &props);
-        if (IS_ERR(mbp_backlight_device)) {
-                release_region(driver_data->iostart, driver_data->iolen);
-                return PTR_ERR(mbp_backlight_device);
-        }
-
-        mbp_backlight_device->props.brightness =
-                driver_data->backlight_ops.get_brightness(mbp_backlight_device);
-        backlight_update_status(mbp_backlight_device);
-
-        return 0;
-}
-
-static void __exit mbp_exit(void)
-{
-        backlight_device_unregister(mbp_backlight_device);
-
-        release_region(driver_data->iostart, driver_data->iolen);
-}
-
-module_init(mbp_init);
-module_exit(mbp_exit);
-
-MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
-MODULE_DESCRIPTION("Nvidia-based Macbook Pro Backlight Driver");
-MODULE_LICENSE("GPL");
-MODULE_DEVICE_TABLE(dmi, mbp_device_table);
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index d3bc56296c8d..08d26a72394c 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -146,6 +146,7 @@ static int omapbl_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = OMAPBL_MAX_INTENSITY;
         dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops,
                                         &props);
diff --git a/drivers/video/backlight/pcf50633-backlight.c b/drivers/video/backlight/pcf50633-backlight.c
index 3c424f7efdcc..ef5628d60563 100644
--- a/drivers/video/backlight/pcf50633-backlight.c
+++ b/drivers/video/backlight/pcf50633-backlight.c
@@ -112,6 +112,7 @@ static int __devinit pcf50633_bl_probe(struct platform_device *pdev)
         if (!pcf_bl)
                 return -ENOMEM;
 
+        bl_props.type = BACKLIGHT_RAW;
         bl_props.max_brightness = 0x3f;
         bl_props.power = FB_BLANK_UNBLANK;
 
diff --git a/drivers/video/backlight/progear_bl.c b/drivers/video/backlight/progear_bl.c
index 809278c90738..6af183d6465e 100644
--- a/drivers/video/backlight/progear_bl.c
+++ b/drivers/video/backlight/progear_bl.c
@@ -84,6 +84,7 @@ static int progearbl_probe(struct platform_device *pdev)
         pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
         progear_backlight_device = backlight_device_register("progear-bl",
                                                              &pdev->dev, NULL,
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 21866ec69656..b8f38ec6eb18 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -28,6 +28,7 @@ struct pwm_bl_data {
         unsigned int            lth_brightness;
         int                     (*notify)(struct device *,
                                           int brightness);
+        int                     (*check_fb)(struct device *, struct fb_info *);
 };
 
 static int pwm_backlight_update_status(struct backlight_device *bl)
@@ -62,9 +63,18 @@ static int pwm_backlight_get_brightness(struct backlight_device *bl)
         return bl->props.brightness;
 }
 
+static int pwm_backlight_check_fb(struct backlight_device *bl,
+                                  struct fb_info *info)
+{
+        struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
+
+        return !pb->check_fb || pb->check_fb(pb->dev, info);
+}
+
 static const struct backlight_ops pwm_backlight_ops = {
         .update_status  = pwm_backlight_update_status,
         .get_brightness = pwm_backlight_get_brightness,
+        .check_fb       = pwm_backlight_check_fb,
 };
 
 static int pwm_backlight_probe(struct platform_device *pdev)
@@ -95,6 +105,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
 
         pb->period = data->pwm_period_ns;
         pb->notify = data->notify;
+        pb->check_fb = data->check_fb;
         pb->lth_brightness = data->lth_brightness *
                 (data->pwm_period_ns / data->max_brightness);
         pb->dev = &pdev->dev;
@@ -108,6 +119,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
                 dev_dbg(&pdev->dev, "got pwm for backlight\n");
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = data->max_brightness;
         bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
                                        &pwm_backlight_ops, &props);
diff --git a/drivers/video/backlight/s6e63m0.c b/drivers/video/backlight/s6e63m0.c
index 5927db0da999..322040f686c2 100644
--- a/drivers/video/backlight/s6e63m0.c
+++ b/drivers/video/backlight/s6e63m0.c
@@ -778,6 +778,7 @@ static int __devinit s6e63m0_probe(struct spi_device *spi)
 
         bd->props.max_brightness = MAX_BRIGHTNESS;
         bd->props.brightness = MAX_BRIGHTNESS;
+        bd->props.type = BACKLIGHT_RAW;
         lcd->bd = bd;
 
         /*
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index 2a04b382ec48..425a7365470b 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -102,6 +102,7 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
         data->i2c = client;
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 512 - 1;
         data->bl = backlight_device_register("tosa-bl", &client->dev, data,
                                              &bl_ops, &props);
diff --git a/drivers/video/backlight/wm831x_bl.c b/drivers/video/backlight/wm831x_bl.c
index 08fd87f3aecc..d4c6eb248ff9 100644
--- a/drivers/video/backlight/wm831x_bl.c
+++ b/drivers/video/backlight/wm831x_bl.c
@@ -193,6 +193,7 @@ static int wm831x_backlight_probe(struct platform_device *pdev)
         data->current_brightness = 0;
         data->isink_reg = isink_reg;
 
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = max_isel;
         bl = backlight_device_register("wm831x", &pdev->dev, data,
                                        &wm831x_backlight_ops, &props);
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index e7d0f525041e..2464b910b590 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -649,6 +649,7 @@ static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
         }
 #ifndef NO_BL_SUPPORT
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 255;
         bl_dev = backlight_device_register("bf54x-bl", NULL, NULL,
                                            &bfin_lq043fb_bl_ops, &props);
diff --git a/drivers/video/bfin-lq035q1-fb.c b/drivers/video/bfin-lq035q1-fb.c
index c8e1f04941bd..23b6c4b62c78 100644
--- a/drivers/video/bfin-lq035q1-fb.c
+++ b/drivers/video/bfin-lq035q1-fb.c
@@ -154,8 +154,10 @@ static int __devinit lq035q1_spidev_probe(struct spi_device *spi)
 
         ret = lq035q1_control(spi, LQ035_SHUT_CTL, LQ035_ON);
         ret |= lq035q1_control(spi, LQ035_DRIVER_OUTPUT_CTL, ctl->mode);
-        if (ret)
+        if (ret) {
+                kfree(ctl);
                 return ret;
+        }
 
         spi_set_drvdata(spi, ctl);
 
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index 3cf77676947c..d8de29f0dd8d 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -545,6 +545,7 @@ static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
         }
 #ifndef NO_BL_SUPPORT
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = 255;
         bl_dev = backlight_device_register("bf52x-bl", NULL, NULL,
                                            &bfin_lq043fb_bl_ops, &props);
diff --git a/drivers/video/bfin_adv7393fb.h b/drivers/video/bfin_adv7393fb.h
index 8c7f9e4fc6eb..cd591b5152a5 100644
--- a/drivers/video/bfin_adv7393fb.h
+++ b/drivers/video/bfin_adv7393fb.h
@@ -87,12 +87,12 @@ static const u8 init_NTSC_TESTPATTERN[] = {
 
 static const u8 init_NTSC[] = {
         0x00, 0x1E,     /* Power up all DACs and PLL */
-        0xC3, 0x26,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC5, 0x12,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC2, 0x4A,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC6, 0x5E,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xBD, 0x19,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xBF, 0x42,     /* Program RGB->YCrCb Color Space convertion matrix */
+        0xC3, 0x26,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC5, 0x12,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC2, 0x4A,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC6, 0x5E,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xBD, 0x19,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xBF, 0x42,     /* Program RGB->YCrCb Color Space conversion matrix */
         0x8C, 0x1F,     /* NTSC Subcarrier Frequency */
         0x8D, 0x7C,     /* NTSC Subcarrier Frequency */
         0x8E, 0xF0,     /* NTSC Subcarrier Frequency */
@@ -109,12 +109,12 @@ static const u8 init_NTSC[] = {
 
 static const u8 init_PAL[] = {
         0x00, 0x1E,     /* Power up all DACs and PLL */
-        0xC3, 0x26,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC5, 0x12,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC2, 0x4A,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xC6, 0x5E,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xBD, 0x19,     /* Program RGB->YCrCb Color Space convertion matrix */
-        0xBF, 0x42,     /* Program RGB->YCrCb Color Space convertion matrix */
+        0xC3, 0x26,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC5, 0x12,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC2, 0x4A,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xC6, 0x5E,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xBD, 0x19,     /* Program RGB->YCrCb Color Space conversion matrix */
+        0xBF, 0x42,     /* Program RGB->YCrCb Color Space conversion matrix */
         0x8C, 0xCB,     /* PAL Subcarrier Frequency */
         0x8D, 0x8A,     /* PAL Subcarrier Frequency */
         0x8E, 0x09,     /* PAL Subcarrier Frequency */
diff --git a/drivers/video/cg14.c b/drivers/video/cg14.c
index e2c85b0db632..f18895006627 100644
--- a/drivers/video/cg14.c
+++ b/drivers/video/cg14.c
@@ -565,6 +565,7 @@ out_dealloc_cmap:
 
 out_unmap_regs:
         cg14_unmap_regs(op, info, par);
+        framebuffer_release(info);
 
 out_err:
         return err;
diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c
index 4ffad90bde42..179e96cdb323 100644
--- a/drivers/video/cg6.c
+++ b/drivers/video/cg6.c
@@ -821,6 +821,7 @@ out_dealloc_cmap:
 
 out_unmap_regs:
         cg6_unmap_regs(op, info, par);
+        framebuffer_release(info);
 
 out_err:
         return err;
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 9c092b8d64e6..8745637e4b7e 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -370,7 +370,6 @@ static void fb_flashcursor(struct work_struct *work)
 {
         struct fb_info *info = container_of(work, struct fb_info, queue);
         struct fbcon_ops *ops = info->fbcon_par;
-        struct display *p;
         struct vc_data *vc = NULL;
         int c;
         int mode;
@@ -386,7 +385,6 @@ static void fb_flashcursor(struct work_struct *work)
                 return;
         }
 
-        p = &fb_display[vc->vc_num];
         c = scr_readw((u16 *) vc->vc_pos);
         mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
                 CM_ERASE : CM_DRAW;
@@ -823,10 +821,10 @@ static int set_con2fb_map(int unit, int newidx, int user)
         if (oldidx == newidx)
                 return 0;
 
-        if (!info || fbcon_has_exited)
+        if (!info)
                 return -EINVAL;
 
-        if (!err && !search_for_mapped_con()) {
+        if (!search_for_mapped_con() || !con_is_bound(&fb_con)) {
                 info_idx = newidx;
                 return fbcon_takeover(0);
         }
diff --git a/drivers/video/console/font_mini_4x6.c b/drivers/video/console/font_mini_4x6.c
index a19a7f33133e..fa6e698e63c4 100644
--- a/drivers/video/console/font_mini_4x6.c
+++ b/drivers/video/console/font_mini_4x6.c
@@ -1,5 +1,5 @@
 
-/* Hand composed "Miniscule" 4x6 font, with binary data generated using
+/* Hand composed "Minuscule" 4x6 font, with binary data generated using
  * Perl stub.
  *
  * Use 'perl -x mini_4x6.c < mini_4x6.c > new_version.c' to regenerate
diff --git a/drivers/video/console/tileblit.c b/drivers/video/console/tileblit.c
index 0056a41e5c35..15e8e1a89c45 100644
--- a/drivers/video/console/tileblit.c
+++ b/drivers/video/console/tileblit.c
@@ -83,7 +83,7 @@ static void tile_cursor(struct vc_data *vc, struct fb_info *info, int mode,
                         int softback_lines, int fg, int bg)
 {
         struct fb_tilecursor cursor;
-        int use_sw = (vc->vc_cursor_type & 0x01);
+        int use_sw = (vc->vc_cursor_type & 0x10);
 
         cursor.sx = vc->vc_x;
         cursor.sy = vc->vc_y;
diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c
index 8d61ef96eedd..8b7d47386f39 100644
--- a/drivers/video/da8xx-fb.c
+++ b/drivers/video/da8xx-fb.c
@@ -763,7 +763,7 @@ static int fb_wait_for_vsync(struct fb_info *info)
 
         /*
          * Set flag to 0 and wait for isr to set to 1. It would seem there is a
-         * race condition here where the ISR could have occured just before or
+         * race condition here where the ISR could have occurred just before or
          * just after this set. But since we are just coarsely waiting for
          * a frame to complete then that's OK. i.e. if the frame completed
          * just before this code executed then we have to wait another full
diff --git a/drivers/video/display/display-sysfs.c b/drivers/video/display/display-sysfs.c
index f6a09ab0dac6..0c647d7af0ee 100644
--- a/drivers/video/display/display-sysfs.c
+++ b/drivers/video/display/display-sysfs.c
@@ -182,7 +182,7 @@ void display_device_unregister(struct display_device *ddev)
         mutex_lock(&ddev->lock);
         device_unregister(ddev->dev);
         mutex_unlock(&ddev->lock);
-        // Mark device index as avaliable
+        // Mark device index as available
         mutex_lock(&allocated_dsp_lock);
         idr_remove(&allocated_dsp, ddev->idx);
         mutex_unlock(&allocated_dsp_lock);
diff --git a/drivers/video/edid.h b/drivers/video/edid.h
index bd89fb3be8c2..d03a232d90b2 100644
--- a/drivers/video/edid.h
+++ b/drivers/video/edid.h
@@ -101,8 +101,8 @@
 #define V_SYNC_WIDTH       COMBINE_HI_4LO( V_SYNC_WIDTH_HI, V_SYNC_WIDTH_LO )
 #define V_SYNC_OFFSET      COMBINE_HI_4LO( V_SYNC_OFFSET_HI, V_SYNC_OFFSET_LO )
 
-#define H_SYNC_WIDTH       COMBINE_HI_4LO( H_SYNC_WIDTH_HI, H_SYNC_WIDTH_LO )
-#define H_SYNC_OFFSET      COMBINE_HI_4LO( H_SYNC_OFFSET_HI, H_SYNC_OFFSET_LO )
+#define H_SYNC_WIDTH       COMBINE_HI_8LO( H_SYNC_WIDTH_HI, H_SYNC_WIDTH_LO )
+#define H_SYNC_OFFSET      COMBINE_HI_8LO( H_SYNC_OFFSET_HI, H_SYNC_OFFSET_LO )
 
 #define H_SIZE_LO          (unsigned)block[ 12 ]
 #define V_SIZE_LO          (unsigned)block[ 13 ]
diff --git a/drivers/video/efifb.c b/drivers/video/efifb.c
index 70477c2e4b61..4eb38db36e4b 100644
--- a/drivers/video/efifb.c
+++ b/drivers/video/efifb.c
@@ -53,6 +53,7 @@ enum {
         M_MB_7_1,       /* MacBook, 7th rev. */
         M_MB_SR,        /* MacBook, 2nd gen, (Santa Rosa) */
         M_MBA,          /* MacBook Air */
+        M_MBA_3,        /* Macbook Air, 3rd rev */
         M_MBP,          /* MacBook Pro */
         M_MBP_2,        /* MacBook Pro 2nd gen */
         M_MBP_2_2,      /* MacBook Pro 2,2nd gen */
@@ -64,43 +65,54 @@ enum {
         M_MBP_6_1,      /* MacBook Pro, 6,1th gen */
         M_MBP_6_2,      /* MacBook Pro, 6,2th gen */
         M_MBP_7_1,      /* MacBook Pro, 7,1th gen */
+        M_MBP_8_2,      /* MacBook Pro, 8,2nd gen */
         M_UNKNOWN       /* placeholder */
 };
 
+#define OVERRIDE_NONE   0x0
+#define OVERRIDE_BASE   0x1
+#define OVERRIDE_STRIDE 0x2
+#define OVERRIDE_HEIGHT 0x4
+#define OVERRIDE_WIDTH  0x8
+
 static struct efifb_dmi_info {
         char *optname;
         unsigned long base;
         int stride;
         int width;
         int height;
+        int flags;
 } dmi_list[] __initdata = {
-        [M_I17] = { "i17", 0x80010000, 1472 * 4, 1440, 900 },
-        [M_I20] = { "i20", 0x80010000, 1728 * 4, 1680, 1050 }, /* guess */
-        [M_I20_SR] = { "imac7", 0x40010000, 1728 * 4, 1680, 1050 },
-        [M_I24] = { "i24", 0x80010000, 2048 * 4, 1920, 1200 }, /* guess */
-        [M_I24_8_1] = { "imac8", 0xc0060000, 2048 * 4, 1920, 1200 },
-        [M_I24_10_1] = { "imac10", 0xc0010000, 2048 * 4, 1920, 1080 },
-        [M_I27_11_1] = { "imac11", 0xc0010000, 2560 * 4, 2560, 1440 },
-        [M_MINI]= { "mini", 0x80000000, 2048 * 4, 1024, 768 },
-        [M_MINI_3_1] = { "mini31", 0x40010000, 1024 * 4, 1024, 768 },
-        [M_MINI_4_1] = { "mini41", 0xc0010000, 2048 * 4, 1920, 1200 },
-        [M_MB] = { "macbook", 0x80000000, 2048 * 4, 1280, 800 },
-        [M_MB_5_1] = { "macbook51", 0x80010000, 2048 * 4, 1280, 800 },
-        [M_MB_6_1] = { "macbook61", 0x80010000, 2048 * 4, 1280, 800 },
-        [M_MB_7_1] = { "macbook71", 0x80010000, 2048 * 4, 1280, 800 },
-        [M_MBA] = { "mba", 0x80000000, 2048 * 4, 1280, 800 },
-        [M_MBP] = { "mbp", 0x80010000, 1472 * 4, 1440, 900 },
-        [M_MBP_2] = { "mbp2", 0, 0, 0, 0 }, /* placeholder */
-        [M_MBP_2_2] = { "mbp22", 0x80010000, 1472 * 4, 1440, 900 },
-        [M_MBP_SR] = { "mbp3", 0x80030000, 2048 * 4, 1440, 900 },
-        [M_MBP_4] = { "mbp4", 0xc0060000, 2048 * 4, 1920, 1200 },
-        [M_MBP_5_1] = { "mbp51", 0xc0010000, 2048 * 4, 1440, 900 },
-        [M_MBP_5_2] = { "mbp52", 0xc0010000, 2048 * 4, 1920, 1200 },
-        [M_MBP_5_3] = { "mbp53", 0xd0010000, 2048 * 4, 1440, 900 },
-        [M_MBP_6_1] = { "mbp61", 0x90030000, 2048 * 4, 1920, 1200 },
-        [M_MBP_6_2] = { "mbp62", 0x90030000, 2048 * 4, 1680, 1050 },
-        [M_MBP_7_1] = { "mbp71", 0xc0010000, 2048 * 4, 1280, 800 },
-        [M_UNKNOWN] = { NULL, 0, 0, 0, 0 }
+        [M_I17] = { "i17", 0x80010000, 1472 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_I20] = { "i20", 0x80010000, 1728 * 4, 1680, 1050, OVERRIDE_NONE }, /* guess */
+        [M_I20_SR] = { "imac7", 0x40010000, 1728 * 4, 1680, 1050, OVERRIDE_NONE },
+        [M_I24] = { "i24", 0x80010000, 2048 * 4, 1920, 1200, OVERRIDE_NONE }, /* guess */
+        [M_I24_8_1] = { "imac8", 0xc0060000, 2048 * 4, 1920, 1200, OVERRIDE_NONE },
+        [M_I24_10_1] = { "imac10", 0xc0010000, 2048 * 4, 1920, 1080, OVERRIDE_NONE },
+        [M_I27_11_1] = { "imac11", 0xc0010000, 2560 * 4, 2560, 1440, OVERRIDE_NONE },
+        [M_MINI]= { "mini", 0x80000000, 2048 * 4, 1024, 768, OVERRIDE_NONE },
+        [M_MINI_3_1] = { "mini31", 0x40010000, 1024 * 4, 1024, 768, OVERRIDE_NONE },
+        [M_MINI_4_1] = { "mini41", 0xc0010000, 2048 * 4, 1920, 1200, OVERRIDE_NONE },
+        [M_MB] = { "macbook", 0x80000000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        [M_MB_5_1] = { "macbook51", 0x80010000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        [M_MB_6_1] = { "macbook61", 0x80010000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        [M_MB_7_1] = { "macbook71", 0x80010000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        [M_MBA] = { "mba", 0x80000000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        /* 11" Macbook Air 3,1 passes the wrong stride */
+        [M_MBA_3] = { "mba3", 0, 2048 * 4, 0, 0, OVERRIDE_STRIDE },
+        [M_MBP] = { "mbp", 0x80010000, 1472 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_MBP_2] = { "mbp2", 0, 0, 0, 0, OVERRIDE_NONE }, /* placeholder */
+        [M_MBP_2_2] = { "mbp22", 0x80010000, 1472 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_MBP_SR] = { "mbp3", 0x80030000, 2048 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_MBP_4] = { "mbp4", 0xc0060000, 2048 * 4, 1920, 1200, OVERRIDE_NONE },
+        [M_MBP_5_1] = { "mbp51", 0xc0010000, 2048 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_MBP_5_2] = { "mbp52", 0xc0010000, 2048 * 4, 1920, 1200, OVERRIDE_NONE },
+        [M_MBP_5_3] = { "mbp53", 0xd0010000, 2048 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_MBP_6_1] = { "mbp61", 0x90030000, 2048 * 4, 1920, 1200, OVERRIDE_NONE },
+        [M_MBP_6_2] = { "mbp62", 0x90030000, 2048 * 4, 1680, 1050, OVERRIDE_NONE },
+        [M_MBP_7_1] = { "mbp71", 0xc0010000, 2048 * 4, 1280, 800, OVERRIDE_NONE },
+        [M_MBP_8_2] = { "mbp82", 0x90010000, 1472 * 4, 1440, 900, OVERRIDE_NONE },
+        [M_UNKNOWN] = { NULL, 0, 0, 0, 0, OVERRIDE_NONE }
 };
 
 static int set_system(const struct dmi_system_id *id);
@@ -138,6 +150,7 @@ static const struct dmi_system_id dmi_system_table[] __initconst = {
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook6,1", M_MB_6_1),
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook7,1", M_MB_7_1),
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookAir1,1", M_MBA),
+        EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookAir3,1", M_MBA_3),
         EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro1,1", M_MBP),
         EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro2,1", M_MBP_2),
         EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro2,2", M_MBP_2_2),
@@ -151,19 +164,26 @@ static const struct dmi_system_id dmi_system_table[] __initconst = {
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro6,1", M_MBP_6_1),
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro6,2", M_MBP_6_2),
         EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro7,1", M_MBP_7_1),
+        EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro8,2", M_MBP_8_2),
         {},
 };
 
+#define choose_value(dmivalue, fwvalue, field, flags) ({        \
+                typeof(fwvalue) _ret_ = fwvalue;                \
+                if ((flags) & (field))                          \
+                        _ret_ = dmivalue;                       \
+                else if ((fwvalue) == 0)                        \
+                        _ret_ = dmivalue;                       \
+                _ret_;                                          \
+        })
+
 static int set_system(const struct dmi_system_id *id)
 {
         struct efifb_dmi_info *info = id->driver_data;
-        if (info->base == 0)
-                return 0;
 
-        printk(KERN_INFO "efifb: dmi detected %s - framebuffer at %p "
-                         "(%dx%d, stride %d)\n", id->ident,
-                         (void *)info->base, info->width, info->height,
-                         info->stride);
+        if (info->base == 0 && info->height == 0 && info->width == 0
+                        && info->stride == 0)
+                return 0;
 
         /* Trust the bootloader over the DMI tables */
         if (screen_info.lfb_base == 0) {
@@ -171,40 +191,47 @@ static int set_system(const struct dmi_system_id *id)
                 struct pci_dev *dev = NULL;
                 int found_bar = 0;
 #endif
-                screen_info.lfb_base = info->base;
+                if (info->base) {
+                        screen_info.lfb_base = choose_value(info->base,
+                                screen_info.lfb_base, OVERRIDE_BASE,
+                                info->flags);
 
 #if defined(CONFIG_PCI)
-                /* make sure that the address in the table is actually on a
-                 * VGA device's PCI BAR */
-
-                for_each_pci_dev(dev) {
-                        int i;
-                        if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
-                                continue;
-                        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
-                                resource_size_t start, end;
-
-                                start = pci_resource_start(dev, i);
-                                if (start == 0)
-                                        break;
-                                end = pci_resource_end(dev, i);
-                                if (screen_info.lfb_base >= start &&
-                                                screen_info.lfb_base < end) {
-                                        found_bar = 1;
+                        /* make sure that the address in the table is actually
+                         * on a VGA device's PCI BAR */
+
+                        for_each_pci_dev(dev) {
+                                int i;
+                                if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
+                                        continue;
+                                for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                                        resource_size_t start, end;
+
+                                        start = pci_resource_start(dev, i);
+                                        if (start == 0)
+                                                break;
+                                        end = pci_resource_end(dev, i);
+                                        if (screen_info.lfb_base >= start &&
+                                            screen_info.lfb_base < end) {
+                                                found_bar = 1;
+                                        }
                                 }
                         }
-                }
-                if (!found_bar)
-                        screen_info.lfb_base = 0;
+                        if (!found_bar)
+                                screen_info.lfb_base = 0;
 #endif
+                }
         }
         if (screen_info.lfb_base) {
-                if (screen_info.lfb_linelength == 0)
-                        screen_info.lfb_linelength = info->stride;
-                if (screen_info.lfb_width == 0)
-                        screen_info.lfb_width = info->width;
-                if (screen_info.lfb_height == 0)
-                        screen_info.lfb_height = info->height;
+                screen_info.lfb_linelength = choose_value(info->stride,
+                        screen_info.lfb_linelength, OVERRIDE_STRIDE,
+                        info->flags);
+                screen_info.lfb_width = choose_value(info->width,
+                        screen_info.lfb_width, OVERRIDE_WIDTH,
+                        info->flags);
+                screen_info.lfb_height = choose_value(info->height,
+                        screen_info.lfb_height, OVERRIDE_HEIGHT,
+                        info->flags);
                 if (screen_info.orig_video_isVGA == 0)
                         screen_info.orig_video_isVGA = VIDEO_TYPE_EFI;
         } else {
@@ -214,6 +241,13 @@ static int set_system(const struct dmi_system_id *id)
                 screen_info.orig_video_isVGA = 0;
                 return 0;
         }
+
+        printk(KERN_INFO "efifb: dmi detected %s - framebuffer at %p "
+                         "(%dx%d, stride %d)\n", id->ident,
+                         (void *)screen_info.lfb_base, screen_info.lfb_width,
+                         screen_info.lfb_height, screen_info.lfb_linelength);
+
+
         return 1;
 }
 
diff --git a/drivers/video/ep93xx-fb.c b/drivers/video/ep93xx-fb.c
index b358d045f130..cbdb1bd77c21 100644
--- a/drivers/video/ep93xx-fb.c
+++ b/drivers/video/ep93xx-fb.c
@@ -456,7 +456,7 @@ static int __init ep93xxfb_alloc_videomem(struct fb_info *info)
          * There is a bug in the ep93xx framebuffer which causes problems
          * if bit 27 of the physical address is set.
          * See: http://marc.info/?l=linux-arm-kernel&m=110061245502000&w=2
-         * There does not seem to be any offical errata for this, but I
+         * There does not seem to be any official errata for this, but I
          * have confirmed the problem exists on my hardware (ep9315) at
          * least.
          */
diff --git a/drivers/video/fb-puv3.c b/drivers/video/fb-puv3.c
index dbd2dc4745d1..27f2c57e06e9 100644
--- a/drivers/video/fb-puv3.c
+++ b/drivers/video/fb-puv3.c
@@ -13,7 +13,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/vmalloc.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/fb.h>
@@ -531,7 +530,7 @@ static int unifb_set_par(struct fb_info *info)
                 return -EINVAL;
         }
 
-        writel(PKUNITY_UNIGFX_MMAP_BASE, UDE_FSA);
+        writel(info->fix.smem_start, UDE_FSA);
         writel(info->var.yres, UDE_LS);
         writel(get_line_length(info->var.xres,
                         info->var.bits_per_pixel) >> 3, UDE_PS);
@@ -680,13 +679,27 @@ static int unifb_probe(struct platform_device *dev)
         struct fb_info *info;
         u32 unifb_regs[UNIFB_REGS_NUM];
         int retval = -ENOMEM;
-        struct resource *iomem, *mapmem;
+        struct resource *iomem;
+        void *videomemory;
+
+        videomemory = (void *)__get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                get_order(UNIFB_MEMSIZE));
+        if (!videomemory)
+                goto err;
+
+        memset(videomemory, 0, UNIFB_MEMSIZE);
+
+        unifb_fix.smem_start = virt_to_phys(videomemory);
+        unifb_fix.smem_len = UNIFB_MEMSIZE;
+
+        iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        unifb_fix.mmio_start = iomem->start;
 
         info = framebuffer_alloc(sizeof(u32)*256, &dev->dev);
         if (!info)
                 goto err;
 
-        info->screen_base = (char __iomem *)KUSER_UNIGFX_BASE;
+        info->screen_base = (char __iomem *)videomemory;
         info->fbops = &unifb_ops;
 
         retval = fb_find_mode(&info->var, info, NULL,
@@ -695,13 +708,6 @@ static int unifb_probe(struct platform_device *dev)
         if (!retval || (retval == 4))
                 info->var = unifb_default;
 
-        iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        unifb_fix.mmio_start = iomem->start;
-
-        mapmem = platform_get_resource(dev, IORESOURCE_MEM, 1);
-        unifb_fix.smem_start = mapmem->start;
-        unifb_fix.smem_len = UNIFB_MEMSIZE;
-
         info->fix = unifb_fix;
         info->pseudo_palette = info->par;
         info->par = NULL;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index e2bf95370e40..e0c2284924b6 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1507,7 +1507,7 @@ void remove_conflicting_framebuffers(struct apertures_struct *a,
                         (primary && gen_aper && gen_aper->count &&
                          gen_aper->ranges[0].base == VGA_FB_PHYS)) {
 
-                        printk(KERN_ERR "fb: conflicting fb hw usage "
+                        printk(KERN_INFO "fb: conflicting fb hw usage "
                                "%s vs %s - removing generic driver\n",
                                name, registered_fb[i]->fix.id);
                         unregister_framebuffer(registered_fb[i]);
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index f4a32779168b..04251ce89184 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -33,7 +33,7 @@
  * for driver private data (info->par). info->par (if any) will be
  * aligned to sizeof(long).
  *
- * Returns the new structure, or NULL if an error occured.
+ * Returns the new structure, or NULL if an error occurred.
  *
  */
 struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c
index 910c5e6f6702..14102a3f70f5 100644
--- a/drivers/video/ffb.c
+++ b/drivers/video/ffb.c
@@ -1010,7 +1010,7 @@ out_dealloc_cmap:
         fb_dealloc_cmap(&info->cmap);
 
 out_unmap_dac:
-        of_iounmap(&op->resource[2], par->fbc, sizeof(struct ffb_fbc));
+        of_iounmap(&op->resource[1], par->dac, sizeof(struct ffb_dac));
 
 out_unmap_fbc:
         of_iounmap(&op->resource[2], par->fbc, sizeof(struct ffb_fbc));
diff --git a/drivers/video/fm2fb.c b/drivers/video/fm2fb.c
index 1b0feb8e7244..d0533b7aad79 100644
--- a/drivers/video/fm2fb.c
+++ b/drivers/video/fm2fb.c
@@ -45,7 +45,7 @@
  *      buffer needs an amount of memory of 1.769.472 bytes which
  *      is near to 2 MByte (the allocated address space of Zorro2).
  *      The memory is channel interleaved. That means every channel
- *      owns four VRAMs. Unfortunatly most FrameMasters II are
+ *      owns four VRAMs. Unfortunately most FrameMasters II are
  *      not assembled with memory for the alpha channel. In this
  *      case it could be possible to add the frame buffer into the
  *      normal memory pool.
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index 9048f87fa8c1..bedf5be27f05 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -882,7 +882,7 @@ static inline __u32 CNVT_TOHW(__u32 val, __u32 width)
  * which needs to be scaled in this function for the hardware. Things to take
  * into consideration are how many color registers, if any, are supported with
  * the current color visual. With truecolor mode no color palettes are
- * supported. Here a psuedo palette is created which we store the value in
+ * supported. Here a pseudo palette is created which we store the value in
  * pseudo_palette in struct fb_info. For pseudocolor mode we have a limited
  * color palette.
  */
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 933899dca33a..7e7b7a9ba274 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -721,7 +721,7 @@ static int gbefb_set_par(struct fb_info *info)
 
            Tiles have the advantage that they can be allocated individually in
            memory. However, this mapping is not linear at all, which is not
-           really convienient. In order to support linear addressing, the GBE
+           really convenient. In order to support linear addressing, the GBE
            DMA hardware is fooled into thinking the screen is only one tile
            large and but has a greater height, so that the DMA transfer covers
            the same region.
diff --git a/drivers/video/geode/lxfb.h b/drivers/video/geode/lxfb.h
index be8ccb47ebe0..cfcd8090f313 100644
--- a/drivers/video/geode/lxfb.h
+++ b/drivers/video/geode/lxfb.h
@@ -117,7 +117,7 @@ enum gp_registers {
 };
 
 #define GP_BLT_STATUS_CE                (1 << 4)        /* cmd buf empty */
-#define GP_BLT_STATUS_PB                (1 << 0)        /* primative busy */
+#define GP_BLT_STATUS_PB                (1 << 0)        /* primitive busy */
 
 
 /* Display Controller registers (table 6-47 from the data book) */
diff --git a/drivers/video/hecubafb.c b/drivers/video/hecubafb.c
index c77bcc6ab463..1b94643ecbcf 100644
--- a/drivers/video/hecubafb.c
+++ b/drivers/video/hecubafb.c
@@ -299,7 +299,7 @@ static int __devexit hecubafb_remove(struct platform_device *dev)
 
 static struct platform_driver hecubafb_driver = {
         .probe  = hecubafb_probe,
-        .remove = hecubafb_remove,
+        .remove = __devexit_p(hecubafb_remove),
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "hecubafb",
diff --git a/drivers/video/hpfb.c b/drivers/video/hpfb.c
index c8e280f1bb0b..ebf8495ff198 100644
--- a/drivers/video/hpfb.c
+++ b/drivers/video/hpfb.c
@@ -321,11 +321,11 @@ static int __devinit hpfb_dio_probe(struct dio_dev * d, const struct dio_device_
         unsigned long paddr, vaddr;
 
         paddr = d->resource.start;
-        if (!request_mem_region(d->resource.start, d->resource.end - d->resource.start, d->name))
+        if (!request_mem_region(d->resource.start, resource_size(&d->resource), d->name))
                 return -EBUSY;
 
         if (d->scode >= DIOII_SCBASE) {
-                vaddr = (unsigned long)ioremap(paddr, d->resource.end - d->resource.start);
+                vaddr = (unsigned long)ioremap(paddr, resource_size(&d->resource));
         } else {
                 vaddr = paddr + DIO_VIRADDRBASE;
         }
@@ -344,7 +344,7 @@ static void __devexit hpfb_remove_one(struct dio_dev *d)
         unregister_framebuffer(&fb_info);
         if (d->scode >= DIOII_SCBASE)
                 iounmap((void *)fb_regs);
-        release_mem_region(d->resource.start, d->resource.end - d->resource.start);
+        release_mem_region(d->resource.start, resource_size(&d->resource));
 }
 
 static struct dio_device_id hpfb_dio_tbl[] = {
diff --git a/drivers/video/i810/i810_accel.c b/drivers/video/i810/i810_accel.c
index f5bedee4310a..7672d2ea9b35 100644
--- a/drivers/video/i810/i810_accel.c
+++ b/drivers/video/i810/i810_accel.c
@@ -112,7 +112,7 @@ static inline int wait_for_engine_idle(struct fb_info *info)
  * @par: pointer to i810fb_par structure
  *
  * DESCRIPTION:
- * Checks/waits for sufficent space in ringbuffer of size
+ * Checks/waits for sufficient space in ringbuffer of size
  * space.  Returns the tail of the buffer
  */ 
 static inline u32 begin_iring(struct fb_info *info, u32 space)
diff --git a/drivers/video/imxfb.c b/drivers/video/imxfb.c
index 69bd4a581d4a..ef72cb483834 100644
--- a/drivers/video/imxfb.c
+++ b/drivers/video/imxfb.c
@@ -499,6 +499,7 @@ static void imxfb_init_backlight(struct imxfb_info *fbi)
 
         memset(&props, 0, sizeof(struct backlight_properties));
         props.max_brightness = 0xff;
+        props.type = BACKLIGHT_RAW;
         writel(fbi->pwmr, fbi->regs + LCDC_PWMR);
 
         bl = backlight_device_register("imxfb-bl", &fbi->pdev->dev, fbi,
diff --git a/drivers/video/intelfb/Makefile b/drivers/video/intelfb/Makefile
index 6c782d3ae1be..f7d631ebee8e 100644
--- a/drivers/video/intelfb/Makefile
+++ b/drivers/video/intelfb/Makefile
@@ -4,7 +4,4 @@ intelfb-y := intelfbdrv.o intelfbhw.o
 intelfb-$(CONFIG_FB_INTEL_I2C) += intelfb_i2c.o
 intelfb-objs := $(intelfb-y)
 
-ifdef CONFIG_FB_INTEL_DEBUG
-#EXTRA_CFLAGS += -DDEBUG -DVERBOSE -DREGDUMP
-EXTRA_CFLAGS += -DDEBUG -DREGDUMP
-endif
+ccflags-$(CONFIG_FB_INTEL_DEBUG) := -DDEBUG -DREGDUMP
diff --git a/drivers/video/kyro/STG4000OverlayDevice.c b/drivers/video/kyro/STG4000OverlayDevice.c
index a8c9713413e6..0aeeaa10708b 100644
--- a/drivers/video/kyro/STG4000OverlayDevice.c
+++ b/drivers/video/kyro/STG4000OverlayDevice.c
@@ -417,7 +417,7 @@ int SetOverlayViewPort(volatile STG4000REG __iomem *pSTGReg,
         /***************** Horizontal decimation/scaling ***************************/
 
         /*
-         * Now we handle the horizontal case, this is a simplified verison of
+         * Now we handle the horizontal case, this is a simplified version of
          * the vertical case in that we decimate by factors of 2.  as we are
          * working in words we should always be able to decimate by these
          * factors.  as we always have to have a buffer which is aligned to a
diff --git a/drivers/video/kyro/STG4000Reg.h b/drivers/video/kyro/STG4000Reg.h
index 244549e61368..5d6269882589 100644
--- a/drivers/video/kyro/STG4000Reg.h
+++ b/drivers/video/kyro/STG4000Reg.h
@@ -16,7 +16,7 @@
 
 /*
  * Macros that access memory mapped card registers in PCI space
- * Add an appropraite section for your OS or processor architecture.
+ * Add an appropriate section for your OS or processor architecture.
  */
 #if defined(__KERNEL__)
 #include <asm/page.h>
diff --git a/drivers/video/matrox/matroxfb_DAC1064.h b/drivers/video/matrox/matroxfb_DAC1064.h
index c6ed7801efe2..1e6e45b57b78 100644
--- a/drivers/video/matrox/matroxfb_DAC1064.h
+++ b/drivers/video/matrox/matroxfb_DAC1064.h
@@ -46,7 +46,7 @@ void DAC1064_global_restore(struct matrox_fb_info *minfo);
 #define      M1064_XDVICLKCTRL_DVILOOPCTL       0x30
         /* CRTC2 pixel clock allowed to(0)/blocked from(1) driving CRTC2 */
 #define      M1064_XDVICLKCTRL_C2DVICLKEN       0x40
-        /* P1PLL loop filter bandwith selection */
+        /* P1PLL loop filter bandwidth selection */
 #define      M1064_XDVICLKCTRL_P1LOOPBWDTCTL    0x80
 #define M1064_XCURCOL0RED       0x08
 #define M1064_XCURCOL0GREEN     0x09
diff --git a/drivers/video/matrox/matroxfb_Ti3026.c b/drivers/video/matrox/matroxfb_Ti3026.c
index 835aaaae6b96..9a44cec394b5 100644
--- a/drivers/video/matrox/matroxfb_Ti3026.c
+++ b/drivers/video/matrox/matroxfb_Ti3026.c
@@ -387,7 +387,7 @@ static int Ti3026_init(struct matrox_fb_info *minfo, struct my_timming *m)
                         hw->DACreg[POS3026_XMISCCTRL] = TVP3026_XMISCCTRL_DAC_PUP | TVP3026_XMISCCTRL_DAC_8BIT | TVP3026_XMISCCTRL_PSEL_DIS | TVP3026_XMISCCTRL_PSEL_LOW;
                         break;
                 case 16:
-                        /* XLATCHCTRL should be _4_1 / _2_1... Why is not? (_2_1 is used everytime) */
+                        /* XLATCHCTRL should be _4_1 / _2_1... Why is not? (_2_1 is used every time) */
                         hw->DACreg[POS3026_XTRUECOLORCTRL] = (minfo->fbcon.var.green.length == 5) ? (TVP3026_XTRUECOLORCTRL_DIRECTCOLOR | TVP3026_XTRUECOLORCTRL_ORGB_1555) : (TVP3026_XTRUECOLORCTRL_DIRECTCOLOR | TVP3026_XTRUECOLORCTRL_RGB_565);
                         hw->DACreg[POS3026_XMUXCTRL] = muxctrl | TVP3026_XMUXCTRL_PIXEL_16BIT;
                         hw->DACreg[POS3026_XCLKCTRL] = TVP3026_XCLKCTRL_SRC_PLL | TVP3026_XCLKCTRL_DIV2;
@@ -399,7 +399,7 @@ static int Ti3026_init(struct matrox_fb_info *minfo, struct my_timming *m)
                         hw->DACreg[POS3026_XCLKCTRL] = TVP3026_XCLKCTRL_SRC_PLL | TVP3026_XCLKCTRL_DIV4;
                         break;
                 case 32:
-                        /* XLATCHCTRL should be _2_1 / _1_1... Why is not? (_2_1 is used everytime) */
+                        /* XLATCHCTRL should be _2_1 / _1_1... Why is not? (_2_1 is used every time) */
                         hw->DACreg[POS3026_XMUXCTRL] = muxctrl | TVP3026_XMUXCTRL_PIXEL_32BIT;
                         break;
                 default:
diff --git a/drivers/video/matrox/matroxfb_base.c b/drivers/video/matrox/matroxfb_base.c
index a082debe824b..44bf8d4a216b 100644
--- a/drivers/video/matrox/matroxfb_base.c
+++ b/drivers/video/matrox/matroxfb_base.c
@@ -101,8 +101,6 @@
 
 #include <linux/version.h>
 
-#define __OLD_VIDIOC_
-
 #include "matroxfb_base.h"
 #include "matroxfb_misc.h"
 #include "matroxfb_accel.h"
@@ -623,7 +621,7 @@ static int matroxfb_decode_var(const struct matrox_fb_info *minfo,
                 var->yoffset = var->yres_virtual - var->yres;
 
         if (bpp == 16 && var->green.length == 5) {
-                bpp--; /* an artifical value - 15 */
+                bpp--; /* an artificial value - 15 */
         }
 
         for (rgbt = table; rgbt->bpp < bpp; rgbt++);
@@ -1152,7 +1150,6 @@ static int matroxfb_ioctl(struct fb_info *info,
                                         return -EFAULT;
                                 return err;
                         }
-                case VIDIOC_S_CTRL_OLD:
                 case VIDIOC_S_CTRL:
                         {
                                 struct v4l2_control ctrl;
@@ -1461,13 +1458,6 @@ static struct board {
                 MGA_G100,
                 &vbG100,
                 "MGA-G100 (AGP)"},
-        {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G200EV_PCI,        0xFF,
-                0,                      0,
-                DEVF_G200,
-                230000,
-                MGA_G200,
-                &vbG200,
-                "MGA-G200eV (PCI)"},
         {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G200_PCI,  0xFF,
                 0,                      0,
                 DEVF_G200,
@@ -2119,8 +2109,6 @@ static struct pci_device_id matroxfb_devices[] = {
                 PCI_ANY_ID,     PCI_ANY_ID,     0, 0, 0},
         {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G100_AGP,
                 PCI_ANY_ID,     PCI_ANY_ID,     0, 0, 0},
-        {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G200EV_PCI,
-                PCI_ANY_ID,     PCI_ANY_ID,     0, 0, 0},
         {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G200_PCI,
                 PCI_ANY_ID,     PCI_ANY_ID,     0, 0, 0},
         {PCI_VENDOR_ID_MATROX,  PCI_DEVICE_ID_MATROX_G200_AGP,
diff --git a/drivers/video/matrox/matroxfb_base.h b/drivers/video/matrox/matroxfb_base.h
index f96a471cb1a8..11ed57bb704e 100644
--- a/drivers/video/matrox/matroxfb_base.h
+++ b/drivers/video/matrox/matroxfb_base.h
@@ -12,7 +12,7 @@
 #undef MATROXFB_DEBUG
 
 /* heavy debugging: */
-/* -- logs putc[s], so everytime a char is displayed, it's logged */
+/* -- logs putc[s], so every time a char is displayed, it's logged */
 #undef MATROXFB_DEBUG_HEAVY
 
 /* This one _could_ cause infinite loops */
diff --git a/drivers/video/metronomefb.c b/drivers/video/metronomefb.c
index 63ed3b72b01c..ed64edfd2c43 100644
--- a/drivers/video/metronomefb.c
+++ b/drivers/video/metronomefb.c
@@ -765,7 +765,7 @@ static int __devexit metronomefb_remove(struct platform_device *dev)
 
 static struct platform_driver metronomefb_driver = {
         .probe  = metronomefb_probe,
-        .remove = metronomefb_remove,
+        .remove = __devexit_p(metronomefb_remove),
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "metronomefb",
diff --git a/drivers/video/nuc900fb.h b/drivers/video/nuc900fb.h
index 6c23aa3d3b89..bc7c9300f276 100644
--- a/drivers/video/nuc900fb.h
+++ b/drivers/video/nuc900fb.h
@@ -8,7 +8,7 @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- *   Auther:
+ *   Author:
  *        Wang Qiang(rurality.linux@gmail.com)  2009/12/16
  */
 
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
index 6aac6d1b937b..8471008aa6ff 100644
--- a/drivers/video/nvidia/nv_backlight.c
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -111,6 +111,7 @@ void nvidia_bl_init(struct nvidia_par *par)
         snprintf(name, sizeof(name), "nvidiabl%d", info->node);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, info->dev, par, &nvidia_bl_ops,
                                        &props);
diff --git a/drivers/video/omap/Kconfig b/drivers/video/omap/Kconfig
index 083c8fe53e24..196fa2e7f438 100644
--- a/drivers/video/omap/Kconfig
+++ b/drivers/video/omap/Kconfig
@@ -5,13 +5,18 @@ config FB_OMAP
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select TWL4030_CORE if MACH_OMAP_2430SDP
         help
           Frame buffer driver for OMAP based boards.
 
 config FB_OMAP_LCD_VGA
         bool "Use LCD in VGA mode"
                 depends on MACH_OMAP_3430SDP || MACH_OMAP_LDP
-
+                help
+                  Set LCD resolution as VGA (640 X 480).
+                  Default resolution without this option is QVGA(320 X 240).
+                  Please take a look at drivers/video/omap/lcd_ldp.c file
+                  for lcd driver code.
 choice
         depends on FB_OMAP && MACH_OVERO
         prompt "Screen resolution"
@@ -59,7 +64,7 @@ config FB_OMAP_MANUAL_UPDATE
         depends on FB_OMAP && FB_OMAP_LCDC_EXTERNAL
         help
           Say Y here, if your user-space applications are capable of
-          notifying the frame buffer driver when a change has occured in
+          notifying the frame buffer driver when a change has occurred in
           the frame buffer content and thus a reload of the image data to
           the external frame buffer is required. If unsure, say N.
 
diff --git a/drivers/video/omap/blizzard.c b/drivers/video/omap/blizzard.c
index 87785c215a52..c0504a8a5079 100644
--- a/drivers/video/omap/blizzard.c
+++ b/drivers/video/omap/blizzard.c
@@ -397,8 +397,7 @@ static inline void free_req(struct blizzard_request *req)
 
         spin_lock_irqsave(&blizzard.req_lock, flags);
 
-        list_del(&req->entry);
-        list_add(&req->entry, &blizzard.free_req_list);
+        list_move(&req->entry, &blizzard.free_req_list);
         if (!(req->flags & REQ_FROM_IRQ_POOL))
                 up(&blizzard.req_sema);
 
diff --git a/drivers/video/omap/hwa742.c b/drivers/video/omap/hwa742.c
index 0016f77cd13f..084aa0ac562b 100644
--- a/drivers/video/omap/hwa742.c
+++ b/drivers/video/omap/hwa742.c
@@ -269,8 +269,7 @@ static inline void free_req(struct hwa742_request *req)
 
         spin_lock_irqsave(&hwa742.req_lock, flags);
 
-        list_del(&req->entry);
-        list_add(&req->entry, &hwa742.free_req_list);
+        list_move(&req->entry, &hwa742.free_req_list);
         if (!(req->flags & REQ_FROM_IRQ_POOL))
                 up(&hwa742.req_sema);
 
diff --git a/drivers/video/omap2/displays/Kconfig b/drivers/video/omap2/displays/Kconfig
index 940cab394c2e..d18ad6b2372a 100644
--- a/drivers/video/omap2/displays/Kconfig
+++ b/drivers/video/omap2/displays/Kconfig
@@ -9,6 +9,12 @@ config PANEL_GENERIC_DPI
           Supports LCD Panel used in TI SDP3430 and EVM boards,
           OMAP3517 EVM boards and CM-T35.
 
+config PANEL_LGPHILIPS_LB035Q02
+        tristate "LG.Philips LB035Q02 LCD Panel"
+        depends on OMAP2_DSS && SPI
+        help
+          LCD Panel used on the Gumstix Overo Palo35
+
 config PANEL_SHARP_LS037V7DW01
         tristate "Sharp LS037V7DW01 LCD Panel"
         depends on OMAP2_DSS
diff --git a/drivers/video/omap2/displays/Makefile b/drivers/video/omap2/displays/Makefile
index 861f0255ec6b..0f601ab3abf4 100644
--- a/drivers/video/omap2/displays/Makefile
+++ b/drivers/video/omap2/displays/Makefile
@@ -1,4 +1,5 @@
 obj-$(CONFIG_PANEL_GENERIC_DPI) += panel-generic-dpi.o
+obj-$(CONFIG_PANEL_LGPHILIPS_LB035Q02) += panel-lgphilips-lb035q02.o
 obj-$(CONFIG_PANEL_SHARP_LS037V7DW01) += panel-sharp-ls037v7dw01.o
 obj-$(CONFIG_PANEL_NEC_NL8048HL11_01B) += panel-nec-nl8048hl11-01b.o
 
diff --git a/drivers/video/omap2/displays/panel-acx565akm.c b/drivers/video/omap2/displays/panel-acx565akm.c
index e77310653207..7e04c921aa2a 100644
--- a/drivers/video/omap2/displays/panel-acx565akm.c
+++ b/drivers/video/omap2/displays/panel-acx565akm.c
@@ -534,6 +534,7 @@ static int acx_panel_probe(struct omap_dss_device *dssdev)
 
         props.fb_blank = FB_BLANK_UNBLANK;
         props.power = FB_BLANK_UNBLANK;
+        props.type = BACKLIGHT_RAW;
 
         bldev = backlight_device_register("acx565akm", &md->spi->dev,
                         md, &acx565akm_bl_ops, &props);
diff --git a/drivers/video/omap2/displays/panel-generic-dpi.c b/drivers/video/omap2/displays/panel-generic-dpi.c
index 07eb30ee59c8..4a9b9ff59467 100644
--- a/drivers/video/omap2/displays/panel-generic-dpi.c
+++ b/drivers/video/omap2/displays/panel-generic-dpi.c
@@ -156,6 +156,31 @@ static struct panel_config generic_dpi_panels[] = {
                 .power_off_delay        = 0,
                 .name                   = "toppoly_tdo35s",
         },
+
+        /* Samsung LTE430WQ-F0C */
+        {
+                {
+                        .x_res          = 480,
+                        .y_res          = 272,
+
+                        .pixel_clock    = 9200,
+
+                        .hfp            = 8,
+                        .hsw            = 41,
+                        .hbp            = 45 - 41,
+
+                        .vfp            = 4,
+                        .vsw            = 10,
+                        .vbp            = 12 - 10,
+                },
+                .acbi                   = 0x0,
+                .acb                    = 0x0,
+                .config                 = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
+                                                OMAP_DSS_LCD_IHS,
+                .power_on_delay         = 0,
+                .power_off_delay        = 0,
+                .name                   = "samsung_lte430wq_f0c",
+        },
 };
 
 struct panel_drv_data {
diff --git a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
new file mode 100644
index 000000000000..271324db2436
--- /dev/null
+++ b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
@@ -0,0 +1,279 @@
+/*
+ * LCD panel driver for LG.Philips LB035Q02
+ *
+ * Author: Steve Sakoman <steve@sakoman.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/spi/spi.h>
+#include <linux/mutex.h>
+
+#include <plat/display.h>
+
+struct lb035q02_data {
+        struct mutex lock;
+};
+
+static struct omap_video_timings lb035q02_timings = {
+        .x_res = 320,
+        .y_res = 240,
+
+        .pixel_clock    = 6500,
+
+        .hsw            = 2,
+        .hfp            = 20,
+        .hbp            = 68,
+
+        .vsw            = 2,
+        .vfp            = 4,
+        .vbp            = 18,
+};
+
+static int lb035q02_panel_power_on(struct omap_dss_device *dssdev)
+{
+        int r;
+
+        if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
+                return 0;
+
+        r = omapdss_dpi_display_enable(dssdev);
+        if (r)
+                goto err0;
+
+        if (dssdev->platform_enable) {
+                r = dssdev->platform_enable(dssdev);
+                if (r)
+                        goto err1;
+        }
+
+        return 0;
+err1:
+        omapdss_dpi_display_disable(dssdev);
+err0:
+        return r;
+}
+
+static void lb035q02_panel_power_off(struct omap_dss_device *dssdev)
+{
+        if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
+                return;
+
+        if (dssdev->platform_disable)
+                dssdev->platform_disable(dssdev);
+
+        omapdss_dpi_display_disable(dssdev);
+}
+
+static int lb035q02_panel_probe(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld;
+        int r;
+
+        dssdev->panel.config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
+                OMAP_DSS_LCD_IHS;
+        dssdev->panel.timings = lb035q02_timings;
+
+        ld = kzalloc(sizeof(*ld), GFP_KERNEL);
+        if (!ld) {
+                r = -ENOMEM;
+                goto err;
+        }
+        mutex_init(&ld->lock);
+        dev_set_drvdata(&dssdev->dev, ld);
+        return 0;
+err:
+        return r;
+}
+
+static void lb035q02_panel_remove(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
+
+        kfree(ld);
+}
+
+static int lb035q02_panel_enable(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
+        int r;
+
+        mutex_lock(&ld->lock);
+
+        r = lb035q02_panel_power_on(dssdev);
+        if (r)
+                goto err;
+        dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
+
+        mutex_unlock(&ld->lock);
+        return 0;
+err:
+        mutex_unlock(&ld->lock);
+        return r;
+}
+
+static void lb035q02_panel_disable(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
+
+        mutex_lock(&ld->lock);
+
+        lb035q02_panel_power_off(dssdev);
+        dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
+
+        mutex_unlock(&ld->lock);
+}
+
+static int lb035q02_panel_suspend(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
+
+        mutex_lock(&ld->lock);
+
+        lb035q02_panel_power_off(dssdev);
+        dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
+
+        mutex_unlock(&ld->lock);
+        return 0;
+}
+
+static int lb035q02_panel_resume(struct omap_dss_device *dssdev)
+{
+        struct lb035q02_data *ld = dev_get_drvdata(&dssdev->dev);
+        int r;
+
+        mutex_lock(&ld->lock);
+
+        r = lb035q02_panel_power_on(dssdev);
+        if (r)
+                goto err;
+        dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
+
+        mutex_unlock(&ld->lock);
+        return 0;
+err:
+        mutex_unlock(&ld->lock);
+        return r;
+}
+
+static struct omap_dss_driver lb035q02_driver = {
+        .probe          = lb035q02_panel_probe,
+        .remove         = lb035q02_panel_remove,
+
+        .enable         = lb035q02_panel_enable,
+        .disable        = lb035q02_panel_disable,
+        .suspend        = lb035q02_panel_suspend,
+        .resume         = lb035q02_panel_resume,
+
+        .driver         = {
+                .name   = "lgphilips_lb035q02_panel",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int lb035q02_write_reg(struct spi_device *spi, u8 reg, u16 val)
+{
+        struct spi_message msg;
+        struct spi_transfer index_xfer = {
+                .len            = 3,
+                .cs_change      = 1,
+        };
+        struct spi_transfer value_xfer = {
+                .len            = 3,
+        };
+        u8      buffer[16];
+
+        spi_message_init(&msg);
+
+        /* register index */
+        buffer[0] = 0x70;
+        buffer[1] = 0x00;
+        buffer[2] = reg & 0x7f;
+        index_xfer.tx_buf = buffer;
+        spi_message_add_tail(&index_xfer, &msg);
+
+        /* register value */
+        buffer[4] = 0x72;
+        buffer[5] = val >> 8;
+        buffer[6] = val;
+        value_xfer.tx_buf = buffer + 4;
+        spi_message_add_tail(&value_xfer, &msg);
+
+        return spi_sync(spi, &msg);
+}
+
+static void init_lb035q02_panel(struct spi_device *spi)
+{
+        /* Init sequence from page 28 of the lb035q02 spec */
+        lb035q02_write_reg(spi, 0x01, 0x6300);
+        lb035q02_write_reg(spi, 0x02, 0x0200);
+        lb035q02_write_reg(spi, 0x03, 0x0177);
+        lb035q02_write_reg(spi, 0x04, 0x04c7);
+        lb035q02_write_reg(spi, 0x05, 0xffc0);
+        lb035q02_write_reg(spi, 0x06, 0xe806);
+        lb035q02_write_reg(spi, 0x0a, 0x4008);
+        lb035q02_write_reg(spi, 0x0b, 0x0000);
+        lb035q02_write_reg(spi, 0x0d, 0x0030);
+        lb035q02_write_reg(spi, 0x0e, 0x2800);
+        lb035q02_write_reg(spi, 0x0f, 0x0000);
+        lb035q02_write_reg(spi, 0x16, 0x9f80);
+        lb035q02_write_reg(spi, 0x17, 0x0a0f);
+        lb035q02_write_reg(spi, 0x1e, 0x00c1);
+        lb035q02_write_reg(spi, 0x30, 0x0300);
+        lb035q02_write_reg(spi, 0x31, 0x0007);
+        lb035q02_write_reg(spi, 0x32, 0x0000);
+        lb035q02_write_reg(spi, 0x33, 0x0000);
+        lb035q02_write_reg(spi, 0x34, 0x0707);
+        lb035q02_write_reg(spi, 0x35, 0x0004);
+        lb035q02_write_reg(spi, 0x36, 0x0302);
+        lb035q02_write_reg(spi, 0x37, 0x0202);
+        lb035q02_write_reg(spi, 0x3a, 0x0a0d);
+        lb035q02_write_reg(spi, 0x3b, 0x0806);
+}
+
+static int __devinit lb035q02_panel_spi_probe(struct spi_device *spi)
+{
+        init_lb035q02_panel(spi);
+        return omap_dss_register_driver(&lb035q02_driver);
+}
+
+static int __devexit lb035q02_panel_spi_remove(struct spi_device *spi)
+{
+        omap_dss_unregister_driver(&lb035q02_driver);
+        return 0;
+}
+
+static struct spi_driver lb035q02_spi_driver = {
+        .driver         = {
+                .name   = "lgphilips_lb035q02_panel-spi",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = lb035q02_panel_spi_probe,
+        .remove         = __devexit_p(lb035q02_panel_spi_remove),
+};
+
+static int __init lb035q02_panel_drv_init(void)
+{
+        return spi_register_driver(&lb035q02_spi_driver);
+}
+
+static void __exit lb035q02_panel_drv_exit(void)
+{
+        spi_unregister_driver(&lb035q02_spi_driver);
+}
+
+module_init(lb035q02_panel_drv_init);
+module_exit(lb035q02_panel_drv_exit);
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
index 9a138f650e05..d2b35d2df2a6 100644
--- a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
+++ b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
@@ -99,6 +99,7 @@ static int sharp_ls_panel_probe(struct omap_dss_device *dssdev)
 
         memset(&props, 0, sizeof(struct backlight_properties));
         props.max_brightness = dssdev->max_backlight_level;
+        props.type = BACKLIGHT_RAW;
 
         bl = backlight_device_register("sharp-ls", &dssdev->dev, dssdev,
                         &sharp_ls_bl_ops, &props);
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index 61026f96ad20..adc9900458e1 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -218,6 +218,8 @@ struct taal_data {
                 u16 w;
                 u16 h;
         } update_region;
+        int channel;
+
         struct delayed_work te_timeout_work;
 
         bool use_dsi_bl;
@@ -257,12 +259,12 @@ static void hw_guard_wait(struct taal_data *td)
         }
 }
 
-static int taal_dcs_read_1(u8 dcs_cmd, u8 *data)
+static int taal_dcs_read_1(struct taal_data *td, u8 dcs_cmd, u8 *data)
 {
         int r;
         u8 buf[1];
 
-        r = dsi_vc_dcs_read(TCH, dcs_cmd, buf, 1);
+        r = dsi_vc_dcs_read(td->channel, dcs_cmd, buf, 1);
 
         if (r < 0)
                 return r;
@@ -272,17 +274,17 @@ static int taal_dcs_read_1(u8 dcs_cmd, u8 *data)
         return 0;
 }
 
-static int taal_dcs_write_0(u8 dcs_cmd)
+static int taal_dcs_write_0(struct taal_data *td, u8 dcs_cmd)
 {
-        return dsi_vc_dcs_write(TCH, &dcs_cmd, 1);
+        return dsi_vc_dcs_write(td->channel, &dcs_cmd, 1);
 }
 
-static int taal_dcs_write_1(u8 dcs_cmd, u8 param)
+static int taal_dcs_write_1(struct taal_data *td, u8 dcs_cmd, u8 param)
 {
         u8 buf[2];
         buf[0] = dcs_cmd;
         buf[1] = param;
-        return dsi_vc_dcs_write(TCH, buf, 2);
+        return dsi_vc_dcs_write(td->channel, buf, 2);
 }
 
 static int taal_sleep_in(struct taal_data *td)
@@ -294,7 +296,7 @@ static int taal_sleep_in(struct taal_data *td)
         hw_guard_wait(td);
 
         cmd = DCS_SLEEP_IN;
-        r = dsi_vc_dcs_write_nosync(TCH, &cmd, 1);
+        r = dsi_vc_dcs_write_nosync(td->channel, &cmd, 1);
         if (r)
                 return r;
 
@@ -312,7 +314,7 @@ static int taal_sleep_out(struct taal_data *td)
 
         hw_guard_wait(td);
 
-        r = taal_dcs_write_0(DCS_SLEEP_OUT);
+        r = taal_dcs_write_0(td, DCS_SLEEP_OUT);
         if (r)
                 return r;
 
@@ -324,30 +326,30 @@ static int taal_sleep_out(struct taal_data *td)
         return 0;
 }
 
-static int taal_get_id(u8 *id1, u8 *id2, u8 *id3)
+static int taal_get_id(struct taal_data *td, u8 *id1, u8 *id2, u8 *id3)
 {
         int r;
 
-        r = taal_dcs_read_1(DCS_GET_ID1, id1);
+        r = taal_dcs_read_1(td, DCS_GET_ID1, id1);
         if (r)
                 return r;
-        r = taal_dcs_read_1(DCS_GET_ID2, id2);
+        r = taal_dcs_read_1(td, DCS_GET_ID2, id2);
         if (r)
                 return r;
-        r = taal_dcs_read_1(DCS_GET_ID3, id3);
+        r = taal_dcs_read_1(td, DCS_GET_ID3, id3);
         if (r)
                 return r;
 
         return 0;
 }
 
-static int taal_set_addr_mode(u8 rotate, bool mirror)
+static int taal_set_addr_mode(struct taal_data *td, u8 rotate, bool mirror)
 {
         int r;
         u8 mode;
         int b5, b6, b7;
 
-        r = taal_dcs_read_1(DCS_READ_MADCTL, &mode);
+        r = taal_dcs_read_1(td, DCS_READ_MADCTL, &mode);
         if (r)
                 return r;
 
@@ -381,10 +383,11 @@ static int taal_set_addr_mode(u8 rotate, bool mirror)
         mode &= ~((1<<7) | (1<<6) | (1<<5));
         mode |= (b7 << 7) | (b6 << 6) | (b5 << 5);
 
-        return taal_dcs_write_1(DCS_MEM_ACC_CTRL, mode);
+        return taal_dcs_write_1(td, DCS_MEM_ACC_CTRL, mode);
 }
 
-static int taal_set_update_window(u16 x, u16 y, u16 w, u16 h)
+static int taal_set_update_window(struct taal_data *td,
+                u16 x, u16 y, u16 w, u16 h)
 {
         int r;
         u16 x1 = x;
@@ -399,7 +402,7 @@ static int taal_set_update_window(u16 x, u16 y, u16 w, u16 h)
         buf[3] = (x2 >> 8) & 0xff;
         buf[4] = (x2 >> 0) & 0xff;
 
-        r = dsi_vc_dcs_write_nosync(TCH, buf, sizeof(buf));
+        r = dsi_vc_dcs_write_nosync(td->channel, buf, sizeof(buf));
         if (r)
                 return r;
 
@@ -409,11 +412,11 @@ static int taal_set_update_window(u16 x, u16 y, u16 w, u16 h)
         buf[3] = (y2 >> 8) & 0xff;
         buf[4] = (y2 >> 0) & 0xff;
 
-        r = dsi_vc_dcs_write_nosync(TCH, buf, sizeof(buf));
+        r = dsi_vc_dcs_write_nosync(td->channel, buf, sizeof(buf));
         if (r)
                 return r;
 
-        dsi_vc_send_bta_sync(TCH);
+        dsi_vc_send_bta_sync(td->channel);
 
         return r;
 }
@@ -439,7 +442,7 @@ static int taal_bl_update_status(struct backlight_device *dev)
         if (td->use_dsi_bl) {
                 if (td->enabled) {
                         dsi_bus_lock();
-                        r = taal_dcs_write_1(DCS_BRIGHTNESS, level);
+                        r = taal_dcs_write_1(td, DCS_BRIGHTNESS, level);
                         dsi_bus_unlock();
                 } else {
                         r = 0;
@@ -502,7 +505,7 @@ static ssize_t taal_num_errors_show(struct device *dev,
 
         if (td->enabled) {
                 dsi_bus_lock();
-                r = taal_dcs_read_1(DCS_READ_NUM_ERRORS, &errors);
+                r = taal_dcs_read_1(td, DCS_READ_NUM_ERRORS, &errors);
                 dsi_bus_unlock();
         } else {
                 r = -ENODEV;
@@ -528,7 +531,7 @@ static ssize_t taal_hw_revision_show(struct device *dev,
 
         if (td->enabled) {
                 dsi_bus_lock();
-                r = taal_get_id(&id1, &id2, &id3);
+                r = taal_get_id(td, &id1, &id2, &id3);
                 dsi_bus_unlock();
         } else {
                 r = -ENODEV;
@@ -590,7 +593,7 @@ static ssize_t store_cabc_mode(struct device *dev,
         if (td->enabled) {
                 dsi_bus_lock();
                 if (!td->cabc_broken)
-                        taal_dcs_write_1(DCS_WRITE_CABC, i);
+                        taal_dcs_write_1(td, DCS_WRITE_CABC, i);
                 dsi_bus_unlock();
         }
 
@@ -729,6 +732,8 @@ static int taal_probe(struct omap_dss_device *dssdev)
                 props.max_brightness = 255;
         else
                 props.max_brightness = 127;
+
+        props.type = BACKLIGHT_RAW;
         bldev = backlight_device_register("taal", &dssdev->dev, dssdev,
                                           &taal_bl_ops, &props);
         if (IS_ERR(bldev)) {
@@ -774,14 +779,29 @@ static int taal_probe(struct omap_dss_device *dssdev)
                 dev_dbg(&dssdev->dev, "Using GPIO TE\n");
         }
 
+        r = omap_dsi_request_vc(dssdev, &td->channel);
+        if (r) {
+                dev_err(&dssdev->dev, "failed to get virtual channel\n");
+                goto err_req_vc;
+        }
+
+        r = omap_dsi_set_vc_id(dssdev, td->channel, TCH);
+        if (r) {
+                dev_err(&dssdev->dev, "failed to set VC_ID\n");
+                goto err_vc_id;
+        }
+
         r = sysfs_create_group(&dssdev->dev.kobj, &taal_attr_group);
         if (r) {
                 dev_err(&dssdev->dev, "failed to create sysfs files\n");
-                goto err_sysfs;
+                goto err_vc_id;
         }
 
         return 0;
-err_sysfs:
+
+err_vc_id:
+        omap_dsi_release_vc(dssdev, td->channel);
+err_req_vc:
         if (panel_data->use_ext_te)
                 free_irq(gpio_to_irq(panel_data->ext_te_gpio), dssdev);
 err_irq:
@@ -808,6 +828,7 @@ static void taal_remove(struct omap_dss_device *dssdev)
         dev_dbg(&dssdev->dev, "remove\n");
 
         sysfs_remove_group(&dssdev->dev.kobj, &taal_attr_group);
+        omap_dsi_release_vc(dssdev, td->channel);
 
         if (panel_data->use_ext_te) {
                 int gpio = panel_data->ext_te_gpio;
@@ -846,13 +867,13 @@ static int taal_power_on(struct omap_dss_device *dssdev)
 
         taal_hw_reset(dssdev);
 
-        omapdss_dsi_vc_enable_hs(TCH, false);
+        omapdss_dsi_vc_enable_hs(td->channel, false);
 
         r = taal_sleep_out(td);
         if (r)
                 goto err;
 
-        r = taal_get_id(&id1, &id2, &id3);
+        r = taal_get_id(td, &id1, &id2, &id3);
         if (r)
                 goto err;
 
@@ -861,30 +882,30 @@ static int taal_power_on(struct omap_dss_device *dssdev)
                 (id2 == 0x00 || id2 == 0xff || id2 == 0x81))
                 td->cabc_broken = true;
 
-        r = taal_dcs_write_1(DCS_BRIGHTNESS, 0xff);
+        r = taal_dcs_write_1(td, DCS_BRIGHTNESS, 0xff);
         if (r)
                 goto err;
 
-        r = taal_dcs_write_1(DCS_CTRL_DISPLAY,
+        r = taal_dcs_write_1(td, DCS_CTRL_DISPLAY,
                         (1<<2) | (1<<5));       /* BL | BCTRL */
         if (r)
                 goto err;
 
-        r = taal_dcs_write_1(DCS_PIXEL_FORMAT, 0x7); /* 24bit/pixel */
+        r = taal_dcs_write_1(td, DCS_PIXEL_FORMAT, 0x7); /* 24bit/pixel */
         if (r)
                 goto err;
 
-        r = taal_set_addr_mode(td->rotate, td->mirror);
+        r = taal_set_addr_mode(td, td->rotate, td->mirror);
         if (r)
                 goto err;
 
         if (!td->cabc_broken) {
-                r = taal_dcs_write_1(DCS_WRITE_CABC, td->cabc_mode);
+                r = taal_dcs_write_1(td, DCS_WRITE_CABC, td->cabc_mode);
                 if (r)
                         goto err;
         }
 
-        r = taal_dcs_write_0(DCS_DISPLAY_ON);
+        r = taal_dcs_write_0(td, DCS_DISPLAY_ON);
         if (r)
                 goto err;
 
@@ -903,7 +924,7 @@ static int taal_power_on(struct omap_dss_device *dssdev)
                 td->intro_printed = true;
         }
 
-        omapdss_dsi_vc_enable_hs(TCH, true);
+        omapdss_dsi_vc_enable_hs(td->channel, true);
 
         return 0;
 err:
@@ -921,7 +942,7 @@ static void taal_power_off(struct omap_dss_device *dssdev)
         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
         int r;
 
-        r = taal_dcs_write_0(DCS_DISPLAY_OFF);
+        r = taal_dcs_write_0(td, DCS_DISPLAY_OFF);
         if (!r) {
                 r = taal_sleep_in(td);
                 /* HACK: wait a bit so that the message goes through */
@@ -1089,7 +1110,7 @@ static irqreturn_t taal_te_isr(int irq, void *data)
         if (old) {
                 cancel_delayed_work(&td->te_timeout_work);
 
-                r = omap_dsi_update(dssdev, TCH,
+                r = omap_dsi_update(dssdev, td->channel,
                                 td->update_region.x,
                                 td->update_region.y,
                                 td->update_region.w,
@@ -1139,7 +1160,7 @@ static int taal_update(struct omap_dss_device *dssdev,
         if (r)
                 goto err;
 
-        r = taal_set_update_window(x, y, w, h);
+        r = taal_set_update_window(td, x, y, w, h);
         if (r)
                 goto err;
 
@@ -1153,7 +1174,7 @@ static int taal_update(struct omap_dss_device *dssdev,
                                 msecs_to_jiffies(250));
                 atomic_set(&td->do_update, 1);
         } else {
-                r = omap_dsi_update(dssdev, TCH, x, y, w, h,
+                r = omap_dsi_update(dssdev, td->channel, x, y, w, h,
                                 taal_framedone_cb, dssdev);
                 if (r)
                         goto err;
@@ -1191,9 +1212,9 @@ static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable)
         int r;
 
         if (enable)
-                r = taal_dcs_write_1(DCS_TEAR_ON, 0);
+                r = taal_dcs_write_1(td, DCS_TEAR_ON, 0);
         else
-                r = taal_dcs_write_0(DCS_TEAR_OFF);
+                r = taal_dcs_write_0(td, DCS_TEAR_OFF);
 
         if (!panel_data->use_ext_te)
                 omapdss_dsi_enable_te(dssdev, enable);
@@ -1263,7 +1284,7 @@ static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
         dsi_bus_lock();
 
         if (td->enabled) {
-                r = taal_set_addr_mode(rotate, td->mirror);
+                r = taal_set_addr_mode(td, rotate, td->mirror);
                 if (r)
                         goto err;
         }
@@ -1306,7 +1327,7 @@ static int taal_mirror(struct omap_dss_device *dssdev, bool enable)
 
         dsi_bus_lock();
         if (td->enabled) {
-                r = taal_set_addr_mode(td->rotate, enable);
+                r = taal_set_addr_mode(td, td->rotate, enable);
                 if (r)
                         goto err;
         }
@@ -1350,13 +1371,13 @@ static int taal_run_test(struct omap_dss_device *dssdev, int test_num)
 
         dsi_bus_lock();
 
-        r = taal_dcs_read_1(DCS_GET_ID1, &id1);
+        r = taal_dcs_read_1(td, DCS_GET_ID1, &id1);
         if (r)
                 goto err2;
-        r = taal_dcs_read_1(DCS_GET_ID2, &id2);
+        r = taal_dcs_read_1(td, DCS_GET_ID2, &id2);
         if (r)
                 goto err2;
-        r = taal_dcs_read_1(DCS_GET_ID3, &id3);
+        r = taal_dcs_read_1(td, DCS_GET_ID3, &id3);
         if (r)
                 goto err2;
 
@@ -1404,9 +1425,9 @@ static int taal_memory_read(struct omap_dss_device *dssdev,
         else
                 plen = 2;
 
-        taal_set_update_window(x, y, w, h);
+        taal_set_update_window(td, x, y, w, h);
 
-        r = dsi_vc_set_max_rx_packet_size(TCH, plen);
+        r = dsi_vc_set_max_rx_packet_size(td->channel, plen);
         if (r)
                 goto err2;
 
@@ -1414,7 +1435,7 @@ static int taal_memory_read(struct omap_dss_device *dssdev,
                 u8 dcs_cmd = first ? 0x2e : 0x3e;
                 first = 0;
 
-                r = dsi_vc_dcs_read(TCH, dcs_cmd,
+                r = dsi_vc_dcs_read(td->channel, dcs_cmd,
                                 buf + buf_used, size - buf_used);
 
                 if (r < 0) {
@@ -1440,7 +1461,7 @@ static int taal_memory_read(struct omap_dss_device *dssdev,
         r = buf_used;
 
 err3:
-        dsi_vc_set_max_rx_packet_size(TCH, 1);
+        dsi_vc_set_max_rx_packet_size(td->channel, 1);
 err2:
         dsi_bus_unlock();
 err1:
@@ -1466,7 +1487,7 @@ static void taal_esd_work(struct work_struct *work)
 
         dsi_bus_lock();
 
-        r = taal_dcs_read_1(DCS_RDDSDR, &state1);
+        r = taal_dcs_read_1(td, DCS_RDDSDR, &state1);
         if (r) {
                 dev_err(&dssdev->dev, "failed to read Taal status\n");
                 goto err;
@@ -1479,7 +1500,7 @@ static void taal_esd_work(struct work_struct *work)
                 goto err;
         }
 
-        r = taal_dcs_read_1(DCS_RDDSDR, &state2);
+        r = taal_dcs_read_1(td, DCS_RDDSDR, &state2);
         if (r) {
                 dev_err(&dssdev->dev, "failed to read Taal status\n");
                 goto err;
@@ -1495,7 +1516,7 @@ static void taal_esd_work(struct work_struct *work)
         /* Self-diagnostics result is also shown on TE GPIO line. We need
          * to re-enable TE after self diagnostics */
         if (td->te_enabled && panel_data->use_ext_te) {
-                r = taal_dcs_write_1(DCS_TEAR_ON, 0);
+                r = taal_dcs_write_1(td, DCS_TEAR_ON, 0);
                 if (r)
                         goto err;
         }
diff --git a/drivers/video/omap2/dss/Kconfig b/drivers/video/omap2/dss/Kconfig
index 43b64403eaa4..bfc5da0e9700 100644
--- a/drivers/video/omap2/dss/Kconfig
+++ b/drivers/video/omap2/dss/Kconfig
@@ -1,8 +1,8 @@
 menuconfig OMAP2_DSS
-        tristate "OMAP2/3 Display Subsystem support (EXPERIMENTAL)"
-        depends on ARCH_OMAP2 || ARCH_OMAP3
+        tristate "OMAP2+ Display Subsystem support (EXPERIMENTAL)"
+        depends on ARCH_OMAP2PLUS
         help
-          OMAP2/3 Display Subsystem support.
+          OMAP2+ Display Subsystem support.
 
 if OMAP2_DSS
 
@@ -60,6 +60,14 @@ config OMAP2_DSS_VENC
         help
           OMAP Video Encoder support for S-Video and composite TV-out.
 
+config OMAP4_DSS_HDMI
+        bool "HDMI support"
+        depends on ARCH_OMAP4
+        default y
+        help
+          HDMI Interface. This adds the High Definition Multimedia Interface.
+          See http://www.hdmi.org/ for HDMI specification.
+
 config OMAP2_DSS_SDI
         bool "SDI support"
         depends on ARCH_OMAP3
diff --git a/drivers/video/omap2/dss/Makefile b/drivers/video/omap2/dss/Makefile
index 7db17b5e570c..10d9d3bb3e24 100644
--- a/drivers/video/omap2/dss/Makefile
+++ b/drivers/video/omap2/dss/Makefile
@@ -5,3 +5,5 @@ omapdss-$(CONFIG_OMAP2_DSS_RFBI) += rfbi.o
 omapdss-$(CONFIG_OMAP2_DSS_VENC) += venc.o
 omapdss-$(CONFIG_OMAP2_DSS_SDI) += sdi.o
 omapdss-$(CONFIG_OMAP2_DSS_DSI) += dsi.o
+omapdss-$(CONFIG_OMAP4_DSS_HDMI) += hdmi.o \
+                                    hdmi_omap4_panel.o
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index 8e89f6049280..1aa2ed1e786e 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -34,332 +34,26 @@
 #include <linux/regulator/consumer.h>
 
 #include <plat/display.h>
-#include <plat/clock.h>
 
 #include "dss.h"
 #include "dss_features.h"
 
 static struct {
         struct platform_device *pdev;
-        int             ctx_id;
-
-        struct clk      *dss_ick;
-        struct clk      *dss1_fck;
-        struct clk      *dss2_fck;
-        struct clk      *dss_54m_fck;
-        struct clk      *dss_96m_fck;
-        unsigned        num_clks_enabled;
 
         struct regulator *vdds_dsi_reg;
         struct regulator *vdds_sdi_reg;
-        struct regulator *vdda_dac_reg;
 } core;
 
-static void dss_clk_enable_all_no_ctx(void);
-static void dss_clk_disable_all_no_ctx(void);
-static void dss_clk_enable_no_ctx(enum dss_clock clks);
-static void dss_clk_disable_no_ctx(enum dss_clock clks);
-
 static char *def_disp_name;
 module_param_named(def_disp, def_disp_name, charp, 0);
-MODULE_PARM_DESC(def_disp_name, "default display name");
+MODULE_PARM_DESC(def_disp, "default display name");
 
 #ifdef DEBUG
 unsigned int dss_debug;
 module_param_named(debug, dss_debug, bool, 0644);
 #endif
 
-/* CONTEXT */
-static int dss_get_ctx_id(void)
-{
-        struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
-        int r;
-
-        if (!pdata->get_last_off_on_transaction_id)
-                return 0;
-        r = pdata->get_last_off_on_transaction_id(&core.pdev->dev);
-        if (r < 0) {
-                dev_err(&core.pdev->dev, "getting transaction ID failed, "
-                                "will force context restore\n");
-                r = -1;
-        }
-        return r;
-}
-
-int dss_need_ctx_restore(void)
-{
-        int id = dss_get_ctx_id();
-
-        if (id < 0 || id != core.ctx_id) {
-                DSSDBG("ctx id %d -> id %d\n",
-                                core.ctx_id, id);
-                core.ctx_id = id;
-                return 1;
-        } else {
-                return 0;
-        }
-}
-
-static void save_all_ctx(void)
-{
-        DSSDBG("save context\n");
-
-        dss_clk_enable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK1);
-
-        dss_save_context();
-        dispc_save_context();
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_save_context();
-#endif
-
-        dss_clk_disable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK1);
-}
-
-static void restore_all_ctx(void)
-{
-        DSSDBG("restore context\n");
-
-        dss_clk_enable_all_no_ctx();
-
-        dss_restore_context();
-        dispc_restore_context();
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_restore_context();
-#endif
-
-        dss_clk_disable_all_no_ctx();
-}
-
-#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
-/* CLOCKS */
-static void core_dump_clocks(struct seq_file *s)
-{
-        int i;
-        struct clk *clocks[5] = {
-                core.dss_ick,
-                core.dss1_fck,
-                core.dss2_fck,
-                core.dss_54m_fck,
-                core.dss_96m_fck
-        };
-
-        seq_printf(s, "- CORE -\n");
-
-        seq_printf(s, "internal clk count\t\t%u\n", core.num_clks_enabled);
-
-        for (i = 0; i < 5; i++) {
-                if (!clocks[i])
-                        continue;
-                seq_printf(s, "%-15s\t%lu\t%d\n",
-                                clocks[i]->name,
-                                clk_get_rate(clocks[i]),
-                                clocks[i]->usecount);
-        }
-}
-#endif /* defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT) */
-
-static int dss_get_clock(struct clk **clock, const char *clk_name)
-{
-        struct clk *clk;
-
-        clk = clk_get(&core.pdev->dev, clk_name);
-
-        if (IS_ERR(clk)) {
-                DSSERR("can't get clock %s", clk_name);
-                return PTR_ERR(clk);
-        }
-
-        *clock = clk;
-
-        DSSDBG("clk %s, rate %ld\n", clk_name, clk_get_rate(clk));
-
-        return 0;
-}
-
-static int dss_get_clocks(void)
-{
-        int r;
-
-        core.dss_ick = NULL;
-        core.dss1_fck = NULL;
-        core.dss2_fck = NULL;
-        core.dss_54m_fck = NULL;
-        core.dss_96m_fck = NULL;
-
-        r = dss_get_clock(&core.dss_ick, "ick");
-        if (r)
-                goto err;
-
-        r = dss_get_clock(&core.dss1_fck, "dss1_fck");
-        if (r)
-                goto err;
-
-        r = dss_get_clock(&core.dss2_fck, "dss2_fck");
-        if (r)
-                goto err;
-
-        r = dss_get_clock(&core.dss_54m_fck, "tv_fck");
-        if (r)
-                goto err;
-
-        r = dss_get_clock(&core.dss_96m_fck, "video_fck");
-        if (r)
-                goto err;
-
-        return 0;
-
-err:
-        if (core.dss_ick)
-                clk_put(core.dss_ick);
-        if (core.dss1_fck)
-                clk_put(core.dss1_fck);
-        if (core.dss2_fck)
-                clk_put(core.dss2_fck);
-        if (core.dss_54m_fck)
-                clk_put(core.dss_54m_fck);
-        if (core.dss_96m_fck)
-                clk_put(core.dss_96m_fck);
-
-        return r;
-}
-
-static void dss_put_clocks(void)
-{
-        if (core.dss_96m_fck)
-                clk_put(core.dss_96m_fck);
-        clk_put(core.dss_54m_fck);
-        clk_put(core.dss1_fck);
-        clk_put(core.dss2_fck);
-        clk_put(core.dss_ick);
-}
-
-unsigned long dss_clk_get_rate(enum dss_clock clk)
-{
-        switch (clk) {
-        case DSS_CLK_ICK:
-                return clk_get_rate(core.dss_ick);
-        case DSS_CLK_FCK1:
-                return clk_get_rate(core.dss1_fck);
-        case DSS_CLK_FCK2:
-                return clk_get_rate(core.dss2_fck);
-        case DSS_CLK_54M:
-                return clk_get_rate(core.dss_54m_fck);
-        case DSS_CLK_96M:
-                return clk_get_rate(core.dss_96m_fck);
-        }
-
-        BUG();
-        return 0;
-}
-
-static unsigned count_clk_bits(enum dss_clock clks)
-{
-        unsigned num_clks = 0;
-
-        if (clks & DSS_CLK_ICK)
-                ++num_clks;
-        if (clks & DSS_CLK_FCK1)
-                ++num_clks;
-        if (clks & DSS_CLK_FCK2)
-                ++num_clks;
-        if (clks & DSS_CLK_54M)
-                ++num_clks;
-        if (clks & DSS_CLK_96M)
-                ++num_clks;
-
-        return num_clks;
-}
-
-static void dss_clk_enable_no_ctx(enum dss_clock clks)
-{
-        unsigned num_clks = count_clk_bits(clks);
-
-        if (clks & DSS_CLK_ICK)
-                clk_enable(core.dss_ick);
-        if (clks & DSS_CLK_FCK1)
-                clk_enable(core.dss1_fck);
-        if (clks & DSS_CLK_FCK2)
-                clk_enable(core.dss2_fck);
-        if (clks & DSS_CLK_54M)
-                clk_enable(core.dss_54m_fck);
-        if (clks & DSS_CLK_96M)
-                clk_enable(core.dss_96m_fck);
-
-        core.num_clks_enabled += num_clks;
-}
-
-void dss_clk_enable(enum dss_clock clks)
-{
-        bool check_ctx = core.num_clks_enabled == 0;
-
-        dss_clk_enable_no_ctx(clks);
-
-        if (check_ctx && cpu_is_omap34xx() && dss_need_ctx_restore())
-                restore_all_ctx();
-}
-
-static void dss_clk_disable_no_ctx(enum dss_clock clks)
-{
-        unsigned num_clks = count_clk_bits(clks);
-
-        if (clks & DSS_CLK_ICK)
-                clk_disable(core.dss_ick);
-        if (clks & DSS_CLK_FCK1)
-                clk_disable(core.dss1_fck);
-        if (clks & DSS_CLK_FCK2)
-                clk_disable(core.dss2_fck);
-        if (clks & DSS_CLK_54M)
-                clk_disable(core.dss_54m_fck);
-        if (clks & DSS_CLK_96M)
-                clk_disable(core.dss_96m_fck);
-
-        core.num_clks_enabled -= num_clks;
-}
-
-void dss_clk_disable(enum dss_clock clks)
-{
-        if (cpu_is_omap34xx()) {
-                unsigned num_clks = count_clk_bits(clks);
-
-                BUG_ON(core.num_clks_enabled < num_clks);
-
-                if (core.num_clks_enabled == num_clks)
-                        save_all_ctx();
-        }
-
-        dss_clk_disable_no_ctx(clks);
-}
-
-static void dss_clk_enable_all_no_ctx(void)
-{
-        enum dss_clock clks;
-
-        clks = DSS_CLK_ICK | DSS_CLK_FCK1 | DSS_CLK_FCK2 | DSS_CLK_54M;
-        if (cpu_is_omap34xx())
-                clks |= DSS_CLK_96M;
-        dss_clk_enable_no_ctx(clks);
-}
-
-static void dss_clk_disable_all_no_ctx(void)
-{
-        enum dss_clock clks;
-
-        clks = DSS_CLK_ICK | DSS_CLK_FCK1 | DSS_CLK_FCK2 | DSS_CLK_54M;
-        if (cpu_is_omap34xx())
-                clks |= DSS_CLK_96M;
-        dss_clk_disable_no_ctx(clks);
-}
-
-static void dss_clk_disable_all(void)
-{
-        enum dss_clock clks;
-
-        clks = DSS_CLK_ICK | DSS_CLK_FCK1 | DSS_CLK_FCK2 | DSS_CLK_54M;
-        if (cpu_is_omap34xx())
-                clks |= DSS_CLK_96M;
-        dss_clk_disable(clks);
-}
-
 /* REGULATORS */
 
 struct regulator *dss_get_vdds_dsi(void)
@@ -390,32 +84,7 @@ struct regulator *dss_get_vdds_sdi(void)
         return reg;
 }
 
-struct regulator *dss_get_vdda_dac(void)
-{
-        struct regulator *reg;
-
-        if (core.vdda_dac_reg != NULL)
-                return core.vdda_dac_reg;
-
-        reg = regulator_get(&core.pdev->dev, "vdda_dac");
-        if (!IS_ERR(reg))
-                core.vdda_dac_reg = reg;
-
-        return reg;
-}
-
-/* DEBUGFS */
 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
-static void dss_debug_dump_clocks(struct seq_file *s)
-{
-        core_dump_clocks(s);
-        dss_dump_clocks(s);
-        dispc_dump_clocks(s);
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_dump_clocks(s);
-#endif
-}
-
 static int dss_debug_show(struct seq_file *s, void *unused)
 {
         void (*func)(struct seq_file *) = s->private;
@@ -497,7 +166,6 @@ static inline void dss_uninitialize_debugfs(void)
 static int omap_dss_probe(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
-        int skip_init = 0;
         int r;
         int i;
 
@@ -508,63 +176,43 @@ static int omap_dss_probe(struct platform_device *pdev)
         dss_init_overlay_managers(pdev);
         dss_init_overlays(pdev);
 
-        r = dss_get_clocks();
-        if (r)
-                goto err_clocks;
-
-        dss_clk_enable_all_no_ctx();
-
-        core.ctx_id = dss_get_ctx_id();
-        DSSDBG("initial ctx id %u\n", core.ctx_id);
-
-#ifdef CONFIG_FB_OMAP_BOOTLOADER_INIT
-        /* DISPC_CONTROL */
-        if (omap_readl(0x48050440) & 1) /* LCD enabled? */
-                skip_init = 1;
-#endif
-
-        r = dss_init(skip_init);
+        r = dss_init_platform_driver();
         if (r) {
-                DSSERR("Failed to initialize DSS\n");
+                DSSERR("Failed to initialize DSS platform driver\n");
                 goto err_dss;
         }
 
-        r = rfbi_init();
-        if (r) {
-                DSSERR("Failed to initialize rfbi\n");
-                goto err_rfbi;
-        }
+        /* keep clocks enabled to prevent context saves/restores during init */
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
-        r = dpi_init(pdev);
+        r = rfbi_init_platform_driver();
         if (r) {
-                DSSERR("Failed to initialize dpi\n");
-                goto err_dpi;
+                DSSERR("Failed to initialize rfbi platform driver\n");
+                goto err_rfbi;
         }
 
-        r = dispc_init();
+        r = dispc_init_platform_driver();
         if (r) {
-                DSSERR("Failed to initialize dispc\n");
+                DSSERR("Failed to initialize dispc platform driver\n");
                 goto err_dispc;
         }
 
-        r = venc_init(pdev);
+        r = venc_init_platform_driver();
         if (r) {
-                DSSERR("Failed to initialize venc\n");
+                DSSERR("Failed to initialize venc platform driver\n");
                 goto err_venc;
         }
 
-        if (cpu_is_omap34xx()) {
-                r = sdi_init(skip_init);
-                if (r) {
-                        DSSERR("Failed to initialize SDI\n");
-                        goto err_sdi;
-                }
+        r = dsi_init_platform_driver();
+        if (r) {
+                DSSERR("Failed to initialize DSI platform driver\n");
+                goto err_dsi;
+        }
 
-                r = dsi_init(pdev);
-                if (r) {
-                        DSSERR("Failed to initialize DSI\n");
-                        goto err_dsi;
-                }
+        r = hdmi_init_platform_driver();
+        if (r) {
+                DSSERR("Failed to initialize hdmi\n");
+                goto err_hdmi;
         }
 
         r = dss_initialize_debugfs();
@@ -589,32 +237,25 @@ static int omap_dss_probe(struct platform_device *pdev)
                         pdata->default_device = dssdev;
         }
 
-        dss_clk_disable_all();
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         return 0;
 
 err_register:
         dss_uninitialize_debugfs();
 err_debugfs:
-        if (cpu_is_omap34xx())
-                dsi_exit();
+        hdmi_uninit_platform_driver();
+err_hdmi:
+        dsi_uninit_platform_driver();
 err_dsi:
-        if (cpu_is_omap34xx())
-                sdi_exit();
-err_sdi:
-        venc_exit();
+        venc_uninit_platform_driver();
 err_venc:
-        dispc_exit();
+        dispc_uninit_platform_driver();
 err_dispc:
-        dpi_exit();
-err_dpi:
-        rfbi_exit();
+        rfbi_uninit_platform_driver();
 err_rfbi:
-        dss_exit();
+        dss_uninit_platform_driver();
 err_dss:
-        dss_clk_disable_all_no_ctx();
-        dss_put_clocks();
-err_clocks:
 
         return r;
 }
@@ -623,61 +264,15 @@ static int omap_dss_remove(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
         int i;
-        int c;
 
         dss_uninitialize_debugfs();
 
-        venc_exit();
-        dispc_exit();
-        dpi_exit();
-        rfbi_exit();
-        if (cpu_is_omap34xx()) {
-                dsi_exit();
-                sdi_exit();
-        }
-
-        dss_exit();
-
-        /* these should be removed at some point */
-        c = core.dss_ick->usecount;
-        if (c > 0) {
-                DSSERR("warning: dss_ick usecount %d, disabling\n", c);
-                while (c-- > 0)
-                        clk_disable(core.dss_ick);
-        }
-
-        c = core.dss1_fck->usecount;
-        if (c > 0) {
-                DSSERR("warning: dss1_fck usecount %d, disabling\n", c);
-                while (c-- > 0)
-                        clk_disable(core.dss1_fck);
-        }
-
-        c = core.dss2_fck->usecount;
-        if (c > 0) {
-                DSSERR("warning: dss2_fck usecount %d, disabling\n", c);
-                while (c-- > 0)
-                        clk_disable(core.dss2_fck);
-        }
-
-        c = core.dss_54m_fck->usecount;
-        if (c > 0) {
-                DSSERR("warning: dss_54m_fck usecount %d, disabling\n", c);
-                while (c-- > 0)
-                        clk_disable(core.dss_54m_fck);
-        }
-
-        if (core.dss_96m_fck) {
-                c = core.dss_96m_fck->usecount;
-                if (c > 0) {
-                        DSSERR("warning: dss_96m_fck usecount %d, disabling\n",
-                                        c);
-                        while (c-- > 0)
-                                clk_disable(core.dss_96m_fck);
-                }
-        }
-
-        dss_put_clocks();
+        venc_uninit_platform_driver();
+        dispc_uninit_platform_driver();
+        rfbi_uninit_platform_driver();
+        dsi_uninit_platform_driver();
+        hdmi_uninit_platform_driver();
+        dss_uninit_platform_driver();
 
         dss_uninit_overlays(pdev);
         dss_uninit_overlay_managers(pdev);
@@ -965,11 +560,6 @@ static void __exit omap_dss_exit(void)
                 core.vdds_sdi_reg = NULL;
         }
 
-        if (core.vdda_dac_reg != NULL) {
-                regulator_put(core.vdda_dac_reg);
-                core.vdda_dac_reg = NULL;
-        }
-
         platform_driver_unregister(&omap_dss_driver);
 
         omap_dss_bus_unregister();
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 9f8c69f16e61..7804779c9da1 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -32,6 +32,7 @@
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <linux/hardirq.h>
+#include <linux/interrupt.h>
 
 #include <plat/sram.h>
 #include <plat/clock.h>
@@ -42,8 +43,6 @@
 #include "dss_features.h"
 
 /* DISPC */
-#define DISPC_BASE                      0x48050400
-
 #define DISPC_SZ_REGS                   SZ_4K
 
 struct dispc_reg { u16 idx; };
@@ -74,7 +73,7 @@ struct dispc_reg { u16 idx; };
 #define DISPC_TIMING_H(ch)              DISPC_REG(ch != 2 ? 0x0064 : 0x0400)
 #define DISPC_TIMING_V(ch)              DISPC_REG(ch != 2 ? 0x0068 : 0x0404)
 #define DISPC_POL_FREQ(ch)              DISPC_REG(ch != 2 ? 0x006C : 0x0408)
-#define DISPC_DIVISOR(ch)               DISPC_REG(ch != 2 ? 0x0070 : 0x040C)
+#define DISPC_DIVISORo(ch)              DISPC_REG(ch != 2 ? 0x0070 : 0x040C)
 #define DISPC_GLOBAL_ALPHA              DISPC_REG(0x0074)
 #define DISPC_SIZE_DIG                  DISPC_REG(0x0078)
 #define DISPC_SIZE_LCD(ch)              DISPC_REG(ch != 2 ? 0x007C : 0x03CC)
@@ -129,6 +128,7 @@ struct dispc_reg { u16 idx; };
 
 #define DISPC_VID_PRELOAD(n)            DISPC_REG(0x230 + (n)*0x04)
 
+#define DISPC_DIVISOR                   DISPC_REG(0x0804)
 
 #define DISPC_IRQ_MASK_ERROR            (DISPC_IRQ_GFX_FIFO_UNDERFLOW | \
                                          DISPC_IRQ_OCP_ERR | \
@@ -178,7 +178,9 @@ struct dispc_irq_stats {
 };
 
 static struct {
+        struct platform_device *pdev;
         void __iomem    *base;
+        int irq;
 
         u32     fifo_size[3];
 
@@ -230,7 +232,7 @@ void dispc_save_context(void)
         SR(TIMING_H(0));
         SR(TIMING_V(0));
         SR(POL_FREQ(0));
-        SR(DIVISOR(0));
+        SR(DIVISORo(0));
         SR(GLOBAL_ALPHA);
         SR(SIZE_DIG);
         SR(SIZE_LCD(0));
@@ -242,7 +244,7 @@ void dispc_save_context(void)
                 SR(TIMING_H(2));
                 SR(TIMING_V(2));
                 SR(POL_FREQ(2));
-                SR(DIVISOR(2));
+                SR(DIVISORo(2));
                 SR(CONFIG2);
         }
 
@@ -373,6 +375,9 @@ void dispc_save_context(void)
         SR(VID_FIR_COEF_V(1, 7));
 
         SR(VID_PRELOAD(1));
+
+        if (dss_has_feature(FEAT_CORE_CLK_DIV))
+                SR(DIVISOR);
 }
 
 void dispc_restore_context(void)
@@ -389,7 +394,7 @@ void dispc_restore_context(void)
         RR(TIMING_H(0));
         RR(TIMING_V(0));
         RR(POL_FREQ(0));
-        RR(DIVISOR(0));
+        RR(DIVISORo(0));
         RR(GLOBAL_ALPHA);
         RR(SIZE_DIG);
         RR(SIZE_LCD(0));
@@ -400,7 +405,7 @@ void dispc_restore_context(void)
                 RR(TIMING_H(2));
                 RR(TIMING_V(2));
                 RR(POL_FREQ(2));
-                RR(DIVISOR(2));
+                RR(DIVISORo(2));
                 RR(CONFIG2);
         }
 
@@ -532,6 +537,9 @@ void dispc_restore_context(void)
 
         RR(VID_PRELOAD(1));
 
+        if (dss_has_feature(FEAT_CORE_CLK_DIV))
+                RR(DIVISOR);
+
         /* enable last, because LCD & DIGIT enable are here */
         RR(CONTROL);
         if (dss_has_feature(FEAT_MGR_LCD2))
@@ -552,9 +560,9 @@ void dispc_restore_context(void)
 static inline void enable_clocks(bool enable)
 {
         if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 }
 
 bool dispc_go_busy(enum omap_channel channel)
@@ -1000,6 +1008,20 @@ void dispc_set_burst_size(enum omap_plane plane,
         enable_clocks(0);
 }
 
+void dispc_enable_gamma_table(bool enable)
+{
+        /*
+         * This is partially implemented to support only disabling of
+         * the gamma table.
+         */
+        if (enable) {
+                DSSWARN("Gamma table enabling for TV not yet supported");
+                return;
+        }
+
+        REG_FLD_MOD(DISPC_CONFIG, enable, 9, 9);
+}
+
 static void _dispc_set_vid_color_conv(enum omap_plane plane, bool enable)
 {
         u32 val;
@@ -1129,10 +1151,16 @@ static void _dispc_set_vid_accu0(enum omap_plane plane, int haccu, int vaccu)
         u32 val;
         const struct dispc_reg ac0_reg[] = { DISPC_VID_ACCU0(0),
                                       DISPC_VID_ACCU0(1) };
+        u8 hor_start, hor_end, vert_start, vert_end;
 
         BUG_ON(plane == OMAP_DSS_GFX);
 
-        val = FLD_VAL(vaccu, 25, 16) | FLD_VAL(haccu, 9, 0);
+        dss_feat_get_reg_field(FEAT_REG_HORIZONTALACCU, &hor_start, &hor_end);
+        dss_feat_get_reg_field(FEAT_REG_VERTICALACCU, &vert_start, &vert_end);
+
+        val = FLD_VAL(vaccu, vert_start, vert_end) |
+                        FLD_VAL(haccu, hor_start, hor_end);
+
         dispc_write_reg(ac0_reg[plane-1], val);
 }
 
@@ -1141,10 +1169,16 @@ static void _dispc_set_vid_accu1(enum omap_plane plane, int haccu, int vaccu)
         u32 val;
         const struct dispc_reg ac1_reg[] = { DISPC_VID_ACCU1(0),
                                       DISPC_VID_ACCU1(1) };
+        u8 hor_start, hor_end, vert_start, vert_end;
 
         BUG_ON(plane == OMAP_DSS_GFX);
 
-        val = FLD_VAL(vaccu, 25, 16) | FLD_VAL(haccu, 9, 0);
+        dss_feat_get_reg_field(FEAT_REG_HORIZONTALACCU, &hor_start, &hor_end);
+        dss_feat_get_reg_field(FEAT_REG_VERTICALACCU, &vert_start, &vert_end);
+
+        val = FLD_VAL(vaccu, vert_start, vert_end) |
+                        FLD_VAL(haccu, hor_start, hor_end);
+
         dispc_write_reg(ac1_reg[plane-1], val);
 }
 
@@ -1182,16 +1216,25 @@ static void _dispc_set_scaling(enum omap_plane plane,
         _dispc_set_fir(plane, fir_hinc, fir_vinc);
 
         l = dispc_read_reg(dispc_reg_att[plane]);
-        l &= ~((0x0f << 5) | (0x3 << 21));
 
+        /* RESIZEENABLE and VERTICALTAPS */
+        l &= ~((0x3 << 5) | (0x1 << 21));
         l |= fir_hinc ? (1 << 5) : 0;
         l |= fir_vinc ? (1 << 6) : 0;
+        l |= five_taps ? (1 << 21) : 0;
 
-        l |= hscaleup ? 0 : (1 << 7);
-        l |= vscaleup ? 0 : (1 << 8);
+        /* VRESIZECONF and HRESIZECONF */
+        if (dss_has_feature(FEAT_RESIZECONF)) {
+                l &= ~(0x3 << 7);
+                l |= hscaleup ? 0 : (1 << 7);
+                l |= vscaleup ? 0 : (1 << 8);
+        }
 
-        l |= five_taps ? (1 << 21) : 0;
-        l |= five_taps ? (1 << 22) : 0;
+        /* LINEBUFFERSPLIT */
+        if (dss_has_feature(FEAT_LINEBUFFERSPLIT)) {
+                l &= ~(0x1 << 22);
+                l |= five_taps ? (1 << 22) : 0;
+        }
 
         dispc_write_reg(dispc_reg_att[plane], l);
 
@@ -1215,9 +1258,11 @@ static void _dispc_set_scaling(enum omap_plane plane,
 static void _dispc_set_rotation_attrs(enum omap_plane plane, u8 rotation,
                 bool mirroring, enum omap_color_mode color_mode)
 {
+        bool row_repeat = false;
+        int vidrot = 0;
+
         if (color_mode == OMAP_DSS_COLOR_YUV2 ||
                         color_mode == OMAP_DSS_COLOR_UYVY) {
-                int vidrot = 0;
 
                 if (mirroring) {
                         switch (rotation) {
@@ -1251,16 +1296,15 @@ static void _dispc_set_rotation_attrs(enum omap_plane plane, u8 rotation,
                         }
                 }
 
-                REG_FLD_MOD(dispc_reg_att[plane], vidrot, 13, 12);
-
                 if (rotation == OMAP_DSS_ROT_90 || rotation == OMAP_DSS_ROT_270)
-                        REG_FLD_MOD(dispc_reg_att[plane], 0x1, 18, 18);
+                        row_repeat = true;
                 else
-                        REG_FLD_MOD(dispc_reg_att[plane], 0x0, 18, 18);
-        } else {
-                REG_FLD_MOD(dispc_reg_att[plane], 0, 13, 12);
-                REG_FLD_MOD(dispc_reg_att[plane], 0, 18, 18);
+                        row_repeat = false;
         }
+
+        REG_FLD_MOD(dispc_reg_att[plane], vidrot, 13, 12);
+        if (dss_has_feature(FEAT_ROWREPEATENABLE))
+                REG_FLD_MOD(dispc_reg_att[plane], row_repeat ? 1 : 0, 18, 18);
 }
 
 static int color_mode_to_bpp(enum omap_color_mode color_mode)
@@ -2293,7 +2337,7 @@ static void dispc_set_lcd_divisor(enum omap_channel channel, u16 lck_div,
         BUG_ON(pck_div < 2);
 
         enable_clocks(1);
-        dispc_write_reg(DISPC_DIVISOR(channel),
+        dispc_write_reg(DISPC_DIVISORo(channel),
                         FLD_VAL(lck_div, 23, 16) | FLD_VAL(pck_div, 7, 0));
         enable_clocks(0);
 }
@@ -2302,7 +2346,7 @@ static void dispc_get_lcd_divisor(enum omap_channel channel, int *lck_div,
                 int *pck_div)
 {
         u32 l;
-        l = dispc_read_reg(DISPC_DIVISOR(channel));
+        l = dispc_read_reg(DISPC_DIVISORo(channel));
         *lck_div = FLD_GET(l, 23, 16);
         *pck_div = FLD_GET(l, 7, 0);
 }
@@ -2311,14 +2355,17 @@ unsigned long dispc_fclk_rate(void)
 {
         unsigned long r = 0;
 
-        if (dss_get_dispc_clk_source() == DSS_SRC_DSS1_ALWON_FCLK)
-                r = dss_clk_get_rate(DSS_CLK_FCK1);
-        else
-#ifdef CONFIG_OMAP2_DSS_DSI
-                r = dsi_get_dsi1_pll_rate();
-#else
-        BUG();
-#endif
+        switch (dss_get_dispc_clk_source()) {
+        case DSS_CLK_SRC_FCK:
+                r = dss_clk_get_rate(DSS_CLK_FCK);
+                break;
+        case DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
+                r = dsi_get_pll_hsdiv_dispc_rate();
+                break;
+        default:
+                BUG();
+        }
+
         return r;
 }
 
@@ -2328,47 +2375,72 @@ unsigned long dispc_lclk_rate(enum omap_channel channel)
         unsigned long r;
         u32 l;
 
-        l = dispc_read_reg(DISPC_DIVISOR(channel));
+        l = dispc_read_reg(DISPC_DIVISORo(channel));
 
         lcd = FLD_GET(l, 23, 16);
 
-        r = dispc_fclk_rate();
+        switch (dss_get_lcd_clk_source(channel)) {
+        case DSS_CLK_SRC_FCK:
+                r = dss_clk_get_rate(DSS_CLK_FCK);
+                break;
+        case DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
+                r = dsi_get_pll_hsdiv_dispc_rate();
+                break;
+        default:
+                BUG();
+        }
 
         return r / lcd;
 }
 
 unsigned long dispc_pclk_rate(enum omap_channel channel)
 {
-        int lcd, pcd;
+        int pcd;
         unsigned long r;
         u32 l;
 
-        l = dispc_read_reg(DISPC_DIVISOR(channel));
+        l = dispc_read_reg(DISPC_DIVISORo(channel));
 
-        lcd = FLD_GET(l, 23, 16);
         pcd = FLD_GET(l, 7, 0);
 
-        r = dispc_fclk_rate();
+        r = dispc_lclk_rate(channel);
 
-        return r / lcd / pcd;
+        return r / pcd;
 }
 
 void dispc_dump_clocks(struct seq_file *s)
 {
         int lcd, pcd;
+        u32 l;
+        enum dss_clk_source dispc_clk_src = dss_get_dispc_clk_source();
+        enum dss_clk_source lcd_clk_src;
 
         enable_clocks(1);
 
         seq_printf(s, "- DISPC -\n");
 
-        seq_printf(s, "dispc fclk source = %s\n",
-                        dss_get_dispc_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
-                        "dss1_alwon_fclk" : "dsi1_pll_fclk");
+        seq_printf(s, "dispc fclk source = %s (%s)\n",
+                        dss_get_generic_clk_source_name(dispc_clk_src),
+                        dss_feat_get_clk_source_name(dispc_clk_src));
 
         seq_printf(s, "fck\t\t%-16lu\n", dispc_fclk_rate());
 
+        if (dss_has_feature(FEAT_CORE_CLK_DIV)) {
+                seq_printf(s, "- DISPC-CORE-CLK -\n");
+                l = dispc_read_reg(DISPC_DIVISOR);
+                lcd = FLD_GET(l, 23, 16);
+
+                seq_printf(s, "lck\t\t%-16lulck div\t%u\n",
+                                (dispc_fclk_rate()/lcd), lcd);
+        }
         seq_printf(s, "- LCD1 -\n");
 
+        lcd_clk_src = dss_get_lcd_clk_source(OMAP_DSS_CHANNEL_LCD);
+
+        seq_printf(s, "lcd1_clk source = %s (%s)\n",
+                dss_get_generic_clk_source_name(lcd_clk_src),
+                dss_feat_get_clk_source_name(lcd_clk_src));
+
         dispc_get_lcd_divisor(OMAP_DSS_CHANNEL_LCD, &lcd, &pcd);
 
         seq_printf(s, "lck\t\t%-16lulck div\t%u\n",
@@ -2378,6 +2450,12 @@ void dispc_dump_clocks(struct seq_file *s)
         if (dss_has_feature(FEAT_MGR_LCD2)) {
                 seq_printf(s, "- LCD2 -\n");
 
+                lcd_clk_src = dss_get_lcd_clk_source(OMAP_DSS_CHANNEL_LCD2);
+
+                seq_printf(s, "lcd2_clk source = %s (%s)\n",
+                        dss_get_generic_clk_source_name(lcd_clk_src),
+                        dss_feat_get_clk_source_name(lcd_clk_src));
+
                 dispc_get_lcd_divisor(OMAP_DSS_CHANNEL_LCD2, &lcd, &pcd);
 
                 seq_printf(s, "lck\t\t%-16lulck div\t%u\n",
@@ -2440,7 +2518,7 @@ void dispc_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dispc_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         DUMPREG(DISPC_REVISION);
         DUMPREG(DISPC_SYSCONFIG);
@@ -2459,7 +2537,7 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_TIMING_H(0));
         DUMPREG(DISPC_TIMING_V(0));
         DUMPREG(DISPC_POL_FREQ(0));
-        DUMPREG(DISPC_DIVISOR(0));
+        DUMPREG(DISPC_DIVISORo(0));
         DUMPREG(DISPC_GLOBAL_ALPHA);
         DUMPREG(DISPC_SIZE_DIG);
         DUMPREG(DISPC_SIZE_LCD(0));
@@ -2471,7 +2549,7 @@ void dispc_dump_regs(struct seq_file *s)
                 DUMPREG(DISPC_TIMING_H(2));
                 DUMPREG(DISPC_TIMING_V(2));
                 DUMPREG(DISPC_POL_FREQ(2));
-                DUMPREG(DISPC_DIVISOR(2));
+                DUMPREG(DISPC_DIVISORo(2));
                 DUMPREG(DISPC_SIZE_LCD(2));
         }
 
@@ -2597,7 +2675,7 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_VID_PRELOAD(0));
         DUMPREG(DISPC_VID_PRELOAD(1));
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 #undef DUMPREG
 }
 
@@ -2713,8 +2791,8 @@ int dispc_get_clock_div(enum omap_channel channel,
 
         fck = dispc_fclk_rate();
 
-        cinfo->lck_div = REG_GET(DISPC_DIVISOR(channel), 23, 16);
-        cinfo->pck_div = REG_GET(DISPC_DIVISOR(channel), 7, 0);
+        cinfo->lck_div = REG_GET(DISPC_DIVISORo(channel), 23, 16);
+        cinfo->pck_div = REG_GET(DISPC_DIVISORo(channel), 7, 0);
 
         cinfo->lck = fck / cinfo->lck_div;
         cinfo->pck = cinfo->lck / cinfo->pck_div;
@@ -2791,6 +2869,9 @@ int omap_dispc_register_isr(omap_dispc_isr_t isr, void *arg, u32 mask)
                 break;
         }
 
+        if (ret)
+                goto err;
+
         _omap_dispc_set_irqs();
 
         spin_unlock_irqrestore(&dispc.irq_lock, flags);
@@ -2866,10 +2947,10 @@ static void print_irq_status(u32 status)
  * but we presume they are on because we got an IRQ. However,
  * an irq handler may turn the clocks off, so we may not have
  * clock later in the function. */
-void dispc_irq_handler(void)
+static irqreturn_t omap_dispc_irq_handler(int irq, void *arg)
 {
         int i;
-        u32 irqstatus;
+        u32 irqstatus, irqenable;
         u32 handledirqs = 0;
         u32 unhandled_errors;
         struct omap_dispc_isr_data *isr_data;
@@ -2878,6 +2959,13 @@ void dispc_irq_handler(void)
         spin_lock(&dispc.irq_lock);
 
         irqstatus = dispc_read_reg(DISPC_IRQSTATUS);
+        irqenable = dispc_read_reg(DISPC_IRQENABLE);
+
+        /* IRQ is not for us */
+        if (!(irqstatus & irqenable)) {
+                spin_unlock(&dispc.irq_lock);
+                return IRQ_NONE;
+        }
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
         spin_lock(&dispc.irq_stats_lock);
@@ -2929,6 +3017,8 @@ void dispc_irq_handler(void)
         }
 
         spin_unlock(&dispc.irq_lock);
+
+        return IRQ_HANDLED;
 }
 
 static void dispc_error_worker(struct work_struct *work)
@@ -3253,6 +3343,15 @@ static void _omap_dispc_initial_config(void)
         l = FLD_MOD(l, 1, 0, 0);        /* AUTOIDLE */
         dispc_write_reg(DISPC_SYSCONFIG, l);
 
+        /* Exclusively enable DISPC_CORE_CLK and set divider to 1 */
+        if (dss_has_feature(FEAT_CORE_CLK_DIV)) {
+                l = dispc_read_reg(DISPC_DIVISOR);
+                /* Use DISPC_DIVISOR.LCD, instead of DISPC_DIVISOR1.LCD */
+                l = FLD_MOD(l, 1, 0, 0);
+                l = FLD_MOD(l, 1, 23, 16);
+                dispc_write_reg(DISPC_DIVISOR, l);
+        }
+
         /* FUNCGATED */
         if (dss_has_feature(FEAT_FUNCGATED))
                 REG_FLD_MOD(DISPC_CONFIG, 1, 9, 9);
@@ -3269,47 +3368,6 @@ static void _omap_dispc_initial_config(void)
         dispc_read_plane_fifo_sizes();
 }
 
-int dispc_init(void)
-{
-        u32 rev;
-
-        spin_lock_init(&dispc.irq_lock);
-
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
-        spin_lock_init(&dispc.irq_stats_lock);
-        dispc.irq_stats.last_reset = jiffies;
-#endif
-
-        INIT_WORK(&dispc.error_work, dispc_error_worker);
-
-        dispc.base = ioremap(DISPC_BASE, DISPC_SZ_REGS);
-        if (!dispc.base) {
-                DSSERR("can't ioremap DISPC\n");
-                return -ENOMEM;
-        }
-
-        enable_clocks(1);
-
-        _omap_dispc_initial_config();
-
-        _omap_dispc_initialize_irq();
-
-        dispc_save_context();
-
-        rev = dispc_read_reg(DISPC_REVISION);
-        printk(KERN_INFO "OMAP DISPC rev %d.%d\n",
-               FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
-
-        enable_clocks(0);
-
-        return 0;
-}
-
-void dispc_exit(void)
-{
-        iounmap(dispc.base);
-}
-
 int dispc_enable_plane(enum omap_plane plane, bool enable)
 {
         DSSDBG("dispc_enable_plane %d, %d\n", plane, enable);
@@ -3359,3 +3417,94 @@ int dispc_setup_plane(enum omap_plane plane,
 
         return r;
 }
+
+/* DISPC HW IP initialisation */
+static int omap_dispchw_probe(struct platform_device *pdev)
+{
+        u32 rev;
+        int r = 0;
+        struct resource *dispc_mem;
+
+        dispc.pdev = pdev;
+
+        spin_lock_init(&dispc.irq_lock);
+
+#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
+        spin_lock_init(&dispc.irq_stats_lock);
+        dispc.irq_stats.last_reset = jiffies;
+#endif
+
+        INIT_WORK(&dispc.error_work, dispc_error_worker);
+
+        dispc_mem = platform_get_resource(dispc.pdev, IORESOURCE_MEM, 0);
+        if (!dispc_mem) {
+                DSSERR("can't get IORESOURCE_MEM DISPC\n");
+                r = -EINVAL;
+                goto fail0;
+        }
+        dispc.base = ioremap(dispc_mem->start, resource_size(dispc_mem));
+        if (!dispc.base) {
+                DSSERR("can't ioremap DISPC\n");
+                r = -ENOMEM;
+                goto fail0;
+        }
+        dispc.irq = platform_get_irq(dispc.pdev, 0);
+        if (dispc.irq < 0) {
+                DSSERR("platform_get_irq failed\n");
+                r = -ENODEV;
+                goto fail1;
+        }
+
+        r = request_irq(dispc.irq, omap_dispc_irq_handler, IRQF_SHARED,
+                "OMAP DISPC", dispc.pdev);
+        if (r < 0) {
+                DSSERR("request_irq failed\n");
+                goto fail1;
+        }
+
+        enable_clocks(1);
+
+        _omap_dispc_initial_config();
+
+        _omap_dispc_initialize_irq();
+
+        dispc_save_context();
+
+        rev = dispc_read_reg(DISPC_REVISION);
+        dev_dbg(&pdev->dev, "OMAP DISPC rev %d.%d\n",
+               FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
+
+        enable_clocks(0);
+
+        return 0;
+fail1:
+        iounmap(dispc.base);
+fail0:
+        return r;
+}
+
+static int omap_dispchw_remove(struct platform_device *pdev)
+{
+        free_irq(dispc.irq, dispc.pdev);
+        iounmap(dispc.base);
+        return 0;
+}
+
+static struct platform_driver omap_dispchw_driver = {
+        .probe          = omap_dispchw_probe,
+        .remove         = omap_dispchw_remove,
+        .driver         = {
+                .name   = "omapdss_dispc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int dispc_init_platform_driver(void)
+{
+        return platform_driver_register(&omap_dispchw_driver);
+}
+
+void dispc_uninit_platform_driver(void)
+{
+        return platform_driver_unregister(&omap_dispchw_driver);
+}
diff --git a/drivers/video/omap2/dss/display.c b/drivers/video/omap2/dss/display.c
index 22dd7a474f79..a85a6f38b40c 100644
--- a/drivers/video/omap2/dss/display.c
+++ b/drivers/video/omap2/dss/display.c
@@ -25,14 +25,11 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/jiffies.h>
-#include <linux/list.h>
 #include <linux/platform_device.h>
 
 #include <plat/display.h>
 #include "dss.h"
 
-static LIST_HEAD(display_list);
-
 static ssize_t display_enabled_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
@@ -345,6 +342,7 @@ int omapdss_default_get_recommended_bpp(struct omap_dss_device *dssdev)
                         return 16;
         case OMAP_DISPLAY_TYPE_VENC:
         case OMAP_DISPLAY_TYPE_SDI:
+        case OMAP_DISPLAY_TYPE_HDMI:
                 return 24;
         default:
                 BUG();
@@ -371,6 +369,7 @@ bool dss_use_replication(struct omap_dss_device *dssdev,
         case OMAP_DISPLAY_TYPE_DPI:
                 bpp = dssdev->phy.dpi.data_lines;
                 break;
+        case OMAP_DISPLAY_TYPE_HDMI:
         case OMAP_DISPLAY_TYPE_VENC:
         case OMAP_DISPLAY_TYPE_SDI:
                 bpp = 24;
@@ -396,29 +395,6 @@ void dss_init_device(struct platform_device *pdev,
         switch (dssdev->type) {
 #ifdef CONFIG_OMAP2_DSS_DPI
         case OMAP_DISPLAY_TYPE_DPI:
-#endif
-#ifdef CONFIG_OMAP2_DSS_RFBI
-        case OMAP_DISPLAY_TYPE_DBI:
-#endif
-#ifdef CONFIG_OMAP2_DSS_SDI
-        case OMAP_DISPLAY_TYPE_SDI:
-#endif
-#ifdef CONFIG_OMAP2_DSS_DSI
-        case OMAP_DISPLAY_TYPE_DSI:
-#endif
-#ifdef CONFIG_OMAP2_DSS_VENC
-        case OMAP_DISPLAY_TYPE_VENC:
-#endif
-                break;
-        default:
-                DSSERR("Support for display '%s' not compiled in.\n",
-                                dssdev->name);
-                return;
-        }
-
-        switch (dssdev->type) {
-#ifdef CONFIG_OMAP2_DSS_DPI
-        case OMAP_DISPLAY_TYPE_DPI:
                 r = dpi_init_display(dssdev);
                 break;
 #endif
@@ -442,8 +418,13 @@ void dss_init_device(struct platform_device *pdev,
                 r = dsi_init_display(dssdev);
                 break;
 #endif
+        case OMAP_DISPLAY_TYPE_HDMI:
+                r = hdmi_init_display(dssdev);
+                break;
         default:
-                BUG();
+                DSSERR("Support for display '%s' not compiled in.\n",
+                                dssdev->name);
+                return;
         }
 
         if (r) {
diff --git a/drivers/video/omap2/dss/dpi.c b/drivers/video/omap2/dss/dpi.c
index 75fb0a515430..2d3ca4ca4a05 100644
--- a/drivers/video/omap2/dss/dpi.c
+++ b/drivers/video/omap2/dss/dpi.c
@@ -57,13 +57,13 @@ static int dpi_set_dsi_clk(struct omap_dss_device *dssdev, bool is_tft,
         if (r)
                 return r;
 
-        dss_select_dispc_clk_source(DSS_SRC_DSI1_PLL_FCLK);
+        dss_select_dispc_clk_source(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC);
 
         r = dispc_set_clock_div(dssdev->manager->id, &dispc_cinfo);
         if (r)
                 return r;
 
-        *fck = dsi_cinfo.dsi1_pll_fclk;
+        *fck = dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
         *lck_div = dispc_cinfo.lck_div;
         *pck_div = dispc_cinfo.pck_div;
 
@@ -107,7 +107,7 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
         bool is_tft;
         int r = 0;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         dispc_set_pol_freq(dssdev->manager->id, dssdev->panel.config,
                         dssdev->panel.acbi, dssdev->panel.acb);
@@ -137,7 +137,7 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
         dispc_set_lcd_timings(dssdev->manager->id, t);
 
 err0:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
         return r;
 }
 
@@ -173,14 +173,14 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
                         goto err1;
         }
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         r = dpi_basic_init(dssdev);
         if (r)
                 goto err2;
 
 #ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL
-        dss_clk_enable(DSS_CLK_FCK2);
+        dss_clk_enable(DSS_CLK_SYSCK);
         r = dsi_pll_init(dssdev, 0, 1);
         if (r)
                 goto err3;
@@ -199,10 +199,10 @@ err4:
 #ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL
         dsi_pll_uninit();
 err3:
-        dss_clk_disable(DSS_CLK_FCK2);
+        dss_clk_disable(DSS_CLK_SYSCK);
 #endif
 err2:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
 err1:
@@ -217,12 +217,12 @@ void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
         dssdev->manager->disable(dssdev->manager);
 
 #ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL
-        dss_select_dispc_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
+        dss_select_dispc_clk_source(DSS_CLK_SRC_FCK);
         dsi_pll_uninit();
-        dss_clk_disable(DSS_CLK_FCK2);
+        dss_clk_disable(DSS_CLK_SYSCK);
 #endif
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
@@ -271,7 +271,7 @@ int dpi_check_timings(struct omap_dss_device *dssdev,
                 if (r)
                         return r;
 
-                fck = dsi_cinfo.dsi1_pll_fclk;
+                fck = dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
                 lck_div = dispc_cinfo.lck_div;
                 pck_div = dispc_cinfo.pck_div;
         }
@@ -303,22 +303,27 @@ int dpi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
 
-        return 0;
-}
+        if (cpu_is_omap34xx() && dpi.vdds_dsi_reg == NULL) {
+                struct regulator *vdds_dsi;
 
-int dpi_init(struct platform_device *pdev)
-{
-        if (cpu_is_omap34xx()) {
-                dpi.vdds_dsi_reg = dss_get_vdds_dsi();
-                if (IS_ERR(dpi.vdds_dsi_reg)) {
+                vdds_dsi = dss_get_vdds_dsi();
+
+                if (IS_ERR(vdds_dsi)) {
                         DSSERR("can't get VDDS_DSI regulator\n");
-                        return PTR_ERR(dpi.vdds_dsi_reg);
+                        return PTR_ERR(vdds_dsi);
                 }
+
+                dpi.vdds_dsi_reg = vdds_dsi;
         }
 
         return 0;
 }
 
+int dpi_init(void)
+{
+        return 0;
+}
+
 void dpi_exit(void)
 {
 }
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index ddf3a0560822..0a7f1a47f8e3 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -38,12 +38,11 @@
 #include <plat/clock.h>
 
 #include "dss.h"
+#include "dss_features.h"
 
 /*#define VERBOSE_IRQ*/
 #define DSI_CATCH_MISSING_TE
 
-#define DSI_BASE                0x4804FC00
-
 struct dsi_reg { u16 idx; };
 
 #define DSI_REG(idx)            ((const struct dsi_reg) { idx })
@@ -186,13 +185,15 @@ struct dsi_reg { u16 idx; };
 #define DSI_DT_RX_SHORT_READ_1          0x21
 #define DSI_DT_RX_SHORT_READ_2          0x22
 
-#define FINT_MAX 2100000
-#define FINT_MIN 750000
-#define REGN_MAX (1 << 7)
-#define REGM_MAX ((1 << 11) - 1)
-#define REGM3_MAX (1 << 4)
-#define REGM4_MAX (1 << 4)
-#define LP_DIV_MAX ((1 << 13) - 1)
+typedef void (*omap_dsi_isr_t) (void *arg, u32 mask);
+
+#define DSI_MAX_NR_ISRS                2
+
+struct dsi_isr_data {
+        omap_dsi_isr_t  isr;
+        void            *arg;
+        u32             mask;
+};
 
 enum fifo_size {
         DSI_FIFO_SIZE_0         = 0,
@@ -220,9 +221,17 @@ struct dsi_irq_stats {
         unsigned cio_irqs[32];
 };
 
+struct dsi_isr_tables {
+        struct dsi_isr_data isr_table[DSI_MAX_NR_ISRS];
+        struct dsi_isr_data isr_table_vc[4][DSI_MAX_NR_ISRS];
+        struct dsi_isr_data isr_table_cio[DSI_MAX_NR_ISRS];
+};
+
 static struct
 {
+        struct platform_device *pdev;
         void __iomem    *base;
+        int irq;
 
         struct dsi_clock_info current_cinfo;
 
@@ -232,6 +241,7 @@ static struct
                 enum dsi_vc_mode mode;
                 struct omap_dss_device *dssdev;
                 enum fifo_size fifo_size;
+                int vc_id;
         } vc[4];
 
         struct mutex lock;
@@ -239,8 +249,10 @@ static struct
 
         unsigned pll_locked;
 
-        struct completion bta_completion;
-        void (*bta_callback)(void);
+        spinlock_t irq_lock;
+        struct dsi_isr_tables isr_tables;
+        /* space for a copy used by the interrupt handler */
+        struct dsi_isr_tables isr_tables_copy;
 
         int update_channel;
         struct dsi_update_region update_region;
@@ -275,6 +287,11 @@ static struct
         spinlock_t irq_stats_lock;
         struct dsi_irq_stats irq_stats;
 #endif
+        /* DSI PLL Parameter Ranges */
+        unsigned long regm_max, regn_max;
+        unsigned long  regm_dispc_max, regm_dsi_max;
+        unsigned long  fint_min, fint_max;
+        unsigned long lpdiv_max;
 } dsi;
 
 #ifdef DEBUG
@@ -318,6 +335,11 @@ static bool dsi_bus_is_locked(void)
         return dsi.bus_lock.count == 0;
 }
 
+static void dsi_completion_handler(void *data, u32 mask)
+{
+        complete((struct completion *)data);
+}
+
 static inline int wait_for_bit_change(const struct dsi_reg idx, int bitnum,
                 int value)
 {
@@ -387,6 +409,9 @@ static void dsi_perf_show(const char *name)
 
 static void print_irq_status(u32 status)
 {
+        if (status == 0)
+                return;
+
 #ifndef VERBOSE_IRQ
         if ((status & ~DSI_IRQ_CHANNEL_MASK) == 0)
                 return;
@@ -422,6 +447,9 @@ static void print_irq_status(u32 status)
 
 static void print_irq_status_vc(int channel, u32 status)
 {
+        if (status == 0)
+                return;
+
 #ifndef VERBOSE_IRQ
         if ((status & ~DSI_VC_IRQ_PACKET_SENT) == 0)
                 return;
@@ -448,6 +476,9 @@ static void print_irq_status_vc(int channel, u32 status)
 
 static void print_irq_status_cio(u32 status)
 {
+        if (status == 0)
+                return;
+
         printk(KERN_DEBUG "DSI CIO IRQ 0x%x: ", status);
 
 #define PIS(x) \
@@ -478,22 +509,33 @@ static void print_irq_status_cio(u32 status)
         printk("\n");
 }
 
-static int debug_irq;
-
-/* called from dss */
-void dsi_irq_handler(void)
+#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
+static void dsi_collect_irq_stats(u32 irqstatus, u32 *vcstatus, u32 ciostatus)
 {
-        u32 irqstatus, vcstatus, ciostatus;
         int i;
 
-        irqstatus = dsi_read_reg(DSI_IRQSTATUS);
-
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
         spin_lock(&dsi.irq_stats_lock);
+
         dsi.irq_stats.irq_count++;
         dss_collect_irq_stats(irqstatus, dsi.irq_stats.dsi_irqs);
+
+        for (i = 0; i < 4; ++i)
+                dss_collect_irq_stats(vcstatus[i], dsi.irq_stats.vc_irqs[i]);
+
+        dss_collect_irq_stats(ciostatus, dsi.irq_stats.cio_irqs);
+
+        spin_unlock(&dsi.irq_stats_lock);
+}
+#else
+#define dsi_collect_irq_stats(irqstatus, vcstatus, ciostatus)
 #endif
 
+static int debug_irq;
+
+static void dsi_handle_irq_errors(u32 irqstatus, u32 *vcstatus, u32 ciostatus)
+{
+        int i;
+
         if (irqstatus & DSI_IRQ_ERROR_MASK) {
                 DSSERR("DSI error, irqstatus %x\n", irqstatus);
                 print_irq_status(irqstatus);
@@ -504,37 +546,88 @@ void dsi_irq_handler(void)
                 print_irq_status(irqstatus);
         }
 
-#ifdef DSI_CATCH_MISSING_TE
-        if (irqstatus & DSI_IRQ_TE_TRIGGER)
-                del_timer(&dsi.te_timer);
-#endif
+        for (i = 0; i < 4; ++i) {
+                if (vcstatus[i] & DSI_VC_IRQ_ERROR_MASK) {
+                        DSSERR("DSI VC(%d) error, vc irqstatus %x\n",
+                                       i, vcstatus[i]);
+                        print_irq_status_vc(i, vcstatus[i]);
+                } else if (debug_irq) {
+                        print_irq_status_vc(i, vcstatus[i]);
+                }
+        }
+
+        if (ciostatus & DSI_CIO_IRQ_ERROR_MASK) {
+                DSSERR("DSI CIO error, cio irqstatus %x\n", ciostatus);
+                print_irq_status_cio(ciostatus);
+        } else if (debug_irq) {
+                print_irq_status_cio(ciostatus);
+        }
+}
+
+static void dsi_call_isrs(struct dsi_isr_data *isr_array,
+                unsigned isr_array_size, u32 irqstatus)
+{
+        struct dsi_isr_data *isr_data;
+        int i;
+
+        for (i = 0; i < isr_array_size; i++) {
+                isr_data = &isr_array[i];
+                if (isr_data->isr && isr_data->mask & irqstatus)
+                        isr_data->isr(isr_data->arg, irqstatus);
+        }
+}
+
+static void dsi_handle_isrs(struct dsi_isr_tables *isr_tables,
+                u32 irqstatus, u32 *vcstatus, u32 ciostatus)
+{
+        int i;
+
+        dsi_call_isrs(isr_tables->isr_table,
+                        ARRAY_SIZE(isr_tables->isr_table),
+                        irqstatus);
 
         for (i = 0; i < 4; ++i) {
-                if ((irqstatus & (1<<i)) == 0)
+                if (vcstatus[i] == 0)
                         continue;
+                dsi_call_isrs(isr_tables->isr_table_vc[i],
+                                ARRAY_SIZE(isr_tables->isr_table_vc[i]),
+                                vcstatus[i]);
+        }
 
-                vcstatus = dsi_read_reg(DSI_VC_IRQSTATUS(i));
+        if (ciostatus != 0)
+                dsi_call_isrs(isr_tables->isr_table_cio,
+                                ARRAY_SIZE(isr_tables->isr_table_cio),
+                                ciostatus);
+}
 
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
-                dss_collect_irq_stats(vcstatus, dsi.irq_stats.vc_irqs[i]);
-#endif
+static irqreturn_t omap_dsi_irq_handler(int irq, void *arg)
+{
+        u32 irqstatus, vcstatus[4], ciostatus;
+        int i;
 
-                if (vcstatus & DSI_VC_IRQ_BTA) {
-                        complete(&dsi.bta_completion);
+        spin_lock(&dsi.irq_lock);
 
-                        if (dsi.bta_callback)
-                                dsi.bta_callback();
-                }
+        irqstatus = dsi_read_reg(DSI_IRQSTATUS);
 
-                if (vcstatus & DSI_VC_IRQ_ERROR_MASK) {
-                        DSSERR("DSI VC(%d) error, vc irqstatus %x\n",
-                                       i, vcstatus);
-                        print_irq_status_vc(i, vcstatus);
-                } else if (debug_irq) {
-                        print_irq_status_vc(i, vcstatus);
+        /* IRQ is not for us */
+        if (!irqstatus) {
+                spin_unlock(&dsi.irq_lock);
+                return IRQ_NONE;
+        }
+
+        dsi_write_reg(DSI_IRQSTATUS, irqstatus & ~DSI_IRQ_CHANNEL_MASK);
+        /* flush posted write */
+        dsi_read_reg(DSI_IRQSTATUS);
+
+        for (i = 0; i < 4; ++i) {
+                if ((irqstatus & (1 << i)) == 0) {
+                        vcstatus[i] = 0;
+                        continue;
                 }
 
-                dsi_write_reg(DSI_VC_IRQSTATUS(i), vcstatus);
+                vcstatus[i] = dsi_read_reg(DSI_VC_IRQSTATUS(i));
+
+                dsi_write_reg(DSI_VC_IRQSTATUS(i), vcstatus[i]);
                 /* flush posted write */
                 dsi_read_reg(DSI_VC_IRQSTATUS(i));
         }
@@ -542,117 +635,307 @@ void dsi_irq_handler(void)
         if (irqstatus & DSI_IRQ_COMPLEXIO_ERR) {
                 ciostatus = dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
 
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
-                dss_collect_irq_stats(ciostatus, dsi.irq_stats.cio_irqs);
-#endif
-
                 dsi_write_reg(DSI_COMPLEXIO_IRQ_STATUS, ciostatus);
                 /* flush posted write */
                 dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
+        } else {
+                ciostatus = 0;
+        }
 
-                if (ciostatus & DSI_CIO_IRQ_ERROR_MASK) {
-                        DSSERR("DSI CIO error, cio irqstatus %x\n", ciostatus);
-                        print_irq_status_cio(ciostatus);
-                } else if (debug_irq) {
-                        print_irq_status_cio(ciostatus);
-                }
+#ifdef DSI_CATCH_MISSING_TE
+        if (irqstatus & DSI_IRQ_TE_TRIGGER)
+                del_timer(&dsi.te_timer);
+#endif
+
+        /* make a copy and unlock, so that isrs can unregister
+         * themselves */
+        memcpy(&dsi.isr_tables_copy, &dsi.isr_tables, sizeof(dsi.isr_tables));
+
+        spin_unlock(&dsi.irq_lock);
+
+        dsi_handle_isrs(&dsi.isr_tables_copy, irqstatus, vcstatus, ciostatus);
+
+        dsi_handle_irq_errors(irqstatus, vcstatus, ciostatus);
+
+        dsi_collect_irq_stats(irqstatus, vcstatus, ciostatus);
+
+        return IRQ_HANDLED;
+}
+
+/* dsi.irq_lock has to be locked by the caller */
+static void _omap_dsi_configure_irqs(struct dsi_isr_data *isr_array,
+                unsigned isr_array_size, u32 default_mask,
+                const struct dsi_reg enable_reg,
+                const struct dsi_reg status_reg)
+{
+        struct dsi_isr_data *isr_data;
+        u32 mask;
+        u32 old_mask;
+        int i;
+
+        mask = default_mask;
+
+        for (i = 0; i < isr_array_size; i++) {
+                isr_data = &isr_array[i];
+
+                if (isr_data->isr == NULL)
+                        continue;
+
+                mask |= isr_data->mask;
         }
 
-        dsi_write_reg(DSI_IRQSTATUS, irqstatus & ~DSI_IRQ_CHANNEL_MASK);
-        /* flush posted write */
-        dsi_read_reg(DSI_IRQSTATUS);
+        old_mask = dsi_read_reg(enable_reg);
+        /* clear the irqstatus for newly enabled irqs */
+        dsi_write_reg(status_reg, (mask ^ old_mask) & mask);
+        dsi_write_reg(enable_reg, mask);
 
-#ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
-        spin_unlock(&dsi.irq_stats_lock);
+        /* flush posted writes */
+        dsi_read_reg(enable_reg);
+        dsi_read_reg(status_reg);
+}
+
+/* dsi.irq_lock has to be locked by the caller */
+static void _omap_dsi_set_irqs(void)
+{
+        u32 mask = DSI_IRQ_ERROR_MASK;
+#ifdef DSI_CATCH_MISSING_TE
+        mask |= DSI_IRQ_TE_TRIGGER;
 #endif
+        _omap_dsi_configure_irqs(dsi.isr_tables.isr_table,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table), mask,
+                        DSI_IRQENABLE, DSI_IRQSTATUS);
+}
+
+/* dsi.irq_lock has to be locked by the caller */
+static void _omap_dsi_set_irqs_vc(int vc)
+{
+        _omap_dsi_configure_irqs(dsi.isr_tables.isr_table_vc[vc],
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_vc[vc]),
+                        DSI_VC_IRQ_ERROR_MASK,
+                        DSI_VC_IRQENABLE(vc), DSI_VC_IRQSTATUS(vc));
 }
 
+/* dsi.irq_lock has to be locked by the caller */
+static void _omap_dsi_set_irqs_cio(void)
+{
+        _omap_dsi_configure_irqs(dsi.isr_tables.isr_table_cio,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_cio),
+                        DSI_CIO_IRQ_ERROR_MASK,
+                        DSI_COMPLEXIO_IRQ_ENABLE, DSI_COMPLEXIO_IRQ_STATUS);
+}
 
 static void _dsi_initialize_irq(void)
 {
-        u32 l;
+        unsigned long flags;
+        int vc;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        memset(&dsi.isr_tables, 0, sizeof(dsi.isr_tables));
+
+        _omap_dsi_set_irqs();
+        for (vc = 0; vc < 4; ++vc)
+                _omap_dsi_set_irqs_vc(vc);
+        _omap_dsi_set_irqs_cio();
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
+}
+
+static int _dsi_register_isr(omap_dsi_isr_t isr, void *arg, u32 mask,
+                struct dsi_isr_data *isr_array, unsigned isr_array_size)
+{
+        struct dsi_isr_data *isr_data;
+        int free_idx;
         int i;
 
-        /* disable all interrupts */
-        dsi_write_reg(DSI_IRQENABLE, 0);
-        for (i = 0; i < 4; ++i)
-                dsi_write_reg(DSI_VC_IRQENABLE(i), 0);
-        dsi_write_reg(DSI_COMPLEXIO_IRQ_ENABLE, 0);
+        BUG_ON(isr == NULL);
 
-        /* clear interrupt status */
-        l = dsi_read_reg(DSI_IRQSTATUS);
-        dsi_write_reg(DSI_IRQSTATUS, l & ~DSI_IRQ_CHANNEL_MASK);
+        /* check for duplicate entry and find a free slot */
+        free_idx = -1;
+        for (i = 0; i < isr_array_size; i++) {
+                isr_data = &isr_array[i];
 
-        for (i = 0; i < 4; ++i) {
-                l = dsi_read_reg(DSI_VC_IRQSTATUS(i));
-                dsi_write_reg(DSI_VC_IRQSTATUS(i), l);
+                if (isr_data->isr == isr && isr_data->arg == arg &&
+                                isr_data->mask == mask) {
+                        return -EINVAL;
+                }
+
+                if (isr_data->isr == NULL && free_idx == -1)
+                        free_idx = i;
         }
 
-        l = dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
-        dsi_write_reg(DSI_COMPLEXIO_IRQ_STATUS, l);
+        if (free_idx == -1)
+                return -EBUSY;
 
-        /* enable error irqs */
-        l = DSI_IRQ_ERROR_MASK;
-#ifdef DSI_CATCH_MISSING_TE
-        l |= DSI_IRQ_TE_TRIGGER;
-#endif
-        dsi_write_reg(DSI_IRQENABLE, l);
+        isr_data = &isr_array[free_idx];
+        isr_data->isr = isr;
+        isr_data->arg = arg;
+        isr_data->mask = mask;
 
-        l = DSI_VC_IRQ_ERROR_MASK;
-        for (i = 0; i < 4; ++i)
-                dsi_write_reg(DSI_VC_IRQENABLE(i), l);
+        return 0;
+}
+
+static int _dsi_unregister_isr(omap_dsi_isr_t isr, void *arg, u32 mask,
+                struct dsi_isr_data *isr_array, unsigned isr_array_size)
+{
+        struct dsi_isr_data *isr_data;
+        int i;
+
+        for (i = 0; i < isr_array_size; i++) {
+                isr_data = &isr_array[i];
+                if (isr_data->isr != isr || isr_data->arg != arg ||
+                                isr_data->mask != mask)
+                        continue;
+
+                isr_data->isr = NULL;
+                isr_data->arg = NULL;
+                isr_data->mask = 0;
+
+                return 0;
+        }
 
-        l = DSI_CIO_IRQ_ERROR_MASK;
-        dsi_write_reg(DSI_COMPLEXIO_IRQ_ENABLE, l);
+        return -EINVAL;
 }
 
-static u32 dsi_get_errors(void)
+static int dsi_register_isr(omap_dsi_isr_t isr, void *arg, u32 mask)
 {
         unsigned long flags;
-        u32 e;
-        spin_lock_irqsave(&dsi.errors_lock, flags);
-        e = dsi.errors;
-        dsi.errors = 0;
-        spin_unlock_irqrestore(&dsi.errors_lock, flags);
-        return e;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_register_isr(isr, arg, mask, dsi.isr_tables.isr_table,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table));
+
+        if (r == 0)
+                _omap_dsi_set_irqs();
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
+
+        return r;
 }
 
-static void dsi_vc_enable_bta_irq(int channel)
+static int dsi_unregister_isr(omap_dsi_isr_t isr, void *arg, u32 mask)
 {
-        u32 l;
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_unregister_isr(isr, arg, mask, dsi.isr_tables.isr_table,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table));
+
+        if (r == 0)
+                _omap_dsi_set_irqs();
 
-        dsi_write_reg(DSI_VC_IRQSTATUS(channel), DSI_VC_IRQ_BTA);
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
 
-        l = dsi_read_reg(DSI_VC_IRQENABLE(channel));
-        l |= DSI_VC_IRQ_BTA;
-        dsi_write_reg(DSI_VC_IRQENABLE(channel), l);
+        return r;
 }
 
-static void dsi_vc_disable_bta_irq(int channel)
+static int dsi_register_isr_vc(int channel, omap_dsi_isr_t isr, void *arg,
+                u32 mask)
 {
-        u32 l;
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_register_isr(isr, arg, mask,
+                        dsi.isr_tables.isr_table_vc[channel],
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_vc[channel]));
+
+        if (r == 0)
+                _omap_dsi_set_irqs_vc(channel);
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
+
+        return r;
+}
+
+static int dsi_unregister_isr_vc(int channel, omap_dsi_isr_t isr, void *arg,
+                u32 mask)
+{
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_unregister_isr(isr, arg, mask,
+                        dsi.isr_tables.isr_table_vc[channel],
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_vc[channel]));
+
+        if (r == 0)
+                _omap_dsi_set_irqs_vc(channel);
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
+
+        return r;
+}
+
+static int dsi_register_isr_cio(omap_dsi_isr_t isr, void *arg, u32 mask)
+{
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_register_isr(isr, arg, mask, dsi.isr_tables.isr_table_cio,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_cio));
+
+        if (r == 0)
+                _omap_dsi_set_irqs_cio();
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
+
+        return r;
+}
+
+static int dsi_unregister_isr_cio(omap_dsi_isr_t isr, void *arg, u32 mask)
+{
+        unsigned long flags;
+        int r;
+
+        spin_lock_irqsave(&dsi.irq_lock, flags);
+
+        r = _dsi_unregister_isr(isr, arg, mask, dsi.isr_tables.isr_table_cio,
+                        ARRAY_SIZE(dsi.isr_tables.isr_table_cio));
+
+        if (r == 0)
+                _omap_dsi_set_irqs_cio();
+
+        spin_unlock_irqrestore(&dsi.irq_lock, flags);
 
-        l = dsi_read_reg(DSI_VC_IRQENABLE(channel));
-        l &= ~DSI_VC_IRQ_BTA;
-        dsi_write_reg(DSI_VC_IRQENABLE(channel), l);
+        return r;
 }
 
-/* DSI func clock. this could also be DSI2_PLL_FCLK */
+static u32 dsi_get_errors(void)
+{
+        unsigned long flags;
+        u32 e;
+        spin_lock_irqsave(&dsi.errors_lock, flags);
+        e = dsi.errors;
+        dsi.errors = 0;
+        spin_unlock_irqrestore(&dsi.errors_lock, flags);
+        return e;
+}
+
+/* DSI func clock. this could also be dsi_pll_hsdiv_dsi_clk */
 static inline void enable_clocks(bool enable)
 {
         if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 }
 
 /* source clock for DSI PLL. this could also be PCLKFREE */
 static inline void dsi_enable_pll_clock(bool enable)
 {
         if (enable)
-                dss_clk_enable(DSS_CLK_FCK2);
+                dss_clk_enable(DSS_CLK_SYSCK);
         else
-                dss_clk_disable(DSS_CLK_FCK2);
+                dss_clk_disable(DSS_CLK_SYSCK);
 
         if (enable && dsi.pll_locked) {
                 if (wait_for_bit_change(DSI_PLL_STATUS, 1, 1) != 1)
@@ -707,14 +990,14 @@ static inline int dsi_if_enable(bool enable)
         return 0;
 }
 
-unsigned long dsi_get_dsi1_pll_rate(void)
+unsigned long dsi_get_pll_hsdiv_dispc_rate(void)
 {
-        return dsi.current_cinfo.dsi1_pll_fclk;
+        return dsi.current_cinfo.dsi_pll_hsdiv_dispc_clk;
 }
 
-static unsigned long dsi_get_dsi2_pll_rate(void)
+static unsigned long dsi_get_pll_hsdiv_dsi_rate(void)
 {
-        return dsi.current_cinfo.dsi2_pll_fclk;
+        return dsi.current_cinfo.dsi_pll_hsdiv_dsi_clk;
 }
 
 static unsigned long dsi_get_txbyteclkhs(void)
@@ -726,12 +1009,12 @@ static unsigned long dsi_fclk_rate(void)
 {
         unsigned long r;
 
-        if (dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK) {
-                /* DSI FCLK source is DSS1_ALWON_FCK, which is dss1_fck */
-                r = dss_clk_get_rate(DSS_CLK_FCK1);
+        if (dss_get_dsi_clk_source() == DSS_CLK_SRC_FCK) {
+                /* DSI FCLK source is DSS_CLK_FCK */
+                r = dss_clk_get_rate(DSS_CLK_FCK);
         } else {
-                /* DSI FCLK source is DSI2_PLL_FCLK */
-                r = dsi_get_dsi2_pll_rate();
+                /* DSI FCLK source is dsi_pll_hsdiv_dsi_clk */
+                r = dsi_get_pll_hsdiv_dsi_rate();
         }
 
         return r;
@@ -745,7 +1028,7 @@ static int dsi_set_lp_clk_divisor(struct omap_dss_device *dssdev)
 
         lp_clk_div = dssdev->phy.dsi.div.lp_clk_div;
 
-        if (lp_clk_div == 0 || lp_clk_div > LP_DIV_MAX)
+        if (lp_clk_div == 0 || lp_clk_div > dsi.lpdiv_max)
                 return -EINVAL;
 
         dsi_fclk = dsi_fclk_rate();
@@ -795,22 +1078,22 @@ static int dsi_pll_power(enum dsi_pll_power_state state)
 static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
                 struct dsi_clock_info *cinfo)
 {
-        if (cinfo->regn == 0 || cinfo->regn > REGN_MAX)
+        if (cinfo->regn == 0 || cinfo->regn > dsi.regn_max)
                 return -EINVAL;
 
-        if (cinfo->regm == 0 || cinfo->regm > REGM_MAX)
+        if (cinfo->regm == 0 || cinfo->regm > dsi.regm_max)
                 return -EINVAL;
 
-        if (cinfo->regm3 > REGM3_MAX)
+        if (cinfo->regm_dispc > dsi.regm_dispc_max)
                 return -EINVAL;
 
-        if (cinfo->regm4 > REGM4_MAX)
+        if (cinfo->regm_dsi > dsi.regm_dsi_max)
                 return -EINVAL;
 
-        if (cinfo->use_dss2_fck) {
-                cinfo->clkin = dss_clk_get_rate(DSS_CLK_FCK2);
+        if (cinfo->use_sys_clk) {
+                cinfo->clkin = dss_clk_get_rate(DSS_CLK_SYSCK);
                 /* XXX it is unclear if highfreq should be used
-                 * with DSS2_FCK source also */
+                 * with DSS_SYS_CLK source also */
                 cinfo->highfreq = 0;
         } else {
                 cinfo->clkin = dispc_pclk_rate(dssdev->manager->id);
@@ -823,7 +1106,7 @@ static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
 
         cinfo->fint = cinfo->clkin / (cinfo->regn * (cinfo->highfreq ? 2 : 1));
 
-        if (cinfo->fint > FINT_MAX || cinfo->fint < FINT_MIN)
+        if (cinfo->fint > dsi.fint_max || cinfo->fint < dsi.fint_min)
                 return -EINVAL;
 
         cinfo->clkin4ddr = 2 * cinfo->regm * cinfo->fint;
@@ -831,15 +1114,17 @@ static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
         if (cinfo->clkin4ddr > 1800 * 1000 * 1000)
                 return -EINVAL;
 
-        if (cinfo->regm3 > 0)
-                cinfo->dsi1_pll_fclk = cinfo->clkin4ddr / cinfo->regm3;
+        if (cinfo->regm_dispc > 0)
+                cinfo->dsi_pll_hsdiv_dispc_clk =
+                        cinfo->clkin4ddr / cinfo->regm_dispc;
         else
-                cinfo->dsi1_pll_fclk = 0;
+                cinfo->dsi_pll_hsdiv_dispc_clk = 0;
 
-        if (cinfo->regm4 > 0)
-                cinfo->dsi2_pll_fclk = cinfo->clkin4ddr / cinfo->regm4;
+        if (cinfo->regm_dsi > 0)
+                cinfo->dsi_pll_hsdiv_dsi_clk =
+                        cinfo->clkin4ddr / cinfo->regm_dsi;
         else
-                cinfo->dsi2_pll_fclk = 0;
+                cinfo->dsi_pll_hsdiv_dsi_clk = 0;
 
         return 0;
 }
@@ -852,23 +1137,25 @@ int dsi_pll_calc_clock_div_pck(bool is_tft, unsigned long req_pck,
         struct dispc_clock_info best_dispc;
         int min_fck_per_pck;
         int match = 0;
-        unsigned long dss_clk_fck2;
+        unsigned long dss_sys_clk, max_dss_fck;
+
+        dss_sys_clk = dss_clk_get_rate(DSS_CLK_SYSCK);
 
-        dss_clk_fck2 = dss_clk_get_rate(DSS_CLK_FCK2);
+        max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
 
         if (req_pck == dsi.cache_req_pck &&
-                        dsi.cache_cinfo.clkin == dss_clk_fck2) {
+                        dsi.cache_cinfo.clkin == dss_sys_clk) {
                 DSSDBG("DSI clock info found from cache\n");
                 *dsi_cinfo = dsi.cache_cinfo;
-                dispc_find_clk_divs(is_tft, req_pck, dsi_cinfo->dsi1_pll_fclk,
-                                dispc_cinfo);
+                dispc_find_clk_divs(is_tft, req_pck,
+                        dsi_cinfo->dsi_pll_hsdiv_dispc_clk, dispc_cinfo);
                 return 0;
         }
 
         min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
 
         if (min_fck_per_pck &&
-                req_pck * min_fck_per_pck > DISPC_MAX_FCK) {
+                req_pck * min_fck_per_pck > max_dss_fck) {
                 DSSERR("Requested pixel clock not possible with the current "
                                 "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
                                 "the constraint off.\n");
@@ -882,24 +1169,24 @@ retry:
         memset(&best_dispc, 0, sizeof(best_dispc));
 
         memset(&cur, 0, sizeof(cur));
-        cur.clkin = dss_clk_fck2;
-        cur.use_dss2_fck = 1;
+        cur.clkin = dss_sys_clk;
+        cur.use_sys_clk = 1;
         cur.highfreq = 0;
 
         /* no highfreq: 0.75MHz < Fint = clkin / regn < 2.1MHz */
         /* highfreq: 0.75MHz < Fint = clkin / (2*regn) < 2.1MHz */
         /* To reduce PLL lock time, keep Fint high (around 2 MHz) */
-        for (cur.regn = 1; cur.regn < REGN_MAX; ++cur.regn) {
+        for (cur.regn = 1; cur.regn < dsi.regn_max; ++cur.regn) {
                 if (cur.highfreq == 0)
                         cur.fint = cur.clkin / cur.regn;
                 else
                         cur.fint = cur.clkin / (2 * cur.regn);
 
-                if (cur.fint > FINT_MAX || cur.fint < FINT_MIN)
+                if (cur.fint > dsi.fint_max || cur.fint < dsi.fint_min)
                         continue;
 
                 /* DSIPHY(MHz) = (2 * regm / regn) * (clkin / (highfreq + 1)) */
-                for (cur.regm = 1; cur.regm < REGM_MAX; ++cur.regm) {
+                for (cur.regm = 1; cur.regm < dsi.regm_max; ++cur.regm) {
                         unsigned long a, b;
 
                         a = 2 * cur.regm * (cur.clkin/1000);
@@ -909,30 +1196,32 @@ retry:
                         if (cur.clkin4ddr > 1800 * 1000 * 1000)
                                 break;
 
-                        /* DSI1_PLL_FCLK(MHz) = DSIPHY(MHz) / regm3  < 173MHz */
-                        for (cur.regm3 = 1; cur.regm3 < REGM3_MAX;
-                                        ++cur.regm3) {
+                        /* dsi_pll_hsdiv_dispc_clk(MHz) =
+                         * DSIPHY(MHz) / regm_dispc  < 173MHz/186Mhz */
+                        for (cur.regm_dispc = 1; cur.regm_dispc < dsi.regm_dispc_max;
+                                        ++cur.regm_dispc) {
                                 struct dispc_clock_info cur_dispc;
-                                cur.dsi1_pll_fclk = cur.clkin4ddr / cur.regm3;
+                                cur.dsi_pll_hsdiv_dispc_clk =
+                                        cur.clkin4ddr / cur.regm_dispc;
 
                                 /* this will narrow down the search a bit,
                                  * but still give pixclocks below what was
                                  * requested */
-                                if (cur.dsi1_pll_fclk  < req_pck)
+                                if (cur.dsi_pll_hsdiv_dispc_clk  < req_pck)
                                         break;
 
-                                if (cur.dsi1_pll_fclk > DISPC_MAX_FCK)
+                                if (cur.dsi_pll_hsdiv_dispc_clk > max_dss_fck)
                                         continue;
 
                                 if (min_fck_per_pck &&
-                                        cur.dsi1_pll_fclk <
+                                        cur.dsi_pll_hsdiv_dispc_clk <
                                                 req_pck * min_fck_per_pck)
                                         continue;
 
                                 match = 1;
 
                                 dispc_find_clk_divs(is_tft, req_pck,
-                                                cur.dsi1_pll_fclk,
+                                                cur.dsi_pll_hsdiv_dispc_clk,
                                                 &cur_dispc);
 
                                 if (abs(cur_dispc.pck - req_pck) <
@@ -961,9 +1250,9 @@ found:
                 return -EINVAL;
         }
 
-        /* DSI2_PLL_FCLK (regm4) is not used */
-        best.regm4 = 0;
-        best.dsi2_pll_fclk = 0;
+        /* dsi_pll_hsdiv_dsi_clk (regm_dsi) is not used */
+        best.regm_dsi = 0;
+        best.dsi_pll_hsdiv_dsi_clk = 0;
 
         if (dsi_cinfo)
                 *dsi_cinfo = best;
@@ -982,23 +1271,27 @@ int dsi_pll_set_clock_div(struct dsi_clock_info *cinfo)
         int r = 0;
         u32 l;
         int f;
+        u8 regn_start, regn_end, regm_start, regm_end;
+        u8 regm_dispc_start, regm_dispc_end, regm_dsi_start, regm_dsi_end;
 
         DSSDBGF();
 
         dsi.current_cinfo.fint = cinfo->fint;
         dsi.current_cinfo.clkin4ddr = cinfo->clkin4ddr;
-        dsi.current_cinfo.dsi1_pll_fclk = cinfo->dsi1_pll_fclk;
-        dsi.current_cinfo.dsi2_pll_fclk = cinfo->dsi2_pll_fclk;
+        dsi.current_cinfo.dsi_pll_hsdiv_dispc_clk =
+                        cinfo->dsi_pll_hsdiv_dispc_clk;
+        dsi.current_cinfo.dsi_pll_hsdiv_dsi_clk =
+                        cinfo->dsi_pll_hsdiv_dsi_clk;
 
         dsi.current_cinfo.regn = cinfo->regn;
         dsi.current_cinfo.regm = cinfo->regm;
-        dsi.current_cinfo.regm3 = cinfo->regm3;
-        dsi.current_cinfo.regm4 = cinfo->regm4;
+        dsi.current_cinfo.regm_dispc = cinfo->regm_dispc;
+        dsi.current_cinfo.regm_dsi = cinfo->regm_dsi;
 
         DSSDBG("DSI Fint %ld\n", cinfo->fint);
 
         DSSDBG("clkin (%s) rate %ld, highfreq %d\n",
-                        cinfo->use_dss2_fck ? "dss2_fck" : "pclkfree",
+                        cinfo->use_sys_clk ? "dss_sys_clk" : "pclkfree",
                         cinfo->clkin,
                         cinfo->highfreq);
 
@@ -1015,24 +1308,39 @@ int dsi_pll_set_clock_div(struct dsi_clock_info *cinfo)
 
         DSSDBG("Clock lane freq %ld Hz\n", cinfo->clkin4ddr / 4);
 
-        DSSDBG("regm3 = %d, dsi1_pll_fclk = %lu\n",
-                        cinfo->regm3, cinfo->dsi1_pll_fclk);
-        DSSDBG("regm4 = %d, dsi2_pll_fclk = %lu\n",
-                        cinfo->regm4, cinfo->dsi2_pll_fclk);
+        DSSDBG("regm_dispc = %d, %s (%s) = %lu\n", cinfo->regm_dispc,
+                dss_get_generic_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
+                dss_feat_get_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
+                cinfo->dsi_pll_hsdiv_dispc_clk);
+        DSSDBG("regm_dsi = %d, %s (%s) = %lu\n", cinfo->regm_dsi,
+                dss_get_generic_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
+                dss_feat_get_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
+                cinfo->dsi_pll_hsdiv_dsi_clk);
+
+        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGN, &regn_start, &regn_end);
+        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM, &regm_start, &regm_end);
+        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DISPC, &regm_dispc_start,
+                        &regm_dispc_end);
+        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DSI, &regm_dsi_start,
+                        &regm_dsi_end);
 
         REG_FLD_MOD(DSI_PLL_CONTROL, 0, 0, 0); /* DSI_PLL_AUTOMODE = manual */
 
         l = dsi_read_reg(DSI_PLL_CONFIGURATION1);
         l = FLD_MOD(l, 1, 0, 0);                /* DSI_PLL_STOPMODE */
-        l = FLD_MOD(l, cinfo->regn - 1, 7, 1);  /* DSI_PLL_REGN */
-        l = FLD_MOD(l, cinfo->regm, 18, 8);     /* DSI_PLL_REGM */
-        l = FLD_MOD(l, cinfo->regm3 > 0 ? cinfo->regm3 - 1 : 0,
-                        22, 19);                /* DSI_CLOCK_DIV */
-        l = FLD_MOD(l, cinfo->regm4 > 0 ? cinfo->regm4 - 1 : 0,
-                        26, 23);                /* DSIPROTO_CLOCK_DIV */
+        /* DSI_PLL_REGN */
+        l = FLD_MOD(l, cinfo->regn - 1, regn_start, regn_end);
+        /* DSI_PLL_REGM */
+        l = FLD_MOD(l, cinfo->regm, regm_start, regm_end);
+        /* DSI_CLOCK_DIV */
+        l = FLD_MOD(l, cinfo->regm_dispc > 0 ? cinfo->regm_dispc - 1 : 0,
+                        regm_dispc_start, regm_dispc_end);
+        /* DSIPROTO_CLOCK_DIV */
+        l = FLD_MOD(l, cinfo->regm_dsi > 0 ? cinfo->regm_dsi - 1 : 0,
+                        regm_dsi_start, regm_dsi_end);
         dsi_write_reg(DSI_PLL_CONFIGURATION1, l);
 
-        BUG_ON(cinfo->fint < 750000 || cinfo->fint > 2100000);
+        BUG_ON(cinfo->fint < dsi.fint_min || cinfo->fint > dsi.fint_max);
         if (cinfo->fint < 1000000)
                 f = 0x3;
         else if (cinfo->fint < 1250000)
@@ -1046,7 +1354,7 @@ int dsi_pll_set_clock_div(struct dsi_clock_info *cinfo)
 
         l = dsi_read_reg(DSI_PLL_CONFIGURATION2);
         l = FLD_MOD(l, f, 4, 1);                /* DSI_PLL_FREQSEL */
-        l = FLD_MOD(l, cinfo->use_dss2_fck ? 0 : 1,
+        l = FLD_MOD(l, cinfo->use_sys_clk ? 0 : 1,
                         11, 11);                /* DSI_PLL_CLKSEL */
         l = FLD_MOD(l, cinfo->highfreq,
                         12, 12);                /* DSI_PLL_HIGHFREQ */
@@ -1101,6 +1409,26 @@ int dsi_pll_init(struct omap_dss_device *dssdev, bool enable_hsclk,
 
         DSSDBG("PLL init\n");
 
+#ifdef CONFIG_OMAP2_DSS_USE_DSI_PLL
+        /*
+         * HACK: this is just a quick hack to get the USE_DSI_PLL
+         * option working. USE_DSI_PLL is itself a big hack, and
+         * should be removed.
+         */
+        if (dsi.vdds_dsi_reg == NULL) {
+                struct regulator *vdds_dsi;
+
+                vdds_dsi = regulator_get(&dsi.pdev->dev, "vdds_dsi");
+
+                if (IS_ERR(vdds_dsi)) {
+                        DSSERR("can't get VDDS_DSI regulator\n");
+                        return PTR_ERR(vdds_dsi);
+                }
+
+                dsi.vdds_dsi_reg = vdds_dsi;
+        }
+#endif
+
         enable_clocks(1);
         dsi_enable_pll_clock(1);
 
@@ -1162,6 +1490,10 @@ void dsi_dump_clocks(struct seq_file *s)
 {
         int clksel;
         struct dsi_clock_info *cinfo = &dsi.current_cinfo;
+        enum dss_clk_source dispc_clk_src, dsi_clk_src;
+
+        dispc_clk_src = dss_get_dispc_clk_source();
+        dsi_clk_src = dss_get_dsi_clk_source();
 
         enable_clocks(1);
 
@@ -1171,30 +1503,34 @@ void dsi_dump_clocks(struct seq_file *s)
 
         seq_printf(s,   "dsi pll source = %s\n",
                         clksel == 0 ?
-                        "dss2_alwon_fclk" : "pclkfree");
+                        "dss_sys_clk" : "pclkfree");
 
         seq_printf(s,   "Fint\t\t%-16luregn %u\n", cinfo->fint, cinfo->regn);
 
         seq_printf(s,   "CLKIN4DDR\t%-16luregm %u\n",
                         cinfo->clkin4ddr, cinfo->regm);
 
-        seq_printf(s,   "dsi1_pll_fck\t%-16luregm3 %u\t(%s)\n",
-                        cinfo->dsi1_pll_fclk,
-                        cinfo->regm3,
-                        dss_get_dispc_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
+        seq_printf(s,   "%s (%s)\t%-16luregm_dispc %u\t(%s)\n",
+                        dss_get_generic_clk_source_name(dispc_clk_src),
+                        dss_feat_get_clk_source_name(dispc_clk_src),
+                        cinfo->dsi_pll_hsdiv_dispc_clk,
+                        cinfo->regm_dispc,
+                        dispc_clk_src == DSS_CLK_SRC_FCK ?
                         "off" : "on");
 
-        seq_printf(s,   "dsi2_pll_fck\t%-16luregm4 %u\t(%s)\n",
-                        cinfo->dsi2_pll_fclk,
-                        cinfo->regm4,
-                        dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
+        seq_printf(s,   "%s (%s)\t%-16luregm_dsi %u\t(%s)\n",
+                        dss_get_generic_clk_source_name(dsi_clk_src),
+                        dss_feat_get_clk_source_name(dsi_clk_src),
+                        cinfo->dsi_pll_hsdiv_dsi_clk,
+                        cinfo->regm_dsi,
+                        dsi_clk_src == DSS_CLK_SRC_FCK ?
                         "off" : "on");
 
         seq_printf(s,   "- DSI -\n");
 
-        seq_printf(s,   "dsi fclk source = %s\n",
-                        dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
-                        "dss1_alwon_fclk" : "dsi2_pll_fclk");
+        seq_printf(s,   "dsi fclk source = %s (%s)\n",
+                        dss_get_generic_clk_source_name(dsi_clk_src),
+                        dss_feat_get_clk_source_name(dsi_clk_src));
 
         seq_printf(s,   "DSI_FCLK\t%lu\n", dsi_fclk_rate());
 
@@ -1306,7 +1642,7 @@ void dsi_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dsi_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         DUMPREG(DSI_REVISION);
         DUMPREG(DSI_SYSCONFIG);
@@ -1378,7 +1714,7 @@ void dsi_dump_regs(struct seq_file *s)
         DUMPREG(DSI_PLL_CONFIGURATION1);
         DUMPREG(DSI_PLL_CONFIGURATION2);
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 #undef DUMPREG
 }
 
@@ -1622,20 +1958,6 @@ static int _dsi_reset(void)
         return _dsi_wait_reset();
 }
 
-static void dsi_reset_tx_fifo(int channel)
-{
-        u32 mask;
-        u32 l;
-
-        /* set fifosize of the channel to 0, then return the old size */
-        l = dsi_read_reg(DSI_TX_FIFO_VC_SIZE);
-
-        mask = FLD_MASK((8 * channel) + 7, (8 * channel) + 4);
-        dsi_write_reg(DSI_TX_FIFO_VC_SIZE, l & ~mask);
-
-        dsi_write_reg(DSI_TX_FIFO_VC_SIZE, l);
-}
-
 static void dsi_config_tx_fifo(enum fifo_size size1, enum fifo_size size2,
                 enum fifo_size size3, enum fifo_size size4)
 {
@@ -1753,8 +2075,6 @@ static void dsi_vc_initial_config(int channel)
         r = FLD_MOD(r, 4, 23, 21); /* DMA_TX_REQ_NB = no dma */
 
         dsi_write_reg(DSI_VC_CTRL(channel), r);
-
-        dsi.vc[channel].mode = DSI_VC_MODE_L4;
 }
 
 static int dsi_vc_config_l4(int channel)
@@ -1922,33 +2242,44 @@ static int dsi_vc_send_bta(int channel)
 
 int dsi_vc_send_bta_sync(int channel)
 {
+        DECLARE_COMPLETION_ONSTACK(completion);
         int r = 0;
         u32 err;
 
-        INIT_COMPLETION(dsi.bta_completion);
+        r = dsi_register_isr_vc(channel, dsi_completion_handler,
+                        &completion, DSI_VC_IRQ_BTA);
+        if (r)
+                goto err0;
 
-        dsi_vc_enable_bta_irq(channel);
+        r = dsi_register_isr(dsi_completion_handler, &completion,
+                        DSI_IRQ_ERROR_MASK);
+        if (r)
+                goto err1;
 
         r = dsi_vc_send_bta(channel);
         if (r)
-                goto err;
+                goto err2;
 
-        if (wait_for_completion_timeout(&dsi.bta_completion,
+        if (wait_for_completion_timeout(&completion,
                                 msecs_to_jiffies(500)) == 0) {
                 DSSERR("Failed to receive BTA\n");
                 r = -EIO;
-                goto err;
+                goto err2;
         }
 
         err = dsi_get_errors();
         if (err) {
                 DSSERR("Error while sending BTA: %x\n", err);
                 r = -EIO;
-                goto err;
+                goto err2;
         }
-err:
-        dsi_vc_disable_bta_irq(channel);
-
+err2:
+        dsi_unregister_isr(dsi_completion_handler, &completion,
+                        DSI_IRQ_ERROR_MASK);
+err1:
+        dsi_unregister_isr_vc(channel, dsi_completion_handler,
+                        &completion, DSI_VC_IRQ_BTA);
+err0:
         return r;
 }
 EXPORT_SYMBOL(dsi_vc_send_bta_sync);
@@ -1961,7 +2292,7 @@ static inline void dsi_vc_write_long_header(int channel, u8 data_type,
 
         WARN_ON(!dsi_bus_is_locked());
 
-        data_id = data_type | channel << 6;
+        data_id = data_type | dsi.vc[channel].vc_id << 6;
 
         val = FLD_VAL(data_id, 7, 0) | FLD_VAL(len, 23, 8) |
                 FLD_VAL(ecc, 31, 24);
@@ -2064,7 +2395,7 @@ static int dsi_vc_send_short(int channel, u8 data_type, u16 data, u8 ecc)
                 return -EINVAL;
         }
 
-        data_id = data_type | channel << 6;
+        data_id = data_type | dsi.vc[channel].vc_id << 6;
 
         r = (data_id << 0) | (data << 8) | (ecc << 24);
 
@@ -2762,19 +3093,20 @@ static void dsi_te_timeout(unsigned long arg)
 }
 #endif
 
+static void dsi_framedone_bta_callback(void *data, u32 mask);
+
 static void dsi_handle_framedone(int error)
 {
         const int channel = dsi.update_channel;
 
-        cancel_delayed_work(&dsi.framedone_timeout_work);
+        dsi_unregister_isr_vc(channel, dsi_framedone_bta_callback,
+                        NULL, DSI_VC_IRQ_BTA);
 
-        dsi_vc_disable_bta_irq(channel);
+        cancel_delayed_work(&dsi.framedone_timeout_work);
 
         /* SIDLEMODE back to smart-idle */
         dispc_enable_sidle();
 
-        dsi.bta_callback = NULL;
-
         if (dsi.te_enabled) {
                 /* enable LP_RX_TO again after the TE */
                 REG_FLD_MOD(DSI_TIMING2, 1, 15, 15); /* LP_RX_TO */
@@ -2808,7 +3140,7 @@ static void dsi_framedone_timeout_work_callback(struct work_struct *work)
         dsi_handle_framedone(-ETIMEDOUT);
 }
 
-static void dsi_framedone_bta_callback(void)
+static void dsi_framedone_bta_callback(void *data, u32 mask)
 {
         dsi_handle_framedone(0);
 
@@ -2848,15 +3180,19 @@ static void dsi_framedone_irq_callback(void *data, u32 mask)
          * asynchronously.
          * */
 
-        dsi.bta_callback = dsi_framedone_bta_callback;
-
-        barrier();
-
-        dsi_vc_enable_bta_irq(channel);
+        r = dsi_register_isr_vc(channel, dsi_framedone_bta_callback,
+                        NULL, DSI_VC_IRQ_BTA);
+        if (r) {
+                DSSERR("Failed to register BTA ISR\n");
+                dsi_handle_framedone(-EIO);
+                return;
+        }
 
         r = dsi_vc_send_bta(channel);
         if (r) {
                 DSSERR("BTA after framedone failed\n");
+                dsi_unregister_isr_vc(channel, dsi_framedone_bta_callback,
+                                NULL, DSI_VC_IRQ_BTA);
                 dsi_handle_framedone(-EIO);
         }
 }
@@ -2984,12 +3320,12 @@ static int dsi_configure_dsi_clocks(struct omap_dss_device *dssdev)
         struct dsi_clock_info cinfo;
         int r;
 
-        /* we always use DSS2_FCK as input clock */
-        cinfo.use_dss2_fck = true;
+        /* we always use DSS_CLK_SYSCK as input clock */
+        cinfo.use_sys_clk = true;
         cinfo.regn  = dssdev->phy.dsi.div.regn;
         cinfo.regm  = dssdev->phy.dsi.div.regm;
-        cinfo.regm3 = dssdev->phy.dsi.div.regm3;
-        cinfo.regm4 = dssdev->phy.dsi.div.regm4;
+        cinfo.regm_dispc = dssdev->phy.dsi.div.regm_dispc;
+        cinfo.regm_dsi = dssdev->phy.dsi.div.regm_dsi;
         r = dsi_calc_clock_rates(dssdev, &cinfo);
         if (r) {
                 DSSERR("Failed to calc dsi clocks\n");
@@ -3011,7 +3347,7 @@ static int dsi_configure_dispc_clocks(struct omap_dss_device *dssdev)
         int r;
         unsigned long long fck;
 
-        fck = dsi_get_dsi1_pll_rate();
+        fck = dsi_get_pll_hsdiv_dispc_rate();
 
         dispc_cinfo.lck_div = dssdev->phy.dsi.div.lck_div;
         dispc_cinfo.pck_div = dssdev->phy.dsi.div.pck_div;
@@ -3045,8 +3381,8 @@ static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
         if (r)
                 goto err1;
 
-        dss_select_dispc_clk_source(DSS_SRC_DSI1_PLL_FCLK);
-        dss_select_dsi_clk_source(DSS_SRC_DSI2_PLL_FCLK);
+        dss_select_dispc_clk_source(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC);
+        dss_select_dsi_clk_source(DSS_CLK_SRC_DSI_PLL_HSDIV_DSI);
 
         DSSDBG("PLL OK\n");
 
@@ -3082,8 +3418,8 @@ static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
 err3:
         dsi_complexio_uninit();
 err2:
-        dss_select_dispc_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
-        dss_select_dsi_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
+        dss_select_dispc_clk_source(DSS_CLK_SRC_FCK);
+        dss_select_dsi_clk_source(DSS_CLK_SRC_FCK);
 err1:
         dsi_pll_uninit();
 err0:
@@ -3099,8 +3435,8 @@ static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev)
         dsi_vc_enable(2, 0);
         dsi_vc_enable(3, 0);
 
-        dss_select_dispc_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
-        dss_select_dsi_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
+        dss_select_dispc_clk_source(DSS_CLK_SRC_FCK);
+        dss_select_dsi_clk_source(DSS_CLK_SRC_FCK);
         dsi_complexio_uninit();
         dsi_pll_uninit();
 }
@@ -3220,29 +3556,107 @@ int dsi_init_display(struct omap_dss_device *dssdev)
         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
                 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
 
-        dsi.vc[0].dssdev = dssdev;
-        dsi.vc[1].dssdev = dssdev;
+        if (dsi.vdds_dsi_reg == NULL) {
+                struct regulator *vdds_dsi;
+
+                vdds_dsi = regulator_get(&dsi.pdev->dev, "vdds_dsi");
+
+                if (IS_ERR(vdds_dsi)) {
+                        DSSERR("can't get VDDS_DSI regulator\n");
+                        return PTR_ERR(vdds_dsi);
+                }
+
+                dsi.vdds_dsi_reg = vdds_dsi;
+        }
 
         return 0;
 }
 
-void dsi_wait_dsi1_pll_active(void)
+int omap_dsi_request_vc(struct omap_dss_device *dssdev, int *channel)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dsi.vc); i++) {
+                if (!dsi.vc[i].dssdev) {
+                        dsi.vc[i].dssdev = dssdev;
+                        *channel = i;
+                        return 0;
+                }
+        }
+
+        DSSERR("cannot get VC for display %s", dssdev->name);
+        return -ENOSPC;
+}
+EXPORT_SYMBOL(omap_dsi_request_vc);
+
+int omap_dsi_set_vc_id(struct omap_dss_device *dssdev, int channel, int vc_id)
+{
+        if (vc_id < 0 || vc_id > 3) {
+                DSSERR("VC ID out of range\n");
+                return -EINVAL;
+        }
+
+        if (channel < 0 || channel > 3) {
+                DSSERR("Virtual Channel out of range\n");
+                return -EINVAL;
+        }
+
+        if (dsi.vc[channel].dssdev != dssdev) {
+                DSSERR("Virtual Channel not allocated to display %s\n",
+                        dssdev->name);
+                return -EINVAL;
+        }
+
+        dsi.vc[channel].vc_id = vc_id;
+
+        return 0;
+}
+EXPORT_SYMBOL(omap_dsi_set_vc_id);
+
+void omap_dsi_release_vc(struct omap_dss_device *dssdev, int channel)
+{
+        if ((channel >= 0 && channel <= 3) &&
+                dsi.vc[channel].dssdev == dssdev) {
+                dsi.vc[channel].dssdev = NULL;
+                dsi.vc[channel].vc_id = 0;
+        }
+}
+EXPORT_SYMBOL(omap_dsi_release_vc);
+
+void dsi_wait_pll_hsdiv_dispc_active(void)
 {
         if (wait_for_bit_change(DSI_PLL_STATUS, 7, 1) != 1)
-                DSSERR("DSI1 PLL clock not active\n");
+                DSSERR("%s (%s) not active\n",
+                        dss_get_generic_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
+                        dss_feat_get_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC));
 }
 
-void dsi_wait_dsi2_pll_active(void)
+void dsi_wait_pll_hsdiv_dsi_active(void)
 {
         if (wait_for_bit_change(DSI_PLL_STATUS, 8, 1) != 1)
-                DSSERR("DSI2 PLL clock not active\n");
+                DSSERR("%s (%s) not active\n",
+                        dss_get_generic_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
+                        dss_feat_get_clk_source_name(DSS_CLK_SRC_DSI_PLL_HSDIV_DSI));
+}
+
+static void dsi_calc_clock_param_ranges(void)
+{
+        dsi.regn_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGN);
+        dsi.regm_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM);
+        dsi.regm_dispc_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM_DISPC);
+        dsi.regm_dsi_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM_DSI);
+        dsi.fint_min = dss_feat_get_param_min(FEAT_PARAM_DSIPLL_FINT);
+        dsi.fint_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_FINT);
+        dsi.lpdiv_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_LPDIV);
 }
 
-int dsi_init(struct platform_device *pdev)
+static int dsi_init(struct platform_device *pdev)
 {
         u32 rev;
-        int r;
+        int r, i;
+        struct resource *dsi_mem;
 
+        spin_lock_init(&dsi.irq_lock);
         spin_lock_init(&dsi.errors_lock);
         dsi.errors = 0;
 
@@ -3251,8 +3665,6 @@ int dsi_init(struct platform_device *pdev)
         dsi.irq_stats.last_reset = jiffies;
 #endif
 
-        init_completion(&dsi.bta_completion);
-
         mutex_init(&dsi.lock);
         sema_init(&dsi.bus_lock, 1);
 
@@ -3268,24 +3680,45 @@ int dsi_init(struct platform_device *pdev)
         dsi.te_timer.function = dsi_te_timeout;
         dsi.te_timer.data = 0;
 #endif
-        dsi.base = ioremap(DSI_BASE, DSI_SZ_REGS);
+        dsi_mem = platform_get_resource(dsi.pdev, IORESOURCE_MEM, 0);
+        if (!dsi_mem) {
+                DSSERR("can't get IORESOURCE_MEM DSI\n");
+                r = -EINVAL;
+                goto err1;
+        }
+        dsi.base = ioremap(dsi_mem->start, resource_size(dsi_mem));
         if (!dsi.base) {
                 DSSERR("can't ioremap DSI\n");
                 r = -ENOMEM;
                 goto err1;
         }
+        dsi.irq = platform_get_irq(dsi.pdev, 0);
+        if (dsi.irq < 0) {
+                DSSERR("platform_get_irq failed\n");
+                r = -ENODEV;
+                goto err2;
+        }
 
-        dsi.vdds_dsi_reg = dss_get_vdds_dsi();
-        if (IS_ERR(dsi.vdds_dsi_reg)) {
-                DSSERR("can't get VDDS_DSI regulator\n");
-                r = PTR_ERR(dsi.vdds_dsi_reg);
+        r = request_irq(dsi.irq, omap_dsi_irq_handler, IRQF_SHARED,
+                "OMAP DSI1", dsi.pdev);
+        if (r < 0) {
+                DSSERR("request_irq failed\n");
                 goto err2;
         }
 
+        /* DSI VCs initialization */
+        for (i = 0; i < ARRAY_SIZE(dsi.vc); i++) {
+                dsi.vc[i].mode = DSI_VC_MODE_L4;
+                dsi.vc[i].dssdev = NULL;
+                dsi.vc[i].vc_id = 0;
+        }
+
+        dsi_calc_clock_param_ranges();
+
         enable_clocks(1);
 
         rev = dsi_read_reg(DSI_REVISION);
-        printk(KERN_INFO "OMAP DSI rev %d.%d\n",
+        dev_dbg(&pdev->dev, "OMAP DSI rev %d.%d\n",
                FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
 
         enable_clocks(0);
@@ -3298,8 +3731,14 @@ err1:
         return r;
 }
 
-void dsi_exit(void)
+static void dsi_exit(void)
 {
+        if (dsi.vdds_dsi_reg != NULL) {
+                regulator_put(dsi.vdds_dsi_reg);
+                dsi.vdds_dsi_reg = NULL;
+        }
+
+        free_irq(dsi.irq, dsi.pdev);
         iounmap(dsi.base);
 
         destroy_workqueue(dsi.workqueue);
@@ -3307,3 +3746,41 @@ void dsi_exit(void)
         DSSDBG("omap_dsi_exit\n");
 }
 
+/* DSI1 HW IP initialisation */
+static int omap_dsi1hw_probe(struct platform_device *pdev)
+{
+        int r;
+        dsi.pdev = pdev;
+        r = dsi_init(pdev);
+        if (r) {
+                DSSERR("Failed to initialize DSI\n");
+                goto err_dsi;
+        }
+err_dsi:
+        return r;
+}
+
+static int omap_dsi1hw_remove(struct platform_device *pdev)
+{
+        dsi_exit();
+        return 0;
+}
+
+static struct platform_driver omap_dsi1hw_driver = {
+        .probe          = omap_dsi1hw_probe,
+        .remove         = omap_dsi1hw_remove,
+        .driver         = {
+                .name   = "omapdss_dsi1",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int dsi_init_platform_driver(void)
+{
+        return platform_driver_register(&omap_dsi1hw_driver);
+}
+
+void dsi_uninit_platform_driver(void)
+{
+        return platform_driver_unregister(&omap_dsi1hw_driver);
+}
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 77c3621c9171..3f1fee63c678 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -26,14 +26,13 @@
 #include <linux/io.h>
 #include <linux/err.h>
 #include <linux/delay.h>
-#include <linux/interrupt.h>
 #include <linux/seq_file.h>
 #include <linux/clk.h>
 
 #include <plat/display.h>
+#include <plat/clock.h>
 #include "dss.h"
-
-#define DSS_BASE                        0x48050000
+#include "dss_features.h"
 
 #define DSS_SZ_REGS                     SZ_512
 
@@ -59,9 +58,17 @@ struct dss_reg {
         dss_write_reg(idx, FLD_MOD(dss_read_reg(idx), val, start, end))
 
 static struct {
+        struct platform_device *pdev;
         void __iomem    *base;
+        int             ctx_id;
 
         struct clk      *dpll4_m4_ck;
+        struct clk      *dss_ick;
+        struct clk      *dss_fck;
+        struct clk      *dss_sys_clk;
+        struct clk      *dss_tv_fck;
+        struct clk      *dss_video_fck;
+        unsigned        num_clks_enabled;
 
         unsigned long   cache_req_pck;
         unsigned long   cache_prate;
@@ -70,10 +77,22 @@ static struct {
 
         enum dss_clk_source dsi_clk_source;
         enum dss_clk_source dispc_clk_source;
+        enum dss_clk_source lcd_clk_source[MAX_DSS_LCD_MANAGERS];
 
         u32             ctx[DSS_SZ_REGS / sizeof(u32)];
 } dss;
 
+static const char * const dss_generic_clk_source_names[] = {
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC]       = "DSI_PLL_HSDIV_DISPC",
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DSI]         = "DSI_PLL_HSDIV_DSI",
+        [DSS_CLK_SRC_FCK]                       = "DSS_FCK",
+};
+
+static void dss_clk_enable_all_no_ctx(void);
+static void dss_clk_disable_all_no_ctx(void);
+static void dss_clk_enable_no_ctx(enum dss_clock clks);
+static void dss_clk_disable_no_ctx(enum dss_clock clks);
+
 static int _omap_dss_wait_reset(void);
 
 static inline void dss_write_reg(const struct dss_reg idx, u32 val)
@@ -99,10 +118,11 @@ void dss_save_context(void)
         SR(SYSCONFIG);
         SR(CONTROL);
 
-#ifdef CONFIG_OMAP2_DSS_SDI
-        SR(SDI_CONTROL);
-        SR(PLL_CONTROL);
-#endif
+        if (dss_feat_get_supported_displays(OMAP_DSS_CHANNEL_LCD) &
+                        OMAP_DISPLAY_TYPE_SDI) {
+                SR(SDI_CONTROL);
+                SR(PLL_CONTROL);
+        }
 }
 
 void dss_restore_context(void)
@@ -113,10 +133,11 @@ void dss_restore_context(void)
         RR(SYSCONFIG);
         RR(CONTROL);
 
-#ifdef CONFIG_OMAP2_DSS_SDI
-        RR(SDI_CONTROL);
-        RR(PLL_CONTROL);
-#endif
+        if (dss_feat_get_supported_displays(OMAP_DSS_CHANNEL_LCD) &
+                        OMAP_DISPLAY_TYPE_SDI) {
+                RR(SDI_CONTROL);
+                RR(PLL_CONTROL);
+        }
 }
 
 #undef SR
@@ -209,66 +230,96 @@ void dss_sdi_disable(void)
         REG_FLD_MOD(DSS_PLL_CONTROL, 0, 18, 18); /* SDI_PLL_SYSRESET */
 }
 
+const char *dss_get_generic_clk_source_name(enum dss_clk_source clk_src)
+{
+        return dss_generic_clk_source_names[clk_src];
+}
+
 void dss_dump_clocks(struct seq_file *s)
 {
         unsigned long dpll4_ck_rate;
         unsigned long dpll4_m4_ck_rate;
+        const char *fclk_name, *fclk_real_name;
+        unsigned long fclk_rate;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
-
-        dpll4_ck_rate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
-        dpll4_m4_ck_rate = clk_get_rate(dss.dpll4_m4_ck);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         seq_printf(s, "- DSS -\n");
 
-        seq_printf(s, "dpll4_ck %lu\n", dpll4_ck_rate);
+        fclk_name = dss_get_generic_clk_source_name(DSS_CLK_SRC_FCK);
+        fclk_real_name = dss_feat_get_clk_source_name(DSS_CLK_SRC_FCK);
+        fclk_rate = dss_clk_get_rate(DSS_CLK_FCK);
 
-        if (cpu_is_omap3630())
-                seq_printf(s, "dss1_alwon_fclk = %lu / %lu  = %lu\n",
-                        dpll4_ck_rate,
-                        dpll4_ck_rate / dpll4_m4_ck_rate,
-                        dss_clk_get_rate(DSS_CLK_FCK1));
-        else
-                seq_printf(s, "dss1_alwon_fclk = %lu / %lu * 2 = %lu\n",
-                        dpll4_ck_rate,
-                        dpll4_ck_rate / dpll4_m4_ck_rate,
-                        dss_clk_get_rate(DSS_CLK_FCK1));
+        if (dss.dpll4_m4_ck) {
+                dpll4_ck_rate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
+                dpll4_m4_ck_rate = clk_get_rate(dss.dpll4_m4_ck);
+
+                seq_printf(s, "dpll4_ck %lu\n", dpll4_ck_rate);
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                if (cpu_is_omap3630() || cpu_is_omap44xx())
+                        seq_printf(s, "%s (%s) = %lu / %lu  = %lu\n",
+                                        fclk_name, fclk_real_name,
+                                        dpll4_ck_rate,
+                                        dpll4_ck_rate / dpll4_m4_ck_rate,
+                                        fclk_rate);
+                else
+                        seq_printf(s, "%s (%s) = %lu / %lu * 2 = %lu\n",
+                                        fclk_name, fclk_real_name,
+                                        dpll4_ck_rate,
+                                        dpll4_ck_rate / dpll4_m4_ck_rate,
+                                        fclk_rate);
+        } else {
+                seq_printf(s, "%s (%s) = %lu\n",
+                                fclk_name, fclk_real_name,
+                                fclk_rate);
+        }
+
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 }
 
 void dss_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dss_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         DUMPREG(DSS_REVISION);
         DUMPREG(DSS_SYSCONFIG);
         DUMPREG(DSS_SYSSTATUS);
         DUMPREG(DSS_IRQSTATUS);
         DUMPREG(DSS_CONTROL);
-        DUMPREG(DSS_SDI_CONTROL);
-        DUMPREG(DSS_PLL_CONTROL);
-        DUMPREG(DSS_SDI_STATUS);
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        if (dss_feat_get_supported_displays(OMAP_DSS_CHANNEL_LCD) &
+                        OMAP_DISPLAY_TYPE_SDI) {
+                DUMPREG(DSS_SDI_CONTROL);
+                DUMPREG(DSS_PLL_CONTROL);
+                DUMPREG(DSS_SDI_STATUS);
+        }
+
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 #undef DUMPREG
 }
 
 void dss_select_dispc_clk_source(enum dss_clk_source clk_src)
 {
         int b;
+        u8 start, end;
+
+        switch (clk_src) {
+        case DSS_CLK_SRC_FCK:
+                b = 0;
+                break;
+        case DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
+                b = 1;
+                dsi_wait_pll_hsdiv_dispc_active();
+                break;
+        default:
+                BUG();
+        }
 
-        BUG_ON(clk_src != DSS_SRC_DSI1_PLL_FCLK &&
-                        clk_src != DSS_SRC_DSS1_ALWON_FCLK);
-
-        b = clk_src == DSS_SRC_DSS1_ALWON_FCLK ? 0 : 1;
-
-        if (clk_src == DSS_SRC_DSI1_PLL_FCLK)
-                dsi_wait_dsi1_pll_active();
+        dss_feat_get_reg_field(FEAT_REG_DISPC_CLK_SWITCH, &start, &end);
 
-        REG_FLD_MOD(DSS_CONTROL, b, 0, 0);      /* DISPC_CLK_SWITCH */
+        REG_FLD_MOD(DSS_CONTROL, b, start, end);        /* DISPC_CLK_SWITCH */
 
         dss.dispc_clk_source = clk_src;
 }
@@ -277,19 +328,51 @@ void dss_select_dsi_clk_source(enum dss_clk_source clk_src)
 {
         int b;
 
-        BUG_ON(clk_src != DSS_SRC_DSI2_PLL_FCLK &&
-                        clk_src != DSS_SRC_DSS1_ALWON_FCLK);
-
-        b = clk_src == DSS_SRC_DSS1_ALWON_FCLK ? 0 : 1;
-
-        if (clk_src == DSS_SRC_DSI2_PLL_FCLK)
-                dsi_wait_dsi2_pll_active();
+        switch (clk_src) {
+        case DSS_CLK_SRC_FCK:
+                b = 0;
+                break;
+        case DSS_CLK_SRC_DSI_PLL_HSDIV_DSI:
+                b = 1;
+                dsi_wait_pll_hsdiv_dsi_active();
+                break;
+        default:
+                BUG();
+        }
 
         REG_FLD_MOD(DSS_CONTROL, b, 1, 1);      /* DSI_CLK_SWITCH */
 
         dss.dsi_clk_source = clk_src;
 }
 
+void dss_select_lcd_clk_source(enum omap_channel channel,
+                enum dss_clk_source clk_src)
+{
+        int b, ix, pos;
+
+        if (!dss_has_feature(FEAT_LCD_CLK_SRC))
+                return;
+
+        switch (clk_src) {
+        case DSS_CLK_SRC_FCK:
+                b = 0;
+                break;
+        case DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
+                BUG_ON(channel != OMAP_DSS_CHANNEL_LCD);
+                b = 1;
+                dsi_wait_pll_hsdiv_dispc_active();
+                break;
+        default:
+                BUG();
+        }
+
+        pos = channel == OMAP_DSS_CHANNEL_LCD ? 0 : 12;
+        REG_FLD_MOD(DSS_CONTROL, b, pos, pos);  /* LCDx_CLK_SWITCH */
+
+        ix = channel == OMAP_DSS_CHANNEL_LCD ? 0 : 1;
+        dss.lcd_clk_source[ix] = clk_src;
+}
+
 enum dss_clk_source dss_get_dispc_clk_source(void)
 {
         return dss.dispc_clk_source;
@@ -300,34 +383,52 @@ enum dss_clk_source dss_get_dsi_clk_source(void)
         return dss.dsi_clk_source;
 }
 
+enum dss_clk_source dss_get_lcd_clk_source(enum omap_channel channel)
+{
+        int ix = channel == OMAP_DSS_CHANNEL_LCD ? 0 : 1;
+        return dss.lcd_clk_source[ix];
+}
+
 /* calculate clock rates using dividers in cinfo */
 int dss_calc_clock_rates(struct dss_clock_info *cinfo)
 {
-        unsigned long prate;
+        if (dss.dpll4_m4_ck) {
+                unsigned long prate;
+                u16 fck_div_max = 16;
 
-        if (cinfo->fck_div > (cpu_is_omap3630() ? 32 : 16) ||
-                                                cinfo->fck_div == 0)
-                return -EINVAL;
+                if (cpu_is_omap3630() || cpu_is_omap44xx())
+                        fck_div_max = 32;
+
+                if (cinfo->fck_div > fck_div_max || cinfo->fck_div == 0)
+                        return -EINVAL;
 
-        prate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
+                prate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
 
-        cinfo->fck = prate / cinfo->fck_div;
+                cinfo->fck = prate / cinfo->fck_div;
+        } else {
+                if (cinfo->fck_div != 0)
+                        return -EINVAL;
+                cinfo->fck = dss_clk_get_rate(DSS_CLK_FCK);
+        }
 
         return 0;
 }
 
 int dss_set_clock_div(struct dss_clock_info *cinfo)
 {
-        unsigned long prate;
-        int r;
+        if (dss.dpll4_m4_ck) {
+                unsigned long prate;
+                int r;
 
-        if (cpu_is_omap34xx()) {
                 prate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
                 DSSDBG("dpll4_m4 = %ld\n", prate);
 
                 r = clk_set_rate(dss.dpll4_m4_ck, prate / cinfo->fck_div);
                 if (r)
                         return r;
+        } else {
+                if (cinfo->fck_div != 0)
+                        return -EINVAL;
         }
 
         DSSDBG("fck = %ld (%d)\n", cinfo->fck, cinfo->fck_div);
@@ -337,12 +438,14 @@ int dss_set_clock_div(struct dss_clock_info *cinfo)
 
 int dss_get_clock_div(struct dss_clock_info *cinfo)
 {
-        cinfo->fck = dss_clk_get_rate(DSS_CLK_FCK1);
+        cinfo->fck = dss_clk_get_rate(DSS_CLK_FCK);
 
-        if (cpu_is_omap34xx()) {
+        if (dss.dpll4_m4_ck) {
                 unsigned long prate;
+
                 prate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
-                if (cpu_is_omap3630())
+
+                if (cpu_is_omap3630() || cpu_is_omap44xx())
                         cinfo->fck_div = prate / (cinfo->fck);
                 else
                         cinfo->fck_div = prate / (cinfo->fck / 2);
@@ -355,7 +458,7 @@ int dss_get_clock_div(struct dss_clock_info *cinfo)
 
 unsigned long dss_get_dpll4_rate(void)
 {
-        if (cpu_is_omap34xx())
+        if (dss.dpll4_m4_ck)
                 return clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
         else
                 return 0;
@@ -369,16 +472,18 @@ int dss_calc_clock_div(bool is_tft, unsigned long req_pck,
         struct dss_clock_info best_dss;
         struct dispc_clock_info best_dispc;
 
-        unsigned long fck;
+        unsigned long fck, max_dss_fck;
 
-        u16 fck_div;
+        u16 fck_div, fck_div_max = 16;
 
         int match = 0;
         int min_fck_per_pck;
 
         prate = dss_get_dpll4_rate();
 
-        fck = dss_clk_get_rate(DSS_CLK_FCK1);
+        max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
+
+        fck = dss_clk_get_rate(DSS_CLK_FCK);
         if (req_pck == dss.cache_req_pck &&
                         ((cpu_is_omap34xx() && prate == dss.cache_prate) ||
                          dss.cache_dss_cinfo.fck == fck)) {
@@ -391,7 +496,7 @@ int dss_calc_clock_div(bool is_tft, unsigned long req_pck,
         min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
 
         if (min_fck_per_pck &&
-                req_pck * min_fck_per_pck > DISPC_MAX_FCK) {
+                req_pck * min_fck_per_pck > max_dss_fck) {
                 DSSERR("Requested pixel clock not possible with the current "
                                 "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
                                 "the constraint off.\n");
@@ -402,10 +507,10 @@ retry:
         memset(&best_dss, 0, sizeof(best_dss));
         memset(&best_dispc, 0, sizeof(best_dispc));
 
-        if (cpu_is_omap24xx()) {
+        if (dss.dpll4_m4_ck == NULL) {
                 struct dispc_clock_info cur_dispc;
                 /* XXX can we change the clock on omap2? */
-                fck = dss_clk_get_rate(DSS_CLK_FCK1);
+                fck = dss_clk_get_rate(DSS_CLK_FCK);
                 fck_div = 1;
 
                 dispc_find_clk_divs(is_tft, req_pck, fck, &cur_dispc);
@@ -417,17 +522,19 @@ retry:
                 best_dispc = cur_dispc;
 
                 goto found;
-        } else if (cpu_is_omap34xx()) {
-                for (fck_div = (cpu_is_omap3630() ? 32 : 16);
-                                        fck_div > 0; --fck_div) {
+        } else {
+                if (cpu_is_omap3630() || cpu_is_omap44xx())
+                        fck_div_max = 32;
+
+                for (fck_div = fck_div_max; fck_div > 0; --fck_div) {
                         struct dispc_clock_info cur_dispc;
 
-                        if (cpu_is_omap3630())
+                        if (fck_div_max == 32)
                                 fck = prate / fck_div;
                         else
                                 fck = prate / fck_div * 2;
 
-                        if (fck > DISPC_MAX_FCK)
+                        if (fck > max_dss_fck)
                                 continue;
 
                         if (min_fck_per_pck &&
@@ -450,8 +557,6 @@ retry:
                                         goto found;
                         }
                 }
-        } else {
-                BUG();
         }
 
 found:
@@ -482,31 +587,6 @@ found:
         return 0;
 }
 
-
-
-static irqreturn_t dss_irq_handler_omap2(int irq, void *arg)
-{
-        dispc_irq_handler();
-
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t dss_irq_handler_omap3(int irq, void *arg)
-{
-        u32 irqstatus;
-
-        irqstatus = dss_read_reg(DSS_IRQSTATUS);
-
-        if (irqstatus & (1<<0)) /* DISPC_IRQ */
-                dispc_irq_handler();
-#ifdef CONFIG_OMAP2_DSS_DSI
-        if (irqstatus & (1<<1)) /* DSI_IRQ */
-                dsi_irq_handler();
-#endif
-
-        return IRQ_HANDLED;
-}
-
 static int _omap_dss_wait_reset(void)
 {
         int t = 0;
@@ -549,34 +629,45 @@ void dss_set_dac_pwrdn_bgz(bool enable)
         REG_FLD_MOD(DSS_CONTROL, enable, 5, 5); /* DAC Power-Down Control */
 }
 
-int dss_init(bool skip_init)
+void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select hdmi)
+{
+        REG_FLD_MOD(DSS_CONTROL, hdmi, 15, 15); /* VENC_HDMI_SWITCH */
+}
+
+static int dss_init(void)
 {
         int r;
         u32 rev;
+        struct resource *dss_mem;
+        struct clk *dpll4_m4_ck;
 
-        dss.base = ioremap(DSS_BASE, DSS_SZ_REGS);
+        dss_mem = platform_get_resource(dss.pdev, IORESOURCE_MEM, 0);
+        if (!dss_mem) {
+                DSSERR("can't get IORESOURCE_MEM DSS\n");
+                r = -EINVAL;
+                goto fail0;
+        }
+        dss.base = ioremap(dss_mem->start, resource_size(dss_mem));
         if (!dss.base) {
                 DSSERR("can't ioremap DSS\n");
                 r = -ENOMEM;
                 goto fail0;
         }
 
-        if (!skip_init) {
-                /* disable LCD and DIGIT output. This seems to fix the synclost
-                 * problem that we get, if the bootloader starts the DSS and
-                 * the kernel resets it */
-                omap_writel(omap_readl(0x48050440) & ~0x3, 0x48050440);
+        /* disable LCD and DIGIT output. This seems to fix the synclost
+         * problem that we get, if the bootloader starts the DSS and
+         * the kernel resets it */
+        omap_writel(omap_readl(0x48050440) & ~0x3, 0x48050440);
 
-                /* We need to wait here a bit, otherwise we sometimes start to
-                 * get synclost errors, and after that only power cycle will
-                 * restore DSS functionality. I have no idea why this happens.
-                 * And we have to wait _before_ resetting the DSS, but after
-                 * enabling clocks.
-                 */
-                msleep(50);
+        /* We need to wait here a bit, otherwise we sometimes start to
+         * get synclost errors, and after that only power cycle will
+         * restore DSS functionality. I have no idea why this happens.
+         * And we have to wait _before_ resetting the DSS, but after
+         * enabling clocks.
+         */
+        msleep(50);
 
-                _omap_dss_reset();
-        }
+        _omap_dss_reset();
 
         /* autoidle */
         REG_FLD_MOD(DSS_SYSCONFIG, 1, 0, 0);
@@ -589,29 +680,30 @@ int dss_init(bool skip_init)
         REG_FLD_MOD(DSS_CONTROL, 1, 3, 3);      /* venc clock 4x enable */
         REG_FLD_MOD(DSS_CONTROL, 0, 2, 2);      /* venc clock mode = normal */
 #endif
-
-        r = request_irq(INT_24XX_DSS_IRQ,
-                        cpu_is_omap24xx()
-                        ? dss_irq_handler_omap2
-                        : dss_irq_handler_omap3,
-                        0, "OMAP DSS", NULL);
-
-        if (r < 0) {
-                DSSERR("omap2 dss: request_irq failed\n");
-                goto fail1;
-        }
-
         if (cpu_is_omap34xx()) {
-                dss.dpll4_m4_ck = clk_get(NULL, "dpll4_m4_ck");
-                if (IS_ERR(dss.dpll4_m4_ck)) {
+                dpll4_m4_ck = clk_get(NULL, "dpll4_m4_ck");
+                if (IS_ERR(dpll4_m4_ck)) {
                         DSSERR("Failed to get dpll4_m4_ck\n");
-                        r = PTR_ERR(dss.dpll4_m4_ck);
-                        goto fail2;
+                        r = PTR_ERR(dpll4_m4_ck);
+                        goto fail1;
                 }
+        } else if (cpu_is_omap44xx()) {
+                dpll4_m4_ck = clk_get(NULL, "dpll_per_m5x2_ck");
+                if (IS_ERR(dpll4_m4_ck)) {
+                        DSSERR("Failed to get dpll4_m4_ck\n");
+                        r = PTR_ERR(dpll4_m4_ck);
+                        goto fail1;
+                }
+        } else { /* omap24xx */
+                dpll4_m4_ck = NULL;
         }
 
-        dss.dsi_clk_source = DSS_SRC_DSS1_ALWON_FCLK;
-        dss.dispc_clk_source = DSS_SRC_DSS1_ALWON_FCLK;
+        dss.dpll4_m4_ck = dpll4_m4_ck;
+
+        dss.dsi_clk_source = DSS_CLK_SRC_FCK;
+        dss.dispc_clk_source = DSS_CLK_SRC_FCK;
+        dss.lcd_clk_source[0] = DSS_CLK_SRC_FCK;
+        dss.lcd_clk_source[1] = DSS_CLK_SRC_FCK;
 
         dss_save_context();
 
@@ -621,21 +713,416 @@ int dss_init(bool skip_init)
 
         return 0;
 
-fail2:
-        free_irq(INT_24XX_DSS_IRQ, NULL);
 fail1:
         iounmap(dss.base);
 fail0:
         return r;
 }
 
-void dss_exit(void)
+static void dss_exit(void)
 {
-        if (cpu_is_omap34xx())
+        if (dss.dpll4_m4_ck)
                 clk_put(dss.dpll4_m4_ck);
 
-        free_irq(INT_24XX_DSS_IRQ, NULL);
-
         iounmap(dss.base);
 }
 
+/* CONTEXT */
+static int dss_get_ctx_id(void)
+{
+        struct omap_display_platform_data *pdata = dss.pdev->dev.platform_data;
+        int r;
+
+        if (!pdata->board_data->get_last_off_on_transaction_id)
+                return 0;
+        r = pdata->board_data->get_last_off_on_transaction_id(&dss.pdev->dev);
+        if (r < 0) {
+                dev_err(&dss.pdev->dev, "getting transaction ID failed, "
+                                "will force context restore\n");
+                r = -1;
+        }
+        return r;
+}
+
+int dss_need_ctx_restore(void)
+{
+        int id = dss_get_ctx_id();
+
+        if (id < 0 || id != dss.ctx_id) {
+                DSSDBG("ctx id %d -> id %d\n",
+                                dss.ctx_id, id);
+                dss.ctx_id = id;
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+static void save_all_ctx(void)
+{
+        DSSDBG("save context\n");
+
+        dss_clk_enable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK);
+
+        dss_save_context();
+        dispc_save_context();
+#ifdef CONFIG_OMAP2_DSS_DSI
+        dsi_save_context();
+#endif
+
+        dss_clk_disable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK);
+}
+
+static void restore_all_ctx(void)
+{
+        DSSDBG("restore context\n");
+
+        dss_clk_enable_all_no_ctx();
+
+        dss_restore_context();
+        dispc_restore_context();
+#ifdef CONFIG_OMAP2_DSS_DSI
+        dsi_restore_context();
+#endif
+
+        dss_clk_disable_all_no_ctx();
+}
+
+static int dss_get_clock(struct clk **clock, const char *clk_name)
+{
+        struct clk *clk;
+
+        clk = clk_get(&dss.pdev->dev, clk_name);
+
+        if (IS_ERR(clk)) {
+                DSSERR("can't get clock %s", clk_name);
+                return PTR_ERR(clk);
+        }
+
+        *clock = clk;
+
+        DSSDBG("clk %s, rate %ld\n", clk_name, clk_get_rate(clk));
+
+        return 0;
+}
+
+static int dss_get_clocks(void)
+{
+        int r;
+        struct omap_display_platform_data *pdata = dss.pdev->dev.platform_data;
+
+        dss.dss_ick = NULL;
+        dss.dss_fck = NULL;
+        dss.dss_sys_clk = NULL;
+        dss.dss_tv_fck = NULL;
+        dss.dss_video_fck = NULL;
+
+        r = dss_get_clock(&dss.dss_ick, "ick");
+        if (r)
+                goto err;
+
+        r = dss_get_clock(&dss.dss_fck, "fck");
+        if (r)
+                goto err;
+
+        if (!pdata->opt_clock_available) {
+                r = -ENODEV;
+                goto err;
+        }
+
+        if (pdata->opt_clock_available("sys_clk")) {
+                r = dss_get_clock(&dss.dss_sys_clk, "sys_clk");
+                if (r)
+                        goto err;
+        }
+
+        if (pdata->opt_clock_available("tv_clk")) {
+                r = dss_get_clock(&dss.dss_tv_fck, "tv_clk");
+                if (r)
+                        goto err;
+        }
+
+        if (pdata->opt_clock_available("video_clk")) {
+                r = dss_get_clock(&dss.dss_video_fck, "video_clk");
+                if (r)
+                        goto err;
+        }
+
+        return 0;
+
+err:
+        if (dss.dss_ick)
+                clk_put(dss.dss_ick);
+        if (dss.dss_fck)
+                clk_put(dss.dss_fck);
+        if (dss.dss_sys_clk)
+                clk_put(dss.dss_sys_clk);
+        if (dss.dss_tv_fck)
+                clk_put(dss.dss_tv_fck);
+        if (dss.dss_video_fck)
+                clk_put(dss.dss_video_fck);
+
+        return r;
+}
+
+static void dss_put_clocks(void)
+{
+        if (dss.dss_video_fck)
+                clk_put(dss.dss_video_fck);
+        if (dss.dss_tv_fck)
+                clk_put(dss.dss_tv_fck);
+        if (dss.dss_sys_clk)
+                clk_put(dss.dss_sys_clk);
+        clk_put(dss.dss_fck);
+        clk_put(dss.dss_ick);
+}
+
+unsigned long dss_clk_get_rate(enum dss_clock clk)
+{
+        switch (clk) {
+        case DSS_CLK_ICK:
+                return clk_get_rate(dss.dss_ick);
+        case DSS_CLK_FCK:
+                return clk_get_rate(dss.dss_fck);
+        case DSS_CLK_SYSCK:
+                return clk_get_rate(dss.dss_sys_clk);
+        case DSS_CLK_TVFCK:
+                return clk_get_rate(dss.dss_tv_fck);
+        case DSS_CLK_VIDFCK:
+                return clk_get_rate(dss.dss_video_fck);
+        }
+
+        BUG();
+        return 0;
+}
+
+static unsigned count_clk_bits(enum dss_clock clks)
+{
+        unsigned num_clks = 0;
+
+        if (clks & DSS_CLK_ICK)
+                ++num_clks;
+        if (clks & DSS_CLK_FCK)
+                ++num_clks;
+        if (clks & DSS_CLK_SYSCK)
+                ++num_clks;
+        if (clks & DSS_CLK_TVFCK)
+                ++num_clks;
+        if (clks & DSS_CLK_VIDFCK)
+                ++num_clks;
+
+        return num_clks;
+}
+
+static void dss_clk_enable_no_ctx(enum dss_clock clks)
+{
+        unsigned num_clks = count_clk_bits(clks);
+
+        if (clks & DSS_CLK_ICK)
+                clk_enable(dss.dss_ick);
+        if (clks & DSS_CLK_FCK)
+                clk_enable(dss.dss_fck);
+        if ((clks & DSS_CLK_SYSCK) && dss.dss_sys_clk)
+                clk_enable(dss.dss_sys_clk);
+        if ((clks & DSS_CLK_TVFCK) && dss.dss_tv_fck)
+                clk_enable(dss.dss_tv_fck);
+        if ((clks & DSS_CLK_VIDFCK) && dss.dss_video_fck)
+                clk_enable(dss.dss_video_fck);
+
+        dss.num_clks_enabled += num_clks;
+}
+
+void dss_clk_enable(enum dss_clock clks)
+{
+        bool check_ctx = dss.num_clks_enabled == 0;
+
+        dss_clk_enable_no_ctx(clks);
+
+        /*
+         * HACK: On omap4 the registers may not be accessible right after
+         * enabling the clocks. At some point this will be handled by
+         * pm_runtime, but for the time begin this should make things work.
+         */
+        if (cpu_is_omap44xx() && check_ctx)
+                udelay(10);
+
+        if (check_ctx && cpu_is_omap34xx() && dss_need_ctx_restore())
+                restore_all_ctx();
+}
+
+static void dss_clk_disable_no_ctx(enum dss_clock clks)
+{
+        unsigned num_clks = count_clk_bits(clks);
+
+        if (clks & DSS_CLK_ICK)
+                clk_disable(dss.dss_ick);
+        if (clks & DSS_CLK_FCK)
+                clk_disable(dss.dss_fck);
+        if ((clks & DSS_CLK_SYSCK) && dss.dss_sys_clk)
+                clk_disable(dss.dss_sys_clk);
+        if ((clks & DSS_CLK_TVFCK) && dss.dss_tv_fck)
+                clk_disable(dss.dss_tv_fck);
+        if ((clks & DSS_CLK_VIDFCK) && dss.dss_video_fck)
+                clk_disable(dss.dss_video_fck);
+
+        dss.num_clks_enabled -= num_clks;
+}
+
+void dss_clk_disable(enum dss_clock clks)
+{
+        if (cpu_is_omap34xx()) {
+                unsigned num_clks = count_clk_bits(clks);
+
+                BUG_ON(dss.num_clks_enabled < num_clks);
+
+                if (dss.num_clks_enabled == num_clks)
+                        save_all_ctx();
+        }
+
+        dss_clk_disable_no_ctx(clks);
+}
+
+static void dss_clk_enable_all_no_ctx(void)
+{
+        enum dss_clock clks;
+
+        clks = DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_SYSCK | DSS_CLK_TVFCK;
+        if (cpu_is_omap34xx())
+                clks |= DSS_CLK_VIDFCK;
+        dss_clk_enable_no_ctx(clks);
+}
+
+static void dss_clk_disable_all_no_ctx(void)
+{
+        enum dss_clock clks;
+
+        clks = DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_SYSCK | DSS_CLK_TVFCK;
+        if (cpu_is_omap34xx())
+                clks |= DSS_CLK_VIDFCK;
+        dss_clk_disable_no_ctx(clks);
+}
+
+#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
+/* CLOCKS */
+static void core_dump_clocks(struct seq_file *s)
+{
+        int i;
+        struct clk *clocks[5] = {
+                dss.dss_ick,
+                dss.dss_fck,
+                dss.dss_sys_clk,
+                dss.dss_tv_fck,
+                dss.dss_video_fck
+        };
+
+        seq_printf(s, "- CORE -\n");
+
+        seq_printf(s, "internal clk count\t\t%u\n", dss.num_clks_enabled);
+
+        for (i = 0; i < 5; i++) {
+                if (!clocks[i])
+                        continue;
+                seq_printf(s, "%-15s\t%lu\t%d\n",
+                                clocks[i]->name,
+                                clk_get_rate(clocks[i]),
+                                clocks[i]->usecount);
+        }
+}
+#endif /* defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT) */
+
+/* DEBUGFS */
+#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
+void dss_debug_dump_clocks(struct seq_file *s)
+{
+        core_dump_clocks(s);
+        dss_dump_clocks(s);
+        dispc_dump_clocks(s);
+#ifdef CONFIG_OMAP2_DSS_DSI
+        dsi_dump_clocks(s);
+#endif
+}
+#endif
+
+
+/* DSS HW IP initialisation */
+static int omap_dsshw_probe(struct platform_device *pdev)
+{
+        int r;
+
+        dss.pdev = pdev;
+
+        r = dss_get_clocks();
+        if (r)
+                goto err_clocks;
+
+        dss_clk_enable_all_no_ctx();
+
+        dss.ctx_id = dss_get_ctx_id();
+        DSSDBG("initial ctx id %u\n", dss.ctx_id);
+
+        r = dss_init();
+        if (r) {
+                DSSERR("Failed to initialize DSS\n");
+                goto err_dss;
+        }
+
+        r = dpi_init();
+        if (r) {
+                DSSERR("Failed to initialize DPI\n");
+                goto err_dpi;
+        }
+
+        r = sdi_init();
+        if (r) {
+                DSSERR("Failed to initialize SDI\n");
+                goto err_sdi;
+        }
+
+        dss_clk_disable_all_no_ctx();
+        return 0;
+err_sdi:
+        dpi_exit();
+err_dpi:
+        dss_exit();
+err_dss:
+        dss_clk_disable_all_no_ctx();
+        dss_put_clocks();
+err_clocks:
+        return r;
+}
+
+static int omap_dsshw_remove(struct platform_device *pdev)
+{
+
+        dss_exit();
+
+        /*
+         * As part of hwmod changes, DSS is not the only controller of dss
+         * clocks; hwmod framework itself will also enable clocks during hwmod
+         * init for dss, and autoidle is set in h/w for DSS. Hence, there's no
+         * need to disable clocks if their usecounts > 1.
+         */
+        WARN_ON(dss.num_clks_enabled > 0);
+
+        dss_put_clocks();
+        return 0;
+}
+
+static struct platform_driver omap_dsshw_driver = {
+        .probe          = omap_dsshw_probe,
+        .remove         = omap_dsshw_remove,
+        .driver         = {
+                .name   = "omapdss_dss",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int dss_init_platform_driver(void)
+{
+        return platform_driver_register(&omap_dsshw_driver);
+}
+
+void dss_uninit_platform_driver(void)
+{
+        return platform_driver_unregister(&omap_dsshw_driver);
+}
diff --git a/drivers/video/omap2/dss/dss.h b/drivers/video/omap2/dss/dss.h
index b394951120ac..c2f582bb19c0 100644
--- a/drivers/video/omap2/dss/dss.h
+++ b/drivers/video/omap2/dss/dss.h
@@ -97,8 +97,6 @@ extern unsigned int dss_debug;
 #define FLD_MOD(orig, val, start, end) \
         (((orig) & ~FLD_MASK(start, end)) | FLD_VAL(val, start, end))
 
-#define DISPC_MAX_FCK 173000000
-
 enum omap_burst_size {
         OMAP_DSS_BURST_4x32 = 0,
         OMAP_DSS_BURST_8x32 = 1,
@@ -112,17 +110,25 @@ enum omap_parallel_interface_mode {
 };
 
 enum dss_clock {
-        DSS_CLK_ICK     = 1 << 0,
-        DSS_CLK_FCK1    = 1 << 1,
-        DSS_CLK_FCK2    = 1 << 2,
-        DSS_CLK_54M     = 1 << 3,
-        DSS_CLK_96M     = 1 << 4,
+        DSS_CLK_ICK     = 1 << 0,       /* DSS_L3_ICLK and DSS_L4_ICLK */
+        DSS_CLK_FCK     = 1 << 1,       /* DSS1_ALWON_FCLK */
+        DSS_CLK_SYSCK   = 1 << 2,       /* DSS2_ALWON_FCLK */
+        DSS_CLK_TVFCK   = 1 << 3,       /* DSS_TV_FCLK */
+        DSS_CLK_VIDFCK  = 1 << 4,       /* DSS_96M_FCLK*/
 };
 
 enum dss_clk_source {
-        DSS_SRC_DSI1_PLL_FCLK,
-        DSS_SRC_DSI2_PLL_FCLK,
-        DSS_SRC_DSS1_ALWON_FCLK,
+        DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC,        /* OMAP3: DSI1_PLL_FCLK
+                                                 * OMAP4: PLL1_CLK1 */
+        DSS_CLK_SRC_DSI_PLL_HSDIV_DSI,          /* OMAP3: DSI2_PLL_FCLK
+                                                 * OMAP4: PLL1_CLK2 */
+        DSS_CLK_SRC_FCK,                        /* OMAP2/3: DSS1_ALWON_FCLK
+                                                 * OMAP4: DSS_FCLK */
+};
+
+enum dss_hdmi_venc_clk_source_select {
+        DSS_VENC_TV_CLK = 0,
+        DSS_HDMI_M_PCLK = 1,
 };
 
 struct dss_clock_info {
@@ -148,36 +154,42 @@ struct dsi_clock_info {
         unsigned long fint;
         unsigned long clkin4ddr;
         unsigned long clkin;
-        unsigned long dsi1_pll_fclk;
-        unsigned long dsi2_pll_fclk;
-
+        unsigned long dsi_pll_hsdiv_dispc_clk;  /* OMAP3: DSI1_PLL_CLK
+                                                 * OMAP4: PLLx_CLK1 */
+        unsigned long dsi_pll_hsdiv_dsi_clk;    /* OMAP3: DSI2_PLL_CLK
+                                                 * OMAP4: PLLx_CLK2 */
         unsigned long lp_clk;
 
         /* dividers */
         u16 regn;
         u16 regm;
-        u16 regm3;
-        u16 regm4;
-
+        u16 regm_dispc; /* OMAP3: REGM3
+                         * OMAP4: REGM4 */
+        u16 regm_dsi;   /* OMAP3: REGM4
+                         * OMAP4: REGM5 */
         u16 lp_clk_div;
 
         u8 highfreq;
-        bool use_dss2_fck;
+        bool use_sys_clk;
+};
+
+/* HDMI PLL structure */
+struct hdmi_pll_info {
+        u16 regn;
+        u16 regm;
+        u32 regmf;
+        u16 regm2;
+        u16 regsd;
+        u16 dcofreq;
 };
 
 struct seq_file;
 struct platform_device;
 
 /* core */
-void dss_clk_enable(enum dss_clock clks);
-void dss_clk_disable(enum dss_clock clks);
-unsigned long dss_clk_get_rate(enum dss_clock clk);
-int dss_need_ctx_restore(void);
-void dss_dump_clocks(struct seq_file *s);
 struct bus_type *dss_get_bus(void);
 struct regulator *dss_get_vdds_dsi(void);
 struct regulator *dss_get_vdds_sdi(void);
-struct regulator *dss_get_vdda_dac(void);
 
 /* display */
 int dss_suspend_all_devices(void);
@@ -214,13 +226,23 @@ void dss_overlay_setup_l4_manager(struct omap_overlay_manager *mgr);
 void dss_recheck_connections(struct omap_dss_device *dssdev, bool force);
 
 /* DSS */
-int dss_init(bool skip_init);
-void dss_exit(void);
+int dss_init_platform_driver(void);
+void dss_uninit_platform_driver(void);
 
+void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select);
 void dss_save_context(void);
 void dss_restore_context(void);
+void dss_clk_enable(enum dss_clock clks);
+void dss_clk_disable(enum dss_clock clks);
+unsigned long dss_clk_get_rate(enum dss_clock clk);
+int dss_need_ctx_restore(void);
+const char *dss_get_generic_clk_source_name(enum dss_clk_source clk_src);
+void dss_dump_clocks(struct seq_file *s);
 
 void dss_dump_regs(struct seq_file *s);
+#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
+void dss_debug_dump_clocks(struct seq_file *s);
+#endif
 
 void dss_sdi_init(u8 datapairs);
 int dss_sdi_enable(void);
@@ -228,8 +250,11 @@ void dss_sdi_disable(void);
 
 void dss_select_dispc_clk_source(enum dss_clk_source clk_src);
 void dss_select_dsi_clk_source(enum dss_clk_source clk_src);
+void dss_select_lcd_clk_source(enum omap_channel channel,
+                enum dss_clk_source clk_src);
 enum dss_clk_source dss_get_dispc_clk_source(void);
 enum dss_clk_source dss_get_dsi_clk_source(void);
+enum dss_clk_source dss_get_lcd_clk_source(enum omap_channel channel);
 
 void dss_set_venc_output(enum omap_dss_venc_type type);
 void dss_set_dac_pwrdn_bgz(bool enable);
@@ -244,11 +269,11 @@ int dss_calc_clock_div(bool is_tft, unsigned long req_pck,
 
 /* SDI */
 #ifdef CONFIG_OMAP2_DSS_SDI
-int sdi_init(bool skip_init);
+int sdi_init(void);
 void sdi_exit(void);
 int sdi_init_display(struct omap_dss_device *display);
 #else
-static inline int sdi_init(bool skip_init)
+static inline int sdi_init(void)
 {
         return 0;
 }
@@ -259,8 +284,8 @@ static inline void sdi_exit(void)
 
 /* DSI */
 #ifdef CONFIG_OMAP2_DSS_DSI
-int dsi_init(struct platform_device *pdev);
-void dsi_exit(void);
+int dsi_init_platform_driver(void);
+void dsi_uninit_platform_driver(void);
 
 void dsi_dump_clocks(struct seq_file *s);
 void dsi_dump_irqs(struct seq_file *s);
@@ -271,7 +296,7 @@ void dsi_restore_context(void);
 
 int dsi_init_display(struct omap_dss_device *display);
 void dsi_irq_handler(void);
-unsigned long dsi_get_dsi1_pll_rate(void);
+unsigned long dsi_get_pll_hsdiv_dispc_rate(void);
 int dsi_pll_set_clock_div(struct dsi_clock_info *cinfo);
 int dsi_pll_calc_clock_div_pck(bool is_tft, unsigned long req_pck,
                 struct dsi_clock_info *cinfo,
@@ -282,31 +307,36 @@ void dsi_pll_uninit(void);
 void dsi_get_overlay_fifo_thresholds(enum omap_plane plane,
                 u32 fifo_size, enum omap_burst_size *burst_size,
                 u32 *fifo_low, u32 *fifo_high);
-void dsi_wait_dsi1_pll_active(void);
-void dsi_wait_dsi2_pll_active(void);
+void dsi_wait_pll_hsdiv_dispc_active(void);
+void dsi_wait_pll_hsdiv_dsi_active(void);
 #else
-static inline int dsi_init(struct platform_device *pdev)
+static inline int dsi_init_platform_driver(void)
 {
         return 0;
 }
-static inline void dsi_exit(void)
+static inline void dsi_uninit_platform_driver(void)
 {
 }
-static inline void dsi_wait_dsi1_pll_active(void)
+static inline unsigned long dsi_get_pll_hsdiv_dispc_rate(void)
 {
+        WARN("%s: DSI not compiled in, returning rate as 0\n", __func__);
+        return 0;
 }
-static inline void dsi_wait_dsi2_pll_active(void)
+static inline void dsi_wait_pll_hsdiv_dispc_active(void)
+{
+}
+static inline void dsi_wait_pll_hsdiv_dsi_active(void)
 {
 }
 #endif
 
 /* DPI */
 #ifdef CONFIG_OMAP2_DSS_DPI
-int dpi_init(struct platform_device *pdev);
+int dpi_init(void);
 void dpi_exit(void);
 int dpi_init_display(struct omap_dss_device *dssdev);
 #else
-static inline int dpi_init(struct platform_device *pdev)
+static inline int dpi_init(void)
 {
         return 0;
 }
@@ -316,8 +346,8 @@ static inline void dpi_exit(void)
 #endif
 
 /* DISPC */
-int dispc_init(void);
-void dispc_exit(void);
+int dispc_init_platform_driver(void);
+void dispc_uninit_platform_driver(void);
 void dispc_dump_clocks(struct seq_file *s);
 void dispc_dump_irqs(struct seq_file *s);
 void dispc_dump_regs(struct seq_file *s);
@@ -350,6 +380,7 @@ void dispc_set_plane_size(enum omap_plane plane, u16 width, u16 height);
 void dispc_set_channel_out(enum omap_plane plane,
                 enum omap_channel channel_out);
 
+void dispc_enable_gamma_table(bool enable);
 int dispc_setup_plane(enum omap_plane plane,
                       u32 paddr, u16 screen_width,
                       u16 pos_x, u16 pos_y,
@@ -409,24 +440,50 @@ int dispc_get_clock_div(enum omap_channel channel,
 
 /* VENC */
 #ifdef CONFIG_OMAP2_DSS_VENC
-int venc_init(struct platform_device *pdev);
-void venc_exit(void);
+int venc_init_platform_driver(void);
+void venc_uninit_platform_driver(void);
 void venc_dump_regs(struct seq_file *s);
 int venc_init_display(struct omap_dss_device *display);
 #else
-static inline int venc_init(struct platform_device *pdev)
+static inline int venc_init_platform_driver(void)
+{
+        return 0;
+}
+static inline void venc_uninit_platform_driver(void)
+{
+}
+#endif
+
+/* HDMI */
+#ifdef CONFIG_OMAP4_DSS_HDMI
+int hdmi_init_platform_driver(void);
+void hdmi_uninit_platform_driver(void);
+int hdmi_init_display(struct omap_dss_device *dssdev);
+#else
+static inline int hdmi_init_display(struct omap_dss_device *dssdev)
+{
+        return 0;
+}
+static inline int hdmi_init_platform_driver(void)
 {
         return 0;
 }
-static inline void venc_exit(void)
+static inline void hdmi_uninit_platform_driver(void)
 {
 }
 #endif
+int omapdss_hdmi_display_enable(struct omap_dss_device *dssdev);
+void omapdss_hdmi_display_disable(struct omap_dss_device *dssdev);
+void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev);
+int omapdss_hdmi_display_check_timing(struct omap_dss_device *dssdev,
+                                        struct omap_video_timings *timings);
+int hdmi_panel_init(void);
+void hdmi_panel_exit(void);
 
 /* RFBI */
 #ifdef CONFIG_OMAP2_DSS_RFBI
-int rfbi_init(void);
-void rfbi_exit(void);
+int rfbi_init_platform_driver(void);
+void rfbi_uninit_platform_driver(void);
 void rfbi_dump_regs(struct seq_file *s);
 
 int rfbi_configure(int rfbi_module, int bpp, int lines);
@@ -437,11 +494,11 @@ void rfbi_set_timings(int rfbi_module, struct rfbi_timings *t);
 unsigned long rfbi_get_max_tx_rate(void);
 int rfbi_init_display(struct omap_dss_device *display);
 #else
-static inline int rfbi_init(void)
+static inline int rfbi_init_platform_driver(void)
 {
         return 0;
 }
-static inline void rfbi_exit(void)
+static inline void rfbi_uninit_platform_driver(void)
 {
 }
 #endif
diff --git a/drivers/video/omap2/dss/dss_features.c b/drivers/video/omap2/dss/dss_features.c
index cf3ef696e141..aa1622241d0d 100644
--- a/drivers/video/omap2/dss/dss_features.c
+++ b/drivers/video/omap2/dss/dss_features.c
@@ -25,14 +25,18 @@
 #include <plat/display.h>
 #include <plat/cpu.h>
 
+#include "dss.h"
 #include "dss_features.h"
 
 /* Defines a generic omap register field */
 struct dss_reg_field {
-        enum dss_feat_reg_field id;
         u8 start, end;
 };
 
+struct dss_param_range {
+        int min, max;
+};
+
 struct omap_dss_features {
         const struct dss_reg_field *reg_fields;
         const int num_reg_fields;
@@ -43,29 +47,68 @@ struct omap_dss_features {
         const int num_ovls;
         const enum omap_display_type *supported_displays;
         const enum omap_color_mode *supported_color_modes;
+        const char * const *clksrc_names;
+        const struct dss_param_range *dss_params;
 };
 
 /* This struct is assigned to one of the below during initialization */
 static struct omap_dss_features *omap_current_dss_features;
 
 static const struct dss_reg_field omap2_dss_reg_fields[] = {
-        { FEAT_REG_FIRHINC, 11, 0 },
-        { FEAT_REG_FIRVINC, 27, 16 },
-        { FEAT_REG_FIFOLOWTHRESHOLD, 8, 0 },
-        { FEAT_REG_FIFOHIGHTHRESHOLD, 24, 16 },
-        { FEAT_REG_FIFOSIZE, 8, 0 },
+        [FEAT_REG_FIRHINC]                      = { 11, 0 },
+        [FEAT_REG_FIRVINC]                      = { 27, 16 },
+        [FEAT_REG_FIFOLOWTHRESHOLD]             = { 8, 0 },
+        [FEAT_REG_FIFOHIGHTHRESHOLD]            = { 24, 16 },
+        [FEAT_REG_FIFOSIZE]                     = { 8, 0 },
+        [FEAT_REG_HORIZONTALACCU]               = { 9, 0 },
+        [FEAT_REG_VERTICALACCU]                 = { 25, 16 },
+        [FEAT_REG_DISPC_CLK_SWITCH]             = { 0, 0 },
+        [FEAT_REG_DSIPLL_REGN]                  = { 0, 0 },
+        [FEAT_REG_DSIPLL_REGM]                  = { 0, 0 },
+        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 0, 0 },
+        [FEAT_REG_DSIPLL_REGM_DSI]              = { 0, 0 },
 };
 
 static const struct dss_reg_field omap3_dss_reg_fields[] = {
-        { FEAT_REG_FIRHINC, 12, 0 },
-        { FEAT_REG_FIRVINC, 28, 16 },
-        { FEAT_REG_FIFOLOWTHRESHOLD, 11, 0 },
-        { FEAT_REG_FIFOHIGHTHRESHOLD, 27, 16 },
-        { FEAT_REG_FIFOSIZE, 10, 0 },
+        [FEAT_REG_FIRHINC]                      = { 12, 0 },
+        [FEAT_REG_FIRVINC]                      = { 28, 16 },
+        [FEAT_REG_FIFOLOWTHRESHOLD]             = { 11, 0 },
+        [FEAT_REG_FIFOHIGHTHRESHOLD]            = { 27, 16 },
+        [FEAT_REG_FIFOSIZE]                     = { 10, 0 },
+        [FEAT_REG_HORIZONTALACCU]               = { 9, 0 },
+        [FEAT_REG_VERTICALACCU]                 = { 25, 16 },
+        [FEAT_REG_DISPC_CLK_SWITCH]             = { 0, 0 },
+        [FEAT_REG_DSIPLL_REGN]                  = { 7, 1 },
+        [FEAT_REG_DSIPLL_REGM]                  = { 18, 8 },
+        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 22, 19 },
+        [FEAT_REG_DSIPLL_REGM_DSI]              = { 26, 23 },
+};
+
+static const struct dss_reg_field omap4_dss_reg_fields[] = {
+        [FEAT_REG_FIRHINC]                      = { 12, 0 },
+        [FEAT_REG_FIRVINC]                      = { 28, 16 },
+        [FEAT_REG_FIFOLOWTHRESHOLD]             = { 15, 0 },
+        [FEAT_REG_FIFOHIGHTHRESHOLD]            = { 31, 16 },
+        [FEAT_REG_FIFOSIZE]                     = { 15, 0 },
+        [FEAT_REG_HORIZONTALACCU]               = { 10, 0 },
+        [FEAT_REG_VERTICALACCU]                 = { 26, 16 },
+        [FEAT_REG_DISPC_CLK_SWITCH]             = { 9, 8 },
+        [FEAT_REG_DSIPLL_REGN]                  = { 8, 1 },
+        [FEAT_REG_DSIPLL_REGM]                  = { 20, 9 },
+        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 25, 21 },
+        [FEAT_REG_DSIPLL_REGM_DSI]              = { 30, 26 },
 };
 
 static const enum omap_display_type omap2_dss_supported_displays[] = {
         /* OMAP_DSS_CHANNEL_LCD */
+        OMAP_DISPLAY_TYPE_DPI | OMAP_DISPLAY_TYPE_DBI,
+
+        /* OMAP_DSS_CHANNEL_DIGIT */
+        OMAP_DISPLAY_TYPE_VENC,
+};
+
+static const enum omap_display_type omap3430_dss_supported_displays[] = {
+        /* OMAP_DSS_CHANNEL_LCD */
         OMAP_DISPLAY_TYPE_DPI | OMAP_DISPLAY_TYPE_DBI |
         OMAP_DISPLAY_TYPE_SDI | OMAP_DISPLAY_TYPE_DSI,
 
@@ -73,10 +116,10 @@ static const enum omap_display_type omap2_dss_supported_displays[] = {
         OMAP_DISPLAY_TYPE_VENC,
 };
 
-static const enum omap_display_type omap3_dss_supported_displays[] = {
+static const enum omap_display_type omap3630_dss_supported_displays[] = {
         /* OMAP_DSS_CHANNEL_LCD */
         OMAP_DISPLAY_TYPE_DPI | OMAP_DISPLAY_TYPE_DBI |
-        OMAP_DISPLAY_TYPE_SDI | OMAP_DISPLAY_TYPE_DSI,
+        OMAP_DISPLAY_TYPE_DSI,
 
         /* OMAP_DSS_CHANNEL_DIGIT */
         OMAP_DISPLAY_TYPE_VENC,
@@ -87,7 +130,7 @@ static const enum omap_display_type omap4_dss_supported_displays[] = {
         OMAP_DISPLAY_TYPE_DBI | OMAP_DISPLAY_TYPE_DSI,
 
         /* OMAP_DSS_CHANNEL_DIGIT */
-        OMAP_DISPLAY_TYPE_VENC,
+        OMAP_DISPLAY_TYPE_VENC | OMAP_DISPLAY_TYPE_HDMI,
 
         /* OMAP_DSS_CHANNEL_LCD2 */
         OMAP_DISPLAY_TYPE_DPI | OMAP_DISPLAY_TYPE_DBI |
@@ -134,6 +177,54 @@ static const enum omap_color_mode omap3_dss_supported_color_modes[] = {
         OMAP_DSS_COLOR_RGBA32 | OMAP_DSS_COLOR_RGBX32,
 };
 
+static const char * const omap2_dss_clk_source_names[] = {
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC]       = "N/A",
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DSI]         = "N/A",
+        [DSS_CLK_SRC_FCK]                       = "DSS_FCLK1",
+};
+
+static const char * const omap3_dss_clk_source_names[] = {
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC]       = "DSI1_PLL_FCLK",
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DSI]         = "DSI2_PLL_FCLK",
+        [DSS_CLK_SRC_FCK]                       = "DSS1_ALWON_FCLK",
+};
+
+static const char * const omap4_dss_clk_source_names[] = {
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC]       = "PLL1_CLK1",
+        [DSS_CLK_SRC_DSI_PLL_HSDIV_DSI]         = "PLL1_CLK2",
+        [DSS_CLK_SRC_FCK]                       = "DSS_FCLK",
+};
+
+static const struct dss_param_range omap2_dss_param_range[] = {
+        [FEAT_PARAM_DSS_FCK]                    = { 0, 173000000 },
+        [FEAT_PARAM_DSIPLL_REGN]                = { 0, 0 },
+        [FEAT_PARAM_DSIPLL_REGM]                = { 0, 0 },
+        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, 0 },
+        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, 0 },
+        [FEAT_PARAM_DSIPLL_FINT]                = { 0, 0 },
+        [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, 0 },
+};
+
+static const struct dss_param_range omap3_dss_param_range[] = {
+        [FEAT_PARAM_DSS_FCK]                    = { 0, 173000000 },
+        [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 7) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 11) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 4) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 4) - 1 },
+        [FEAT_PARAM_DSIPLL_FINT]                = { 750000, 2100000 },
+        [FEAT_PARAM_DSIPLL_LPDIV]               = { 1, (1 << 13) - 1},
+};
+
+static const struct dss_param_range omap4_dss_param_range[] = {
+        [FEAT_PARAM_DSS_FCK]                    = { 0, 186000000 },
+        [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 8) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 12) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 5) - 1 },
+        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 5) - 1 },
+        [FEAT_PARAM_DSIPLL_FINT]                = { 500000, 2500000 },
+        [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, (1 << 13) - 1 },
+};
+
 /* OMAP2 DSS Features */
 static struct omap_dss_features omap2_dss_features = {
         .reg_fields = omap2_dss_reg_fields,
@@ -141,12 +232,15 @@ static struct omap_dss_features omap2_dss_features = {
 
         .has_feature    =
                 FEAT_LCDENABLEPOL | FEAT_LCDENABLESIGNAL |
-                FEAT_PCKFREEENABLE | FEAT_FUNCGATED,
+                FEAT_PCKFREEENABLE | FEAT_FUNCGATED |
+                FEAT_ROWREPEATENABLE | FEAT_RESIZECONF,
 
         .num_mgrs = 2,
         .num_ovls = 3,
         .supported_displays = omap2_dss_supported_displays,
         .supported_color_modes = omap2_dss_supported_color_modes,
+        .clksrc_names = omap2_dss_clk_source_names,
+        .dss_params = omap2_dss_param_range,
 };
 
 /* OMAP3 DSS Features */
@@ -157,12 +251,15 @@ static struct omap_dss_features omap3430_dss_features = {
         .has_feature    =
                 FEAT_GLOBAL_ALPHA | FEAT_LCDENABLEPOL |
                 FEAT_LCDENABLESIGNAL | FEAT_PCKFREEENABLE |
-                FEAT_FUNCGATED,
+                FEAT_FUNCGATED | FEAT_ROWREPEATENABLE |
+                FEAT_LINEBUFFERSPLIT | FEAT_RESIZECONF,
 
         .num_mgrs = 2,
         .num_ovls = 3,
-        .supported_displays = omap3_dss_supported_displays,
+        .supported_displays = omap3430_dss_supported_displays,
         .supported_color_modes = omap3_dss_supported_color_modes,
+        .clksrc_names = omap3_dss_clk_source_names,
+        .dss_params = omap3_dss_param_range,
 };
 
 static struct omap_dss_features omap3630_dss_features = {
@@ -172,27 +269,34 @@ static struct omap_dss_features omap3630_dss_features = {
         .has_feature    =
                 FEAT_GLOBAL_ALPHA | FEAT_LCDENABLEPOL |
                 FEAT_LCDENABLESIGNAL | FEAT_PCKFREEENABLE |
-                FEAT_PRE_MULT_ALPHA | FEAT_FUNCGATED,
+                FEAT_PRE_MULT_ALPHA | FEAT_FUNCGATED |
+                FEAT_ROWREPEATENABLE | FEAT_LINEBUFFERSPLIT |
+                FEAT_RESIZECONF,
 
         .num_mgrs = 2,
         .num_ovls = 3,
-        .supported_displays = omap3_dss_supported_displays,
+        .supported_displays = omap3630_dss_supported_displays,
         .supported_color_modes = omap3_dss_supported_color_modes,
+        .clksrc_names = omap3_dss_clk_source_names,
+        .dss_params = omap3_dss_param_range,
 };
 
 /* OMAP4 DSS Features */
 static struct omap_dss_features omap4_dss_features = {
-        .reg_fields = omap3_dss_reg_fields,
-        .num_reg_fields = ARRAY_SIZE(omap3_dss_reg_fields),
+        .reg_fields = omap4_dss_reg_fields,
+        .num_reg_fields = ARRAY_SIZE(omap4_dss_reg_fields),
 
         .has_feature    =
                 FEAT_GLOBAL_ALPHA | FEAT_PRE_MULT_ALPHA |
-                FEAT_MGR_LCD2,
+                FEAT_MGR_LCD2 | FEAT_GLOBAL_ALPHA_VID1 |
+                FEAT_CORE_CLK_DIV | FEAT_LCD_CLK_SRC,
 
         .num_mgrs = 3,
         .num_ovls = 3,
         .supported_displays = omap4_dss_supported_displays,
         .supported_color_modes = omap3_dss_supported_color_modes,
+        .clksrc_names = omap4_dss_clk_source_names,
+        .dss_params = omap4_dss_param_range,
 };
 
 /* Functions returning values related to a DSS feature */
@@ -206,6 +310,16 @@ int dss_feat_get_num_ovls(void)
         return omap_current_dss_features->num_ovls;
 }
 
+unsigned long dss_feat_get_param_min(enum dss_range_param param)
+{
+        return omap_current_dss_features->dss_params[param].min;
+}
+
+unsigned long dss_feat_get_param_max(enum dss_range_param param)
+{
+        return omap_current_dss_features->dss_params[param].max;
+}
+
 enum omap_display_type dss_feat_get_supported_displays(enum omap_channel channel)
 {
         return omap_current_dss_features->supported_displays[channel];
@@ -223,6 +337,11 @@ bool dss_feat_color_mode_supported(enum omap_plane plane,
                         color_mode;
 }
 
+const char *dss_feat_get_clk_source_name(enum dss_clk_source id)
+{
+        return omap_current_dss_features->clksrc_names[id];
+}
+
 /* DSS has_feature check */
 bool dss_has_feature(enum dss_feat_id id)
 {
diff --git a/drivers/video/omap2/dss/dss_features.h b/drivers/video/omap2/dss/dss_features.h
index b9c70be92588..12e9c4ef0dec 100644
--- a/drivers/video/omap2/dss/dss_features.h
+++ b/drivers/video/omap2/dss/dss_features.h
@@ -22,6 +22,7 @@
 
 #define MAX_DSS_MANAGERS        3
 #define MAX_DSS_OVERLAYS        3
+#define MAX_DSS_LCD_MANAGERS    2
 
 /* DSS has feature id */
 enum dss_feat_id {
@@ -33,6 +34,12 @@ enum dss_feat_id {
         FEAT_PCKFREEENABLE      = 1 << 5,
         FEAT_FUNCGATED          = 1 << 6,
         FEAT_MGR_LCD2           = 1 << 7,
+        FEAT_LINEBUFFERSPLIT    = 1 << 8,
+        FEAT_ROWREPEATENABLE    = 1 << 9,
+        FEAT_RESIZECONF         = 1 << 10,
+        /* Independent core clk divider */
+        FEAT_CORE_CLK_DIV       = 1 << 11,
+        FEAT_LCD_CLK_SRC        = 1 << 12,
 };
 
 /* DSS register field id */
@@ -42,15 +49,35 @@ enum dss_feat_reg_field {
         FEAT_REG_FIFOHIGHTHRESHOLD,
         FEAT_REG_FIFOLOWTHRESHOLD,
         FEAT_REG_FIFOSIZE,
+        FEAT_REG_HORIZONTALACCU,
+        FEAT_REG_VERTICALACCU,
+        FEAT_REG_DISPC_CLK_SWITCH,
+        FEAT_REG_DSIPLL_REGN,
+        FEAT_REG_DSIPLL_REGM,
+        FEAT_REG_DSIPLL_REGM_DISPC,
+        FEAT_REG_DSIPLL_REGM_DSI,
+};
+
+enum dss_range_param {
+        FEAT_PARAM_DSS_FCK,
+        FEAT_PARAM_DSIPLL_REGN,
+        FEAT_PARAM_DSIPLL_REGM,
+        FEAT_PARAM_DSIPLL_REGM_DISPC,
+        FEAT_PARAM_DSIPLL_REGM_DSI,
+        FEAT_PARAM_DSIPLL_FINT,
+        FEAT_PARAM_DSIPLL_LPDIV,
 };
 
 /* DSS Feature Functions */
 int dss_feat_get_num_mgrs(void);
 int dss_feat_get_num_ovls(void);
+unsigned long dss_feat_get_param_min(enum dss_range_param param);
+unsigned long dss_feat_get_param_max(enum dss_range_param param);
 enum omap_display_type dss_feat_get_supported_displays(enum omap_channel channel);
 enum omap_color_mode dss_feat_get_supported_color_modes(enum omap_plane plane);
 bool dss_feat_color_mode_supported(enum omap_plane plane,
                 enum omap_color_mode color_mode);
+const char *dss_feat_get_clk_source_name(enum dss_clk_source id);
 
 bool dss_has_feature(enum dss_feat_id id);
 void dss_feat_get_reg_field(enum dss_feat_reg_field id, u8 *start, u8 *end);
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
new file mode 100644
index 000000000000..a981def8099a
--- /dev/null
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -0,0 +1,1332 @@
+/*
+ * hdmi.c
+ *
+ * HDMI interface DSS driver setting for TI's OMAP4 family of processor.
+ * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
+ * Authors: Yong Zhi
+ *      Mythri pk <mythripk@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define DSS_SUBSYS_NAME "HDMI"
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/mutex.h>
+#include <linux/delay.h>
+#include <linux/string.h>
+#include <plat/display.h>
+
+#include "dss.h"
+#include "hdmi.h"
+
+static struct {
+        struct mutex lock;
+        struct omap_display_platform_data *pdata;
+        struct platform_device *pdev;
+        void __iomem *base_wp;  /* HDMI wrapper */
+        int code;
+        int mode;
+        u8 edid[HDMI_EDID_MAX_LENGTH];
+        u8 edid_set;
+        bool custom_set;
+        struct hdmi_config cfg;
+} hdmi;
+
+/*
+ * Logic for the below structure :
+ * user enters the CEA or VESA timings by specifying the HDMI/DVI code.
+ * There is a correspondence between CEA/VESA timing and code, please
+ * refer to section 6.3 in HDMI 1.3 specification for timing code.
+ *
+ * In the below structure, cea_vesa_timings corresponds to all OMAP4
+ * supported CEA and VESA timing values.code_cea corresponds to the CEA
+ * code, It is used to get the timing from cea_vesa_timing array.Similarly
+ * with code_vesa. Code_index is used for back mapping, that is once EDID
+ * is read from the TV, EDID is parsed to find the timing values and then
+ * map it to corresponding CEA or VESA index.
+ */
+
+static const struct hdmi_timings cea_vesa_timings[OMAP_HDMI_TIMINGS_NB] = {
+        { {640, 480, 25200, 96, 16, 48, 2, 10, 33} , 0 , 0},
+        { {1280, 720, 74250, 40, 440, 220, 5, 5, 20}, 1, 1},
+        { {1280, 720, 74250, 40, 110, 220, 5, 5, 20}, 1, 1},
+        { {720, 480, 27027, 62, 16, 60, 6, 9, 30}, 0, 0},
+        { {2880, 576, 108000, 256, 48, 272, 5, 5, 39}, 0, 0},
+        { {1440, 240, 27027, 124, 38, 114, 3, 4, 15}, 0, 0},
+        { {1440, 288, 27000, 126, 24, 138, 3, 2, 19}, 0, 0},
+        { {1920, 540, 74250, 44, 528, 148, 5, 2, 15}, 1, 1},
+        { {1920, 540, 74250, 44, 88, 148, 5, 2, 15}, 1, 1},
+        { {1920, 1080, 148500, 44, 88, 148, 5, 4, 36}, 1, 1},
+        { {720, 576, 27000, 64, 12, 68, 5, 5, 39}, 0, 0},
+        { {1440, 576, 54000, 128, 24, 136, 5, 5, 39}, 0, 0},
+        { {1920, 1080, 148500, 44, 528, 148, 5, 4, 36}, 1, 1},
+        { {2880, 480, 108108, 248, 64, 240, 6, 9, 30}, 0, 0},
+        { {1920, 1080, 74250, 44, 638, 148, 5, 4, 36}, 1, 1},
+        /* VESA From Here */
+        { {640, 480, 25175, 96, 16, 48, 2 , 11, 31}, 0, 0},
+        { {800, 600, 40000, 128, 40, 88, 4 , 1, 23}, 1, 1},
+        { {848, 480, 33750, 112, 16, 112, 8 , 6, 23}, 1, 1},
+        { {1280, 768, 79500, 128, 64, 192, 7 , 3, 20}, 1, 0},
+        { {1280, 800, 83500, 128, 72, 200, 6 , 3, 22}, 1, 0},
+        { {1360, 768, 85500, 112, 64, 256, 6 , 3, 18}, 1, 1},
+        { {1280, 960, 108000, 112, 96, 312, 3 , 1, 36}, 1, 1},
+        { {1280, 1024, 108000, 112, 48, 248, 3 , 1, 38}, 1, 1},
+        { {1024, 768, 65000, 136, 24, 160, 6, 3, 29}, 0, 0},
+        { {1400, 1050, 121750, 144, 88, 232, 4, 3, 32}, 1, 0},
+        { {1440, 900, 106500, 152, 80, 232, 6, 3, 25}, 1, 0},
+        { {1680, 1050, 146250, 176 , 104, 280, 6, 3, 30}, 1, 0},
+        { {1366, 768, 85500, 143, 70, 213, 3, 3, 24}, 1, 1},
+        { {1920, 1080, 148500, 44, 148, 80, 5, 4, 36}, 1, 1},
+        { {1280, 768, 68250, 32, 48, 80, 7, 3, 12}, 0, 1},
+        { {1400, 1050, 101000, 32, 48, 80, 4, 3, 23}, 0, 1},
+        { {1680, 1050, 119000, 32, 48, 80, 6, 3, 21}, 0, 1},
+        { {1280, 800, 79500, 32, 48, 80, 6, 3, 14}, 0, 1},
+        { {1280, 720, 74250, 40, 110, 220, 5, 5, 20}, 1, 1}
+};
+
+/*
+ * This is a static mapping array which maps the timing values
+ * with corresponding CEA / VESA code
+ */
+static const int code_index[OMAP_HDMI_TIMINGS_NB] = {
+        1, 19, 4, 2, 37, 6, 21, 20, 5, 16, 17, 29, 31, 35, 32,
+        /* <--15 CEA 17--> vesa*/
+        4, 9, 0xE, 0x17, 0x1C, 0x27, 0x20, 0x23, 0x10, 0x2A,
+        0X2F, 0x3A, 0X51, 0X52, 0x16, 0x29, 0x39, 0x1B
+};
+
+/*
+ * This is reverse static mapping which maps the CEA / VESA code
+ * to the corresponding timing values
+ */
+static const int code_cea[39] = {
+        -1,  0,  3,  3,  2,  8,  5,  5, -1, -1,
+        -1, -1, -1, -1, -1, -1,  9, 10, 10,  1,
+        7,   6,  6, -1, -1, -1, -1, -1, -1, 11,
+        11, 12, 14, -1, -1, 13, 13,  4,  4
+};
+
+static const int code_vesa[85] = {
+        -1, -1, -1, -1, 15, -1, -1, -1, -1, 16,
+        -1, -1, -1, -1, 17, -1, 23, -1, -1, -1,
+        -1, -1, 29, 18, -1, -1, -1, 32, 19, -1,
+        -1, -1, 21, -1, -1, 22, -1, -1, -1, 20,
+        -1, 30, 24, -1, -1, -1, -1, 25, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, 31, 26, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, 27, 28, -1, 33};
+
+static const u8 edid_header[8] = {0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0};
+
+static inline void hdmi_write_reg(const struct hdmi_reg idx, u32 val)
+{
+        __raw_writel(val, hdmi.base_wp + idx.idx);
+}
+
+static inline u32 hdmi_read_reg(const struct hdmi_reg idx)
+{
+        return __raw_readl(hdmi.base_wp + idx.idx);
+}
+
+static inline int hdmi_wait_for_bit_change(const struct hdmi_reg idx,
+                                int b2, int b1, u32 val)
+{
+        u32 t = 0;
+        while (val != REG_GET(idx, b2, b1)) {
+                udelay(1);
+                if (t++ > 10000)
+                        return !val;
+        }
+        return val;
+}
+
+int hdmi_init_display(struct omap_dss_device *dssdev)
+{
+        DSSDBG("init_display\n");
+
+        return 0;
+}
+
+static int hdmi_pll_init(enum hdmi_clk_refsel refsel, int dcofreq,
+                struct hdmi_pll_info *fmt, u16 sd)
+{
+        u32 r;
+
+        /* PLL start always use manual mode */
+        REG_FLD_MOD(PLLCTRL_PLL_CONTROL, 0x0, 0, 0);
+
+        r = hdmi_read_reg(PLLCTRL_CFG1);
+        r = FLD_MOD(r, fmt->regm, 20, 9); /* CFG1_PLL_REGM */
+        r = FLD_MOD(r, fmt->regn, 8, 1);  /* CFG1_PLL_REGN */
+
+        hdmi_write_reg(PLLCTRL_CFG1, r);
+
+        r = hdmi_read_reg(PLLCTRL_CFG2);
+
+        r = FLD_MOD(r, 0x0, 12, 12); /* PLL_HIGHFREQ divide by 2 */
+        r = FLD_MOD(r, 0x1, 13, 13); /* PLL_REFEN */
+        r = FLD_MOD(r, 0x0, 14, 14); /* PHY_CLKINEN de-assert during locking */
+
+        if (dcofreq) {
+                /* divider programming for frequency beyond 1000Mhz */
+                REG_FLD_MOD(PLLCTRL_CFG3, sd, 17, 10);
+                r = FLD_MOD(r, 0x4, 3, 1); /* 1000MHz and 2000MHz */
+        } else {
+                r = FLD_MOD(r, 0x2, 3, 1); /* 500MHz and 1000MHz */
+        }
+
+        hdmi_write_reg(PLLCTRL_CFG2, r);
+
+        r = hdmi_read_reg(PLLCTRL_CFG4);
+        r = FLD_MOD(r, fmt->regm2, 24, 18);
+        r = FLD_MOD(r, fmt->regmf, 17, 0);
+
+        hdmi_write_reg(PLLCTRL_CFG4, r);
+
+        /* go now */
+        REG_FLD_MOD(PLLCTRL_PLL_GO, 0x1, 0, 0);
+
+        /* wait for bit change */
+        if (hdmi_wait_for_bit_change(PLLCTRL_PLL_GO, 0, 0, 1) != 1) {
+                DSSERR("PLL GO bit not set\n");
+                return -ETIMEDOUT;
+        }
+
+        /* Wait till the lock bit is set in PLL status */
+        if (hdmi_wait_for_bit_change(PLLCTRL_PLL_STATUS, 1, 1, 1) != 1) {
+                DSSWARN("cannot lock PLL\n");
+                DSSWARN("CFG1 0x%x\n",
+                        hdmi_read_reg(PLLCTRL_CFG1));
+                DSSWARN("CFG2 0x%x\n",
+                        hdmi_read_reg(PLLCTRL_CFG2));
+                DSSWARN("CFG4 0x%x\n",
+                        hdmi_read_reg(PLLCTRL_CFG4));
+                return -ETIMEDOUT;
+        }
+
+        DSSDBG("PLL locked!\n");
+
+        return 0;
+}
+
+/* PHY_PWR_CMD */
+static int hdmi_set_phy_pwr(enum hdmi_phy_pwr val)
+{
+        /* Command for power control of HDMI PHY */
+        REG_FLD_MOD(HDMI_WP_PWR_CTRL, val, 7, 6);
+
+        /* Status of the power control of HDMI PHY */
+        if (hdmi_wait_for_bit_change(HDMI_WP_PWR_CTRL, 5, 4, val) != val) {
+                DSSERR("Failed to set PHY power mode to %d\n", val);
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+/* PLL_PWR_CMD */
+static int hdmi_set_pll_pwr(enum hdmi_pll_pwr val)
+{
+        /* Command for power control of HDMI PLL */
+        REG_FLD_MOD(HDMI_WP_PWR_CTRL, val, 3, 2);
+
+        /* wait till PHY_PWR_STATUS is set */
+        if (hdmi_wait_for_bit_change(HDMI_WP_PWR_CTRL, 1, 0, val) != val) {
+                DSSERR("Failed to set PHY_PWR_STATUS\n");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static int hdmi_pll_reset(void)
+{
+        /* SYSRESET  controlled by power FSM */
+        REG_FLD_MOD(PLLCTRL_PLL_CONTROL, 0x0, 3, 3);
+
+        /* READ 0x0 reset is in progress */
+        if (hdmi_wait_for_bit_change(PLLCTRL_PLL_STATUS, 0, 0, 1) != 1) {
+                DSSERR("Failed to sysreset PLL\n");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static int hdmi_phy_init(void)
+{
+        u16 r = 0;
+
+        r = hdmi_set_phy_pwr(HDMI_PHYPWRCMD_LDOON);
+        if (r)
+                return r;
+
+        r = hdmi_set_phy_pwr(HDMI_PHYPWRCMD_TXON);
+        if (r)
+                return r;
+
+        /*
+         * Read address 0 in order to get the SCP reset done completed
+         * Dummy access performed to make sure reset is done
+         */
+        hdmi_read_reg(HDMI_TXPHY_TX_CTRL);
+
+        /*
+         * Write to phy address 0 to configure the clock
+         * use HFBITCLK write HDMI_TXPHY_TX_CONTROL_FREQOUT field
+         */
+        REG_FLD_MOD(HDMI_TXPHY_TX_CTRL, 0x1, 31, 30);
+
+        /* Write to phy address 1 to start HDMI line (TXVALID and TMDSCLKEN) */
+        hdmi_write_reg(HDMI_TXPHY_DIGITAL_CTRL, 0xF0000000);
+
+        /* Setup max LDO voltage */
+        REG_FLD_MOD(HDMI_TXPHY_POWER_CTRL, 0xB, 3, 0);
+
+        /* Write to phy address 3 to change the polarity control */
+        REG_FLD_MOD(HDMI_TXPHY_PAD_CFG_CTRL, 0x1, 27, 27);
+
+        return 0;
+}
+
+static int hdmi_wait_softreset(void)
+{
+        /* reset W1 */
+        REG_FLD_MOD(HDMI_WP_SYSCONFIG, 0x1, 0, 0);
+
+        /* wait till SOFTRESET == 0 */
+        if (hdmi_wait_for_bit_change(HDMI_WP_SYSCONFIG, 0, 0, 0) != 0) {
+                DSSERR("sysconfig reset failed\n");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static int hdmi_pll_program(struct hdmi_pll_info *fmt)
+{
+        u16 r = 0;
+        enum hdmi_clk_refsel refsel;
+
+        /* wait for wrapper reset */
+        r = hdmi_wait_softreset();
+        if (r)
+                return r;
+
+        r = hdmi_set_pll_pwr(HDMI_PLLPWRCMD_ALLOFF);
+        if (r)
+                return r;
+
+        r = hdmi_set_pll_pwr(HDMI_PLLPWRCMD_BOTHON_ALLCLKS);
+        if (r)
+                return r;
+
+        r = hdmi_pll_reset();
+        if (r)
+                return r;
+
+        refsel = HDMI_REFSEL_SYSCLK;
+
+        r = hdmi_pll_init(refsel, fmt->dcofreq, fmt, fmt->regsd);
+        if (r)
+                return r;
+
+        return 0;
+}
+
+static void hdmi_phy_off(void)
+{
+        hdmi_set_phy_pwr(HDMI_PHYPWRCMD_OFF);
+}
+
+static int hdmi_core_ddc_edid(u8 *pedid, int ext)
+{
+        u32 i, j;
+        char checksum = 0;
+        u32 offset = 0;
+
+        /* Turn on CLK for DDC */
+        REG_FLD_MOD(HDMI_CORE_AV_DPD, 0x7, 2, 0);
+
+        /*
+         * SW HACK : Without the Delay DDC(i2c bus) reads 0 values /
+         * right shifted values( The behavior is not consistent and seen only
+         * with some TV's)
+         */
+        usleep_range(800, 1000);
+
+        if (!ext) {
+                /* Clk SCL Devices */
+                REG_FLD_MOD(HDMI_CORE_DDC_CMD, 0xA, 3, 0);
+
+                /* HDMI_CORE_DDC_STATUS_IN_PROG */
+                if (hdmi_wait_for_bit_change(HDMI_CORE_DDC_STATUS,
+                                                4, 4, 0) != 0) {
+                        DSSERR("Failed to program DDC\n");
+                        return -ETIMEDOUT;
+                }
+
+                /* Clear FIFO */
+                REG_FLD_MOD(HDMI_CORE_DDC_CMD, 0x9, 3, 0);
+
+                /* HDMI_CORE_DDC_STATUS_IN_PROG */
+                if (hdmi_wait_for_bit_change(HDMI_CORE_DDC_STATUS,
+                                                4, 4, 0) != 0) {
+                        DSSERR("Failed to program DDC\n");
+                        return -ETIMEDOUT;
+                }
+
+        } else {
+                if (ext % 2 != 0)
+                        offset = 0x80;
+        }
+
+        /* Load Segment Address Register */
+        REG_FLD_MOD(HDMI_CORE_DDC_SEGM, ext/2, 7, 0);
+
+        /* Load Slave Address Register */
+        REG_FLD_MOD(HDMI_CORE_DDC_ADDR, 0xA0 >> 1, 7, 1);
+
+        /* Load Offset Address Register */
+        REG_FLD_MOD(HDMI_CORE_DDC_OFFSET, offset, 7, 0);
+
+        /* Load Byte Count */
+        REG_FLD_MOD(HDMI_CORE_DDC_COUNT1, 0x80, 7, 0);
+        REG_FLD_MOD(HDMI_CORE_DDC_COUNT2, 0x0, 1, 0);
+
+        /* Set DDC_CMD */
+        if (ext)
+                REG_FLD_MOD(HDMI_CORE_DDC_CMD, 0x4, 3, 0);
+        else
+                REG_FLD_MOD(HDMI_CORE_DDC_CMD, 0x2, 3, 0);
+
+        /* HDMI_CORE_DDC_STATUS_BUS_LOW */
+        if (REG_GET(HDMI_CORE_DDC_STATUS, 6, 6) == 1) {
+                DSSWARN("I2C Bus Low?\n");
+                return -EIO;
+        }
+        /* HDMI_CORE_DDC_STATUS_NO_ACK */
+        if (REG_GET(HDMI_CORE_DDC_STATUS, 5, 5) == 1) {
+                DSSWARN("I2C No Ack\n");
+                return -EIO;
+        }
+
+        i = ext * 128;
+        j = 0;
+        while (((REG_GET(HDMI_CORE_DDC_STATUS, 4, 4) == 1) ||
+                        (REG_GET(HDMI_CORE_DDC_STATUS, 2, 2) == 0)) &&
+                        j < 128) {
+
+                if (REG_GET(HDMI_CORE_DDC_STATUS, 2, 2) == 0) {
+                        /* FIFO not empty */
+                        pedid[i++] = REG_GET(HDMI_CORE_DDC_DATA, 7, 0);
+                        j++;
+                }
+        }
+
+        for (j = 0; j < 128; j++)
+                checksum += pedid[j];
+
+        if (checksum != 0) {
+                DSSERR("E-EDID checksum failed!!\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int read_edid(u8 *pedid, u16 max_length)
+{
+        int r = 0, n = 0, i = 0;
+        int max_ext_blocks = (max_length / 128) - 1;
+
+        r = hdmi_core_ddc_edid(pedid, 0);
+        if (r) {
+                return r;
+        } else {
+                n = pedid[0x7e];
+
+                /*
+                 * README: need to comply with max_length set by the caller.
+                 * Better implementation should be to allocate necessary
+                 * memory to store EDID according to nb_block field found
+                 * in first block
+                 */
+                if (n > max_ext_blocks)
+                        n = max_ext_blocks;
+
+                for (i = 1; i <= n; i++) {
+                        r = hdmi_core_ddc_edid(pedid, i);
+                        if (r)
+                                return r;
+                }
+        }
+        return 0;
+}
+
+static int get_timings_index(void)
+{
+        int code;
+
+        if (hdmi.mode == 0)
+                code = code_vesa[hdmi.code];
+        else
+                code = code_cea[hdmi.code];
+
+        if (code == -1) {
+                /* HDMI code 4 corresponds to 640 * 480 VGA */
+                hdmi.code = 4;
+                /* DVI mode 1 corresponds to HDMI 0 to DVI */
+                hdmi.mode = HDMI_DVI;
+
+                code = code_vesa[hdmi.code];
+        }
+        return code;
+}
+
+static struct hdmi_cm hdmi_get_code(struct omap_video_timings *timing)
+{
+        int i = 0, code = -1, temp_vsync = 0, temp_hsync = 0;
+        int timing_vsync = 0, timing_hsync = 0;
+        struct omap_video_timings temp;
+        struct hdmi_cm cm = {-1};
+        DSSDBG("hdmi_get_code\n");
+
+        for (i = 0; i < OMAP_HDMI_TIMINGS_NB; i++) {
+                temp = cea_vesa_timings[i].timings;
+                if ((temp.pixel_clock == timing->pixel_clock) &&
+                        (temp.x_res == timing->x_res) &&
+                        (temp.y_res == timing->y_res)) {
+
+                        temp_hsync = temp.hfp + temp.hsw + temp.hbp;
+                        timing_hsync = timing->hfp + timing->hsw + timing->hbp;
+                        temp_vsync = temp.vfp + temp.vsw + temp.vbp;
+                        timing_vsync = timing->vfp + timing->vsw + timing->vbp;
+
+                        DSSDBG("temp_hsync = %d , temp_vsync = %d"
+                                "timing_hsync = %d, timing_vsync = %d\n",
+                                temp_hsync, temp_hsync,
+                                timing_hsync, timing_vsync);
+
+                        if ((temp_hsync == timing_hsync) &&
+                                        (temp_vsync == timing_vsync)) {
+                                code = i;
+                                cm.code = code_index[i];
+                                if (code < 14)
+                                        cm.mode = HDMI_HDMI;
+                                else
+                                        cm.mode = HDMI_DVI;
+                                DSSDBG("Hdmi_code = %d mode = %d\n",
+                                         cm.code, cm.mode);
+                                break;
+                         }
+                }
+        }
+
+        return cm;
+}
+
+static void get_horz_vert_timing_info(int current_descriptor_addrs, u8 *edid ,
+                struct omap_video_timings *timings)
+{
+        /* X and Y resolution */
+        timings->x_res = (((edid[current_descriptor_addrs + 4] & 0xF0) << 4) |
+                         edid[current_descriptor_addrs + 2]);
+        timings->y_res = (((edid[current_descriptor_addrs + 7] & 0xF0) << 4) |
+                         edid[current_descriptor_addrs + 5]);
+
+        timings->pixel_clock = ((edid[current_descriptor_addrs + 1] << 8) |
+                                edid[current_descriptor_addrs]);
+
+        timings->pixel_clock = 10 * timings->pixel_clock;
+
+        /* HORIZONTAL FRONT PORCH */
+        timings->hfp = edid[current_descriptor_addrs + 8] |
+                        ((edid[current_descriptor_addrs + 11] & 0xc0) << 2);
+        /* HORIZONTAL SYNC WIDTH */
+        timings->hsw = edid[current_descriptor_addrs + 9] |
+                        ((edid[current_descriptor_addrs + 11] & 0x30) << 4);
+        /* HORIZONTAL BACK PORCH */
+        timings->hbp = (((edid[current_descriptor_addrs + 4] & 0x0F) << 8) |
+                        edid[current_descriptor_addrs + 3]) -
+                        (timings->hfp + timings->hsw);
+        /* VERTICAL FRONT PORCH */
+        timings->vfp = ((edid[current_descriptor_addrs + 10] & 0xF0) >> 4) |
+                        ((edid[current_descriptor_addrs + 11] & 0x0f) << 2);
+        /* VERTICAL SYNC WIDTH */
+        timings->vsw = (edid[current_descriptor_addrs + 10] & 0x0F) |
+                        ((edid[current_descriptor_addrs + 11] & 0x03) << 4);
+        /* VERTICAL BACK PORCH */
+        timings->vbp = (((edid[current_descriptor_addrs + 7] & 0x0F) << 8) |
+                        edid[current_descriptor_addrs + 6]) -
+                        (timings->vfp + timings->vsw);
+
+}
+
+/* Description : This function gets the resolution information from EDID */
+static void get_edid_timing_data(u8 *edid)
+{
+        u8 count;
+        u16 current_descriptor_addrs;
+        struct hdmi_cm cm;
+        struct omap_video_timings edid_timings;
+
+        /* search block 0, there are 4 DTDs arranged in priority order */
+        for (count = 0; count < EDID_SIZE_BLOCK0_TIMING_DESCRIPTOR; count++) {
+                current_descriptor_addrs =
+                        EDID_DESCRIPTOR_BLOCK0_ADDRESS +
+                        count * EDID_TIMING_DESCRIPTOR_SIZE;
+                get_horz_vert_timing_info(current_descriptor_addrs,
+                                edid, &edid_timings);
+                cm = hdmi_get_code(&edid_timings);
+                DSSDBG("Block0[%d] value matches code = %d , mode = %d\n",
+                        count, cm.code, cm.mode);
+                if (cm.code == -1) {
+                        continue;
+                } else {
+                        hdmi.code = cm.code;
+                        hdmi.mode = cm.mode;
+                        DSSDBG("code = %d , mode = %d\n",
+                                hdmi.code, hdmi.mode);
+                        return;
+                }
+        }
+        if (edid[0x7e] != 0x00) {
+                for (count = 0; count < EDID_SIZE_BLOCK1_TIMING_DESCRIPTOR;
+                        count++) {
+                        current_descriptor_addrs =
+                        EDID_DESCRIPTOR_BLOCK1_ADDRESS +
+                        count * EDID_TIMING_DESCRIPTOR_SIZE;
+                        get_horz_vert_timing_info(current_descriptor_addrs,
+                                                edid, &edid_timings);
+                        cm = hdmi_get_code(&edid_timings);
+                        DSSDBG("Block1[%d] value matches code = %d, mode = %d",
+                                count, cm.code, cm.mode);
+                        if (cm.code == -1) {
+                                continue;
+                        } else {
+                                hdmi.code = cm.code;
+                                hdmi.mode = cm.mode;
+                                DSSDBG("code = %d , mode = %d\n",
+                                        hdmi.code, hdmi.mode);
+                                return;
+                        }
+                }
+        }
+
+        DSSINFO("no valid timing found , falling back to VGA\n");
+        hdmi.code = 4; /* setting default value of 640 480 VGA */
+        hdmi.mode = HDMI_DVI;
+}
+
+static void hdmi_read_edid(struct omap_video_timings *dp)
+{
+        int ret = 0, code;
+
+        memset(hdmi.edid, 0, HDMI_EDID_MAX_LENGTH);
+
+        if (!hdmi.edid_set)
+                ret = read_edid(hdmi.edid, HDMI_EDID_MAX_LENGTH);
+
+        if (!ret) {
+                if (!memcmp(hdmi.edid, edid_header, sizeof(edid_header))) {
+                        /* search for timings of default resolution */
+                        get_edid_timing_data(hdmi.edid);
+                        hdmi.edid_set = true;
+                }
+        } else {
+                DSSWARN("failed to read E-EDID\n");
+        }
+
+        if (!hdmi.edid_set) {
+                DSSINFO("fallback to VGA\n");
+                hdmi.code = 4; /* setting default value of 640 480 VGA */
+                hdmi.mode = HDMI_DVI;
+        }
+
+        code = get_timings_index();
+
+        *dp = cea_vesa_timings[code].timings;
+}
+
+static void hdmi_core_init(struct hdmi_core_video_config *video_cfg,
+                        struct hdmi_core_infoframe_avi *avi_cfg,
+                        struct hdmi_core_packet_enable_repeat *repeat_cfg)
+{
+        DSSDBG("Enter hdmi_core_init\n");
+
+        /* video core */
+        video_cfg->ip_bus_width = HDMI_INPUT_8BIT;
+        video_cfg->op_dither_truc = HDMI_OUTPUTTRUNCATION_8BIT;
+        video_cfg->deep_color_pkt = HDMI_DEEPCOLORPACKECTDISABLE;
+        video_cfg->pkt_mode = HDMI_PACKETMODERESERVEDVALUE;
+        video_cfg->hdmi_dvi = HDMI_DVI;
+        video_cfg->tclk_sel_clkmult = HDMI_FPLL10IDCK;
+
+        /* info frame */
+        avi_cfg->db1_format = 0;
+        avi_cfg->db1_active_info = 0;
+        avi_cfg->db1_bar_info_dv = 0;
+        avi_cfg->db1_scan_info = 0;
+        avi_cfg->db2_colorimetry = 0;
+        avi_cfg->db2_aspect_ratio = 0;
+        avi_cfg->db2_active_fmt_ar = 0;
+        avi_cfg->db3_itc = 0;
+        avi_cfg->db3_ec = 0;
+        avi_cfg->db3_q_range = 0;
+        avi_cfg->db3_nup_scaling = 0;
+        avi_cfg->db4_videocode = 0;
+        avi_cfg->db5_pixel_repeat = 0;
+        avi_cfg->db6_7_line_eoftop = 0 ;
+        avi_cfg->db8_9_line_sofbottom = 0;
+        avi_cfg->db10_11_pixel_eofleft = 0;
+        avi_cfg->db12_13_pixel_sofright = 0;
+
+        /* packet enable and repeat */
+        repeat_cfg->audio_pkt = 0;
+        repeat_cfg->audio_pkt_repeat = 0;
+        repeat_cfg->avi_infoframe = 0;
+        repeat_cfg->avi_infoframe_repeat = 0;
+        repeat_cfg->gen_cntrl_pkt = 0;
+        repeat_cfg->gen_cntrl_pkt_repeat = 0;
+        repeat_cfg->generic_pkt = 0;
+        repeat_cfg->generic_pkt_repeat = 0;
+}
+
+static void hdmi_core_powerdown_disable(void)
+{
+        DSSDBG("Enter hdmi_core_powerdown_disable\n");
+        REG_FLD_MOD(HDMI_CORE_CTRL1, 0x0, 0, 0);
+}
+
+static void hdmi_core_swreset_release(void)
+{
+        DSSDBG("Enter hdmi_core_swreset_release\n");
+        REG_FLD_MOD(HDMI_CORE_SYS_SRST, 0x0, 0, 0);
+}
+
+static void hdmi_core_swreset_assert(void)
+{
+        DSSDBG("Enter hdmi_core_swreset_assert\n");
+        REG_FLD_MOD(HDMI_CORE_SYS_SRST, 0x1, 0, 0);
+}
+
+/* DSS_HDMI_CORE_VIDEO_CONFIG */
+static void hdmi_core_video_config(struct hdmi_core_video_config *cfg)
+{
+        u32 r = 0;
+
+        /* sys_ctrl1 default configuration not tunable */
+        r = hdmi_read_reg(HDMI_CORE_CTRL1);
+        r = FLD_MOD(r, HDMI_CORE_CTRL1_VEN_FOLLOWVSYNC, 5, 5);
+        r = FLD_MOD(r, HDMI_CORE_CTRL1_HEN_FOLLOWHSYNC, 4, 4);
+        r = FLD_MOD(r, HDMI_CORE_CTRL1_BSEL_24BITBUS, 2, 2);
+        r = FLD_MOD(r, HDMI_CORE_CTRL1_EDGE_RISINGEDGE, 1, 1);
+        hdmi_write_reg(HDMI_CORE_CTRL1, r);
+
+        REG_FLD_MOD(HDMI_CORE_SYS_VID_ACEN, cfg->ip_bus_width, 7, 6);
+
+        /* Vid_Mode */
+        r = hdmi_read_reg(HDMI_CORE_SYS_VID_MODE);
+
+        /* dither truncation configuration */
+        if (cfg->op_dither_truc > HDMI_OUTPUTTRUNCATION_12BIT) {
+                r = FLD_MOD(r, cfg->op_dither_truc - 3, 7, 6);
+                r = FLD_MOD(r, 1, 5, 5);
+        } else {
+                r = FLD_MOD(r, cfg->op_dither_truc, 7, 6);
+                r = FLD_MOD(r, 0, 5, 5);
+        }
+        hdmi_write_reg(HDMI_CORE_SYS_VID_MODE, r);
+
+        /* HDMI_Ctrl */
+        r = hdmi_read_reg(HDMI_CORE_AV_HDMI_CTRL);
+        r = FLD_MOD(r, cfg->deep_color_pkt, 6, 6);
+        r = FLD_MOD(r, cfg->pkt_mode, 5, 3);
+        r = FLD_MOD(r, cfg->hdmi_dvi, 0, 0);
+        hdmi_write_reg(HDMI_CORE_AV_HDMI_CTRL, r);
+
+        /* TMDS_CTRL */
+        REG_FLD_MOD(HDMI_CORE_SYS_TMDS_CTRL,
+                cfg->tclk_sel_clkmult, 6, 5);
+}
+
+static void hdmi_core_aux_infoframe_avi_config(
+                struct hdmi_core_infoframe_avi info_avi)
+{
+        u32 val;
+        char sum = 0, checksum = 0;
+
+        sum += 0x82 + 0x002 + 0x00D;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_TYPE, 0x082);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_VERS, 0x002);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_LEN, 0x00D);
+
+        val = (info_avi.db1_format << 5) |
+                (info_avi.db1_active_info << 4) |
+                (info_avi.db1_bar_info_dv << 2) |
+                (info_avi.db1_scan_info);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(0), val);
+        sum += val;
+
+        val = (info_avi.db2_colorimetry << 6) |
+                (info_avi.db2_aspect_ratio << 4) |
+                (info_avi.db2_active_fmt_ar);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(1), val);
+        sum += val;
+
+        val = (info_avi.db3_itc << 7) |
+                (info_avi.db3_ec << 4) |
+                (info_avi.db3_q_range << 2) |
+                (info_avi.db3_nup_scaling);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(2), val);
+        sum += val;
+
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(3), info_avi.db4_videocode);
+        sum += info_avi.db4_videocode;
+
+        val = info_avi.db5_pixel_repeat;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(4), val);
+        sum += val;
+
+        val = info_avi.db6_7_line_eoftop & 0x00FF;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(5), val);
+        sum += val;
+
+        val = ((info_avi.db6_7_line_eoftop >> 8) & 0x00FF);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(6), val);
+        sum += val;
+
+        val = info_avi.db8_9_line_sofbottom & 0x00FF;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(7), val);
+        sum += val;
+
+        val = ((info_avi.db8_9_line_sofbottom >> 8) & 0x00FF);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(8), val);
+        sum += val;
+
+        val = info_avi.db10_11_pixel_eofleft & 0x00FF;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(9), val);
+        sum += val;
+
+        val = ((info_avi.db10_11_pixel_eofleft >> 8) & 0x00FF);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(10), val);
+        sum += val;
+
+        val = info_avi.db12_13_pixel_sofright & 0x00FF;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(11), val);
+        sum += val;
+
+        val = ((info_avi.db12_13_pixel_sofright >> 8) & 0x00FF);
+        hdmi_write_reg(HDMI_CORE_AV_AVI_DBYTE(12), val);
+        sum += val;
+
+        checksum = 0x100 - sum;
+        hdmi_write_reg(HDMI_CORE_AV_AVI_CHSUM, checksum);
+}
+
+static void hdmi_core_av_packet_config(
+                struct hdmi_core_packet_enable_repeat repeat_cfg)
+{
+        /* enable/repeat the infoframe */
+        hdmi_write_reg(HDMI_CORE_AV_PB_CTRL1,
+                (repeat_cfg.audio_pkt << 5) |
+                (repeat_cfg.audio_pkt_repeat << 4) |
+                (repeat_cfg.avi_infoframe << 1) |
+                (repeat_cfg.avi_infoframe_repeat));
+
+        /* enable/repeat the packet */
+        hdmi_write_reg(HDMI_CORE_AV_PB_CTRL2,
+                (repeat_cfg.gen_cntrl_pkt << 3) |
+                (repeat_cfg.gen_cntrl_pkt_repeat << 2) |
+                (repeat_cfg.generic_pkt << 1) |
+                (repeat_cfg.generic_pkt_repeat));
+}
+
+static void hdmi_wp_init(struct omap_video_timings *timings,
+                        struct hdmi_video_format *video_fmt,
+                        struct hdmi_video_interface *video_int)
+{
+        DSSDBG("Enter hdmi_wp_init\n");
+
+        timings->hbp = 0;
+        timings->hfp = 0;
+        timings->hsw = 0;
+        timings->vbp = 0;
+        timings->vfp = 0;
+        timings->vsw = 0;
+
+        video_fmt->packing_mode = HDMI_PACK_10b_RGB_YUV444;
+        video_fmt->y_res = 0;
+        video_fmt->x_res = 0;
+
+        video_int->vsp = 0;
+        video_int->hsp = 0;
+
+        video_int->interlacing = 0;
+        video_int->tm = 0; /* HDMI_TIMING_SLAVE */
+
+}
+
+static void hdmi_wp_video_start(bool start)
+{
+        REG_FLD_MOD(HDMI_WP_VIDEO_CFG, start, 31, 31);
+}
+
+static void hdmi_wp_video_init_format(struct hdmi_video_format *video_fmt,
+        struct omap_video_timings *timings, struct hdmi_config *param)
+{
+        DSSDBG("Enter hdmi_wp_video_init_format\n");
+
+        video_fmt->y_res = param->timings.timings.y_res;
+        video_fmt->x_res = param->timings.timings.x_res;
+
+        timings->hbp = param->timings.timings.hbp;
+        timings->hfp = param->timings.timings.hfp;
+        timings->hsw = param->timings.timings.hsw;
+        timings->vbp = param->timings.timings.vbp;
+        timings->vfp = param->timings.timings.vfp;
+        timings->vsw = param->timings.timings.vsw;
+}
+
+static void hdmi_wp_video_config_format(
+                struct hdmi_video_format *video_fmt)
+{
+        u32 l = 0;
+
+        REG_FLD_MOD(HDMI_WP_VIDEO_CFG, video_fmt->packing_mode, 10, 8);
+
+        l |= FLD_VAL(video_fmt->y_res, 31, 16);
+        l |= FLD_VAL(video_fmt->x_res, 15, 0);
+        hdmi_write_reg(HDMI_WP_VIDEO_SIZE, l);
+}
+
+static void hdmi_wp_video_config_interface(
+                struct hdmi_video_interface *video_int)
+{
+        u32 r;
+        DSSDBG("Enter hdmi_wp_video_config_interface\n");
+
+        r = hdmi_read_reg(HDMI_WP_VIDEO_CFG);
+        r = FLD_MOD(r, video_int->vsp, 7, 7);
+        r = FLD_MOD(r, video_int->hsp, 6, 6);
+        r = FLD_MOD(r, video_int->interlacing, 3, 3);
+        r = FLD_MOD(r, video_int->tm, 1, 0);
+        hdmi_write_reg(HDMI_WP_VIDEO_CFG, r);
+}
+
+static void hdmi_wp_video_config_timing(
+                struct omap_video_timings *timings)
+{
+        u32 timing_h = 0;
+        u32 timing_v = 0;
+
+        DSSDBG("Enter hdmi_wp_video_config_timing\n");
+
+        timing_h |= FLD_VAL(timings->hbp, 31, 20);
+        timing_h |= FLD_VAL(timings->hfp, 19, 8);
+        timing_h |= FLD_VAL(timings->hsw, 7, 0);
+        hdmi_write_reg(HDMI_WP_VIDEO_TIMING_H, timing_h);
+
+        timing_v |= FLD_VAL(timings->vbp, 31, 20);
+        timing_v |= FLD_VAL(timings->vfp, 19, 8);
+        timing_v |= FLD_VAL(timings->vsw, 7, 0);
+        hdmi_write_reg(HDMI_WP_VIDEO_TIMING_V, timing_v);
+}
+
+static void hdmi_basic_configure(struct hdmi_config *cfg)
+{
+        /* HDMI */
+        struct omap_video_timings video_timing;
+        struct hdmi_video_format video_format;
+        struct hdmi_video_interface video_interface;
+        /* HDMI core */
+        struct hdmi_core_infoframe_avi avi_cfg;
+        struct hdmi_core_video_config v_core_cfg;
+        struct hdmi_core_packet_enable_repeat repeat_cfg;
+
+        hdmi_wp_init(&video_timing, &video_format,
+                &video_interface);
+
+        hdmi_core_init(&v_core_cfg,
+                &avi_cfg,
+                &repeat_cfg);
+
+        hdmi_wp_video_init_format(&video_format,
+                        &video_timing, cfg);
+
+        hdmi_wp_video_config_timing(&video_timing);
+
+        /* video config */
+        video_format.packing_mode = HDMI_PACK_24b_RGB_YUV444_YUV422;
+
+        hdmi_wp_video_config_format(&video_format);
+
+        video_interface.vsp = cfg->timings.vsync_pol;
+        video_interface.hsp = cfg->timings.hsync_pol;
+        video_interface.interlacing = cfg->interlace;
+        video_interface.tm = 1 ; /* HDMI_TIMING_MASTER_24BIT */
+
+        hdmi_wp_video_config_interface(&video_interface);
+
+        /*
+         * configure core video part
+         * set software reset in the core
+         */
+        hdmi_core_swreset_assert();
+
+        /* power down off */
+        hdmi_core_powerdown_disable();
+
+        v_core_cfg.pkt_mode = HDMI_PACKETMODE24BITPERPIXEL;
+        v_core_cfg.hdmi_dvi = cfg->cm.mode;
+
+        hdmi_core_video_config(&v_core_cfg);
+
+        /* release software reset in the core */
+        hdmi_core_swreset_release();
+
+        /*
+         * configure packet
+         * info frame video see doc CEA861-D page 65
+         */
+        avi_cfg.db1_format = HDMI_INFOFRAME_AVI_DB1Y_RGB;
+        avi_cfg.db1_active_info =
+                HDMI_INFOFRAME_AVI_DB1A_ACTIVE_FORMAT_OFF;
+        avi_cfg.db1_bar_info_dv = HDMI_INFOFRAME_AVI_DB1B_NO;
+        avi_cfg.db1_scan_info = HDMI_INFOFRAME_AVI_DB1S_0;
+        avi_cfg.db2_colorimetry = HDMI_INFOFRAME_AVI_DB2C_NO;
+        avi_cfg.db2_aspect_ratio = HDMI_INFOFRAME_AVI_DB2M_NO;
+        avi_cfg.db2_active_fmt_ar = HDMI_INFOFRAME_AVI_DB2R_SAME;
+        avi_cfg.db3_itc = HDMI_INFOFRAME_AVI_DB3ITC_NO;
+        avi_cfg.db3_ec = HDMI_INFOFRAME_AVI_DB3EC_XVYUV601;
+        avi_cfg.db3_q_range = HDMI_INFOFRAME_AVI_DB3Q_DEFAULT;
+        avi_cfg.db3_nup_scaling = HDMI_INFOFRAME_AVI_DB3SC_NO;
+        avi_cfg.db4_videocode = cfg->cm.code;
+        avi_cfg.db5_pixel_repeat = HDMI_INFOFRAME_AVI_DB5PR_NO;
+        avi_cfg.db6_7_line_eoftop = 0;
+        avi_cfg.db8_9_line_sofbottom = 0;
+        avi_cfg.db10_11_pixel_eofleft = 0;
+        avi_cfg.db12_13_pixel_sofright = 0;
+
+        hdmi_core_aux_infoframe_avi_config(avi_cfg);
+
+        /* enable/repeat the infoframe */
+        repeat_cfg.avi_infoframe = HDMI_PACKETENABLE;
+        repeat_cfg.avi_infoframe_repeat = HDMI_PACKETREPEATON;
+        /* wakeup */
+        repeat_cfg.audio_pkt = HDMI_PACKETENABLE;
+        repeat_cfg.audio_pkt_repeat = HDMI_PACKETREPEATON;
+        hdmi_core_av_packet_config(repeat_cfg);
+}
+
+static void update_hdmi_timings(struct hdmi_config *cfg,
+                struct omap_video_timings *timings, int code)
+{
+        cfg->timings.timings.x_res = timings->x_res;
+        cfg->timings.timings.y_res = timings->y_res;
+        cfg->timings.timings.hbp = timings->hbp;
+        cfg->timings.timings.hfp = timings->hfp;
+        cfg->timings.timings.hsw = timings->hsw;
+        cfg->timings.timings.vbp = timings->vbp;
+        cfg->timings.timings.vfp = timings->vfp;
+        cfg->timings.timings.vsw = timings->vsw;
+        cfg->timings.timings.pixel_clock = timings->pixel_clock;
+        cfg->timings.vsync_pol = cea_vesa_timings[code].vsync_pol;
+        cfg->timings.hsync_pol = cea_vesa_timings[code].hsync_pol;
+}
+
+static void hdmi_compute_pll(unsigned long clkin, int phy,
+        int n, struct hdmi_pll_info *pi)
+{
+        unsigned long refclk;
+        u32 mf;
+
+        /*
+         * Input clock is predivided by N + 1
+         * out put of which is reference clk
+         */
+        refclk = clkin / (n + 1);
+        pi->regn = n;
+
+        /*
+         * multiplier is pixel_clk/ref_clk
+         * Multiplying by 100 to avoid fractional part removal
+         */
+        pi->regm = (phy * 100/(refclk))/100;
+        pi->regm2 = 1;
+
+        /*
+         * fractional multiplier is remainder of the difference between
+         * multiplier and actual phy(required pixel clock thus should be
+         * multiplied by 2^18(262144) divided by the reference clock
+         */
+        mf = (phy - pi->regm * refclk) * 262144;
+        pi->regmf = mf/(refclk);
+
+        /*
+         * Dcofreq should be set to 1 if required pixel clock
+         * is greater than 1000MHz
+         */
+        pi->dcofreq = phy > 1000 * 100;
+        pi->regsd = ((pi->regm * clkin / 10) / ((n + 1) * 250) + 5) / 10;
+
+        DSSDBG("M = %d Mf = %d\n", pi->regm, pi->regmf);
+        DSSDBG("range = %d sd = %d\n", pi->dcofreq, pi->regsd);
+}
+
+static void hdmi_enable_clocks(int enable)
+{
+        if (enable)
+                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK |
+                                DSS_CLK_SYSCK | DSS_CLK_VIDFCK);
+        else
+                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK |
+                                DSS_CLK_SYSCK | DSS_CLK_VIDFCK);
+}
+
+static int hdmi_power_on(struct omap_dss_device *dssdev)
+{
+        int r, code = 0;
+        struct hdmi_pll_info pll_data;
+        struct omap_video_timings *p;
+        int clkin, n, phy;
+
+        hdmi_enable_clocks(1);
+
+        dispc_enable_channel(OMAP_DSS_CHANNEL_DIGIT, 0);
+
+        p = &dssdev->panel.timings;
+
+        DSSDBG("hdmi_power_on x_res= %d y_res = %d\n",
+                dssdev->panel.timings.x_res,
+                dssdev->panel.timings.y_res);
+
+        if (!hdmi.custom_set) {
+                DSSDBG("Read EDID as no EDID is not set on poweron\n");
+                hdmi_read_edid(p);
+        }
+        code = get_timings_index();
+        dssdev->panel.timings = cea_vesa_timings[code].timings;
+        update_hdmi_timings(&hdmi.cfg, p, code);
+
+        clkin = 3840; /* 38.4 MHz */
+        n = 15; /* this is a constant for our math */
+        phy = p->pixel_clock;
+
+        hdmi_compute_pll(clkin, phy, n, &pll_data);
+
+        hdmi_wp_video_start(0);
+
+        /* config the PLL and PHY first */
+        r = hdmi_pll_program(&pll_data);
+        if (r) {
+                DSSDBG("Failed to lock PLL\n");
+                goto err;
+        }
+
+        r = hdmi_phy_init();
+        if (r) {
+                DSSDBG("Failed to start PHY\n");
+                goto err;
+        }
+
+        hdmi.cfg.cm.mode = hdmi.mode;
+        hdmi.cfg.cm.code = hdmi.code;
+        hdmi_basic_configure(&hdmi.cfg);
+
+        /* Make selection of HDMI in DSS */
+        dss_select_hdmi_venc_clk_source(DSS_HDMI_M_PCLK);
+
+        /* Select the dispc clock source as PRCM clock, to ensure that it is not
+         * DSI PLL source as the clock selected by DSI PLL might not be
+         * sufficient for the resolution selected / that can be changed
+         * dynamically by user. This can be moved to single location , say
+         * Boardfile.
+         */
+        dss_select_dispc_clk_source(DSS_CLK_SRC_FCK);
+
+        /* bypass TV gamma table */
+        dispc_enable_gamma_table(0);
+
+        /* tv size */
+        dispc_set_digit_size(dssdev->panel.timings.x_res,
+                        dssdev->panel.timings.y_res);
+
+        dispc_enable_channel(OMAP_DSS_CHANNEL_DIGIT, 1);
+
+        hdmi_wp_video_start(1);
+
+        return 0;
+err:
+        hdmi_enable_clocks(0);
+        return -EIO;
+}
+
+static void hdmi_power_off(struct omap_dss_device *dssdev)
+{
+        dispc_enable_channel(OMAP_DSS_CHANNEL_DIGIT, 0);
+
+        hdmi_wp_video_start(0);
+        hdmi_phy_off();
+        hdmi_set_pll_pwr(HDMI_PLLPWRCMD_ALLOFF);
+        hdmi_enable_clocks(0);
+
+        hdmi.edid_set = 0;
+}
+
+int omapdss_hdmi_display_check_timing(struct omap_dss_device *dssdev,
+                                        struct omap_video_timings *timings)
+{
+        struct hdmi_cm cm;
+
+        cm = hdmi_get_code(timings);
+        if (cm.code == -1) {
+                DSSERR("Invalid timing entered\n");
+                return -EINVAL;
+        }
+
+        return 0;
+
+}
+
+void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev)
+{
+        struct hdmi_cm cm;
+
+        hdmi.custom_set = 1;
+        cm = hdmi_get_code(&dssdev->panel.timings);
+        hdmi.code = cm.code;
+        hdmi.mode = cm.mode;
+        omapdss_hdmi_display_enable(dssdev);
+        hdmi.custom_set = 0;
+}
+
+int omapdss_hdmi_display_enable(struct omap_dss_device *dssdev)
+{
+        int r = 0;
+
+        DSSDBG("ENTER hdmi_display_enable\n");
+
+        mutex_lock(&hdmi.lock);
+
+        r = omap_dss_start_device(dssdev);
+        if (r) {
+                DSSERR("failed to start device\n");
+                goto err0;
+        }
+
+        if (dssdev->platform_enable) {
+                r = dssdev->platform_enable(dssdev);
+                if (r) {
+                        DSSERR("failed to enable GPIO's\n");
+                        goto err1;
+                }
+        }
+
+        r = hdmi_power_on(dssdev);
+        if (r) {
+                DSSERR("failed to power on device\n");
+                goto err2;
+        }
+
+        mutex_unlock(&hdmi.lock);
+        return 0;
+
+err2:
+        if (dssdev->platform_disable)
+                dssdev->platform_disable(dssdev);
+err1:
+        omap_dss_stop_device(dssdev);
+err0:
+        mutex_unlock(&hdmi.lock);
+        return r;
+}
+
+void omapdss_hdmi_display_disable(struct omap_dss_device *dssdev)
+{
+        DSSDBG("Enter hdmi_display_disable\n");
+
+        mutex_lock(&hdmi.lock);
+
+        hdmi_power_off(dssdev);
+
+        if (dssdev->platform_disable)
+                dssdev->platform_disable(dssdev);
+
+        omap_dss_stop_device(dssdev);
+
+        mutex_unlock(&hdmi.lock);
+}
+
+/* HDMI HW IP initialisation */
+static int omapdss_hdmihw_probe(struct platform_device *pdev)
+{
+        struct resource *hdmi_mem;
+
+        hdmi.pdata = pdev->dev.platform_data;
+        hdmi.pdev = pdev;
+
+        mutex_init(&hdmi.lock);
+
+        hdmi_mem = platform_get_resource(hdmi.pdev, IORESOURCE_MEM, 0);
+        if (!hdmi_mem) {
+                DSSERR("can't get IORESOURCE_MEM HDMI\n");
+                return -EINVAL;
+        }
+
+        /* Base address taken from platform */
+        hdmi.base_wp = ioremap(hdmi_mem->start, resource_size(hdmi_mem));
+        if (!hdmi.base_wp) {
+                DSSERR("can't ioremap WP\n");
+                return -ENOMEM;
+        }
+
+        hdmi_panel_init();
+
+        return 0;
+}
+
+static int omapdss_hdmihw_remove(struct platform_device *pdev)
+{
+        hdmi_panel_exit();
+
+        iounmap(hdmi.base_wp);
+
+        return 0;
+}
+
+static struct platform_driver omapdss_hdmihw_driver = {
+        .probe          = omapdss_hdmihw_probe,
+        .remove         = omapdss_hdmihw_remove,
+        .driver         = {
+                .name   = "omapdss_hdmi",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int hdmi_init_platform_driver(void)
+{
+        return platform_driver_register(&omapdss_hdmihw_driver);
+}
+
+void hdmi_uninit_platform_driver(void)
+{
+        return platform_driver_unregister(&omapdss_hdmihw_driver);
+}
diff --git a/drivers/video/omap2/dss/hdmi.h b/drivers/video/omap2/dss/hdmi.h
new file mode 100644
index 000000000000..9887ab96da3c
--- /dev/null
+++ b/drivers/video/omap2/dss/hdmi.h
@@ -0,0 +1,415 @@
+/*
+ * hdmi.h
+ *
+ * HDMI driver definition for TI OMAP4 processors.
+ *
+ * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _OMAP4_DSS_HDMI_H_
+#define _OMAP4_DSS_HDMI_H_
+
+#include <linux/string.h>
+#include <plat/display.h>
+
+#define HDMI_WP         0x0
+#define HDMI_CORE_SYS           0x400
+#define HDMI_CORE_AV            0x900
+#define HDMI_PLLCTRL            0x200
+#define HDMI_PHY                0x300
+
+struct hdmi_reg { u16 idx; };
+
+#define HDMI_REG(idx)                   ((const struct hdmi_reg) { idx })
+
+/* HDMI Wrapper */
+#define HDMI_WP_REG(idx)                        HDMI_REG(HDMI_WP + idx)
+
+#define HDMI_WP_REVISION                        HDMI_WP_REG(0x0)
+#define HDMI_WP_SYSCONFIG                       HDMI_WP_REG(0x10)
+#define HDMI_WP_IRQSTATUS_RAW                   HDMI_WP_REG(0x24)
+#define HDMI_WP_IRQSTATUS                       HDMI_WP_REG(0x28)
+#define HDMI_WP_PWR_CTRL                        HDMI_WP_REG(0x40)
+#define HDMI_WP_IRQENABLE_SET                   HDMI_WP_REG(0x2C)
+#define HDMI_WP_VIDEO_CFG                       HDMI_WP_REG(0x50)
+#define HDMI_WP_VIDEO_SIZE                      HDMI_WP_REG(0x60)
+#define HDMI_WP_VIDEO_TIMING_H                  HDMI_WP_REG(0x68)
+#define HDMI_WP_VIDEO_TIMING_V                  HDMI_WP_REG(0x6C)
+#define HDMI_WP_WP_CLK                          HDMI_WP_REG(0x70)
+
+/* HDMI IP Core System */
+#define HDMI_CORE_SYS_REG(idx)                  HDMI_REG(HDMI_CORE_SYS + idx)
+
+#define HDMI_CORE_SYS_VND_IDL                   HDMI_CORE_SYS_REG(0x0)
+#define HDMI_CORE_SYS_DEV_IDL                   HDMI_CORE_SYS_REG(0x8)
+#define HDMI_CORE_SYS_DEV_IDH                   HDMI_CORE_SYS_REG(0xC)
+#define HDMI_CORE_SYS_DEV_REV                   HDMI_CORE_SYS_REG(0x10)
+#define HDMI_CORE_SYS_SRST                      HDMI_CORE_SYS_REG(0x14)
+#define HDMI_CORE_CTRL1                 HDMI_CORE_SYS_REG(0x20)
+#define HDMI_CORE_SYS_SYS_STAT                  HDMI_CORE_SYS_REG(0x24)
+#define HDMI_CORE_SYS_VID_ACEN                  HDMI_CORE_SYS_REG(0x124)
+#define HDMI_CORE_SYS_VID_MODE                  HDMI_CORE_SYS_REG(0x128)
+#define HDMI_CORE_SYS_INTR_STATE                HDMI_CORE_SYS_REG(0x1C0)
+#define HDMI_CORE_SYS_INTR1                     HDMI_CORE_SYS_REG(0x1C4)
+#define HDMI_CORE_SYS_INTR2                     HDMI_CORE_SYS_REG(0x1C8)
+#define HDMI_CORE_SYS_INTR3                     HDMI_CORE_SYS_REG(0x1CC)
+#define HDMI_CORE_SYS_INTR4                     HDMI_CORE_SYS_REG(0x1D0)
+#define HDMI_CORE_SYS_UMASK1                    HDMI_CORE_SYS_REG(0x1D4)
+#define HDMI_CORE_SYS_TMDS_CTRL         HDMI_CORE_SYS_REG(0x208)
+#define HDMI_CORE_SYS_DE_DLY                    HDMI_CORE_SYS_REG(0xC8)
+#define HDMI_CORE_SYS_DE_CTRL                   HDMI_CORE_SYS_REG(0xCC)
+#define HDMI_CORE_SYS_DE_TOP                    HDMI_CORE_SYS_REG(0xD0)
+#define HDMI_CORE_SYS_DE_CNTL                   HDMI_CORE_SYS_REG(0xD8)
+#define HDMI_CORE_SYS_DE_CNTH                   HDMI_CORE_SYS_REG(0xDC)
+#define HDMI_CORE_SYS_DE_LINL                   HDMI_CORE_SYS_REG(0xE0)
+#define HDMI_CORE_SYS_DE_LINH_1         HDMI_CORE_SYS_REG(0xE4)
+#define HDMI_CORE_CTRL1_VEN_FOLLOWVSYNC 0x1
+#define HDMI_CORE_CTRL1_HEN_FOLLOWHSYNC 0x1
+#define HDMI_CORE_CTRL1_BSEL_24BITBUS           0x1
+#define HDMI_CORE_CTRL1_EDGE_RISINGEDGE 0x1
+
+/* HDMI DDC E-DID */
+#define HDMI_CORE_DDC_CMD                       HDMI_CORE_SYS_REG(0x3CC)
+#define HDMI_CORE_DDC_STATUS                    HDMI_CORE_SYS_REG(0x3C8)
+#define HDMI_CORE_DDC_ADDR                      HDMI_CORE_SYS_REG(0x3B4)
+#define HDMI_CORE_DDC_OFFSET                    HDMI_CORE_SYS_REG(0x3BC)
+#define HDMI_CORE_DDC_COUNT1                    HDMI_CORE_SYS_REG(0x3C0)
+#define HDMI_CORE_DDC_COUNT2                    HDMI_CORE_SYS_REG(0x3C4)
+#define HDMI_CORE_DDC_DATA                      HDMI_CORE_SYS_REG(0x3D0)
+#define HDMI_CORE_DDC_SEGM                      HDMI_CORE_SYS_REG(0x3B8)
+
+/* HDMI IP Core Audio Video */
+#define HDMI_CORE_AV_REG(idx)                   HDMI_REG(HDMI_CORE_AV + idx)
+
+#define HDMI_CORE_AV_HDMI_CTRL                  HDMI_CORE_AV_REG(0xBC)
+#define HDMI_CORE_AV_DPD                        HDMI_CORE_AV_REG(0xF4)
+#define HDMI_CORE_AV_PB_CTRL1                   HDMI_CORE_AV_REG(0xF8)
+#define HDMI_CORE_AV_PB_CTRL2                   HDMI_CORE_AV_REG(0xFC)
+#define HDMI_CORE_AV_AVI_TYPE                   HDMI_CORE_AV_REG(0x100)
+#define HDMI_CORE_AV_AVI_VERS                   HDMI_CORE_AV_REG(0x104)
+#define HDMI_CORE_AV_AVI_LEN                    HDMI_CORE_AV_REG(0x108)
+#define HDMI_CORE_AV_AVI_CHSUM                  HDMI_CORE_AV_REG(0x10C)
+#define HDMI_CORE_AV_AVI_DBYTE(n)               HDMI_CORE_AV_REG(n * 4 + 0x110)
+#define HDMI_CORE_AV_AVI_DBYTE_NELEMS           HDMI_CORE_AV_REG(15)
+#define HDMI_CORE_AV_SPD_DBYTE                  HDMI_CORE_AV_REG(0x190)
+#define HDMI_CORE_AV_SPD_DBYTE_NELEMS           HDMI_CORE_AV_REG(27)
+#define HDMI_CORE_AV_MPEG_DBYTE         HDMI_CORE_AV_REG(0x290)
+#define HDMI_CORE_AV_MPEG_DBYTE_NELEMS          HDMI_CORE_AV_REG(27)
+#define HDMI_CORE_AV_GEN_DBYTE                  HDMI_CORE_AV_REG(0x300)
+#define HDMI_CORE_AV_GEN_DBYTE_NELEMS           HDMI_CORE_AV_REG(31)
+#define HDMI_CORE_AV_GEN2_DBYTE         HDMI_CORE_AV_REG(0x380)
+#define HDMI_CORE_AV_GEN2_DBYTE_NELEMS          HDMI_CORE_AV_REG(31)
+#define HDMI_CORE_AV_ACR_CTRL                   HDMI_CORE_AV_REG(0x4)
+#define HDMI_CORE_AV_FREQ_SVAL                  HDMI_CORE_AV_REG(0x8)
+#define HDMI_CORE_AV_N_SVAL1                    HDMI_CORE_AV_REG(0xC)
+#define HDMI_CORE_AV_N_SVAL2                    HDMI_CORE_AV_REG(0x10)
+#define HDMI_CORE_AV_N_SVAL3                    HDMI_CORE_AV_REG(0x14)
+#define HDMI_CORE_AV_CTS_SVAL1                  HDMI_CORE_AV_REG(0x18)
+#define HDMI_CORE_AV_CTS_SVAL2                  HDMI_CORE_AV_REG(0x1C)
+#define HDMI_CORE_AV_CTS_SVAL3                  HDMI_CORE_AV_REG(0x20)
+#define HDMI_CORE_AV_CTS_HVAL1                  HDMI_CORE_AV_REG(0x24)
+#define HDMI_CORE_AV_CTS_HVAL2                  HDMI_CORE_AV_REG(0x28)
+#define HDMI_CORE_AV_CTS_HVAL3                  HDMI_CORE_AV_REG(0x2C)
+#define HDMI_CORE_AV_AUD_MODE                   HDMI_CORE_AV_REG(0x50)
+#define HDMI_CORE_AV_SPDIF_CTRL         HDMI_CORE_AV_REG(0x54)
+#define HDMI_CORE_AV_HW_SPDIF_FS                HDMI_CORE_AV_REG(0x60)
+#define HDMI_CORE_AV_SWAP_I2S                   HDMI_CORE_AV_REG(0x64)
+#define HDMI_CORE_AV_SPDIF_ERTH         HDMI_CORE_AV_REG(0x6C)
+#define HDMI_CORE_AV_I2S_IN_MAP         HDMI_CORE_AV_REG(0x70)
+#define HDMI_CORE_AV_I2S_IN_CTRL                HDMI_CORE_AV_REG(0x74)
+#define HDMI_CORE_AV_I2S_CHST0                  HDMI_CORE_AV_REG(0x78)
+#define HDMI_CORE_AV_I2S_CHST1                  HDMI_CORE_AV_REG(0x7C)
+#define HDMI_CORE_AV_I2S_CHST2                  HDMI_CORE_AV_REG(0x80)
+#define HDMI_CORE_AV_I2S_CHST4                  HDMI_CORE_AV_REG(0x84)
+#define HDMI_CORE_AV_I2S_CHST5                  HDMI_CORE_AV_REG(0x88)
+#define HDMI_CORE_AV_ASRC                       HDMI_CORE_AV_REG(0x8C)
+#define HDMI_CORE_AV_I2S_IN_LEN         HDMI_CORE_AV_REG(0x90)
+#define HDMI_CORE_AV_HDMI_CTRL                  HDMI_CORE_AV_REG(0xBC)
+#define HDMI_CORE_AV_AUDO_TXSTAT                HDMI_CORE_AV_REG(0xC0)
+#define HDMI_CORE_AV_AUD_PAR_BUSCLK_1           HDMI_CORE_AV_REG(0xCC)
+#define HDMI_CORE_AV_AUD_PAR_BUSCLK_2           HDMI_CORE_AV_REG(0xD0)
+#define HDMI_CORE_AV_AUD_PAR_BUSCLK_3           HDMI_CORE_AV_REG(0xD4)
+#define HDMI_CORE_AV_TEST_TXCTRL                HDMI_CORE_AV_REG(0xF0)
+#define HDMI_CORE_AV_DPD                        HDMI_CORE_AV_REG(0xF4)
+#define HDMI_CORE_AV_PB_CTRL1                   HDMI_CORE_AV_REG(0xF8)
+#define HDMI_CORE_AV_PB_CTRL2                   HDMI_CORE_AV_REG(0xFC)
+#define HDMI_CORE_AV_AVI_TYPE                   HDMI_CORE_AV_REG(0x100)
+#define HDMI_CORE_AV_AVI_VERS                   HDMI_CORE_AV_REG(0x104)
+#define HDMI_CORE_AV_AVI_LEN                    HDMI_CORE_AV_REG(0x108)
+#define HDMI_CORE_AV_AVI_CHSUM                  HDMI_CORE_AV_REG(0x10C)
+#define HDMI_CORE_AV_SPD_TYPE                   HDMI_CORE_AV_REG(0x180)
+#define HDMI_CORE_AV_SPD_VERS                   HDMI_CORE_AV_REG(0x184)
+#define HDMI_CORE_AV_SPD_LEN                    HDMI_CORE_AV_REG(0x188)
+#define HDMI_CORE_AV_SPD_CHSUM                  HDMI_CORE_AV_REG(0x18C)
+#define HDMI_CORE_AV_MPEG_TYPE                  HDMI_CORE_AV_REG(0x280)
+#define HDMI_CORE_AV_MPEG_VERS                  HDMI_CORE_AV_REG(0x284)
+#define HDMI_CORE_AV_MPEG_LEN                   HDMI_CORE_AV_REG(0x288)
+#define HDMI_CORE_AV_MPEG_CHSUM         HDMI_CORE_AV_REG(0x28C)
+#define HDMI_CORE_AV_CP_BYTE1                   HDMI_CORE_AV_REG(0x37C)
+#define HDMI_CORE_AV_CEC_ADDR_ID                HDMI_CORE_AV_REG(0x3FC)
+#define HDMI_CORE_AV_SPD_DBYTE_ELSIZE           0x4
+#define HDMI_CORE_AV_GEN2_DBYTE_ELSIZE          0x4
+#define HDMI_CORE_AV_MPEG_DBYTE_ELSIZE          0x4
+#define HDMI_CORE_AV_GEN_DBYTE_ELSIZE           0x4
+
+/* PLL */
+#define HDMI_PLL_REG(idx)                       HDMI_REG(HDMI_PLLCTRL + idx)
+
+#define PLLCTRL_PLL_CONTROL                     HDMI_PLL_REG(0x0)
+#define PLLCTRL_PLL_STATUS                      HDMI_PLL_REG(0x4)
+#define PLLCTRL_PLL_GO                          HDMI_PLL_REG(0x8)
+#define PLLCTRL_CFG1                            HDMI_PLL_REG(0xC)
+#define PLLCTRL_CFG2                            HDMI_PLL_REG(0x10)
+#define PLLCTRL_CFG3                            HDMI_PLL_REG(0x14)
+#define PLLCTRL_CFG4                            HDMI_PLL_REG(0x20)
+
+/* HDMI PHY */
+#define HDMI_PHY_REG(idx)                       HDMI_REG(HDMI_PHY + idx)
+
+#define HDMI_TXPHY_TX_CTRL                      HDMI_PHY_REG(0x0)
+#define HDMI_TXPHY_DIGITAL_CTRL         HDMI_PHY_REG(0x4)
+#define HDMI_TXPHY_POWER_CTRL                   HDMI_PHY_REG(0x8)
+#define HDMI_TXPHY_PAD_CFG_CTRL         HDMI_PHY_REG(0xC)
+
+/* HDMI EDID Length  */
+#define HDMI_EDID_MAX_LENGTH                    256
+#define EDID_TIMING_DESCRIPTOR_SIZE             0x12
+#define EDID_DESCRIPTOR_BLOCK0_ADDRESS          0x36
+#define EDID_DESCRIPTOR_BLOCK1_ADDRESS          0x80
+#define EDID_SIZE_BLOCK0_TIMING_DESCRIPTOR      4
+#define EDID_SIZE_BLOCK1_TIMING_DESCRIPTOR      4
+
+#define OMAP_HDMI_TIMINGS_NB                    34
+
+#define REG_FLD_MOD(idx, val, start, end) \
+        hdmi_write_reg(idx, FLD_MOD(hdmi_read_reg(idx), val, start, end))
+#define REG_GET(idx, start, end) \
+        FLD_GET(hdmi_read_reg(idx), start, end)
+
+/* HDMI timing structure */
+struct hdmi_timings {
+        struct omap_video_timings timings;
+        int vsync_pol;
+        int hsync_pol;
+};
+
+enum hdmi_phy_pwr {
+        HDMI_PHYPWRCMD_OFF = 0,
+        HDMI_PHYPWRCMD_LDOON = 1,
+        HDMI_PHYPWRCMD_TXON = 2
+};
+
+enum hdmi_pll_pwr {
+        HDMI_PLLPWRCMD_ALLOFF = 0,
+        HDMI_PLLPWRCMD_PLLONLY = 1,
+        HDMI_PLLPWRCMD_BOTHON_ALLCLKS = 2,
+        HDMI_PLLPWRCMD_BOTHON_NOPHYCLK = 3
+};
+
+enum hdmi_clk_refsel {
+        HDMI_REFSEL_PCLK = 0,
+        HDMI_REFSEL_REF1 = 1,
+        HDMI_REFSEL_REF2 = 2,
+        HDMI_REFSEL_SYSCLK = 3
+};
+
+enum hdmi_core_inputbus_width {
+        HDMI_INPUT_8BIT = 0,
+        HDMI_INPUT_10BIT = 1,
+        HDMI_INPUT_12BIT = 2
+};
+
+enum hdmi_core_dither_trunc {
+        HDMI_OUTPUTTRUNCATION_8BIT = 0,
+        HDMI_OUTPUTTRUNCATION_10BIT = 1,
+        HDMI_OUTPUTTRUNCATION_12BIT = 2,
+        HDMI_OUTPUTDITHER_8BIT = 3,
+        HDMI_OUTPUTDITHER_10BIT = 4,
+        HDMI_OUTPUTDITHER_12BIT = 5
+};
+
+enum hdmi_core_deepcolor_ed {
+        HDMI_DEEPCOLORPACKECTDISABLE = 0,
+        HDMI_DEEPCOLORPACKECTENABLE = 1
+};
+
+enum hdmi_core_packet_mode {
+        HDMI_PACKETMODERESERVEDVALUE = 0,
+        HDMI_PACKETMODE24BITPERPIXEL = 4,
+        HDMI_PACKETMODE30BITPERPIXEL = 5,
+        HDMI_PACKETMODE36BITPERPIXEL = 6,
+        HDMI_PACKETMODE48BITPERPIXEL = 7
+};
+
+enum hdmi_core_hdmi_dvi {
+        HDMI_DVI = 0,
+        HDMI_HDMI = 1
+};
+
+enum hdmi_core_tclkselclkmult {
+        HDMI_FPLL05IDCK = 0,
+        HDMI_FPLL10IDCK = 1,
+        HDMI_FPLL20IDCK = 2,
+        HDMI_FPLL40IDCK = 3
+};
+
+enum hdmi_core_packet_ctrl {
+        HDMI_PACKETENABLE = 1,
+        HDMI_PACKETDISABLE = 0,
+        HDMI_PACKETREPEATON = 1,
+        HDMI_PACKETREPEATOFF = 0
+};
+
+/* INFOFRAME_AVI_ definitions */
+enum hdmi_core_infoframe {
+        HDMI_INFOFRAME_AVI_DB1Y_RGB = 0,
+        HDMI_INFOFRAME_AVI_DB1Y_YUV422 = 1,
+        HDMI_INFOFRAME_AVI_DB1Y_YUV444 = 2,
+        HDMI_INFOFRAME_AVI_DB1A_ACTIVE_FORMAT_OFF = 0,
+        HDMI_INFOFRAME_AVI_DB1A_ACTIVE_FORMAT_ON =  1,
+        HDMI_INFOFRAME_AVI_DB1B_NO = 0,
+        HDMI_INFOFRAME_AVI_DB1B_VERT = 1,
+        HDMI_INFOFRAME_AVI_DB1B_HORI = 2,
+        HDMI_INFOFRAME_AVI_DB1B_VERTHORI = 3,
+        HDMI_INFOFRAME_AVI_DB1S_0 = 0,
+        HDMI_INFOFRAME_AVI_DB1S_1 = 1,
+        HDMI_INFOFRAME_AVI_DB1S_2 = 2,
+        HDMI_INFOFRAME_AVI_DB2C_NO = 0,
+        HDMI_INFOFRAME_AVI_DB2C_ITU601 = 1,
+        HDMI_INFOFRAME_AVI_DB2C_ITU709 = 2,
+        HDMI_INFOFRAME_AVI_DB2C_EC_EXTENDED = 3,
+        HDMI_INFOFRAME_AVI_DB2M_NO = 0,
+        HDMI_INFOFRAME_AVI_DB2M_43 = 1,
+        HDMI_INFOFRAME_AVI_DB2M_169 = 2,
+        HDMI_INFOFRAME_AVI_DB2R_SAME = 8,
+        HDMI_INFOFRAME_AVI_DB2R_43 = 9,
+        HDMI_INFOFRAME_AVI_DB2R_169 = 10,
+        HDMI_INFOFRAME_AVI_DB2R_149 = 11,
+        HDMI_INFOFRAME_AVI_DB3ITC_NO = 0,
+        HDMI_INFOFRAME_AVI_DB3ITC_YES = 1,
+        HDMI_INFOFRAME_AVI_DB3EC_XVYUV601 = 0,
+        HDMI_INFOFRAME_AVI_DB3EC_XVYUV709 = 1,
+        HDMI_INFOFRAME_AVI_DB3Q_DEFAULT = 0,
+        HDMI_INFOFRAME_AVI_DB3Q_LR = 1,
+        HDMI_INFOFRAME_AVI_DB3Q_FR = 2,
+        HDMI_INFOFRAME_AVI_DB3SC_NO = 0,
+        HDMI_INFOFRAME_AVI_DB3SC_HORI = 1,
+        HDMI_INFOFRAME_AVI_DB3SC_VERT = 2,
+        HDMI_INFOFRAME_AVI_DB3SC_HORIVERT = 3,
+        HDMI_INFOFRAME_AVI_DB5PR_NO = 0,
+        HDMI_INFOFRAME_AVI_DB5PR_2 = 1,
+        HDMI_INFOFRAME_AVI_DB5PR_3 = 2,
+        HDMI_INFOFRAME_AVI_DB5PR_4 = 3,
+        HDMI_INFOFRAME_AVI_DB5PR_5 = 4,
+        HDMI_INFOFRAME_AVI_DB5PR_6 = 5,
+        HDMI_INFOFRAME_AVI_DB5PR_7 = 6,
+        HDMI_INFOFRAME_AVI_DB5PR_8 = 7,
+        HDMI_INFOFRAME_AVI_DB5PR_9 = 8,
+        HDMI_INFOFRAME_AVI_DB5PR_10 = 9
+};
+
+enum hdmi_packing_mode {
+        HDMI_PACK_10b_RGB_YUV444 = 0,
+        HDMI_PACK_24b_RGB_YUV444_YUV422 = 1,
+        HDMI_PACK_20b_YUV422 = 2,
+        HDMI_PACK_ALREADYPACKED = 7
+};
+
+struct hdmi_core_video_config {
+        enum hdmi_core_inputbus_width   ip_bus_width;
+        enum hdmi_core_dither_trunc     op_dither_truc;
+        enum hdmi_core_deepcolor_ed     deep_color_pkt;
+        enum hdmi_core_packet_mode      pkt_mode;
+        enum hdmi_core_hdmi_dvi         hdmi_dvi;
+        enum hdmi_core_tclkselclkmult   tclk_sel_clkmult;
+};
+
+/*
+ * Refer to section 8.2 in HDMI 1.3 specification for
+ * details about infoframe databytes
+ */
+struct hdmi_core_infoframe_avi {
+        u8      db1_format;
+                /* Y0, Y1 rgb,yCbCr */
+        u8      db1_active_info;
+                /* A0  Active information Present */
+        u8      db1_bar_info_dv;
+                /* B0, B1 Bar info data valid */
+        u8      db1_scan_info;
+                /* S0, S1 scan information */
+        u8      db2_colorimetry;
+                /* C0, C1 colorimetry */
+        u8      db2_aspect_ratio;
+                /* M0, M1 Aspect ratio (4:3, 16:9) */
+        u8      db2_active_fmt_ar;
+                /* R0...R3 Active format aspect ratio */
+        u8      db3_itc;
+                /* ITC IT content. */
+        u8      db3_ec;
+                /* EC0, EC1, EC2 Extended colorimetry */
+        u8      db3_q_range;
+                /* Q1, Q0 Quantization range */
+        u8      db3_nup_scaling;
+                /* SC1, SC0 Non-uniform picture scaling */
+        u8      db4_videocode;
+                /* VIC0..6 Video format identification */
+        u8      db5_pixel_repeat;
+                /* PR0..PR3 Pixel repetition factor */
+        u16     db6_7_line_eoftop;
+                /* Line number end of top bar */
+        u16     db8_9_line_sofbottom;
+                /* Line number start of bottom bar */
+        u16     db10_11_pixel_eofleft;
+                /* Pixel number end of left bar */
+        u16     db12_13_pixel_sofright;
+                /* Pixel number start of right bar */
+};
+
+struct hdmi_core_packet_enable_repeat {
+        u32     audio_pkt;
+        u32     audio_pkt_repeat;
+        u32     avi_infoframe;
+        u32     avi_infoframe_repeat;
+        u32     gen_cntrl_pkt;
+        u32     gen_cntrl_pkt_repeat;
+        u32     generic_pkt;
+        u32     generic_pkt_repeat;
+};
+
+struct hdmi_video_format {
+        enum hdmi_packing_mode  packing_mode;
+        u32                     y_res;  /* Line per panel */
+        u32                     x_res;  /* pixel per line */
+};
+
+struct hdmi_video_interface {
+        int     vsp;    /* Vsync polarity */
+        int     hsp;    /* Hsync polarity */
+        int     interlacing;
+        int     tm;     /* Timing mode */
+};
+
+struct hdmi_cm {
+        int     code;
+        int     mode;
+};
+
+struct hdmi_config {
+        struct hdmi_timings timings;
+        u16     interlace;
+        struct hdmi_cm cm;
+};
+
+#endif
diff --git a/drivers/video/omap2/dss/hdmi_omap4_panel.c b/drivers/video/omap2/dss/hdmi_omap4_panel.c
new file mode 100644
index 000000000000..ffb5de94131f
--- /dev/null
+++ b/drivers/video/omap2/dss/hdmi_omap4_panel.c
@@ -0,0 +1,222 @@
+/*
+ * hdmi_omap4_panel.c
+ *
+ * HDMI library support functions for TI OMAP4 processors.
+ *
+ * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
+ * Authors:     Mythri P k <mythripk@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <plat/display.h>
+
+#include "dss.h"
+
+static struct {
+        struct mutex hdmi_lock;
+} hdmi;
+
+
+static int hdmi_panel_probe(struct omap_dss_device *dssdev)
+{
+        DSSDBG("ENTER hdmi_panel_probe\n");
+
+        dssdev->panel.config = OMAP_DSS_LCD_TFT |
+                        OMAP_DSS_LCD_IVS | OMAP_DSS_LCD_IHS;
+
+        /*
+         * Initialize the timings to 640 * 480
+         * This is only for framebuffer update not for TV timing setting
+         * Setting TV timing will be done only on enable
+         */
+        dssdev->panel.timings.x_res = 640;
+        dssdev->panel.timings.y_res = 480;
+
+        DSSDBG("hdmi_panel_probe x_res= %d y_res = %d\n",
+                dssdev->panel.timings.x_res,
+                dssdev->panel.timings.y_res);
+        return 0;
+}
+
+static void hdmi_panel_remove(struct omap_dss_device *dssdev)
+{
+
+}
+
+static int hdmi_panel_enable(struct omap_dss_device *dssdev)
+{
+        int r = 0;
+        DSSDBG("ENTER hdmi_panel_enable\n");
+
+        mutex_lock(&hdmi.hdmi_lock);
+
+        if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED) {
+                r = -EINVAL;
+                goto err;
+        }
+
+        r = omapdss_hdmi_display_enable(dssdev);
+        if (r) {
+                DSSERR("failed to power on\n");
+                goto err;
+        }
+
+        dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
+
+err:
+        mutex_unlock(&hdmi.hdmi_lock);
+
+        return r;
+}
+
+static void hdmi_panel_disable(struct omap_dss_device *dssdev)
+{
+        mutex_lock(&hdmi.hdmi_lock);
+
+        if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
+                omapdss_hdmi_display_disable(dssdev);
+
+        dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
+
+        mutex_unlock(&hdmi.hdmi_lock);
+}
+
+static int hdmi_panel_suspend(struct omap_dss_device *dssdev)
+{
+        int r = 0;
+
+        mutex_lock(&hdmi.hdmi_lock);
+
+        if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE) {
+                r = -EINVAL;
+                goto err;
+        }
+
+        dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
+
+        omapdss_hdmi_display_disable(dssdev);
+
+err:
+        mutex_unlock(&hdmi.hdmi_lock);
+
+        return r;
+}
+
+static int hdmi_panel_resume(struct omap_dss_device *dssdev)
+{
+        int r = 0;
+
+        mutex_lock(&hdmi.hdmi_lock);
+
+        if (dssdev->state != OMAP_DSS_DISPLAY_SUSPENDED) {
+                r = -EINVAL;
+                goto err;
+        }
+
+        r = omapdss_hdmi_display_enable(dssdev);
+        if (r) {
+                DSSERR("failed to power on\n");
+                goto err;
+        }
+
+        dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
+
+err:
+        mutex_unlock(&hdmi.hdmi_lock);
+
+        return r;
+}
+
+static void hdmi_get_timings(struct omap_dss_device *dssdev,
+                        struct omap_video_timings *timings)
+{
+        mutex_lock(&hdmi.hdmi_lock);
+
+        *timings = dssdev->panel.timings;
+
+        mutex_unlock(&hdmi.hdmi_lock);
+}
+
+static void hdmi_set_timings(struct omap_dss_device *dssdev,
+                        struct omap_video_timings *timings)
+{
+        DSSDBG("hdmi_set_timings\n");
+
+        mutex_lock(&hdmi.hdmi_lock);
+
+        dssdev->panel.timings = *timings;
+
+        if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
+                /* turn the hdmi off and on to get new timings to use */
+                omapdss_hdmi_display_disable(dssdev);
+                omapdss_hdmi_display_set_timing(dssdev);
+        }
+
+        mutex_unlock(&hdmi.hdmi_lock);
+}
+
+static int hdmi_check_timings(struct omap_dss_device *dssdev,
+                        struct omap_video_timings *timings)
+{
+        int r = 0;
+
+        DSSDBG("hdmi_check_timings\n");
+
+        mutex_lock(&hdmi.hdmi_lock);
+
+        r = omapdss_hdmi_display_check_timing(dssdev, timings);
+        if (r) {
+                DSSERR("Timing cannot be applied\n");
+                goto err;
+        }
+err:
+        mutex_unlock(&hdmi.hdmi_lock);
+        return r;
+}
+
+static struct omap_dss_driver hdmi_driver = {
+        .probe          = hdmi_panel_probe,
+        .remove         = hdmi_panel_remove,
+        .enable         = hdmi_panel_enable,
+        .disable        = hdmi_panel_disable,
+        .suspend        = hdmi_panel_suspend,
+        .resume         = hdmi_panel_resume,
+        .get_timings    = hdmi_get_timings,
+        .set_timings    = hdmi_set_timings,
+        .check_timings  = hdmi_check_timings,
+        .driver                 = {
+                .name   = "hdmi_panel",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int hdmi_panel_init(void)
+{
+        mutex_init(&hdmi.hdmi_lock);
+
+        omap_dss_register_driver(&hdmi_driver);
+
+        return 0;
+}
+
+void hdmi_panel_exit(void)
+{
+        omap_dss_unregister_driver(&hdmi_driver);
+
+}
diff --git a/drivers/video/omap2/dss/manager.c b/drivers/video/omap2/dss/manager.c
index 172d4e697309..bcd37ec86952 100644
--- a/drivers/video/omap2/dss/manager.c
+++ b/drivers/video/omap2/dss/manager.c
@@ -515,6 +515,8 @@ static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
 
         if (mgr->device->type == OMAP_DISPLAY_TYPE_VENC) {
                 irq = DISPC_IRQ_EVSYNC_ODD;
+        } else if (mgr->device->type == OMAP_DISPLAY_TYPE_HDMI) {
+                irq = DISPC_IRQ_EVSYNC_EVEN;
         } else {
                 if (mgr->id == OMAP_DSS_CHANNEL_LCD)
                         irq = DISPC_IRQ_VSYNC;
@@ -536,7 +538,8 @@ static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
         if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
 
-        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC) {
+        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
+                        || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
                 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
         } else {
                 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
@@ -613,7 +616,8 @@ int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
         if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
 
-        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC) {
+        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
+                        || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
                 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
         } else {
                 if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
@@ -1377,6 +1381,7 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
                 case OMAP_DISPLAY_TYPE_DBI:
                 case OMAP_DISPLAY_TYPE_SDI:
                 case OMAP_DISPLAY_TYPE_VENC:
+                case OMAP_DISPLAY_TYPE_HDMI:
                         default_get_overlay_fifo_thresholds(ovl->id, size,
                                         &oc->burst_size, &oc->fifo_low,
                                         &oc->fifo_high);
@@ -1394,7 +1399,7 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
         }
 
         r = 0;
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         if (!dss_cache.irq_enabled) {
                 u32 mask;
 
@@ -1407,7 +1412,7 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
                 dss_cache.irq_enabled = true;
         }
         configure_dispc();
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         spin_unlock_irqrestore(&dss_cache.lock, flags);
 
diff --git a/drivers/video/omap2/dss/overlay.c b/drivers/video/omap2/dss/overlay.c
index 456efef03c20..f1aca6d04011 100644
--- a/drivers/video/omap2/dss/overlay.c
+++ b/drivers/video/omap2/dss/overlay.c
@@ -490,7 +490,7 @@ static int omap_dss_set_manager(struct omap_overlay *ovl,
 
         ovl->manager = mgr;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         /* XXX: on manual update display, in auto update mode, a bug happens
          * here. When an overlay is first enabled on LCD, then it's disabled,
          * and the manager is changed to TV, we sometimes get SYNC_LOST_DIGIT
@@ -499,7 +499,7 @@ static int omap_dss_set_manager(struct omap_overlay *ovl,
          * but I don't understand how or why. */
         msleep(40);
         dispc_set_channel_out(ovl->id, mgr->id);
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         return 0;
 }
@@ -679,7 +679,8 @@ void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
                         lcd2_mgr->set_device(lcd2_mgr, dssdev);
                         mgr = lcd2_mgr;
                 }
-        } else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC) {
+        } else if (dssdev->type != OMAP_DISPLAY_TYPE_VENC
+                        && dssdev->type != OMAP_DISPLAY_TYPE_HDMI) {
                 if (!lcd_mgr->device || force) {
                         if (lcd_mgr->device)
                                 lcd_mgr->unset_device(lcd_mgr);
@@ -688,7 +689,8 @@ void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
                 }
         }
 
-        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC) {
+        if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
+                        || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
                 if (!tv_mgr->device || force) {
                         if (tv_mgr->device)
                                 tv_mgr->unset_device(tv_mgr);
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index 10a2ffe02882..5ea17f49c611 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -36,8 +36,6 @@
 #include <plat/display.h>
 #include "dss.h"
 
-#define RFBI_BASE               0x48050800
-
 struct rfbi_reg { u16 idx; };
 
 #define RFBI_REG(idx)           ((const struct rfbi_reg) { idx })
@@ -100,6 +98,7 @@ static int rfbi_convert_timings(struct rfbi_timings *t);
 static void rfbi_get_clk_info(u32 *clk_period, u32 *max_clk_div);
 
 static struct {
+        struct platform_device *pdev;
         void __iomem    *base;
 
         unsigned long   l4_khz;
@@ -142,9 +141,9 @@ static inline u32 rfbi_read_reg(const struct rfbi_reg idx)
 static void rfbi_enable_clocks(bool enable)
 {
         if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 }
 
 void omap_rfbi_write_command(const void *buf, u32 len)
@@ -497,7 +496,7 @@ unsigned long rfbi_get_max_tx_rate(void)
         };
 
         l4_rate = rfbi.l4_khz / 1000;
-        dss1_rate = dss_clk_get_rate(DSS_CLK_FCK1) / 1000000;
+        dss1_rate = dss_clk_get_rate(DSS_CLK_FCK) / 1000000;
 
         for (i = 0; i < ARRAY_SIZE(ftab); i++) {
                 /* Use a window instead of an exact match, to account
@@ -922,7 +921,7 @@ void rfbi_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, rfbi_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         DUMPREG(RFBI_REVISION);
         DUMPREG(RFBI_SYSCONFIG);
@@ -953,54 +952,10 @@ void rfbi_dump_regs(struct seq_file *s)
         DUMPREG(RFBI_VSYNC_WIDTH);
         DUMPREG(RFBI_HSYNC_WIDTH);
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 #undef DUMPREG
 }
 
-int rfbi_init(void)
-{
-        u32 rev;
-        u32 l;
-
-        spin_lock_init(&rfbi.cmd_lock);
-
-        init_completion(&rfbi.cmd_done);
-        atomic_set(&rfbi.cmd_fifo_full, 0);
-        atomic_set(&rfbi.cmd_pending, 0);
-
-        rfbi.base = ioremap(RFBI_BASE, SZ_256);
-        if (!rfbi.base) {
-                DSSERR("can't ioremap RFBI\n");
-                return -ENOMEM;
-        }
-
-        rfbi_enable_clocks(1);
-
-        msleep(10);
-
-        rfbi.l4_khz = dss_clk_get_rate(DSS_CLK_ICK) / 1000;
-
-        /* Enable autoidle and smart-idle */
-        l = rfbi_read_reg(RFBI_SYSCONFIG);
-        l |= (1 << 0) | (2 << 3);
-        rfbi_write_reg(RFBI_SYSCONFIG, l);
-
-        rev = rfbi_read_reg(RFBI_REVISION);
-        printk(KERN_INFO "OMAP RFBI rev %d.%d\n",
-               FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
-
-        rfbi_enable_clocks(0);
-
-        return 0;
-}
-
-void rfbi_exit(void)
-{
-        DSSDBG("rfbi_exit\n");
-
-        iounmap(rfbi.base);
-}
-
 int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
 {
         int r;
@@ -1056,3 +1011,74 @@ int rfbi_init_display(struct omap_dss_device *dssdev)
         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
         return 0;
 }
+
+/* RFBI HW IP initialisation */
+static int omap_rfbihw_probe(struct platform_device *pdev)
+{
+        u32 rev;
+        u32 l;
+        struct resource *rfbi_mem;
+
+        rfbi.pdev = pdev;
+
+        spin_lock_init(&rfbi.cmd_lock);
+
+        init_completion(&rfbi.cmd_done);
+        atomic_set(&rfbi.cmd_fifo_full, 0);
+        atomic_set(&rfbi.cmd_pending, 0);
+
+        rfbi_mem = platform_get_resource(rfbi.pdev, IORESOURCE_MEM, 0);
+        if (!rfbi_mem) {
+                DSSERR("can't get IORESOURCE_MEM RFBI\n");
+                return -EINVAL;
+        }
+        rfbi.base = ioremap(rfbi_mem->start, resource_size(rfbi_mem));
+        if (!rfbi.base) {
+                DSSERR("can't ioremap RFBI\n");
+                return -ENOMEM;
+        }
+
+        rfbi_enable_clocks(1);
+
+        msleep(10);
+
+        rfbi.l4_khz = dss_clk_get_rate(DSS_CLK_ICK) / 1000;
+
+        /* Enable autoidle and smart-idle */
+        l = rfbi_read_reg(RFBI_SYSCONFIG);
+        l |= (1 << 0) | (2 << 3);
+        rfbi_write_reg(RFBI_SYSCONFIG, l);
+
+        rev = rfbi_read_reg(RFBI_REVISION);
+        dev_dbg(&pdev->dev, "OMAP RFBI rev %d.%d\n",
+               FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
+
+        rfbi_enable_clocks(0);
+
+        return 0;
+}
+
+static int omap_rfbihw_remove(struct platform_device *pdev)
+{
+        iounmap(rfbi.base);
+        return 0;
+}
+
+static struct platform_driver omap_rfbihw_driver = {
+        .probe          = omap_rfbihw_probe,
+        .remove         = omap_rfbihw_remove,
+        .driver         = {
+                .name   = "omapdss_rfbi",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int rfbi_init_platform_driver(void)
+{
+        return platform_driver_register(&omap_rfbihw_driver);
+}
+
+void rfbi_uninit_platform_driver(void)
+{
+        return platform_driver_unregister(&omap_rfbihw_driver);
+}
diff --git a/drivers/video/omap2/dss/sdi.c b/drivers/video/omap2/dss/sdi.c
index b64adf7dfc88..54a53e648180 100644
--- a/drivers/video/omap2/dss/sdi.c
+++ b/drivers/video/omap2/dss/sdi.c
@@ -30,7 +30,6 @@
 #include "dss.h"
 
 static struct {
-        bool skip_init;
         bool update_enabled;
         struct regulator *vdds_sdi_reg;
 } sdi;
@@ -68,9 +67,7 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err1;
 
-        /* In case of skip_init sdi_init has already enabled the clocks */
-        if (!sdi.skip_init)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         sdi_basic_init(dssdev);
 
@@ -80,14 +77,8 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         dispc_set_pol_freq(dssdev->manager->id, dssdev->panel.config,
                         dssdev->panel.acbi, dssdev->panel.acb);
 
-        if (!sdi.skip_init) {
-                r = dss_calc_clock_div(1, t->pixel_clock * 1000,
-                                &dss_cinfo, &dispc_cinfo);
-        } else {
-                r = dss_get_clock_div(&dss_cinfo);
-                r = dispc_get_clock_div(dssdev->manager->id, &dispc_cinfo);
-        }
-
+        r = dss_calc_clock_div(1, t->pixel_clock * 1000,
+                        &dss_cinfo, &dispc_cinfo);
         if (r)
                 goto err2;
 
@@ -116,21 +107,17 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err2;
 
-        if (!sdi.skip_init) {
-                dss_sdi_init(dssdev->phy.sdi.datapairs);
-                r = dss_sdi_enable();
-                if (r)
-                        goto err1;
-                mdelay(2);
-        }
+        dss_sdi_init(dssdev->phy.sdi.datapairs);
+        r = dss_sdi_enable();
+        if (r)
+                goto err1;
+        mdelay(2);
 
         dssdev->manager->enable(dssdev->manager);
 
-        sdi.skip_init = 0;
-
         return 0;
 err2:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
         regulator_disable(sdi.vdds_sdi_reg);
 err1:
         omap_dss_stop_device(dssdev);
@@ -145,7 +132,7 @@ void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
 
         dss_sdi_disable();
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
+        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         regulator_disable(sdi.vdds_sdi_reg);
 
@@ -157,25 +144,24 @@ int sdi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("SDI init\n");
 
+        if (sdi.vdds_sdi_reg == NULL) {
+                struct regulator *vdds_sdi;
+
+                vdds_sdi = dss_get_vdds_sdi();
+
+                if (IS_ERR(vdds_sdi)) {
+                        DSSERR("can't get VDDS_SDI regulator\n");
+                        return PTR_ERR(vdds_sdi);
+                }
+
+                sdi.vdds_sdi_reg = vdds_sdi;
+        }
+
         return 0;
 }
 
-int sdi_init(bool skip_init)
+int sdi_init(void)
 {
-        /* we store this for first display enable, then clear it */
-        sdi.skip_init = skip_init;
-
-        sdi.vdds_sdi_reg = dss_get_vdds_sdi();
-        if (IS_ERR(sdi.vdds_sdi_reg)) {
-                DSSERR("can't get VDDS_SDI regulator\n");
-                return PTR_ERR(sdi.vdds_sdi_reg);
-        }
-        /*
-         * Enable clocks already here, otherwise there would be a toggle
-         * of them until sdi_display_enable is called.
-         */
-        if (skip_init)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
         return 0;
 }
 
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index eff35050e28a..8e35a5bae429 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -39,8 +39,6 @@
 
 #include "dss.h"
 
-#define VENC_BASE       0x48050C00
-
 /* Venc registers */
 #define VENC_REV_ID                             0x00
 #define VENC_STATUS                             0x04
@@ -289,6 +287,7 @@ const struct omap_video_timings omap_dss_ntsc_timings = {
 EXPORT_SYMBOL(omap_dss_ntsc_timings);
 
 static struct {
+        struct platform_device *pdev;
         void __iomem *base;
         struct mutex venc_lock;
         u32 wss_data;
@@ -381,11 +380,11 @@ static void venc_reset(void)
 static void venc_enable_clocks(int enable)
 {
         if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1 | DSS_CLK_54M |
-                                DSS_CLK_96M);
+                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_TVFCK |
+                                DSS_CLK_VIDFCK);
         else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1 | DSS_CLK_54M |
-                                DSS_CLK_96M);
+                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_TVFCK |
+                                DSS_CLK_VIDFCK);
 }
 
 static const struct venc_config *venc_timings_to_config(
@@ -641,50 +640,23 @@ static struct omap_dss_driver venc_driver = {
 };
 /* driver end */
 
-
-
-int venc_init(struct platform_device *pdev)
+int venc_init_display(struct omap_dss_device *dssdev)
 {
-        u8 rev_id;
+        DSSDBG("init_display\n");
 
-        mutex_init(&venc.venc_lock);
+        if (venc.vdda_dac_reg == NULL) {
+                struct regulator *vdda_dac;
 
-        venc.wss_data = 0;
+                vdda_dac = regulator_get(&venc.pdev->dev, "vdda_dac");
 
-        venc.base = ioremap(VENC_BASE, SZ_1K);
-        if (!venc.base) {
-                DSSERR("can't ioremap VENC\n");
-                return -ENOMEM;
-        }
+                if (IS_ERR(vdda_dac)) {
+                        DSSERR("can't get VDDA_DAC regulator\n");
+                        return PTR_ERR(vdda_dac);
+                }
 
-        venc.vdda_dac_reg = dss_get_vdda_dac();
-        if (IS_ERR(venc.vdda_dac_reg)) {
-                iounmap(venc.base);
-                DSSERR("can't get VDDA_DAC regulator\n");
-                return PTR_ERR(venc.vdda_dac_reg);
+                venc.vdda_dac_reg = vdda_dac;
         }
 
-        venc_enable_clocks(1);
-
-        rev_id = (u8)(venc_read_reg(VENC_REV_ID) & 0xff);
-        printk(KERN_INFO "OMAP VENC rev %d\n", rev_id);
-
-        venc_enable_clocks(0);
-
-        return omap_dss_register_driver(&venc_driver);
-}
-
-void venc_exit(void)
-{
-        omap_dss_unregister_driver(&venc_driver);
-
-        iounmap(venc.base);
-}
-
-int venc_init_display(struct omap_dss_device *dssdev)
-{
-        DSSDBG("init_display\n");
-
         return 0;
 }
 
@@ -740,3 +712,73 @@ void venc_dump_regs(struct seq_file *s)
 
 #undef DUMPREG
 }
+
+/* VENC HW IP initialisation */
+static int omap_venchw_probe(struct platform_device *pdev)
+{
+        u8 rev_id;
+        struct resource *venc_mem;
+
+        venc.pdev = pdev;
+
+        mutex_init(&venc.venc_lock);
+
+        venc.wss_data = 0;
+
+        venc_mem = platform_get_resource(venc.pdev, IORESOURCE_MEM, 0);
+        if (!venc_mem) {
+                DSSERR("can't get IORESOURCE_MEM VENC\n");
+                return -EINVAL;
+        }
+        venc.base = ioremap(venc_mem->start, resource_size(venc_mem));
+        if (!venc.base) {
+                DSSERR("can't ioremap VENC\n");
+                return -ENOMEM;
+        }
+
+        venc_enable_clocks(1);
+
+        rev_id = (u8)(venc_read_reg(VENC_REV_ID) & 0xff);
+        dev_dbg(&pdev->dev, "OMAP VENC rev %d\n", rev_id);
+
+        venc_enable_clocks(0);
+
+        return omap_dss_register_driver(&venc_driver);
+}
+
+static int omap_venchw_remove(struct platform_device *pdev)
+{
+        if (venc.vdda_dac_reg != NULL) {
+                regulator_put(venc.vdda_dac_reg);
+                venc.vdda_dac_reg = NULL;
+        }
+        omap_dss_unregister_driver(&venc_driver);
+
+        iounmap(venc.base);
+        return 0;
+}
+
+static struct platform_driver omap_venchw_driver = {
+        .probe          = omap_venchw_probe,
+        .remove         = omap_venchw_remove,
+        .driver         = {
+                .name   = "omapdss_venc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int venc_init_platform_driver(void)
+{
+        if (cpu_is_omap44xx())
+                return 0;
+
+        return platform_driver_register(&omap_venchw_driver);
+}
+
+void venc_uninit_platform_driver(void)
+{
+        if (cpu_is_omap44xx())
+                return;
+
+        return platform_driver_unregister(&omap_venchw_driver);
+}
diff --git a/drivers/video/omap2/omapfb/Kconfig b/drivers/video/omap2/omapfb/Kconfig
index 65149b22cf37..aa33386c81ff 100644
--- a/drivers/video/omap2/omapfb/Kconfig
+++ b/drivers/video/omap2/omapfb/Kconfig
@@ -1,5 +1,5 @@
 menuconfig FB_OMAP2
-        tristate "OMAP2/3 frame buffer support (EXPERIMENTAL)"
+        tristate "OMAP2+ frame buffer support (EXPERIMENTAL)"
         depends on FB && OMAP2_DSS
 
         select OMAP2_VRAM
@@ -8,10 +8,10 @@ menuconfig FB_OMAP2
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
         help
-          Frame buffer driver for OMAP2/3 based boards.
+          Frame buffer driver for OMAP2+ based boards.
 
 config FB_OMAP2_DEBUG_SUPPORT
-        bool "Debug support for OMAP2/3 FB"
+        bool "Debug support for OMAP2+ FB"
         default y
         depends on FB_OMAP2
         help
diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c
index 4fdab8e9c496..505ec6672049 100644
--- a/drivers/video/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/omap2/omapfb/omapfb-main.c
@@ -2090,7 +2090,7 @@ static int omapfb_set_def_mode(struct omapfb2_device *fbdev,
 {
         int r;
         u8 bpp;
-        struct omap_video_timings timings;
+        struct omap_video_timings timings, temp_timings;
 
         r = omapfb_mode_to_timings(mode_str, &timings, &bpp);
         if (r)
@@ -2100,14 +2100,23 @@ static int omapfb_set_def_mode(struct omapfb2_device *fbdev,
         fbdev->bpp_overrides[fbdev->num_bpp_overrides].bpp = bpp;
         ++fbdev->num_bpp_overrides;
 
-        if (!display->driver->check_timings || !display->driver->set_timings)
-                return -EINVAL;
+        if (display->driver->check_timings) {
+                r = display->driver->check_timings(display, &timings);
+                if (r)
+                        return r;
+        } else {
+                /* If check_timings is not present compare xres and yres */
+                if (display->driver->get_timings) {
+                        display->driver->get_timings(display, &temp_timings);
 
-        r = display->driver->check_timings(display, &timings);
-        if (r)
-                return r;
+                        if (temp_timings.x_res != timings.x_res ||
+                                temp_timings.y_res != timings.y_res)
+                                return -EINVAL;
+                }
+        }
 
-        display->driver->set_timings(display, &timings);
+        if (display->driver->set_timings)
+                        display->driver->set_timings(display, &timings);
 
         return 0;
 }
diff --git a/drivers/video/pxa3xx-gcu.c b/drivers/video/pxa3xx-gcu.c
index cf4beb9dc9bb..0283c7021090 100644
--- a/drivers/video/pxa3xx-gcu.c
+++ b/drivers/video/pxa3xx-gcu.c
@@ -25,7 +25,7 @@
 
 /*
  * WARNING: This controller is attached to System Bus 2 of the PXA which
- * needs its arbiter to be enabled explictly (CKENB & 1<<9).
+ * needs its arbiter to be enabled explicitly (CKENB & 1<<9).
  * There is currently no way to do this from Linux, so you need to teach
  * your bootloader for now.
  */
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 825b665245bb..0f4e8c942f9e 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -627,7 +627,12 @@ static void overlay1fb_enable(struct pxafb_layer *ofb)
 
 static void overlay1fb_disable(struct pxafb_layer *ofb)
 {
-        uint32_t lccr5 = lcd_readl(ofb->fbi, LCCR5);
+        uint32_t lccr5;
+
+        if (!(lcd_readl(ofb->fbi, OVL1C1) & OVLxC1_OEN))
+                return;
+
+        lccr5 = lcd_readl(ofb->fbi, LCCR5);
 
         lcd_writel(ofb->fbi, OVL1C1, ofb->control[0] & ~OVLxC1_OEN);
 
@@ -685,7 +690,12 @@ static void overlay2fb_enable(struct pxafb_layer *ofb)
 
 static void overlay2fb_disable(struct pxafb_layer *ofb)
 {
-        uint32_t lccr5 = lcd_readl(ofb->fbi, LCCR5);
+        uint32_t lccr5;
+
+        if (!(lcd_readl(ofb->fbi, OVL2C1) & OVLxC1_OEN))
+                return;
+
+        lccr5 = lcd_readl(ofb->fbi, LCCR5);
 
         lcd_writel(ofb->fbi, OVL2C1, ofb->control[0] & ~OVLxC1_OEN);
 
@@ -720,12 +730,10 @@ static int overlayfb_open(struct fb_info *info, int user)
         if (user == 0)
                 return -ENODEV;
 
-        /* allow only one user at a time */
-        if (atomic_inc_and_test(&ofb->usage))
-                return -EBUSY;
+        if (ofb->usage++ == 0)
+                /* unblank the base framebuffer */
+                fb_blank(&ofb->fbi->fb, FB_BLANK_UNBLANK);
 
-        /* unblank the base framebuffer */
-        fb_blank(&ofb->fbi->fb, FB_BLANK_UNBLANK);
         return 0;
 }
 
@@ -733,12 +741,15 @@ static int overlayfb_release(struct fb_info *info, int user)
 {
         struct pxafb_layer *ofb = (struct pxafb_layer*) info;
 
-        atomic_dec(&ofb->usage);
-        ofb->ops->disable(ofb);
+        if (ofb->usage == 1) {
+                ofb->ops->disable(ofb);
+                ofb->fb.var.height      = -1;
+                ofb->fb.var.width       = -1;
+                ofb->fb.var.xres = ofb->fb.var.xres_virtual = 0;
+                ofb->fb.var.yres = ofb->fb.var.yres_virtual = 0;
 
-        free_pages_exact(ofb->video_mem, ofb->video_mem_size);
-        ofb->video_mem = NULL;
-        ofb->video_mem_size = 0;
+                ofb->usage--;
+        }
         return 0;
 }
 
@@ -750,7 +761,7 @@ static int overlayfb_check_var(struct fb_var_screeninfo *var,
         int xpos, ypos, pfor, bpp;
 
         xpos = NONSTD_TO_XPOS(var->nonstd);
-        ypos = NONSTD_TO_XPOS(var->nonstd);
+        ypos = NONSTD_TO_YPOS(var->nonstd);
         pfor = NONSTD_TO_PFOR(var->nonstd);
 
         bpp = pxafb_var_to_bpp(var);
@@ -794,7 +805,7 @@ static int overlayfb_check_var(struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int overlayfb_map_video_memory(struct pxafb_layer *ofb)
+static int overlayfb_check_video_memory(struct pxafb_layer *ofb)
 {
         struct fb_var_screeninfo *var = &ofb->fb.var;
         int pfor = NONSTD_TO_PFOR(var->nonstd);
@@ -812,27 +823,11 @@ static int overlayfb_map_video_memory(struct pxafb_layer *ofb)
 
         size = PAGE_ALIGN(ofb->fb.fix.line_length * var->yres_virtual);
 
-        /* don't re-allocate if the original video memory is enough */
         if (ofb->video_mem) {
                 if (ofb->video_mem_size >= size)
                         return 0;
-
-                free_pages_exact(ofb->video_mem, ofb->video_mem_size);
         }
-
-        ofb->video_mem = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
-        if (ofb->video_mem == NULL)
-                return -ENOMEM;
-
-        ofb->video_mem_phys = virt_to_phys(ofb->video_mem);
-        ofb->video_mem_size = size;
-
-        mutex_lock(&ofb->fb.mm_lock);
-        ofb->fb.fix.smem_start  = ofb->video_mem_phys;
-        ofb->fb.fix.smem_len    = ofb->fb.fix.line_length * var->yres_virtual;
-        mutex_unlock(&ofb->fb.mm_lock);
-        ofb->fb.screen_base     = ofb->video_mem;
-        return 0;
+        return -EINVAL;
 }
 
 static int overlayfb_set_par(struct fb_info *info)
@@ -841,13 +836,13 @@ static int overlayfb_set_par(struct fb_info *info)
         struct fb_var_screeninfo *var = &info->var;
         int xpos, ypos, pfor, bpp, ret;
 
-        ret = overlayfb_map_video_memory(ofb);
+        ret = overlayfb_check_video_memory(ofb);
         if (ret)
                 return ret;
 
         bpp  = pxafb_var_to_bpp(var);
         xpos = NONSTD_TO_XPOS(var->nonstd);
-        ypos = NONSTD_TO_XPOS(var->nonstd);
+        ypos = NONSTD_TO_YPOS(var->nonstd);
         pfor = NONSTD_TO_PFOR(var->nonstd);
 
         ofb->control[0] = OVLxC1_PPL(var->xres) | OVLxC1_LPO(var->yres) |
@@ -891,7 +886,7 @@ static void __devinit init_pxafb_overlay(struct pxafb_info *fbi,
 
         ofb->id = id;
         ofb->ops = &ofb_ops[id];
-        atomic_set(&ofb->usage, 0);
+        ofb->usage = 0;
         ofb->fbi = fbi;
         init_completion(&ofb->branch_done);
 }
@@ -904,29 +899,60 @@ static inline int pxafb_overlay_supported(void)
         return 0;
 }
 
-static int __devinit pxafb_overlay_init(struct pxafb_info *fbi)
+static int __devinit pxafb_overlay_map_video_memory(struct pxafb_info *pxafb,
+        struct pxafb_layer *ofb)
+{
+        /* We assume that user will use at most video_mem_size for overlay fb,
+         * anyway, it's useless to use 16bpp main plane and 24bpp overlay
+         */
+        ofb->video_mem = alloc_pages_exact(PAGE_ALIGN(pxafb->video_mem_size),
+                GFP_KERNEL | __GFP_ZERO);
+        if (ofb->video_mem == NULL)
+                return -ENOMEM;
+
+        ofb->video_mem_phys = virt_to_phys(ofb->video_mem);
+        ofb->video_mem_size = PAGE_ALIGN(pxafb->video_mem_size);
+
+        mutex_lock(&ofb->fb.mm_lock);
+        ofb->fb.fix.smem_start  = ofb->video_mem_phys;
+        ofb->fb.fix.smem_len    = pxafb->video_mem_size;
+        mutex_unlock(&ofb->fb.mm_lock);
+
+        ofb->fb.screen_base     = ofb->video_mem;
+
+        return 0;
+}
+
+static void __devinit pxafb_overlay_init(struct pxafb_info *fbi)
 {
         int i, ret;
 
         if (!pxafb_overlay_supported())
-                return 0;
+                return;
 
         for (i = 0; i < 2; i++) {
-                init_pxafb_overlay(fbi, &fbi->overlay[i], i);
-                ret = register_framebuffer(&fbi->overlay[i].fb);
+                struct pxafb_layer *ofb = &fbi->overlay[i];
+                init_pxafb_overlay(fbi, ofb, i);
+                ret = register_framebuffer(&ofb->fb);
                 if (ret) {
                         dev_err(fbi->dev, "failed to register overlay %d\n", i);
-                        return ret;
+                        continue;
                 }
+                ret = pxafb_overlay_map_video_memory(fbi, ofb);
+                if (ret) {
+                        dev_err(fbi->dev,
+                                "failed to map video memory for overlay %d\n",
+                                i);
+                        unregister_framebuffer(&ofb->fb);
+                        continue;
+                }
+                ofb->registered = 1;
         }
 
         /* mask all IU/BS/EOF/SOF interrupts */
         lcd_writel(fbi, LCCR5, ~0);
 
-        /* place overlay(s) on top of base */
-        fbi->lccr0 |= LCCR0_OUC;
         pr_info("PXA Overlay driver loaded successfully!\n");
-        return 0;
 }
 
 static void __devexit pxafb_overlay_exit(struct pxafb_info *fbi)
@@ -936,8 +962,15 @@ static void __devexit pxafb_overlay_exit(struct pxafb_info *fbi)
         if (!pxafb_overlay_supported())
                 return;
 
-        for (i = 0; i < 2; i++)
-                unregister_framebuffer(&fbi->overlay[i].fb);
+        for (i = 0; i < 2; i++) {
+                struct pxafb_layer *ofb = &fbi->overlay[i];
+                if (ofb->registered) {
+                        if (ofb->video_mem)
+                                free_pages_exact(ofb->video_mem,
+                                        ofb->video_mem_size);
+                        unregister_framebuffer(&ofb->fb);
+                }
+        }
 }
 #else
 static inline void pxafb_overlay_init(struct pxafb_info *fbi) {}
@@ -1368,7 +1401,8 @@ static int pxafb_activate_var(struct fb_var_screeninfo *var,
             (lcd_readl(fbi, LCCR3) != fbi->reg_lccr3) ||
             (lcd_readl(fbi, LCCR4) != fbi->reg_lccr4) ||
             (lcd_readl(fbi, FDADR0) != fbi->fdadr[0]) ||
-            (lcd_readl(fbi, FDADR1) != fbi->fdadr[1]))
+            ((fbi->lccr0 & LCCR0_SDS) &&
+            (lcd_readl(fbi, FDADR1) != fbi->fdadr[1])))
                 pxafb_schedule_work(fbi, C_REENABLE);
 
         return 0;
@@ -1420,7 +1454,8 @@ static void pxafb_enable_controller(struct pxafb_info *fbi)
         lcd_writel(fbi, LCCR0, fbi->reg_lccr0 & ~LCCR0_ENB);
 
         lcd_writel(fbi, FDADR0, fbi->fdadr[0]);
-        lcd_writel(fbi, FDADR1, fbi->fdadr[1]);
+        if (fbi->lccr0 & LCCR0_SDS)
+                lcd_writel(fbi, FDADR1, fbi->fdadr[1]);
         lcd_writel(fbi, LCCR0, fbi->reg_lccr0 | LCCR0_ENB);
 }
 
@@ -1613,7 +1648,10 @@ pxafb_freq_transition(struct notifier_block *nb, unsigned long val, void *data)
 
         switch (val) {
         case CPUFREQ_PRECHANGE:
-                set_ctrlr_state(fbi, C_DISABLE_CLKCHANGE);
+#ifdef CONFIG_FB_PXA_OVERLAY
+                if (!(fbi->overlay[0].usage || fbi->overlay[1].usage))
+#endif
+                        set_ctrlr_state(fbi, C_DISABLE_CLKCHANGE);
                 break;
 
         case CPUFREQ_POSTCHANGE:
@@ -1806,6 +1844,12 @@ static struct pxafb_info * __devinit pxafb_init_fbinfo(struct device *dev)
 
         pxafb_decode_mach_info(fbi, inf);
 
+#ifdef CONFIG_FB_PXA_OVERLAY
+        /* place overlay(s) on top of base */
+        if (pxafb_overlay_supported())
+                fbi->lccr0 |= LCCR0_OUC;
+#endif
+
         init_waitqueue_head(&fbi->ctrlr_wait);
         INIT_WORK(&fbi->task, pxafb_task);
         mutex_init(&fbi->ctrlr_lock);
diff --git a/drivers/video/pxafb.h b/drivers/video/pxafb.h
index 2353521c5c8c..26ba9fa3f737 100644
--- a/drivers/video/pxafb.h
+++ b/drivers/video/pxafb.h
@@ -92,7 +92,8 @@ struct pxafb_layer_ops {
 struct pxafb_layer {
         struct fb_info          fb;
         int                     id;
-        atomic_t                usage;
+        int                     registered;
+        uint32_t                usage;
         uint32_t                control[2];
 
         struct pxafb_layer_ops  *ops;
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index da388186d617..d8ab7be4fd6b 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -355,6 +355,7 @@ static void riva_bl_init(struct riva_par *par)
         snprintf(name, sizeof(name), "rivabl%d", info->node);
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_RAW;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, info->dev, par, &riva_bl_ops,
                                        &props);
diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c
index 83ce9a04d872..3b6cdcac8f1a 100644
--- a/drivers/video/s3c-fb.c
+++ b/drivers/video/s3c-fb.c
@@ -48,7 +48,7 @@
 #undef writel
 #define writel(v, r) do { \
         printk(KERN_DEBUG "%s: %08x => %p\n", __func__, (unsigned int)v, r); \
-        __raw_writel(v, r); } while(0)
+        __raw_writel(v, r); } while (0)
 #endif /* FB_S3C_DEBUG_REGWRITE */
 
 /* irq_flags bits */
@@ -518,7 +518,7 @@ static int s3c_fb_set_par(struct fb_info *info)
 
                 data = VIDTCON2_LINEVAL(var->yres - 1) |
                        VIDTCON2_HOZVAL(var->xres - 1);
-                writel(data, regs +sfb->variant.vidtcon + 8 );
+                writel(data, regs + sfb->variant.vidtcon + 8);
         }
 
         /* write the buffer address */
@@ -1304,6 +1304,7 @@ static void s3c_fb_clear_win(struct s3c_fb *sfb, int win)
 
 static int __devinit s3c_fb_probe(struct platform_device *pdev)
 {
+        const struct platform_device_id *platid;
         struct s3c_fb_driverdata *fbdrv;
         struct device *dev = &pdev->dev;
         struct s3c_fb_platdata *pd;
@@ -1312,7 +1313,8 @@ static int __devinit s3c_fb_probe(struct platform_device *pdev)
         int win;
         int ret = 0;
 
-        fbdrv = (struct s3c_fb_driverdata *)platform_get_device_id(pdev)->driver_data;
+        platid = platform_get_device_id(pdev);
+        fbdrv = (struct s3c_fb_driverdata *)platid->driver_data;
 
         if (fbdrv->variant.nr_windows > S3C_FB_MAX_WIN) {
                 dev_err(dev, "too many windows, cannot attach\n");
@@ -1340,6 +1342,7 @@ static int __devinit s3c_fb_probe(struct platform_device *pdev)
         sfb->bus_clk = clk_get(dev, "lcd");
         if (IS_ERR(sfb->bus_clk)) {
                 dev_err(dev, "failed to get bus clock\n");
+                ret = PTR_ERR(sfb->bus_clk);
                 goto err_sfb;
         }
 
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index 75738a928610..c4482f2e5799 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -64,15 +64,18 @@ static const struct svga_fb_format s3fb_formats[] = {
 
 static const struct svga_pll s3_pll = {3, 129, 3, 33, 0, 3,
         35000, 240000, 14318};
+static const struct svga_pll s3_trio3d_pll = {3, 129, 3, 31, 0, 4,
+        230000, 460000, 14318};
 
 static const int s3_memsizes[] = {4096, 0, 3072, 8192, 2048, 6144, 1024, 512};
 
 static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64", "S3 Trio64V+",
                         "S3 Trio64UV+", "S3 Trio64V2/DX", "S3 Trio64V2/GX",
-                        "S3 Plato/PX", "S3 Aurora64VP", "S3 Virge",
+                        "S3 Plato/PX", "S3 Aurora64V+", "S3 Virge",
                         "S3 Virge/VX", "S3 Virge/DX", "S3 Virge/GX",
-                        "S3 Virge/GX2", "S3 Virge/GX2P", "S3 Virge/GX2P",
-                        "S3 Trio3D/1X", "S3 Trio3D/2X", "S3 Trio3D/2X"};
+                        "S3 Virge/GX2", "S3 Virge/GX2+", "",
+                        "S3 Trio3D/1X", "S3 Trio3D/2X", "S3 Trio3D/2X",
+                        "S3 Trio3D"};
 
 #define CHIP_UNKNOWN            0x00
 #define CHIP_732_TRIO32         0x01
@@ -87,12 +90,12 @@ static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64",
 #define CHIP_988_VIRGE_VX       0x0A
 #define CHIP_375_VIRGE_DX       0x0B
 #define CHIP_385_VIRGE_GX       0x0C
-#define CHIP_356_VIRGE_GX2      0x0D
-#define CHIP_357_VIRGE_GX2P     0x0E
-#define CHIP_359_VIRGE_GX2P     0x0F
+#define CHIP_357_VIRGE_GX2      0x0D
+#define CHIP_359_VIRGE_GX2P     0x0E
 #define CHIP_360_TRIO3D_1X      0x10
 #define CHIP_362_TRIO3D_2X      0x11
 #define CHIP_368_TRIO3D_2X      0x12
+#define CHIP_365_TRIO3D         0x13
 
 #define CHIP_XXX_TRIO           0x80
 #define CHIP_XXX_TRIO64V2_DXGX  0x81
@@ -119,9 +122,11 @@ static const struct vga_regset s3_v_sync_start_regs[]   = {{0x10, 0, 7}, {0x07,
 static const struct vga_regset s3_v_sync_end_regs[]     = {{0x11, 0, 3}, VGA_REGSET_END};
 
 static const struct vga_regset s3_line_compare_regs[]   = {{0x18, 0, 7}, {0x07, 4, 4}, {0x09, 6, 6}, {0x5E, 6, 6}, VGA_REGSET_END};
-static const struct vga_regset s3_start_address_regs[]  = {{0x0d, 0, 7}, {0x0c, 0, 7}, {0x31, 4, 5}, {0x51, 0, 1}, VGA_REGSET_END};
+static const struct vga_regset s3_start_address_regs[]  = {{0x0d, 0, 7}, {0x0c, 0, 7}, {0x69, 0, 4}, VGA_REGSET_END};
 static const struct vga_regset s3_offset_regs[]         = {{0x13, 0, 7}, {0x51, 4, 5}, VGA_REGSET_END}; /* set 0x43 bit 2 to 0 */
 
+static const struct vga_regset s3_dtpc_regs[]           = {{0x3B, 0, 7}, {0x5D, 6, 6}, VGA_REGSET_END};
+
 static const struct svga_timing_regs s3_timing_regs     = {
         s3_h_total_regs, s3_h_display_regs, s3_h_blank_start_regs,
         s3_h_blank_end_regs, s3_h_sync_start_regs, s3_h_sync_end_regs,
@@ -188,12 +193,19 @@ static void s3fb_settile_fast(struct fb_info *info, struct fb_tilemap *map)
         }
 }
 
+static void s3fb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
+{
+        struct s3fb_info *par = info->par;
+
+        svga_tilecursor(par->state.vgabase, info, cursor);
+}
+
 static struct fb_tile_ops s3fb_tile_ops = {
         .fb_settile     = svga_settile,
         .fb_tilecopy    = svga_tilecopy,
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
-        .fb_tilecursor  = svga_tilecursor,
+        .fb_tilecursor  = s3fb_tilecursor,
         .fb_get_tilemax = svga_get_tilemax,
 };
 
@@ -202,7 +214,7 @@ static struct fb_tile_ops s3fb_fast_tile_ops = {
         .fb_tilecopy    = svga_tilecopy,
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
-        .fb_tilecursor  = svga_tilecursor,
+        .fb_tilecursor  = s3fb_tilecursor,
         .fb_get_tilemax = svga_get_tilemax,
 };
 
@@ -334,33 +346,36 @@ static void s3_set_pixclock(struct fb_info *info, u32 pixclock)
         u8 regval;
         int rv;
 
-        rv = svga_compute_pll(&s3_pll, 1000000000 / pixclock, &m, &n, &r, info->node);
+        rv = svga_compute_pll((par->chip == CHIP_365_TRIO3D) ? &s3_trio3d_pll : &s3_pll,
+                              1000000000 / pixclock, &m, &n, &r, info->node);
         if (rv < 0) {
                 printk(KERN_ERR "fb%d: cannot set requested pixclock, keeping old value\n", info->node);
                 return;
         }
 
         /* Set VGA misc register  */
-        regval = vga_r(NULL, VGA_MIS_R);
-        vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
+        regval = vga_r(par->state.vgabase, VGA_MIS_R);
+        vga_w(par->state.vgabase, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
 
         /* Set S3 clock registers */
-        if (par->chip == CHIP_360_TRIO3D_1X ||
+        if (par->chip == CHIP_357_VIRGE_GX2 ||
+            par->chip == CHIP_359_VIRGE_GX2P ||
+            par->chip == CHIP_360_TRIO3D_1X ||
             par->chip == CHIP_362_TRIO3D_2X ||
             par->chip == CHIP_368_TRIO3D_2X) {
-                vga_wseq(NULL, 0x12, (n - 2) | ((r & 3) << 6)); /* n and two bits of r */
-                vga_wseq(NULL, 0x29, r >> 2); /* remaining highest bit of r */
+                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
-                vga_wseq(NULL, 0x12, (n - 2) | (r << 5));
-        vga_wseq(NULL, 0x13, m - 2);
+                vga_wseq(par->state.vgabase, 0x12, (n - 2) | (r << 5));
+        vga_wseq(par->state.vgabase, 0x13, m - 2);
 
         udelay(1000);
 
         /* Activate clock - write 0, 1, 0 to seq/15 bit 5 */
-        regval = vga_rseq (NULL, 0x15); /* | 0x80; */
-        vga_wseq(NULL, 0x15, regval & ~(1<<5));
-        vga_wseq(NULL, 0x15, regval |  (1<<5));
-        vga_wseq(NULL, 0x15, regval & ~(1<<5));
+        regval = vga_rseq (par->state.vgabase, 0x15); /* | 0x80; */
+        vga_wseq(par->state.vgabase, 0x15, regval & ~(1<<5));
+        vga_wseq(par->state.vgabase, 0x15, regval |  (1<<5));
+        vga_wseq(par->state.vgabase, 0x15, regval & ~(1<<5));
 }
 
 
@@ -372,7 +387,10 @@ static int s3fb_open(struct fb_info *info, int user)
 
         mutex_lock(&(par->open_lock));
         if (par->ref_count == 0) {
+                void __iomem *vgabase = par->state.vgabase;
+
                 memset(&(par->state), 0, sizeof(struct vgastate));
+                par->state.vgabase = vgabase;
                 par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS | VGA_SAVE_CMAP;
                 par->state.num_crtc = 0x70;
                 par->state.num_seq = 0x20;
@@ -470,6 +488,7 @@ static int s3fb_set_par(struct fb_info *info)
         struct s3fb_info *par = info->par;
         u32 value, mode, hmul, offset_value, screen_size, multiplex, dbytes;
         u32 bpp = info->var.bits_per_pixel;
+        u32 htotal, hsstart;
 
         if (bpp != 0) {
                 info->fix.ypanstep = 1;
@@ -504,99 +523,115 @@ static int s3fb_set_par(struct fb_info *info)
         info->var.activate = FB_ACTIVATE_NOW;
 
         /* Unlock registers */
-        vga_wcrt(NULL, 0x38, 0x48);
-        vga_wcrt(NULL, 0x39, 0xA5);
-        vga_wseq(NULL, 0x08, 0x06);
-        svga_wcrt_mask(0x11, 0x00, 0x80);
+        vga_wcrt(par->state.vgabase, 0x38, 0x48);
+        vga_wcrt(par->state.vgabase, 0x39, 0xA5);
+        vga_wseq(par->state.vgabase, 0x08, 0x06);
+        svga_wcrt_mask(par->state.vgabase, 0x11, 0x00, 0x80);
 
         /* Blank screen and turn off sync */
-        svga_wseq_mask(0x01, 0x20, 0x20);
-        svga_wcrt_mask(0x17, 0x00, 0x80);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x00, 0x80);
 
         /* Set default values */
-        svga_set_default_gfx_regs();
-        svga_set_default_atc_regs();
-        svga_set_default_seq_regs();
-        svga_set_default_crt_regs();
-        svga_wcrt_multi(s3_line_compare_regs, 0xFFFFFFFF);
-        svga_wcrt_multi(s3_start_address_regs, 0);
+        svga_set_default_gfx_regs(par->state.vgabase);
+        svga_set_default_atc_regs(par->state.vgabase);
+        svga_set_default_seq_regs(par->state.vgabase);
+        svga_set_default_crt_regs(par->state.vgabase);
+        svga_wcrt_multi(par->state.vgabase, s3_line_compare_regs, 0xFFFFFFFF);
+        svga_wcrt_multi(par->state.vgabase, s3_start_address_regs, 0);
 
         /* S3 specific initialization */
-        svga_wcrt_mask(0x58, 0x10, 0x10); /* enable linear framebuffer */
-        svga_wcrt_mask(0x31, 0x08, 0x08); /* enable sequencer access to framebuffer above 256 kB */
+        svga_wcrt_mask(par->state.vgabase, 0x58, 0x10, 0x10); /* enable linear framebuffer */
+        svga_wcrt_mask(par->state.vgabase, 0x31, 0x08, 0x08); /* enable sequencer access to framebuffer above 256 kB */
 
-/*      svga_wcrt_mask(0x33, 0x08, 0x08); */ /* DDR ?   */
-/*      svga_wcrt_mask(0x43, 0x01, 0x01); */ /* DDR ?   */
-        svga_wcrt_mask(0x33, 0x00, 0x08); /* no DDR ?   */
-        svga_wcrt_mask(0x43, 0x00, 0x01); /* no DDR ?   */
+/*      svga_wcrt_mask(par->state.vgabase, 0x33, 0x08, 0x08); */ /* DDR ?       */
+/*      svga_wcrt_mask(par->state.vgabase, 0x43, 0x01, 0x01); */ /* DDR ?       */
+        svga_wcrt_mask(par->state.vgabase, 0x33, 0x00, 0x08); /* no DDR ?       */
+        svga_wcrt_mask(par->state.vgabase, 0x43, 0x00, 0x01); /* no DDR ?       */
 
-        svga_wcrt_mask(0x5D, 0x00, 0x28); /* Clear strange HSlen bits */
+        svga_wcrt_mask(par->state.vgabase, 0x5D, 0x00, 0x28); /* Clear strange HSlen bits */
 
-/*      svga_wcrt_mask(0x58, 0x03, 0x03); */
+/*      svga_wcrt_mask(par->state.vgabase, 0x58, 0x03, 0x03); */
 
-/*      svga_wcrt_mask(0x53, 0x12, 0x13); */ /* enable MMIO */
-/*      svga_wcrt_mask(0x40, 0x08, 0x08); */ /* enable write buffer */
+/*      svga_wcrt_mask(par->state.vgabase, 0x53, 0x12, 0x13); */ /* enable MMIO */
+/*      svga_wcrt_mask(par->state.vgabase, 0x40, 0x08, 0x08); */ /* enable write buffer */
 
 
         /* Set the offset register */
         pr_debug("fb%d: offset register       : %d\n", info->node, offset_value);
-        svga_wcrt_multi(s3_offset_regs, offset_value);
+        svga_wcrt_multi(par->state.vgabase, s3_offset_regs, offset_value);
 
-        if (par->chip != CHIP_360_TRIO3D_1X &&
+        if (par->chip != CHIP_357_VIRGE_GX2 &&
+            par->chip != CHIP_359_VIRGE_GX2P &&
+            par->chip != CHIP_360_TRIO3D_1X &&
             par->chip != CHIP_362_TRIO3D_2X &&
             par->chip != CHIP_368_TRIO3D_2X) {
-                vga_wcrt(NULL, 0x54, 0x18); /* M parameter */
-                vga_wcrt(NULL, 0x60, 0xff); /* N parameter */
-                vga_wcrt(NULL, 0x61, 0xff); /* L parameter */
-                vga_wcrt(NULL, 0x62, 0xff); /* L parameter */
+                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 */
+                vga_wcrt(par->state.vgabase, 0x62, 0xff); /* L parameter */
         }
 
-        vga_wcrt(NULL, 0x3A, 0x35);
-        svga_wattr(0x33, 0x00);
+        vga_wcrt(par->state.vgabase, 0x3A, 0x35);
+        svga_wattr(par->state.vgabase, 0x33, 0x00);
 
         if (info->var.vmode & FB_VMODE_DOUBLE)
-                svga_wcrt_mask(0x09, 0x80, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x80, 0x80);
         else
-                svga_wcrt_mask(0x09, 0x00, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x00, 0x80);
 
         if (info->var.vmode & FB_VMODE_INTERLACED)
-                svga_wcrt_mask(0x42, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x42, 0x20, 0x20);
         else
-                svga_wcrt_mask(0x42, 0x00, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x42, 0x00, 0x20);
 
         /* Disable hardware graphics cursor */
-        svga_wcrt_mask(0x45, 0x00, 0x01);
+        svga_wcrt_mask(par->state.vgabase, 0x45, 0x00, 0x01);
         /* Disable Streams engine */
-        svga_wcrt_mask(0x67, 0x00, 0x0C);
+        svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0x0C);
 
         mode = svga_match_format(s3fb_formats, &(info->var), &(info->fix));
 
         /* S3 virge DX hack */
         if (par->chip == CHIP_375_VIRGE_DX) {
-                vga_wcrt(NULL, 0x86, 0x80);
-                vga_wcrt(NULL, 0x90, 0x00);
+                vga_wcrt(par->state.vgabase, 0x86, 0x80);
+                vga_wcrt(par->state.vgabase, 0x90, 0x00);
         }
 
         /* S3 virge VX hack */
         if (par->chip == CHIP_988_VIRGE_VX) {
-                vga_wcrt(NULL, 0x50, 0x00);
-                vga_wcrt(NULL, 0x67, 0x50);
+                vga_wcrt(par->state.vgabase, 0x50, 0x00);
+                vga_wcrt(par->state.vgabase, 0x67, 0x50);
 
-                vga_wcrt(NULL, 0x63, (mode <= 2) ? 0x90 : 0x09);
-                vga_wcrt(NULL, 0x66, 0x90);
+                vga_wcrt(par->state.vgabase, 0x63, (mode <= 2) ? 0x90 : 0x09);
+                vga_wcrt(par->state.vgabase, 0x66, 0x90);
         }
 
-        if (par->chip == CHIP_360_TRIO3D_1X ||
+        if (par->chip == CHIP_357_VIRGE_GX2 ||
+            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_365_TRIO3D    ||
+            par->chip == CHIP_375_VIRGE_DX  ||
+            par->chip == CHIP_385_VIRGE_GX) {
                 dbytes = info->var.xres * ((bpp+7)/8);
-                vga_wcrt(NULL, 0x91, (dbytes + 7) / 8);
-                vga_wcrt(NULL, 0x90, (((dbytes + 7) / 8) >> 8) | 0x80);
+                vga_wcrt(par->state.vgabase, 0x91, (dbytes + 7) / 8);
+                vga_wcrt(par->state.vgabase, 0x90, (((dbytes + 7) / 8) >> 8) | 0x80);
 
-                vga_wcrt(NULL, 0x66, 0x81);
+                vga_wcrt(par->state.vgabase, 0x66, 0x81);
         }
 
-        svga_wcrt_mask(0x31, 0x00, 0x40);
+        if (par->chip == CHIP_357_VIRGE_GX2  ||
+            par->chip == CHIP_359_VIRGE_GX2P ||
+            par->chip == CHIP_360_TRIO3D_1X ||
+            par->chip == CHIP_362_TRIO3D_2X ||
+            par->chip == CHIP_368_TRIO3D_2X)
+                vga_wcrt(par->state.vgabase, 0x34, 0x00);
+        else    /* enable Data Transfer Position Control (DTPC) */
+                vga_wcrt(par->state.vgabase, 0x34, 0x10);
+
+        svga_wcrt_mask(par->state.vgabase, 0x31, 0x00, 0x40);
         multiplex = 0;
         hmul = 1;
 
@@ -604,51 +639,53 @@ static int s3fb_set_par(struct fb_info *info)
         switch (mode) {
         case 0:
                 pr_debug("fb%d: text mode\n", info->node);
-                svga_set_textmode_vga_regs();
+                svga_set_textmode_vga_regs(par->state.vgabase);
 
                 /* Set additional registers like in 8-bit mode */
-                svga_wcrt_mask(0x50, 0x00, 0x30);
-                svga_wcrt_mask(0x67, 0x00, 0xF0);
+                svga_wcrt_mask(par->state.vgabase, 0x50, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0xF0);
 
                 /* Disable enhanced mode */
-                svga_wcrt_mask(0x3A, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x3A, 0x00, 0x30);
 
                 if (fasttext) {
                         pr_debug("fb%d: high speed text mode set\n", info->node);
-                        svga_wcrt_mask(0x31, 0x40, 0x40);
+                        svga_wcrt_mask(par->state.vgabase, 0x31, 0x40, 0x40);
                 }
                 break;
         case 1:
                 pr_debug("fb%d: 4 bit pseudocolor\n", info->node);
-                vga_wgfx(NULL, VGA_GFX_MODE, 0x40);
+                vga_wgfx(par->state.vgabase, VGA_GFX_MODE, 0x40);
 
                 /* Set additional registers like in 8-bit mode */
-                svga_wcrt_mask(0x50, 0x00, 0x30);
-                svga_wcrt_mask(0x67, 0x00, 0xF0);
+                svga_wcrt_mask(par->state.vgabase, 0x50, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0xF0);
 
                 /* disable enhanced mode */
-                svga_wcrt_mask(0x3A, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x3A, 0x00, 0x30);
                 break;
         case 2:
                 pr_debug("fb%d: 4 bit pseudocolor, planar\n", info->node);
 
                 /* Set additional registers like in 8-bit mode */
-                svga_wcrt_mask(0x50, 0x00, 0x30);
-                svga_wcrt_mask(0x67, 0x00, 0xF0);
+                svga_wcrt_mask(par->state.vgabase, 0x50, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0xF0);
 
                 /* disable enhanced mode */
-                svga_wcrt_mask(0x3A, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x3A, 0x00, 0x30);
                 break;
         case 3:
                 pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
-                svga_wcrt_mask(0x50, 0x00, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x50, 0x00, 0x30);
                 if (info->var.pixclock > 20000 ||
+                    par->chip == CHIP_357_VIRGE_GX2 ||
+                    par->chip == CHIP_359_VIRGE_GX2P ||
                     par->chip == CHIP_360_TRIO3D_1X ||
                     par->chip == CHIP_362_TRIO3D_2X ||
                     par->chip == CHIP_368_TRIO3D_2X)
-                        svga_wcrt_mask(0x67, 0x00, 0xF0);
+                        svga_wcrt_mask(par->state.vgabase, 0x67, 0x00, 0xF0);
                 else {
-                        svga_wcrt_mask(0x67, 0x10, 0xF0);
+                        svga_wcrt_mask(par->state.vgabase, 0x67, 0x10, 0xF0);
                         multiplex = 1;
                 }
                 break;
@@ -656,13 +693,24 @@ static int s3fb_set_par(struct fb_info *info)
                 pr_debug("fb%d: 5/5/5 truecolor\n", info->node);
                 if (par->chip == CHIP_988_VIRGE_VX) {
                         if (info->var.pixclock > 20000)
-                                svga_wcrt_mask(0x67, 0x20, 0xF0);
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x20, 0xF0);
                         else
-                                svga_wcrt_mask(0x67, 0x30, 0xF0);
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x30, 0xF0);
+                } else if (par->chip == CHIP_365_TRIO3D) {
+                        svga_wcrt_mask(par->state.vgabase, 0x50, 0x10, 0x30);
+                        if (info->var.pixclock > 8695) {
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x30, 0xF0);
+                                hmul = 2;
+                        } else {
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x20, 0xF0);
+                                multiplex = 1;
+                        }
                 } else {
-                        svga_wcrt_mask(0x50, 0x10, 0x30);
-                        svga_wcrt_mask(0x67, 0x30, 0xF0);
-                        if (par->chip != CHIP_360_TRIO3D_1X &&
+                        svga_wcrt_mask(par->state.vgabase, 0x50, 0x10, 0x30);
+                        svga_wcrt_mask(par->state.vgabase, 0x67, 0x30, 0xF0);
+                        if (par->chip != CHIP_357_VIRGE_GX2 &&
+                            par->chip != CHIP_359_VIRGE_GX2P &&
+                            par->chip != CHIP_360_TRIO3D_1X &&
                             par->chip != CHIP_362_TRIO3D_2X &&
                             par->chip != CHIP_368_TRIO3D_2X)
                                 hmul = 2;
@@ -672,13 +720,24 @@ static int s3fb_set_par(struct fb_info *info)
                 pr_debug("fb%d: 5/6/5 truecolor\n", info->node);
                 if (par->chip == CHIP_988_VIRGE_VX) {
                         if (info->var.pixclock > 20000)
-                                svga_wcrt_mask(0x67, 0x40, 0xF0);
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x40, 0xF0);
                         else
-                                svga_wcrt_mask(0x67, 0x50, 0xF0);
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x50, 0xF0);
+                } else if (par->chip == CHIP_365_TRIO3D) {
+                        svga_wcrt_mask(par->state.vgabase, 0x50, 0x10, 0x30);
+                        if (info->var.pixclock > 8695) {
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x50, 0xF0);
+                                hmul = 2;
+                        } else {
+                                svga_wcrt_mask(par->state.vgabase, 0x67, 0x40, 0xF0);
+                                multiplex = 1;
+                        }
                 } else {
-                        svga_wcrt_mask(0x50, 0x10, 0x30);
-                        svga_wcrt_mask(0x67, 0x50, 0xF0);
-                        if (par->chip != CHIP_360_TRIO3D_1X &&
+                        svga_wcrt_mask(par->state.vgabase, 0x50, 0x10, 0x30);
+                        svga_wcrt_mask(par->state.vgabase, 0x67, 0x50, 0xF0);
+                        if (par->chip != CHIP_357_VIRGE_GX2 &&
+                            par->chip != CHIP_359_VIRGE_GX2P &&
+                            par->chip != CHIP_360_TRIO3D_1X &&
                             par->chip != CHIP_362_TRIO3D_2X &&
                             par->chip != CHIP_368_TRIO3D_2X)
                                 hmul = 2;
@@ -687,12 +746,12 @@ static int s3fb_set_par(struct fb_info *info)
         case 6:
                 /* VIRGE VX case */
                 pr_debug("fb%d: 8/8/8 truecolor\n", info->node);
-                svga_wcrt_mask(0x67, 0xD0, 0xF0);
+                svga_wcrt_mask(par->state.vgabase, 0x67, 0xD0, 0xF0);
                 break;
         case 7:
                 pr_debug("fb%d: 8/8/8/8 truecolor\n", info->node);
-                svga_wcrt_mask(0x50, 0x30, 0x30);
-                svga_wcrt_mask(0x67, 0xD0, 0xF0);
+                svga_wcrt_mask(par->state.vgabase, 0x50, 0x30, 0x30);
+                svga_wcrt_mask(par->state.vgabase, 0x67, 0xD0, 0xF0);
                 break;
         default:
                 printk(KERN_ERR "fb%d: unsupported mode - bug\n", info->node);
@@ -700,25 +759,30 @@ static int s3fb_set_par(struct fb_info *info)
         }
 
         if (par->chip != CHIP_988_VIRGE_VX) {
-                svga_wseq_mask(0x15, multiplex ? 0x10 : 0x00, 0x10);
-                svga_wseq_mask(0x18, multiplex ? 0x80 : 0x00, 0x80);
+                svga_wseq_mask(par->state.vgabase, 0x15, multiplex ? 0x10 : 0x00, 0x10);
+                svga_wseq_mask(par->state.vgabase, 0x18, multiplex ? 0x80 : 0x00, 0x80);
         }
 
         s3_set_pixclock(info, info->var.pixclock);
-        svga_set_timings(&s3_timing_regs, &(info->var), hmul, 1,
+        svga_set_timings(par->state.vgabase, &s3_timing_regs, &(info->var), hmul, 1,
                          (info->var.vmode & FB_VMODE_DOUBLE)     ? 2 : 1,
                          (info->var.vmode & FB_VMODE_INTERLACED) ? 2 : 1,
                          hmul, info->node);
 
         /* Set interlaced mode start/end register */
-        value = info->var.xres + info->var.left_margin + info->var.right_margin + info->var.hsync_len;
-        value = ((value * hmul) / 8) - 5;
-        vga_wcrt(NULL, 0x3C, (value + 1) / 2);
+        htotal = info->var.xres + info->var.left_margin + info->var.right_margin + info->var.hsync_len;
+        htotal = ((htotal * hmul) / 8) - 5;
+        vga_wcrt(par->state.vgabase, 0x3C, (htotal + 1) / 2);
+
+        /* Set Data Transfer Position */
+        hsstart = ((info->var.xres + info->var.right_margin) * hmul) / 8;
+        value = clamp((htotal + hsstart + 1) / 2, hsstart + 4, htotal + 1);
+        svga_wcrt_multi(par->state.vgabase, s3_dtpc_regs, value);
 
         memset_io(info->screen_base, 0x00, screen_size);
         /* Device and screen back on */
-        svga_wcrt_mask(0x17, 0x80, 0x80);
-        svga_wseq_mask(0x01, 0x00, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x80, 0x80);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
 
         return 0;
 }
@@ -788,31 +852,33 @@ static int s3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 
 static int s3fb_blank(int blank_mode, struct fb_info *info)
 {
+        struct s3fb_info *par = info->par;
+
         switch (blank_mode) {
         case FB_BLANK_UNBLANK:
                 pr_debug("fb%d: unblank\n", info->node);
-                svga_wcrt_mask(0x56, 0x00, 0x06);
-                svga_wseq_mask(0x01, 0x00, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x56, 0x00, 0x06);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
                 break;
         case FB_BLANK_NORMAL:
                 pr_debug("fb%d: blank\n", info->node);
-                svga_wcrt_mask(0x56, 0x00, 0x06);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x56, 0x00, 0x06);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_HSYNC_SUSPEND:
                 pr_debug("fb%d: hsync\n", info->node);
-                svga_wcrt_mask(0x56, 0x02, 0x06);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x56, 0x02, 0x06);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_VSYNC_SUSPEND:
                 pr_debug("fb%d: vsync\n", info->node);
-                svga_wcrt_mask(0x56, 0x04, 0x06);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x56, 0x04, 0x06);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_POWERDOWN:
                 pr_debug("fb%d: sync down\n", info->node);
-                svga_wcrt_mask(0x56, 0x06, 0x06);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x56, 0x06, 0x06);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         }
 
@@ -822,8 +888,9 @@ static int s3fb_blank(int blank_mode, struct fb_info *info)
 
 /* Pan the display */
 
-static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info) {
-
+static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        struct s3fb_info *par = info->par;
         unsigned int offset;
 
         /* Calculate the offset */
@@ -837,7 +904,7 @@ static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
         }
 
         /* Set the offset */
-        svga_wcrt_multi(s3_start_address_regs, offset);
+        svga_wcrt_multi(par->state.vgabase, s3_start_address_regs, offset);
 
         return 0;
 }
@@ -863,12 +930,14 @@ static struct fb_ops s3fb_ops = {
 
 /* ------------------------------------------------------------------------- */
 
-static int __devinit s3_identification(int chip)
+static int __devinit s3_identification(struct s3fb_info *par)
 {
+        int chip = par->chip;
+
         if (chip == CHIP_XXX_TRIO) {
-                u8 cr30 = vga_rcrt(NULL, 0x30);
-                u8 cr2e = vga_rcrt(NULL, 0x2e);
-                u8 cr2f = vga_rcrt(NULL, 0x2f);
+                u8 cr30 = vga_rcrt(par->state.vgabase, 0x30);
+                u8 cr2e = vga_rcrt(par->state.vgabase, 0x2e);
+                u8 cr2f = vga_rcrt(par->state.vgabase, 0x2f);
 
                 if ((cr30 == 0xE0) || (cr30 == 0xE1)) {
                         if (cr2e == 0x10)
@@ -883,7 +952,7 @@ static int __devinit s3_identification(int chip)
         }
 
         if (chip == CHIP_XXX_TRIO64V2_DXGX) {
-                u8 cr6f = vga_rcrt(NULL, 0x6f);
+                u8 cr6f = vga_rcrt(par->state.vgabase, 0x6f);
 
                 if (! (cr6f & 0x01))
                         return CHIP_775_TRIO64V2_DX;
@@ -892,7 +961,7 @@ static int __devinit s3_identification(int chip)
         }
 
         if (chip == CHIP_XXX_VIRGE_DXGX) {
-                u8 cr6f = vga_rcrt(NULL, 0x6f);
+                u8 cr6f = vga_rcrt(par->state.vgabase, 0x6f);
 
                 if (! (cr6f & 0x01))
                         return CHIP_375_VIRGE_DX;
@@ -901,7 +970,7 @@ static int __devinit s3_identification(int chip)
         }
 
         if (chip == CHIP_36X_TRIO3D_1X_2X) {
-                switch (vga_rcrt(NULL, 0x2f)) {
+                switch (vga_rcrt(par->state.vgabase, 0x2f)) {
                 case 0x00:
                         return CHIP_360_TRIO3D_1X;
                 case 0x01:
@@ -919,6 +988,8 @@ static int __devinit s3_identification(int chip)
 
 static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
+        struct pci_bus_region bus_reg;
+        struct resource vga_res;
         struct fb_info *info;
         struct s3fb_info *par;
         int rc;
@@ -968,47 +1039,68 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
                 goto err_iomap;
         }
 
+        bus_reg.start = 0;
+        bus_reg.end = 64 * 1024;
+
+        vga_res.flags = IORESOURCE_IO;
+
+        pcibios_bus_to_resource(dev, &vga_res, &bus_reg);
+
+        par->state.vgabase = (void __iomem *) vga_res.start;
+
         /* Unlock regs */
-        cr38 = vga_rcrt(NULL, 0x38);
-        cr39 = vga_rcrt(NULL, 0x39);
-        vga_wseq(NULL, 0x08, 0x06);
-        vga_wcrt(NULL, 0x38, 0x48);
-        vga_wcrt(NULL, 0x39, 0xA5);
+        cr38 = vga_rcrt(par->state.vgabase, 0x38);
+        cr39 = vga_rcrt(par->state.vgabase, 0x39);
+        vga_wseq(par->state.vgabase, 0x08, 0x06);
+        vga_wcrt(par->state.vgabase, 0x38, 0x48);
+        vga_wcrt(par->state.vgabase, 0x39, 0xA5);
 
         /* Identify chip type */
         par->chip = id->driver_data & CHIP_MASK;
-        par->rev = vga_rcrt(NULL, 0x2f);
+        par->rev = vga_rcrt(par->state.vgabase, 0x2f);
         if (par->chip & CHIP_UNDECIDED_FLAG)
-                par->chip = s3_identification(par->chip);
+                par->chip = s3_identification(par);
 
         /* Find how many physical memory there is on card */
         /* 0x36 register is accessible even if other registers are locked */
-        regval = vga_rcrt(NULL, 0x36);
+        regval = vga_rcrt(par->state.vgabase, 0x36);
         if (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_365_TRIO3D) {
                 switch ((regval & 0xE0) >> 5) {
                 case 0: /* 8MB -- only 4MB usable for display */
                 case 1: /* 4MB with 32-bit bus */
                 case 2: /* 4MB */
                         info->screen_size = 4 << 20;
                         break;
+                case 4: /* 2MB on 365 Trio3D */
                 case 6: /* 2MB */
                         info->screen_size = 2 << 20;
                         break;
                 }
+        } else if (par->chip == CHIP_357_VIRGE_GX2 ||
+                   par->chip == CHIP_359_VIRGE_GX2P) {
+                switch ((regval & 0xC0) >> 6) {
+                case 1: /* 4MB */
+                        info->screen_size = 4 << 20;
+                        break;
+                case 3: /* 2MB */
+                        info->screen_size = 2 << 20;
+                        break;
+                }
         } else
                 info->screen_size = s3_memsizes[regval >> 5] << 10;
         info->fix.smem_len = info->screen_size;
 
         /* Find MCLK frequency */
-        regval = vga_rseq(NULL, 0x10);
-        par->mclk_freq = ((vga_rseq(NULL, 0x11) + 2) * 14318) / ((regval & 0x1F)  + 2);
+        regval = vga_rseq(par->state.vgabase, 0x10);
+        par->mclk_freq = ((vga_rseq(par->state.vgabase, 0x11) + 2) * 14318) / ((regval & 0x1F)  + 2);
         par->mclk_freq = par->mclk_freq >> (regval >> 5);
 
         /* Restore locks */
-        vga_wcrt(NULL, 0x38, cr38);
-        vga_wcrt(NULL, 0x39, cr39);
+        vga_wcrt(par->state.vgabase, 0x38, cr38);
+        vga_wcrt(par->state.vgabase, 0x39, cr39);
 
         strcpy(info->fix.id, s3_names [par->chip]);
         info->fix.mmio_start = 0;
@@ -1027,6 +1119,14 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
                 goto err_find_mode;
         }
 
+        /* maximize virtual vertical size for fast scrolling */
+        info->var.yres_virtual = info->fix.smem_len * 8 /
+                        (info->var.bits_per_pixel * info->var.xres_virtual);
+        if (info->var.yres_virtual < info->var.yres) {
+                dev_err(info->device, "virtual vertical size smaller than real\n");
+                goto err_find_mode;
+        }
+
         rc = fb_alloc_cmap(&info->cmap, 256, 0);
         if (rc < 0) {
                 dev_err(info->device, "cannot allocate colormap\n");
@@ -1044,8 +1144,8 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
 
         if (par->chip == CHIP_UNKNOWN)
                 printk(KERN_INFO "fb%d: unknown chip, CR2D=%x, CR2E=%x, CRT2F=%x, CRT30=%x\n",
-                        info->node, vga_rcrt(NULL, 0x2d), vga_rcrt(NULL, 0x2e),
-                        vga_rcrt(NULL, 0x2f), vga_rcrt(NULL, 0x30));
+                        info->node, vga_rcrt(par->state.vgabase, 0x2d), vga_rcrt(par->state.vgabase, 0x2e),
+                        vga_rcrt(par->state.vgabase, 0x2f), vga_rcrt(par->state.vgabase, 0x30));
 
         /* Record a reference to the driver data */
         pci_set_drvdata(dev, info);
@@ -1188,10 +1288,11 @@ static struct pci_device_id s3_devices[] __devinitdata = {
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x5631), .driver_data = CHIP_325_VIRGE},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x883D), .driver_data = CHIP_988_VIRGE_VX},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A01), .driver_data = CHIP_XXX_VIRGE_DXGX},
-        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A10), .driver_data = CHIP_356_VIRGE_GX2},
-        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A11), .driver_data = CHIP_357_VIRGE_GX2P},
+        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A10), .driver_data = CHIP_357_VIRGE_GX2},
+        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A11), .driver_data = CHIP_359_VIRGE_GX2P},
         {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},
 
         {0, 0, 0, 0, 0, 0, 0}
 };
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index b16e6138fdd4..bb71fea07284 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -159,8 +159,7 @@ static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
                 else
                         dev_warn(&chan->par->pcidev->dev,
                                  "Failed to register I2C bus %s.\n", name);
-        } else
-                chan->par = NULL;
+        }
 
         return rc;
 }
@@ -170,9 +169,8 @@ void savagefb_create_i2c_busses(struct fb_info *info)
         struct savagefb_par *par = info->par;
         par->chan.par   = par;
 
-        switch(info->fix.accel) {
-        case FB_ACCEL_PROSAVAGE_DDRK:
-        case FB_ACCEL_PROSAVAGE_PM:
+        switch (par->chip) {
+        case S3_PROSAVAGE:
                 par->chan.reg         = CR_SERIAL2;
                 par->chan.ioaddr      = par->mmio.vbase;
                 par->chan.algo.setsda = prosavage_gpio_setsda;
@@ -180,7 +178,7 @@ void savagefb_create_i2c_busses(struct fb_info *info)
                 par->chan.algo.getsda = prosavage_gpio_getsda;
                 par->chan.algo.getscl = prosavage_gpio_getscl;
                 break;
-        case FB_ACCEL_SAVAGE4:
+        case S3_SAVAGE4:
                 par->chan.reg = CR_SERIAL1;
                 if (par->pcidev->revision > 1 && !(VGArCR(0xa6, par) & 0x40))
                         par->chan.reg = CR_SERIAL2;
@@ -190,8 +188,8 @@ void savagefb_create_i2c_busses(struct fb_info *info)
                 par->chan.algo.getsda = prosavage_gpio_getsda;
                 par->chan.algo.getscl = prosavage_gpio_getscl;
                 break;
-        case FB_ACCEL_SAVAGE2000:
-                par->chan.reg         = 0xff20;
+        case S3_SAVAGE2000:
+                par->chan.reg         = MM_SERIAL1;
                 par->chan.ioaddr      = par->mmio.vbase;
                 par->chan.algo.setsda = savage4_gpio_setsda;
                 par->chan.algo.setscl = savage4_gpio_setscl;
diff --git a/drivers/video/savage/savagefb.h b/drivers/video/savage/savagefb.h
index e4c3f214eb8e..4e9490c19d7d 100644
--- a/drivers/video/savage/savagefb.h
+++ b/drivers/video/savage/savagefb.h
@@ -153,7 +153,7 @@ struct savage_reg {
         unsigned char CRTC[25];       /* Crtc Controller */
         unsigned char Sequencer[5];   /* Video Sequencer */
         unsigned char Graphics[9];    /* Video Graphics */
-        unsigned char Attribute[21];  /* Video Atribute */
+        unsigned char Attribute[21];  /* Video Attribute */
 
         unsigned int mode, refresh;
         unsigned char SR08, SR0E, SR0F;
diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c
index 487911e2926c..a2dc1a7ec758 100644
--- a/drivers/video/savage/savagefb_driver.c
+++ b/drivers/video/savage/savagefb_driver.c
@@ -385,7 +385,7 @@ SavageSetup2DEngine(struct savagefb_par  *par)
         BCI_SEND(GlobalBitmapDescriptor);
 
         /*
-         * I don't know why, sending this twice fixes the intial black screen,
+         * I don't know why, sending this twice fixes the initial black screen,
          * prevents X from crashing at least in Toshiba laptops with SavageIX.
          * --Tony
          */
@@ -2211,7 +2211,7 @@ static int __devinit savagefb_probe(struct pci_dev* dev,
                 goto failed_mmio;
 
         video_len = savage_init_hw(par);
-        /* FIXME: cant be negative */
+        /* FIXME: can't be negative */
         if (video_len < 0) {
                 err = video_len;
                 goto failed_mmio;
diff --git a/drivers/video/sh7760fb.c b/drivers/video/sh7760fb.c
index bea38fce2470..8fe19582c460 100644
--- a/drivers/video/sh7760fb.c
+++ b/drivers/video/sh7760fb.c
@@ -459,14 +459,14 @@ static int __devinit sh7760fb_probe(struct platform_device *pdev)
         }
 
         par->ioarea = request_mem_region(res->start,
-                                         (res->end - res->start), pdev->name);
+                                         resource_size(res), pdev->name);
         if (!par->ioarea) {
                 dev_err(&pdev->dev, "mmio area busy\n");
                 ret = -EBUSY;
                 goto out_fb;
         }
 
-        par->base = ioremap_nocache(res->start, res->end - res->start + 1);
+        par->base = ioremap_nocache(res->start, resource_size(res));
         if (!par->base) {
                 dev_err(&pdev->dev, "cannot remap\n");
                 ret = -ENODEV;
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index bf2629f83f40..9bcc61b4ef14 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -643,7 +643,7 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
                         continue;
 
                 board_cfg = &ch->cfg.board_cfg;
-                if (try_module_get(board_cfg->owner) && board_cfg->display_on) {
+                if (board_cfg->display_on && try_module_get(board_cfg->owner)) {
                         board_cfg->display_on(board_cfg->board_data, ch->info);
                         module_put(board_cfg->owner);
                 }
@@ -688,7 +688,7 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
                 }
 
                 board_cfg = &ch->cfg.board_cfg;
-                if (try_module_get(board_cfg->owner) && board_cfg->display_off) {
+                if (board_cfg->display_off && try_module_get(board_cfg->owner)) {
                         board_cfg->display_off(board_cfg->board_data);
                         module_put(board_cfg->owner);
                 }
@@ -1032,6 +1032,49 @@ static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *in
         return 0;
 }
 
+/*
+ * Screen blanking. Behavior is as follows:
+ * FB_BLANK_UNBLANK: screen unblanked, clocks enabled
+ * FB_BLANK_NORMAL: screen blanked, clocks enabled
+ * FB_BLANK_VSYNC,
+ * FB_BLANK_HSYNC,
+ * FB_BLANK_POWEROFF: screen blanked, clocks disabled
+ */
+static int sh_mobile_lcdc_blank(int blank, struct fb_info *info)
+{
+        struct sh_mobile_lcdc_chan *ch = info->par;
+        struct sh_mobile_lcdc_priv *p = ch->lcdc;
+
+        /* blank the screen? */
+        if (blank > FB_BLANK_UNBLANK && ch->blank_status == FB_BLANK_UNBLANK) {
+                struct fb_fillrect rect = {
+                        .width = info->var.xres,
+                        .height = info->var.yres,
+                };
+                sh_mobile_lcdc_fillrect(info, &rect);
+        }
+        /* turn clocks on? */
+        if (blank <= FB_BLANK_NORMAL && ch->blank_status > FB_BLANK_NORMAL) {
+                sh_mobile_lcdc_clk_on(p);
+        }
+        /* turn clocks off? */
+        if (blank > FB_BLANK_NORMAL && ch->blank_status <= FB_BLANK_NORMAL) {
+                /* make sure the screen is updated with the black fill before
+                 * switching the clocks off. one vsync is not enough since
+                 * blanking may occur in the middle of a refresh. deferred io
+                 * 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(info);
+                        sh_mobile_wait_for_vsync(info);
+                }
+                sh_mobile_lcdc_clk_off(p);
+        }
+
+        ch->blank_status = blank;
+        return 0;
+}
+
 static struct fb_ops sh_mobile_lcdc_ops = {
         .owner          = THIS_MODULE,
         .fb_setcolreg   = sh_mobile_lcdc_setcolreg,
@@ -1040,6 +1083,7 @@ static struct fb_ops sh_mobile_lcdc_ops = {
         .fb_fillrect    = sh_mobile_lcdc_fillrect,
         .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,
@@ -1088,8 +1132,9 @@ static struct backlight_device *sh_mobile_lcdc_bl_probe(struct device *parent,
 
         bl = backlight_device_register(ch->cfg.bl_info.name, parent, ch,
                                        &sh_mobile_lcdc_bl_ops, NULL);
-        if (!bl) {
-                dev_err(parent, "unable to register backlight device\n");
+        if (IS_ERR(bl)) {
+                dev_err(parent, "unable to register backlight device: %ld\n",
+                        PTR_ERR(bl));
                 return NULL;
         }
 
@@ -1253,7 +1298,7 @@ static int sh_mobile_lcdc_notify(struct notifier_block *nb,
 
         switch(action) {
         case FB_EVENT_SUSPEND:
-                if (try_module_get(board_cfg->owner) && board_cfg->display_off) {
+                if (board_cfg->display_off && try_module_get(board_cfg->owner)) {
                         board_cfg->display_off(board_cfg->board_data);
                         module_put(board_cfg->owner);
                 }
@@ -1266,7 +1311,7 @@ static int sh_mobile_lcdc_notify(struct notifier_block *nb,
                 mutex_unlock(&ch->open_lock);
 
                 /* HDMI must be enabled before LCDC configuration */
-                if (try_module_get(board_cfg->owner) && board_cfg->display_on) {
+                if (board_cfg->display_on && try_module_get(board_cfg->owner)) {
                         board_cfg->display_on(board_cfg->board_data, info);
                         module_put(board_cfg->owner);
                 }
diff --git a/drivers/video/sh_mobile_lcdcfb.h b/drivers/video/sh_mobile_lcdcfb.h
index 4635eed63eee..f16cb5645a13 100644
--- a/drivers/video/sh_mobile_lcdcfb.h
+++ b/drivers/video/sh_mobile_lcdcfb.h
@@ -37,6 +37,7 @@ struct sh_mobile_lcdc_chan {
         struct completion vsync_completion;
         struct fb_var_screeninfo display_var;
         int use_count;
+        int blank_status;
         struct mutex open_lock;         /* protects the use counter */
 };
 
diff --git a/drivers/video/sis/sis.h b/drivers/video/sis/sis.h
index eac7a01925f3..1987f1b7212f 100644
--- a/drivers/video/sis/sis.h
+++ b/drivers/video/sis/sis.h
@@ -495,6 +495,7 @@ struct sis_video_info {
         unsigned int    refresh_rate;
 
         unsigned int    chip;
+        unsigned int    chip_real_id;
         u8              revision_id;
         int             sisvga_enabled;         /* PCI device was enabled */
 
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index 2fb8c5a660fb..75259845933d 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -4563,6 +4563,11 @@ sisfb_post_sis315330(struct pci_dev *pdev)
 }
 #endif
 
+static inline int sisfb_xgi_is21(struct sis_video_info *ivideo)
+{
+        return ivideo->chip_real_id == XGI_21;
+}
+
 static void __devinit
 sisfb_post_xgi_delay(struct sis_video_info *ivideo, int delay)
 {
@@ -4627,11 +4632,11 @@ sisfb_post_xgi_rwtest(struct sis_video_info *ivideo, int starta,
         return 1;
 }
 
-static void __devinit
+static int __devinit
 sisfb_post_xgi_ramsize(struct sis_video_info *ivideo)
 {
         unsigned int buswidth, ranksize, channelab, mapsize;
-        int i, j, k, l;
+        int i, j, k, l, status;
         u8 reg, sr14;
         static const u8 dramsr13[12 * 5] = {
                 0x02, 0x0e, 0x0b, 0x80, 0x5d,
@@ -4673,7 +4678,7 @@ sisfb_post_xgi_ramsize(struct sis_video_info *ivideo)
                 SiS_SetReg(SISSR, 0x13, 0x35);
                 SiS_SetReg(SISSR, 0x14, 0x41);
                 /* TODO */
-                return;
+                return -ENOMEM;
         }
 
         /* Non-interleaving */
@@ -4835,6 +4840,7 @@ bail_out:
 
         j = (ivideo->chip == XGI_20) ? 5 : 9;
         k = (ivideo->chip == XGI_20) ? 12 : 4;
+        status = -EIO;
 
         for(i = 0; i < k; i++) {
 
@@ -4868,11 +4874,15 @@ bail_out:
                 SiS_SetRegANDOR(SISSR, 0x14, 0x0f, (reg & 0xf0));
                 sisfb_post_xgi_delay(ivideo, 1);
 
-                if(sisfb_post_xgi_rwtest(ivideo, j, ((reg >> 4) + channelab - 2 + 20), mapsize))
+                if (sisfb_post_xgi_rwtest(ivideo, j, ((reg >> 4) + channelab - 2 + 20), mapsize)) {
+                        status = 0;
                         break;
+                }
         }
 
         iounmap(ivideo->video_vbase);
+
+        return status;
 }
 
 static void __devinit
@@ -4931,6 +4941,175 @@ sisfb_post_xgi_setclocks(struct sis_video_info *ivideo, u8 regb)
         sisfb_post_xgi_delay(ivideo, 0x43);
 }
 
+static void __devinit
+sisfb_post_xgi_ddr2_mrs_default(struct sis_video_info *ivideo, u8 regb)
+{
+        unsigned char *bios = ivideo->bios_abase;
+        u8 v1;
+
+        SiS_SetReg(SISSR, 0x28, 0x64);
+        SiS_SetReg(SISSR, 0x29, 0x63);
+        sisfb_post_xgi_delay(ivideo, 15);
+        SiS_SetReg(SISSR, 0x18, 0x00);
+        SiS_SetReg(SISSR, 0x19, 0x20);
+        SiS_SetReg(SISSR, 0x16, 0x00);
+        SiS_SetReg(SISSR, 0x16, 0x80);
+        SiS_SetReg(SISSR, 0x18, 0xc5);
+        SiS_SetReg(SISSR, 0x19, 0x23);
+        SiS_SetReg(SISSR, 0x16, 0x00);
+        SiS_SetReg(SISSR, 0x16, 0x80);
+        sisfb_post_xgi_delay(ivideo, 1);
+        SiS_SetReg(SISCR, 0x97, 0x11);
+        sisfb_post_xgi_setclocks(ivideo, regb);
+        sisfb_post_xgi_delay(ivideo, 0x46);
+        SiS_SetReg(SISSR, 0x18, 0xc5);
+        SiS_SetReg(SISSR, 0x19, 0x23);
+        SiS_SetReg(SISSR, 0x16, 0x00);
+        SiS_SetReg(SISSR, 0x16, 0x80);
+        sisfb_post_xgi_delay(ivideo, 1);
+        SiS_SetReg(SISSR, 0x1b, 0x04);
+        sisfb_post_xgi_delay(ivideo, 1);
+        SiS_SetReg(SISSR, 0x1b, 0x00);
+        sisfb_post_xgi_delay(ivideo, 1);
+        v1 = 0x31;
+        if (ivideo->haveXGIROM) {
+                v1 = bios[0xf0];
+        }
+        SiS_SetReg(SISSR, 0x18, v1);
+        SiS_SetReg(SISSR, 0x19, 0x06);
+        SiS_SetReg(SISSR, 0x16, 0x04);
+        SiS_SetReg(SISSR, 0x16, 0x84);
+        sisfb_post_xgi_delay(ivideo, 1);
+}
+
+static void __devinit
+sisfb_post_xgi_ddr2_mrs_xg21(struct sis_video_info *ivideo)
+{
+        sisfb_post_xgi_setclocks(ivideo, 1);
+
+        SiS_SetReg(SISCR, 0x97, 0x11);
+        sisfb_post_xgi_delay(ivideo, 0x46);
+
+        SiS_SetReg(SISSR, 0x18, 0x00);  /* EMRS2 */
+        SiS_SetReg(SISSR, 0x19, 0x80);
+        SiS_SetReg(SISSR, 0x16, 0x05);
+        SiS_SetReg(SISSR, 0x16, 0x85);
+
+        SiS_SetReg(SISSR, 0x18, 0x00);  /* EMRS3 */
+        SiS_SetReg(SISSR, 0x19, 0xc0);
+        SiS_SetReg(SISSR, 0x16, 0x05);
+        SiS_SetReg(SISSR, 0x16, 0x85);
+
+        SiS_SetReg(SISSR, 0x18, 0x00);  /* EMRS1 */
+        SiS_SetReg(SISSR, 0x19, 0x40);
+        SiS_SetReg(SISSR, 0x16, 0x05);
+        SiS_SetReg(SISSR, 0x16, 0x85);
+
+        SiS_SetReg(SISSR, 0x18, 0x42);  /* MRS1 */
+        SiS_SetReg(SISSR, 0x19, 0x02);
+        SiS_SetReg(SISSR, 0x16, 0x05);
+        SiS_SetReg(SISSR, 0x16, 0x85);
+        sisfb_post_xgi_delay(ivideo, 1);
+
+        SiS_SetReg(SISSR, 0x1b, 0x04);
+        sisfb_post_xgi_delay(ivideo, 1);
+
+        SiS_SetReg(SISSR, 0x1b, 0x00);
+        sisfb_post_xgi_delay(ivideo, 1);
+
+        SiS_SetReg(SISSR, 0x18, 0x42);  /* MRS1 */
+        SiS_SetReg(SISSR, 0x19, 0x00);
+        SiS_SetReg(SISSR, 0x16, 0x05);
+        SiS_SetReg(SISSR, 0x16, 0x85);
+        sisfb_post_xgi_delay(ivideo, 1);
+}
+
+static void __devinit
+sisfb_post_xgi_ddr2(struct sis_video_info *ivideo, u8 regb)
+{
+        unsigned char *bios = ivideo->bios_abase;
+        static const u8 cs158[8] = {
+                0x88, 0xaa, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00
+        };
+        static const u8 cs160[8] = {
+                0x44, 0x77, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00
+        };
+        static const u8 cs168[8] = {
+                0x48, 0x78, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00
+        };
+        u8 reg;
+        u8 v1;
+        u8 v2;
+        u8 v3;
+
+        SiS_SetReg(SISCR, 0xb0, 0x80); /* DDR2 dual frequency mode */
+        SiS_SetReg(SISCR, 0x82, 0x77);
+        SiS_SetReg(SISCR, 0x86, 0x00);
+        reg = SiS_GetReg(SISCR, 0x86);
+        SiS_SetReg(SISCR, 0x86, 0x88);
+        reg = SiS_GetReg(SISCR, 0x86);
+        v1 = cs168[regb]; v2 = cs160[regb]; v3 = cs158[regb];
+        if (ivideo->haveXGIROM) {
+                v1 = bios[regb + 0x168];
+                v2 = bios[regb + 0x160];
+                v3 = bios[regb + 0x158];
+        }
+        SiS_SetReg(SISCR, 0x86, v1);
+        SiS_SetReg(SISCR, 0x82, 0x77);
+        SiS_SetReg(SISCR, 0x85, 0x00);
+        reg = SiS_GetReg(SISCR, 0x85);
+        SiS_SetReg(SISCR, 0x85, 0x88);
+        reg = SiS_GetReg(SISCR, 0x85);
+        SiS_SetReg(SISCR, 0x85, v2);
+        SiS_SetReg(SISCR, 0x82, v3);
+        SiS_SetReg(SISCR, 0x98, 0x01);
+        SiS_SetReg(SISCR, 0x9a, 0x02);
+        if (sisfb_xgi_is21(ivideo))
+                sisfb_post_xgi_ddr2_mrs_xg21(ivideo);
+        else
+                sisfb_post_xgi_ddr2_mrs_default(ivideo, regb);
+}
+
+static u8 __devinit
+sisfb_post_xgi_ramtype(struct sis_video_info *ivideo)
+{
+        unsigned char *bios = ivideo->bios_abase;
+        u8 ramtype;
+        u8 reg;
+        u8 v1;
+
+        ramtype = 0x00; v1 = 0x10;
+        if (ivideo->haveXGIROM) {
+                ramtype = bios[0x62];
+                v1 = bios[0x1d2];
+        }
+        if (!(ramtype & 0x80)) {
+                if (sisfb_xgi_is21(ivideo)) {
+                        SiS_SetRegAND(SISCR, 0xb4, 0xfd); /* GPIO control */
+                        SiS_SetRegOR(SISCR, 0x4a, 0x80);  /* GPIOH EN */
+                        reg = SiS_GetReg(SISCR, 0x48);
+                        SiS_SetRegOR(SISCR, 0xb4, 0x02);
+                        ramtype = reg & 0x01;             /* GPIOH */
+                } else if (ivideo->chip == XGI_20) {
+                        SiS_SetReg(SISCR, 0x97, v1);
+                        reg = SiS_GetReg(SISCR, 0x97);
+                        if (reg & 0x10) {
+                                ramtype = (reg & 0x01) << 1;
+                        }
+                } else {
+                        reg = SiS_GetReg(SISSR, 0x39);
+                        ramtype = reg & 0x02;
+                        if (!(ramtype)) {
+                                reg = SiS_GetReg(SISSR, 0x3a);
+                                ramtype = (reg >> 1) & 0x01;
+                        }
+                }
+        }
+        ramtype &= 0x07;
+
+        return ramtype;
+}
+
 static int __devinit
 sisfb_post_xgi(struct pci_dev *pdev)
 {
@@ -5213,9 +5392,23 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 SiS_SetReg(SISCR, 0x77, v1);
         }
 
-        /* RAM type */
-
-        regb = 0;       /* ! */
+        /* RAM type:
+         *
+         * 0 == DDR1, 1 == DDR2, 2..7 == reserved?
+         *
+         * The code seems to written so that regb should equal ramtype,
+         * however, so far it has been hardcoded to 0. Enable other values only
+         * on XGI Z9, as it passes the POST, and add a warning for others.
+         */
+        ramtype = sisfb_post_xgi_ramtype(ivideo);
+        if (!sisfb_xgi_is21(ivideo) && ramtype) {
+                dev_warn(&pdev->dev,
+                         "RAM type something else than expected: %d\n",
+                         ramtype);
+                regb = 0;
+        } else {
+                regb = ramtype;
+        }
 
         v1 = 0xff;
         if(ivideo->haveXGIROM) {
@@ -5367,7 +5560,10 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 }
         }
 
-        SiS_SetReg(SISSR, 0x17, 0x00);
+        if (regb == 1)
+                SiS_SetReg(SISSR, 0x17, 0x80);          /* DDR2 */
+        else
+                SiS_SetReg(SISSR, 0x17, 0x00);          /* DDR1 */
         SiS_SetReg(SISSR, 0x1a, 0x87);
 
         if(ivideo->chip == XGI_20) {
@@ -5375,31 +5571,6 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 SiS_SetReg(SISSR, 0x1c, 0x00);
         }
 
-        ramtype = 0x00; v1 = 0x10;
-        if(ivideo->haveXGIROM) {
-                ramtype = bios[0x62];
-                v1 = bios[0x1d2];
-        }
-        if(!(ramtype & 0x80)) {
-                if(ivideo->chip == XGI_20) {
-                        SiS_SetReg(SISCR, 0x97, v1);
-                        reg = SiS_GetReg(SISCR, 0x97);
-                        if(reg & 0x10) {
-                                ramtype = (reg & 0x01) << 1;
-                        }
-                } else {
-                        reg = SiS_GetReg(SISSR, 0x39);
-                        ramtype = reg & 0x02;
-                        if(!(ramtype)) {
-                                reg = SiS_GetReg(SISSR, 0x3a);
-                                ramtype = (reg >> 1) & 0x01;
-                        }
-                }
-        }
-        ramtype &= 0x07;
-
-        regb = 0;       /* ! */
-
         switch(ramtype) {
         case 0:
                 sisfb_post_xgi_setclocks(ivideo, regb);
@@ -5485,61 +5656,7 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 SiS_SetReg(SISSR, 0x1b, 0x00);
                 break;
         case 1:
-                SiS_SetReg(SISCR, 0x82, 0x77);
-                SiS_SetReg(SISCR, 0x86, 0x00);
-                reg = SiS_GetReg(SISCR, 0x86);
-                SiS_SetReg(SISCR, 0x86, 0x88);
-                reg = SiS_GetReg(SISCR, 0x86);
-                v1 = cs168[regb]; v2 = cs160[regb]; v3 = cs158[regb];
-                if(ivideo->haveXGIROM) {
-                        v1 = bios[regb + 0x168];
-                        v2 = bios[regb + 0x160];
-                        v3 = bios[regb + 0x158];
-                }
-                SiS_SetReg(SISCR, 0x86, v1);
-                SiS_SetReg(SISCR, 0x82, 0x77);
-                SiS_SetReg(SISCR, 0x85, 0x00);
-                reg = SiS_GetReg(SISCR, 0x85);
-                SiS_SetReg(SISCR, 0x85, 0x88);
-                reg = SiS_GetReg(SISCR, 0x85);
-                SiS_SetReg(SISCR, 0x85, v2);
-                SiS_SetReg(SISCR, 0x82, v3);
-                SiS_SetReg(SISCR, 0x98, 0x01);
-                SiS_SetReg(SISCR, 0x9a, 0x02);
-
-                SiS_SetReg(SISSR, 0x28, 0x64);
-                SiS_SetReg(SISSR, 0x29, 0x63);
-                sisfb_post_xgi_delay(ivideo, 15);
-                SiS_SetReg(SISSR, 0x18, 0x00);
-                SiS_SetReg(SISSR, 0x19, 0x20);
-                SiS_SetReg(SISSR, 0x16, 0x00);
-                SiS_SetReg(SISSR, 0x16, 0x80);
-                SiS_SetReg(SISSR, 0x18, 0xc5);
-                SiS_SetReg(SISSR, 0x19, 0x23);
-                SiS_SetReg(SISSR, 0x16, 0x00);
-                SiS_SetReg(SISSR, 0x16, 0x80);
-                sisfb_post_xgi_delay(ivideo, 1);
-                SiS_SetReg(SISCR, 0x97, 0x11);
-                sisfb_post_xgi_setclocks(ivideo, regb);
-                sisfb_post_xgi_delay(ivideo, 0x46);
-                SiS_SetReg(SISSR, 0x18, 0xc5);
-                SiS_SetReg(SISSR, 0x19, 0x23);
-                SiS_SetReg(SISSR, 0x16, 0x00);
-                SiS_SetReg(SISSR, 0x16, 0x80);
-                sisfb_post_xgi_delay(ivideo, 1);
-                SiS_SetReg(SISSR, 0x1b, 0x04);
-                sisfb_post_xgi_delay(ivideo, 1);
-                SiS_SetReg(SISSR, 0x1b, 0x00);
-                sisfb_post_xgi_delay(ivideo, 1);
-                v1 = 0x31;
-                if(ivideo->haveXGIROM) {
-                        v1 = bios[0xf0];
-                }
-                SiS_SetReg(SISSR, 0x18, v1);
-                SiS_SetReg(SISSR, 0x19, 0x06);
-                SiS_SetReg(SISSR, 0x16, 0x04);
-                SiS_SetReg(SISSR, 0x16, 0x84);
-                sisfb_post_xgi_delay(ivideo, 1);
+                sisfb_post_xgi_ddr2(ivideo, regb);
                 break;
         default:
                 sisfb_post_xgi_setclocks(ivideo, regb);
@@ -5648,6 +5765,7 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 SiS_SetReg(SISSR, 0x14, bios[regb + 0xe0 + 8]);
 
         } else {
+                int err;
 
                 /* Set default mode, don't clear screen */
                 ivideo->SiS_Pr.SiS_UseOEM = false;
@@ -5661,10 +5779,16 @@ sisfb_post_xgi(struct pci_dev *pdev)
 
                 /* Disable read-cache */
                 SiS_SetRegAND(SISSR, 0x21, 0xdf);
-                sisfb_post_xgi_ramsize(ivideo);
+                err = sisfb_post_xgi_ramsize(ivideo);
                 /* Enable read-cache */
                 SiS_SetRegOR(SISSR, 0x21, 0x20);
 
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "%s: RAM size detection failed: %d\n",
+                                __func__, err);
+                        return 0;
+                }
         }
 
 #if 0
@@ -5777,6 +5901,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 #endif
 
         ivideo->chip = chipinfo->chip;
+        ivideo->chip_real_id = chipinfo->chip;
         ivideo->sisvga_engine = chipinfo->vgaengine;
         ivideo->hwcursor_size = chipinfo->hwcursor_size;
         ivideo->CRT2_write_enable = chipinfo->CRT2_write_enable;
@@ -6010,6 +6135,18 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 sisfb_detect_custom_timing(ivideo);
         }
 
+#ifdef CONFIG_FB_SIS_315
+        if (ivideo->chip == XGI_20) {
+                /* Check if our Z7 chip is actually Z9 */
+                SiS_SetRegOR(SISCR, 0x4a, 0x40);        /* GPIOG EN */
+                reg = SiS_GetReg(SISCR, 0x48);
+                if (reg & 0x02) {                       /* GPIOG */
+                        ivideo->chip_real_id = XGI_21;
+                        dev_info(&pdev->dev, "Z9 detected\n");
+                }
+        }
+#endif
+
         /* POST card in case this has not been done by the BIOS */
         if( (!ivideo->sisvga_enabled)
 #if !defined(__i386__) && !defined(__x86_64__)
diff --git a/drivers/video/sis/vgatypes.h b/drivers/video/sis/vgatypes.h
index 12c0dfaf2518..e3f9976cfef0 100644
--- a/drivers/video/sis/vgatypes.h
+++ b/drivers/video/sis/vgatypes.h
@@ -87,6 +87,7 @@ typedef enum _SIS_CHIP_TYPE {
     SIS_341,
     SIS_342,
     XGI_20  = 75,
+    XGI_21,
     XGI_40,
     MAX_SIS_CHIP
 } SIS_CHIP_TYPE;
diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c
index bcb44a594ebc..56ef6b3a9851 100644
--- a/drivers/video/sm501fb.c
+++ b/drivers/video/sm501fb.c
@@ -41,6 +41,26 @@
 #include <linux/sm501.h>
 #include <linux/sm501-regs.h>
 
+#include "edid.h"
+
+static char *fb_mode = "640x480-16@60";
+static unsigned long default_bpp = 16;
+
+static struct fb_videomode __devinitdata sm501_default_mode = {
+        .refresh        = 60,
+        .xres           = 640,
+        .yres           = 480,
+        .pixclock       = 20833,
+        .left_margin    = 142,
+        .right_margin   = 13,
+        .upper_margin   = 21,
+        .lower_margin   = 1,
+        .hsync_len      = 69,
+        .vsync_len      = 3,
+        .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+        .vmode          = FB_VMODE_NONINTERLACED
+};
+
 #define NR_PALETTE      256
 
 enum sm501_controller {
@@ -77,6 +97,7 @@ struct sm501fb_info {
         void __iomem            *regs2d;        /* 2d remapped registers */
         void __iomem            *fbmem;         /* remapped framebuffer */
         size_t                   fbmem_len;     /* length of remapped region */
+        u8 *edid_data;
 };
 
 /* per-framebuffer private data */
@@ -117,7 +138,7 @@ static inline int v_total(struct fb_var_screeninfo *var)
 
 static inline void sm501fb_sync_regs(struct sm501fb_info *info)
 {
-        readl(info->regs);
+        smc501_readl(info->regs);
 }
 
 /* sm501_alloc_mem
@@ -244,7 +265,7 @@ static unsigned long sm501fb_ps_to_hz(unsigned long psvalue)
         return (unsigned long)numerator;
 }
 
-/* sm501fb_hz_to_ps is identical to the oposite transform */
+/* sm501fb_hz_to_ps is identical to the opposite transform */
 
 #define sm501fb_hz_to_ps(x) sm501fb_ps_to_hz(x)
 
@@ -262,7 +283,7 @@ static void sm501fb_setup_gamma(struct sm501fb_info *fbi,
 
         /* set gamma values */
         for (offset = 0; offset < 256 * 4; offset += 4) {
-                writel(value, fbi->regs + palette + offset);
+                smc501_writel(value, fbi->regs + palette + offset);
                 value += 0x010101;      /* Advance RGB by 1,1,1.*/
         }
 }
@@ -476,7 +497,8 @@ static int sm501fb_set_par_common(struct fb_info *info,
 
         /* set start of framebuffer to the screen */
 
-        writel(par->screen.sm_addr | SM501_ADDR_FLIP, fbi->regs + head_addr);
+        smc501_writel(par->screen.sm_addr | SM501_ADDR_FLIP,
+                        fbi->regs + head_addr);
 
         /* program CRT clock  */
 
@@ -519,7 +541,7 @@ static void sm501fb_set_par_geometry(struct fb_info *info,
         reg = info->fix.line_length;
         reg |= ((var->xres * var->bits_per_pixel)/8) << 16;
 
-        writel(reg, fbi->regs + (par->head == HEAD_CRT ?
+        smc501_writel(reg, fbi->regs + (par->head == HEAD_CRT ?
                     SM501_DC_CRT_FB_OFFSET :  SM501_DC_PANEL_FB_OFFSET));
 
         /* program horizontal total */
@@ -527,27 +549,27 @@ static void sm501fb_set_par_geometry(struct fb_info *info,
         reg  = (h_total(var) - 1) << 16;
         reg |= (var->xres - 1);
 
-        writel(reg, base + SM501_OFF_DC_H_TOT);
+        smc501_writel(reg, base + SM501_OFF_DC_H_TOT);
 
         /* program horizontal sync */
 
         reg  = var->hsync_len << 16;
         reg |= var->xres + var->right_margin - 1;
 
-        writel(reg, base + SM501_OFF_DC_H_SYNC);
+        smc501_writel(reg, base + SM501_OFF_DC_H_SYNC);
 
         /* program vertical total */
 
         reg  = (v_total(var) - 1) << 16;
         reg |= (var->yres - 1);
 
-        writel(reg, base + SM501_OFF_DC_V_TOT);
+        smc501_writel(reg, base + SM501_OFF_DC_V_TOT);
 
         /* program vertical sync */
         reg  = var->vsync_len << 16;
         reg |= var->yres + var->lower_margin - 1;
 
-        writel(reg, base + SM501_OFF_DC_V_SYNC);
+        smc501_writel(reg, base + SM501_OFF_DC_V_SYNC);
 }
 
 /* sm501fb_pan_crt
@@ -566,15 +588,15 @@ static int sm501fb_pan_crt(struct fb_var_screeninfo *var,
 
         xoffs = var->xoffset * bytes_pixel;
 
-        reg = readl(fbi->regs + SM501_DC_CRT_CONTROL);
+        reg = smc501_readl(fbi->regs + SM501_DC_CRT_CONTROL);
 
         reg &= ~SM501_DC_CRT_CONTROL_PIXEL_MASK;
         reg |= ((xoffs & 15) / bytes_pixel) << 4;
-        writel(reg, fbi->regs + SM501_DC_CRT_CONTROL);
+        smc501_writel(reg, fbi->regs + SM501_DC_CRT_CONTROL);
 
         reg = (par->screen.sm_addr + xoffs +
                var->yoffset * info->fix.line_length);
-        writel(reg | SM501_ADDR_FLIP, fbi->regs + SM501_DC_CRT_FB_ADDR);
+        smc501_writel(reg | SM501_ADDR_FLIP, fbi->regs + SM501_DC_CRT_FB_ADDR);
 
         sm501fb_sync_regs(fbi);
         return 0;
@@ -593,10 +615,10 @@ static int sm501fb_pan_pnl(struct fb_var_screeninfo *var,
         unsigned long reg;
 
         reg = var->xoffset | (var->xres_virtual << 16);
-        writel(reg, fbi->regs + SM501_DC_PANEL_FB_WIDTH);
+        smc501_writel(reg, fbi->regs + SM501_DC_PANEL_FB_WIDTH);
 
         reg = var->yoffset | (var->yres_virtual << 16);
-        writel(reg, fbi->regs + SM501_DC_PANEL_FB_HEIGHT);
+        smc501_writel(reg, fbi->regs + SM501_DC_PANEL_FB_HEIGHT);
 
         sm501fb_sync_regs(fbi);
         return 0;
@@ -622,7 +644,7 @@ static int sm501fb_set_par_crt(struct fb_info *info)
         /* enable CRT DAC - note 0 is on!*/
         sm501_misc_control(fbi->dev->parent, 0, SM501_MISC_DAC_POWER);
 
-        control = readl(fbi->regs + SM501_DC_CRT_CONTROL);
+        control = smc501_readl(fbi->regs + SM501_DC_CRT_CONTROL);
 
         control &= (SM501_DC_CRT_CONTROL_PIXEL_MASK |
                     SM501_DC_CRT_CONTROL_GAMMA |
@@ -684,7 +706,7 @@ static int sm501fb_set_par_crt(struct fb_info *info)
  out_update:
         dev_dbg(fbi->dev, "new control is %08lx\n", control);
 
-        writel(control, fbi->regs + SM501_DC_CRT_CONTROL);
+        smc501_writel(control, fbi->regs + SM501_DC_CRT_CONTROL);
         sm501fb_sync_regs(fbi);
 
         return 0;
@@ -696,18 +718,18 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
         void __iomem *ctrl_reg = fbi->regs + SM501_DC_PANEL_CONTROL;
         struct sm501_platdata_fbsub *pd = fbi->pdata->fb_pnl;
 
-        control = readl(ctrl_reg);
+        control = smc501_readl(ctrl_reg);
 
         if (to && (control & SM501_DC_PANEL_CONTROL_VDD) == 0) {
                 /* enable panel power */
 
                 control |= SM501_DC_PANEL_CONTROL_VDD;  /* FPVDDEN */
-                writel(control, ctrl_reg);
+                smc501_writel(control, ctrl_reg);
                 sm501fb_sync_regs(fbi);
                 mdelay(10);
 
                 control |= SM501_DC_PANEL_CONTROL_DATA; /* DATA */
-                writel(control, ctrl_reg);
+                smc501_writel(control, ctrl_reg);
                 sm501fb_sync_regs(fbi);
                 mdelay(10);
 
@@ -719,7 +741,7 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                         else
                                 control |= SM501_DC_PANEL_CONTROL_BIAS;
 
-                        writel(control, ctrl_reg);
+                        smc501_writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
@@ -730,7 +752,7 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                         else
                                 control |= SM501_DC_PANEL_CONTROL_FPEN;
 
-                        writel(control, ctrl_reg);
+                        smc501_writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
@@ -742,7 +764,7 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                         else
                                 control &= ~SM501_DC_PANEL_CONTROL_FPEN;
 
-                        writel(control, ctrl_reg);
+                        smc501_writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
@@ -753,18 +775,18 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                         else
                                 control &= ~SM501_DC_PANEL_CONTROL_BIAS;
 
-                        writel(control, ctrl_reg);
+                        smc501_writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
 
                 control &= ~SM501_DC_PANEL_CONTROL_DATA;
-                writel(control, ctrl_reg);
+                smc501_writel(control, ctrl_reg);
                 sm501fb_sync_regs(fbi);
                 mdelay(10);
 
                 control &= ~SM501_DC_PANEL_CONTROL_VDD;
-                writel(control, ctrl_reg);
+                smc501_writel(control, ctrl_reg);
                 sm501fb_sync_regs(fbi);
                 mdelay(10);
         }
@@ -799,7 +821,7 @@ static int sm501fb_set_par_pnl(struct fb_info *info)
 
         /* update control register */
 
-        control = readl(fbi->regs + SM501_DC_PANEL_CONTROL);
+        control = smc501_readl(fbi->regs + SM501_DC_PANEL_CONTROL);
         control &= (SM501_DC_PANEL_CONTROL_GAMMA |
                     SM501_DC_PANEL_CONTROL_VDD  |
                     SM501_DC_PANEL_CONTROL_DATA |
@@ -833,16 +855,16 @@ static int sm501fb_set_par_pnl(struct fb_info *info)
                 BUG();
         }
 
-        writel(0x0, fbi->regs + SM501_DC_PANEL_PANNING_CONTROL);
+        smc501_writel(0x0, fbi->regs + SM501_DC_PANEL_PANNING_CONTROL);
 
         /* panel plane top left and bottom right location */
 
-        writel(0x00, fbi->regs + SM501_DC_PANEL_TL_LOC);
+        smc501_writel(0x00, fbi->regs + SM501_DC_PANEL_TL_LOC);
 
         reg  = var->xres - 1;
         reg |= (var->yres - 1) << 16;
 
-        writel(reg, fbi->regs + SM501_DC_PANEL_BR_LOC);
+        smc501_writel(reg, fbi->regs + SM501_DC_PANEL_BR_LOC);
 
         /* program panel control register */
 
@@ -855,7 +877,7 @@ static int sm501fb_set_par_pnl(struct fb_info *info)
         if ((var->sync & FB_SYNC_VERT_HIGH_ACT) == 0)
                 control |= SM501_DC_PANEL_CONTROL_VSP;
 
-        writel(control, fbi->regs + SM501_DC_PANEL_CONTROL);
+        smc501_writel(control, fbi->regs + SM501_DC_PANEL_CONTROL);
         sm501fb_sync_regs(fbi);
 
         /* ensure the panel interface is not tristated at this point */
@@ -924,7 +946,7 @@ static int sm501fb_setcolreg(unsigned regno,
                         val |= (green >> 8) << 8;
                         val |= blue >> 8;
 
-                        writel(val, base + (regno * 4));
+                        smc501_writel(val, base + (regno * 4));
                 }
 
                 break;
@@ -980,7 +1002,7 @@ static int sm501fb_blank_crt(int blank_mode, struct fb_info *info)
 
         dev_dbg(fbi->dev, "%s(mode=%d, %p)\n", __func__, blank_mode, info);
 
-        ctrl = readl(fbi->regs + SM501_DC_CRT_CONTROL);
+        ctrl = smc501_readl(fbi->regs + SM501_DC_CRT_CONTROL);
 
         switch (blank_mode) {
         case FB_BLANK_POWERDOWN:
@@ -1004,7 +1026,7 @@ static int sm501fb_blank_crt(int blank_mode, struct fb_info *info)
 
         }
 
-        writel(ctrl, fbi->regs + SM501_DC_CRT_CONTROL);
+        smc501_writel(ctrl, fbi->regs + SM501_DC_CRT_CONTROL);
         sm501fb_sync_regs(fbi);
 
         return 0;
@@ -1041,12 +1063,14 @@ static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
         if (cursor->image.depth > 1)
                 return -EINVAL;
 
-        hwc_addr = readl(base + SM501_OFF_HWC_ADDR);
+        hwc_addr = smc501_readl(base + SM501_OFF_HWC_ADDR);
 
         if (cursor->enable)
-                writel(hwc_addr | SM501_HWC_EN, base + SM501_OFF_HWC_ADDR);
+                smc501_writel(hwc_addr | SM501_HWC_EN,
+                                base + SM501_OFF_HWC_ADDR);
         else
-                writel(hwc_addr & ~SM501_HWC_EN, base + SM501_OFF_HWC_ADDR);
+                smc501_writel(hwc_addr & ~SM501_HWC_EN,
+                                base + SM501_OFF_HWC_ADDR);
 
         /* set data */
         if (cursor->set & FB_CUR_SETPOS) {
@@ -1060,7 +1084,7 @@ static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 
                 //y += cursor->image.height;
 
-                writel(x | (y << 16), base + SM501_OFF_HWC_LOC);
+                smc501_writel(x | (y << 16), base + SM501_OFF_HWC_LOC);
         }
 
         if (cursor->set & FB_CUR_SETCMAP) {
@@ -1080,8 +1104,8 @@ static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 
                 dev_dbg(fbi->dev, "fgcol %08lx, bgcol %08lx\n", fg, bg);
 
-                writel(bg, base + SM501_OFF_HWC_COLOR_1_2);
-                writel(fg, base + SM501_OFF_HWC_COLOR_3);
+                smc501_writel(bg, base + SM501_OFF_HWC_COLOR_1_2);
+                smc501_writel(fg, base + SM501_OFF_HWC_COLOR_3);
         }
 
         if (cursor->set & FB_CUR_SETSIZE ||
@@ -1102,7 +1126,7 @@ static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
                         __func__, cursor->image.width, cursor->image.height);
 
                 for (op = 0; op < (64*64*2)/8; op+=4)
-                        writel(0x0, dst + op);
+                        smc501_writel(0x0, dst + op);
 
                 for (y = 0; y < cursor->image.height; y++) {
                         for (x = 0; x < cursor->image.width; x++) {
@@ -1141,7 +1165,7 @@ static ssize_t sm501fb_crtsrc_show(struct device *dev,
         struct sm501fb_info *info = dev_get_drvdata(dev);
         unsigned long ctrl;
 
-        ctrl = readl(info->regs + SM501_DC_CRT_CONTROL);
+        ctrl = smc501_readl(info->regs + SM501_DC_CRT_CONTROL);
         ctrl &= SM501_DC_CRT_CONTROL_SEL;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", ctrl ? "crt" : "panel");
@@ -1172,7 +1196,7 @@ static ssize_t sm501fb_crtsrc_store(struct device *dev,
 
         dev_info(dev, "setting crt source to head %d\n", head);
 
-        ctrl = readl(info->regs + SM501_DC_CRT_CONTROL);
+        ctrl = smc501_readl(info->regs + SM501_DC_CRT_CONTROL);
 
         if (head == HEAD_CRT) {
                 ctrl |= SM501_DC_CRT_CONTROL_SEL;
@@ -1184,7 +1208,7 @@ static ssize_t sm501fb_crtsrc_store(struct device *dev,
                 ctrl &= ~SM501_DC_CRT_CONTROL_TE;
         }
 
-        writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
+        smc501_writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
         sm501fb_sync_regs(info);
 
         return len;
@@ -1205,7 +1229,8 @@ static int sm501fb_show_regs(struct sm501fb_info *info, char *ptr,
         unsigned int reg;
 
         for (reg = start; reg < (len + start); reg += 4)
-                ptr += sprintf(ptr, "%08x = %08x\n", reg, readl(mem + reg));
+                ptr += sprintf(ptr, "%08x = %08x\n", reg,
+                                smc501_readl(mem + reg));
 
         return ptr - buf;
 }
@@ -1257,7 +1282,7 @@ static int sm501fb_sync(struct fb_info *info)
 
         /* wait for the 2d engine to be ready */
         while ((count > 0) &&
-               (readl(fbi->regs + SM501_SYSTEM_CONTROL) &
+               (smc501_readl(fbi->regs + SM501_SYSTEM_CONTROL) &
                 SM501_SYSCTRL_2D_ENGINE_STATUS) != 0)
                 count--;
 
@@ -1312,45 +1337,46 @@ static void sm501fb_copyarea(struct fb_info *info, const struct fb_copyarea *are
                 return;
 
         /* set the base addresses */
-        writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_SOURCE_BASE);
-        writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_DESTINATION_BASE);
+        smc501_writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_SOURCE_BASE);
+        smc501_writel(par->screen.sm_addr,
+                        fbi->regs2d + SM501_2D_DESTINATION_BASE);
 
         /* set the window width */
-        writel((info->var.xres << 16) | info->var.xres,
+        smc501_writel((info->var.xres << 16) | info->var.xres,
                fbi->regs2d + SM501_2D_WINDOW_WIDTH);
 
         /* set window stride */
-        writel((info->var.xres_virtual << 16) | info->var.xres_virtual,
+        smc501_writel((info->var.xres_virtual << 16) | info->var.xres_virtual,
                fbi->regs2d + SM501_2D_PITCH);
 
         /* set data format */
         switch (info->var.bits_per_pixel) {
         case 8:
-                writel(0, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         case 16:
-                writel(0x00100000, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0x00100000, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         case 32:
-                writel(0x00200000, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0x00200000, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         }
 
         /* 2d compare mask */
-        writel(0xffffffff, fbi->regs2d + SM501_2D_COLOR_COMPARE_MASK);
+        smc501_writel(0xffffffff, fbi->regs2d + SM501_2D_COLOR_COMPARE_MASK);
 
         /* 2d mask */
-        writel(0xffffffff, fbi->regs2d + SM501_2D_MASK);
+        smc501_writel(0xffffffff, fbi->regs2d + SM501_2D_MASK);
 
         /* source and destination x y */
-        writel((sx << 16) | sy, fbi->regs2d + SM501_2D_SOURCE);
-        writel((dx << 16) | dy, fbi->regs2d + SM501_2D_DESTINATION);
+        smc501_writel((sx << 16) | sy, fbi->regs2d + SM501_2D_SOURCE);
+        smc501_writel((dx << 16) | dy, fbi->regs2d + SM501_2D_DESTINATION);
 
         /* w/h */
-        writel((width << 16) | height, fbi->regs2d + SM501_2D_DIMENSION);
+        smc501_writel((width << 16) | height, fbi->regs2d + SM501_2D_DIMENSION);
 
         /* do area move */
-        writel(0x800000cc | rtl, fbi->regs2d + SM501_2D_CONTROL);
+        smc501_writel(0x800000cc | rtl, fbi->regs2d + SM501_2D_CONTROL);
 }
 
 static void sm501fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
@@ -1372,47 +1398,49 @@ static void sm501fb_fillrect(struct fb_info *info, const struct fb_fillrect *rec
                 return;
 
         /* set the base addresses */
-        writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_SOURCE_BASE);
-        writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_DESTINATION_BASE);
+        smc501_writel(par->screen.sm_addr, fbi->regs2d + SM501_2D_SOURCE_BASE);
+        smc501_writel(par->screen.sm_addr,
+                        fbi->regs2d + SM501_2D_DESTINATION_BASE);
 
         /* set the window width */
-        writel((info->var.xres << 16) | info->var.xres,
+        smc501_writel((info->var.xres << 16) | info->var.xres,
                fbi->regs2d + SM501_2D_WINDOW_WIDTH);
 
         /* set window stride */
-        writel((info->var.xres_virtual << 16) | info->var.xres_virtual,
+        smc501_writel((info->var.xres_virtual << 16) | info->var.xres_virtual,
                fbi->regs2d + SM501_2D_PITCH);
 
         /* set data format */
         switch (info->var.bits_per_pixel) {
         case 8:
-                writel(0, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         case 16:
-                writel(0x00100000, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0x00100000, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         case 32:
-                writel(0x00200000, fbi->regs2d + SM501_2D_STRETCH);
+                smc501_writel(0x00200000, fbi->regs2d + SM501_2D_STRETCH);
                 break;
         }
 
         /* 2d compare mask */
-        writel(0xffffffff, fbi->regs2d + SM501_2D_COLOR_COMPARE_MASK);
+        smc501_writel(0xffffffff, fbi->regs2d + SM501_2D_COLOR_COMPARE_MASK);
 
         /* 2d mask */
-        writel(0xffffffff, fbi->regs2d + SM501_2D_MASK);
+        smc501_writel(0xffffffff, fbi->regs2d + SM501_2D_MASK);
 
         /* colour */
-        writel(rect->color, fbi->regs2d + SM501_2D_FOREGROUND);
+        smc501_writel(rect->color, fbi->regs2d + SM501_2D_FOREGROUND);
 
         /* x y */
-        writel((rect->dx << 16) | rect->dy, fbi->regs2d + SM501_2D_DESTINATION);
+        smc501_writel((rect->dx << 16) | rect->dy,
+                        fbi->regs2d + SM501_2D_DESTINATION);
 
         /* w/h */
-        writel((width << 16) | height, fbi->regs2d + SM501_2D_DIMENSION);
+        smc501_writel((width << 16) | height, fbi->regs2d + SM501_2D_DIMENSION);
 
         /* do rectangle fill */
-        writel(0x800100cc, fbi->regs2d + SM501_2D_CONTROL);
+        smc501_writel(0x800100cc, fbi->regs2d + SM501_2D_CONTROL);
 }
 
 
@@ -1470,11 +1498,12 @@ static int sm501_init_cursor(struct fb_info *fbi, unsigned int reg_base)
 
         /* initialise the colour registers */
 
-        writel(par->cursor.sm_addr, par->cursor_regs + SM501_OFF_HWC_ADDR);
+        smc501_writel(par->cursor.sm_addr,
+                        par->cursor_regs + SM501_OFF_HWC_ADDR);
 
-        writel(0x00, par->cursor_regs + SM501_OFF_HWC_LOC);
-        writel(0x00, par->cursor_regs + SM501_OFF_HWC_COLOR_1_2);
-        writel(0x00, par->cursor_regs + SM501_OFF_HWC_COLOR_3);
+        smc501_writel(0x00, par->cursor_regs + SM501_OFF_HWC_LOC);
+        smc501_writel(0x00, par->cursor_regs + SM501_OFF_HWC_COLOR_1_2);
+        smc501_writel(0x00, par->cursor_regs + SM501_OFF_HWC_COLOR_3);
         sm501fb_sync_regs(info);
 
         return 0;
@@ -1581,7 +1610,7 @@ static int sm501fb_start(struct sm501fb_info *info,
 
         /* clear palette ram - undefined at power on */
         for (k = 0; k < (256 * 3); k++)
-                writel(0, info->regs + SM501_DC_PANEL_PALETTE + (k * 4));
+                smc501_writel(0, info->regs + SM501_DC_PANEL_PALETTE + (k * 4));
 
         /* enable display controller */
         sm501_unit_power(dev->parent, SM501_GATE_DISPLAY, 1);
@@ -1649,20 +1678,20 @@ static int sm501fb_init_fb(struct fb_info *fb,
         switch (head) {
         case HEAD_CRT:
                 pd = info->pdata->fb_crt;
-                ctrl = readl(info->regs + SM501_DC_CRT_CONTROL);
+                ctrl = smc501_readl(info->regs + SM501_DC_CRT_CONTROL);
                 enable = (ctrl & SM501_DC_CRT_CONTROL_ENABLE) ? 1 : 0;
 
                 /* ensure we set the correct source register */
                 if (info->pdata->fb_route != SM501_FB_CRT_PANEL) {
                         ctrl |= SM501_DC_CRT_CONTROL_SEL;
-                        writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
+                        smc501_writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
                 }
 
                 break;
 
         case HEAD_PANEL:
                 pd = info->pdata->fb_pnl;
-                ctrl = readl(info->regs + SM501_DC_PANEL_CONTROL);
+                ctrl = smc501_readl(info->regs + SM501_DC_PANEL_CONTROL);
                 enable = (ctrl & SM501_DC_PANEL_CONTROL_EN) ? 1 : 0;
                 break;
 
@@ -1680,7 +1709,7 @@ static int sm501fb_init_fb(struct fb_info *fb,
 
         if (head == HEAD_CRT && info->pdata->fb_route == SM501_FB_CRT_PANEL) {
                 ctrl &= ~SM501_DC_CRT_CONTROL_SEL;
-                writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
+                smc501_writel(ctrl, info->regs + SM501_DC_CRT_CONTROL);
                 enable = 0;
         }
 
@@ -1690,7 +1719,7 @@ static int sm501fb_init_fb(struct fb_info *fb,
                (head == HEAD_CRT) ? &sm501fb_ops_crt : &sm501fb_ops_pnl,
                sizeof(struct fb_ops));
 
-        /* update ops dependant on what we've been passed */
+        /* update ops dependent on what we've been passed */
 
         if ((pd->flags & SM501FB_FLAG_USE_HWCURSOR) == 0)
                 par->ops.fb_cursor = NULL;
@@ -1700,6 +1729,15 @@ static int sm501fb_init_fb(struct fb_info *fb,
                 FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT |
                 FBINFO_HWACCEL_XPAN | FBINFO_HWACCEL_YPAN;
 
+#if defined(CONFIG_OF)
+#ifdef __BIG_ENDIAN
+        if (of_get_property(info->dev->parent->of_node, "little-endian", NULL))
+                fb->flags |= FBINFO_FOREIGN_ENDIAN;
+#else
+        if (of_get_property(info->dev->parent->of_node, "big-endian", NULL))
+                fb->flags |= FBINFO_FOREIGN_ENDIAN;
+#endif
+#endif
         /* fixed data */
 
         fb->fix.type            = FB_TYPE_PACKED_PIXELS;
@@ -1717,9 +1755,16 @@ static int sm501fb_init_fb(struct fb_info *fb,
         fb->var.vmode           = FB_VMODE_NONINTERLACED;
         fb->var.bits_per_pixel  = 16;
 
+        if (info->edid_data) {
+                        /* Now build modedb from EDID */
+                        fb_edid_to_monspecs(info->edid_data, &fb->monspecs);
+                        fb_videomode_to_modelist(fb->monspecs.modedb,
+                                                 fb->monspecs.modedb_len,
+                                                 &fb->modelist);
+        }
+
         if (enable && (pd->flags & SM501FB_FLAG_USE_INIT_MODE) && 0) {
                 /* TODO read the mode from the current display */
-
         } else {
                 if (pd->def_mode) {
                         dev_info(info->dev, "using supplied mode\n");
@@ -1729,12 +1774,37 @@ static int sm501fb_init_fb(struct fb_info *fb,
                         fb->var.xres_virtual = fb->var.xres;
                         fb->var.yres_virtual = fb->var.yres;
                 } else {
-                        ret = fb_find_mode(&fb->var, fb,
+                        if (info->edid_data) {
+                                ret = fb_find_mode(&fb->var, fb, fb_mode,
+                                        fb->monspecs.modedb,
+                                        fb->monspecs.modedb_len,
+                                        &sm501_default_mode, default_bpp);
+                                /* edid_data is no longer needed, free it */
+                                kfree(info->edid_data);
+                        } else {
+                                ret = fb_find_mode(&fb->var, fb,
                                            NULL, NULL, 0, NULL, 8);
+                        }
 
-                        if (ret == 0 || ret == 4) {
-                                dev_err(info->dev,
-                                        "failed to get initial mode\n");
+                        switch (ret) {
+                        case 1:
+                                dev_info(info->dev, "using mode specified in "
+                                                "@mode\n");
+                                break;
+                        case 2:
+                                dev_info(info->dev, "using mode specified in "
+                                        "@mode with ignored refresh rate\n");
+                                break;
+                        case 3:
+                                dev_info(info->dev, "using mode default "
+                                        "mode\n");
+                                break;
+                        case 4:
+                                dev_info(info->dev, "using mode from list\n");
+                                break;
+                        default:
+                                dev_info(info->dev, "ret = %d\n", ret);
+                                dev_info(info->dev, "failed to find mode\n");
                                 return -EINVAL;
                         }
                 }
@@ -1875,8 +1945,32 @@ static int __devinit sm501fb_probe(struct platform_device *pdev)
         }
 
         if (info->pdata == NULL) {
-                dev_info(dev, "using default configuration data\n");
+                int found = 0;
+#if defined(CONFIG_OF)
+                struct device_node *np = pdev->dev.parent->of_node;
+                const u8 *prop;
+                const char *cp;
+                int len;
+
                 info->pdata = &sm501fb_def_pdata;
+                if (np) {
+                        /* Get EDID */
+                        cp = of_get_property(np, "mode", &len);
+                        if (cp)
+                                strcpy(fb_mode, cp);
+                        prop = of_get_property(np, "edid", &len);
+                        if (prop && len == EDID_LENGTH) {
+                                info->edid_data = kmemdup(prop, EDID_LENGTH,
+                                                          GFP_KERNEL);
+                                if (info->edid_data)
+                                        found = 1;
+                        }
+                }
+#endif
+                if (!found) {
+                        dev_info(dev, "using default configuration data\n");
+                        info->pdata = &sm501fb_def_pdata;
+                }
         }
 
         /* probe for the presence of each panel */
@@ -2085,7 +2179,7 @@ static int sm501fb_suspend(struct platform_device *pdev, pm_message_t state)
         struct sm501fb_info *info = platform_get_drvdata(pdev);
 
         /* store crt control to resume with */
-        info->pm_crt_ctrl = readl(info->regs + SM501_DC_CRT_CONTROL);
+        info->pm_crt_ctrl = smc501_readl(info->regs + SM501_DC_CRT_CONTROL);
 
         sm501fb_suspend_fb(info, HEAD_CRT);
         sm501fb_suspend_fb(info, HEAD_PANEL);
@@ -2109,10 +2203,10 @@ static int sm501fb_resume(struct platform_device *pdev)
 
         /* restore the items we want to be saved for crt control */
 
-        crt_ctrl = readl(info->regs + SM501_DC_CRT_CONTROL);
+        crt_ctrl = smc501_readl(info->regs + SM501_DC_CRT_CONTROL);
         crt_ctrl &= ~SM501_CRT_CTRL_SAVE;
         crt_ctrl |= info->pm_crt_ctrl & SM501_CRT_CTRL_SAVE;
-        writel(crt_ctrl, info->regs + SM501_DC_CRT_CONTROL);
+        smc501_writel(crt_ctrl, info->regs + SM501_DC_CRT_CONTROL);
 
         sm501fb_resume_fb(info, HEAD_CRT);
         sm501fb_resume_fb(info, HEAD_PANEL);
@@ -2149,6 +2243,11 @@ static void __exit sm501fb_cleanup(void)
 module_init(sm501fb_init);
 module_exit(sm501fb_cleanup);
 
+module_param_named(mode, fb_mode, charp, 0);
+MODULE_PARM_DESC(mode,
+        "Specify resolution as \"<xres>x<yres>[-<bpp>][@<refresh>]\" ");
+module_param_named(bpp, default_bpp, ulong, 0);
+MODULE_PARM_DESC(bpp, "Specify bit-per-pixel if not specified mode");
 MODULE_AUTHOR("Ben Dooks, Vincent Sanders");
 MODULE_DESCRIPTION("SM501 Framebuffer driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index 2ab704118c44..2301c275d63a 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -221,7 +221,7 @@ static int __sst_wait_idle(u8 __iomem *vbase)
         while(1) {
                 if (__sst_read(vbase, STATUS) & STATUS_FBI_BUSY) {
                         f_dddprintk("status: busy\n");
-/* FIXME basicaly, this is a busy wait. maybe not that good. oh well;
+/* FIXME basically, this is a busy wait. maybe not that good. oh well;
  * this is a small loop after all.
  * Or maybe we should use mdelay() or udelay() here instead ? */
                         count = 0;
@@ -501,7 +501,7 @@ static int sstfb_set_par(struct fb_info *info)
         }
 
         if (IS_VOODOO2(par)) {
-                /* voodoo2 has 32 pixel wide tiles , BUT stange things
+                /* voodoo2 has 32 pixel wide tiles , BUT strange things
                    happen with odd number of tiles */
                 par->tiles_in_X = (info->var.xres + 63 ) / 64 * 2;
         } else {
@@ -920,11 +920,11 @@ static int __devinit sst_detect_ti(struct fb_info *info)
  * we get the 1st byte (M value) of preset f1,f7 and fB
  * why those 3 ? mmmh... for now, i'll do it the glide way...
  * and ask questions later. anyway, it seems that all the freq registers are
- * realy at their default state (cf specs) so i ask again, why those 3 regs ?
+ * really at their default state (cf specs) so i ask again, why those 3 regs ?
  * mmmmh.. it seems that's much more ugly than i thought. we use f0 and fA for
  * pll programming, so in fact, we *hope* that the f1, f7 & fB won't be
  * touched...
- * is it realy safe ? how can i reset this ramdac ? geee...
+ * is it really safe ? how can i reset this ramdac ? geee...
  */
 static int __devinit sst_detect_ics(struct fb_info *info)
 {
diff --git a/drivers/video/sticore.h b/drivers/video/sticore.h
index 7fe5be4bc70e..addf7b615ef8 100644
--- a/drivers/video/sticore.h
+++ b/drivers/video/sticore.h
@@ -79,7 +79,7 @@ struct sti_glob_cfg_ext {
          u8 curr_mon;                   /* current monitor configured */
          u8 friendly_boot;              /* in friendly boot mode */
         s16 power;                      /* power calculation (in Watts) */
-        s32 freq_ref;                   /* frequency refrence */
+        s32 freq_ref;                   /* frequency reference */
         u32 sti_mem_addr;               /* pointer to global sti memory (size=sti_mem_request) */
         u32 future_ptr;                 /* pointer to future data */
 };
diff --git a/drivers/video/svgalib.c b/drivers/video/svgalib.c
index fdb45674e2f6..33df9ec91795 100644
--- a/drivers/video/svgalib.c
+++ b/drivers/video/svgalib.c
@@ -20,12 +20,12 @@
 
 
 /* Write a CRT register value spread across multiple registers */
-void svga_wcrt_multi(const struct vga_regset *regset, u32 value) {
-
+void svga_wcrt_multi(void __iomem *regbase, const struct vga_regset *regset, u32 value)
+{
         u8 regval, bitval, bitnum;
 
         while (regset->regnum != VGA_REGSET_END_VAL) {
-                regval = vga_rcrt(NULL, regset->regnum);
+                regval = vga_rcrt(regbase, regset->regnum);
                 bitnum = regset->lowbit;
                 while (bitnum <= regset->highbit) {
                         bitval = 1 << bitnum;
@@ -34,18 +34,18 @@ void svga_wcrt_multi(const struct vga_regset *regset, u32 value) {
                         bitnum ++;
                         value = value >> 1;
                 }
-                vga_wcrt(NULL, regset->regnum, regval);
+                vga_wcrt(regbase, regset->regnum, regval);
                 regset ++;
         }
 }
 
 /* Write a sequencer register value spread across multiple registers */
-void svga_wseq_multi(const struct vga_regset *regset, u32 value) {
-
+void svga_wseq_multi(void __iomem *regbase, const struct vga_regset *regset, u32 value)
+{
         u8 regval, bitval, bitnum;
 
         while (regset->regnum != VGA_REGSET_END_VAL) {
-                regval = vga_rseq(NULL, regset->regnum);
+                regval = vga_rseq(regbase, regset->regnum);
                 bitnum = regset->lowbit;
                 while (bitnum <= regset->highbit) {
                         bitval = 1 << bitnum;
@@ -54,7 +54,7 @@ void svga_wseq_multi(const struct vga_regset *regset, u32 value) {
                         bitnum ++;
                         value = value >> 1;
                 }
-                vga_wseq(NULL, regset->regnum, regval);
+                vga_wseq(regbase, regset->regnum, regval);
                 regset ++;
         }
 }
@@ -75,95 +75,95 @@ static unsigned int svga_regset_size(const struct vga_regset *regset)
 
 
 /* Set graphics controller registers to sane values */
-void svga_set_default_gfx_regs(void)
+void svga_set_default_gfx_regs(void __iomem *regbase)
 {
         /* All standard GFX registers (GR00 - GR08) */
-        vga_wgfx(NULL, VGA_GFX_SR_VALUE, 0x00);
-        vga_wgfx(NULL, VGA_GFX_SR_ENABLE, 0x00);
-        vga_wgfx(NULL, VGA_GFX_COMPARE_VALUE, 0x00);
-        vga_wgfx(NULL, VGA_GFX_DATA_ROTATE, 0x00);
-        vga_wgfx(NULL, VGA_GFX_PLANE_READ, 0x00);
-        vga_wgfx(NULL, VGA_GFX_MODE, 0x00);
-/*      vga_wgfx(NULL, VGA_GFX_MODE, 0x20); */
-/*      vga_wgfx(NULL, VGA_GFX_MODE, 0x40); */
-        vga_wgfx(NULL, VGA_GFX_MISC, 0x05);
-/*      vga_wgfx(NULL, VGA_GFX_MISC, 0x01); */
-        vga_wgfx(NULL, VGA_GFX_COMPARE_MASK, 0x0F);
-        vga_wgfx(NULL, VGA_GFX_BIT_MASK, 0xFF);
+        vga_wgfx(regbase, VGA_GFX_SR_VALUE, 0x00);
+        vga_wgfx(regbase, VGA_GFX_SR_ENABLE, 0x00);
+        vga_wgfx(regbase, VGA_GFX_COMPARE_VALUE, 0x00);
+        vga_wgfx(regbase, VGA_GFX_DATA_ROTATE, 0x00);
+        vga_wgfx(regbase, VGA_GFX_PLANE_READ, 0x00);
+        vga_wgfx(regbase, VGA_GFX_MODE, 0x00);
+/*      vga_wgfx(regbase, VGA_GFX_MODE, 0x20); */
+/*      vga_wgfx(regbase, VGA_GFX_MODE, 0x40); */
+        vga_wgfx(regbase, VGA_GFX_MISC, 0x05);
+/*      vga_wgfx(regbase, VGA_GFX_MISC, 0x01); */
+        vga_wgfx(regbase, VGA_GFX_COMPARE_MASK, 0x0F);
+        vga_wgfx(regbase, VGA_GFX_BIT_MASK, 0xFF);
 }
 
 /* Set attribute controller registers to sane values */
-void svga_set_default_atc_regs(void)
+void svga_set_default_atc_regs(void __iomem *regbase)
 {
         u8 count;
 
-        vga_r(NULL, 0x3DA);
-        vga_w(NULL, VGA_ATT_W, 0x00);
+        vga_r(regbase, 0x3DA);
+        vga_w(regbase, VGA_ATT_W, 0x00);
 
         /* All standard ATC registers (AR00 - AR14) */
         for (count = 0; count <= 0xF; count ++)
-                svga_wattr(count, count);
+                svga_wattr(regbase, count, count);
 
-        svga_wattr(VGA_ATC_MODE, 0x01);
-/*      svga_wattr(VGA_ATC_MODE, 0x41); */
-        svga_wattr(VGA_ATC_OVERSCAN, 0x00);
-        svga_wattr(VGA_ATC_PLANE_ENABLE, 0x0F);
-        svga_wattr(VGA_ATC_PEL, 0x00);
-        svga_wattr(VGA_ATC_COLOR_PAGE, 0x00);
+        svga_wattr(regbase, VGA_ATC_MODE, 0x01);
+/*      svga_wattr(regbase, VGA_ATC_MODE, 0x41); */
+        svga_wattr(regbase, VGA_ATC_OVERSCAN, 0x00);
+        svga_wattr(regbase, VGA_ATC_PLANE_ENABLE, 0x0F);
+        svga_wattr(regbase, VGA_ATC_PEL, 0x00);
+        svga_wattr(regbase, VGA_ATC_COLOR_PAGE, 0x00);
 
-        vga_r(NULL, 0x3DA);
-        vga_w(NULL, VGA_ATT_W, 0x20);
+        vga_r(regbase, 0x3DA);
+        vga_w(regbase, VGA_ATT_W, 0x20);
 }
 
 /* Set sequencer registers to sane values */
-void svga_set_default_seq_regs(void)
+void svga_set_default_seq_regs(void __iomem *regbase)
 {
         /* Standard sequencer registers (SR01 - SR04), SR00 is not set */
-        vga_wseq(NULL, VGA_SEQ_CLOCK_MODE, VGA_SR01_CHAR_CLK_8DOTS);
-        vga_wseq(NULL, VGA_SEQ_PLANE_WRITE, VGA_SR02_ALL_PLANES);
-        vga_wseq(NULL, VGA_SEQ_CHARACTER_MAP, 0x00);
-/*      vga_wseq(NULL, VGA_SEQ_MEMORY_MODE, VGA_SR04_EXT_MEM | VGA_SR04_SEQ_MODE | VGA_SR04_CHN_4M); */
-        vga_wseq(NULL, VGA_SEQ_MEMORY_MODE, VGA_SR04_EXT_MEM | VGA_SR04_SEQ_MODE);
+        vga_wseq(regbase, VGA_SEQ_CLOCK_MODE, VGA_SR01_CHAR_CLK_8DOTS);
+        vga_wseq(regbase, VGA_SEQ_PLANE_WRITE, VGA_SR02_ALL_PLANES);
+        vga_wseq(regbase, VGA_SEQ_CHARACTER_MAP, 0x00);
+/*      vga_wseq(regbase, VGA_SEQ_MEMORY_MODE, VGA_SR04_EXT_MEM | VGA_SR04_SEQ_MODE | VGA_SR04_CHN_4M); */
+        vga_wseq(regbase, VGA_SEQ_MEMORY_MODE, VGA_SR04_EXT_MEM | VGA_SR04_SEQ_MODE);
 }
 
 /* Set CRTC registers to sane values */
-void svga_set_default_crt_regs(void)
+void svga_set_default_crt_regs(void __iomem *regbase)
 {
         /* Standard CRT registers CR03 CR08 CR09 CR14 CR17 */
-        svga_wcrt_mask(0x03, 0x80, 0x80);       /* Enable vertical retrace EVRA */
-        vga_wcrt(NULL, VGA_CRTC_PRESET_ROW, 0);
-        svga_wcrt_mask(VGA_CRTC_MAX_SCAN, 0, 0x1F);
-        vga_wcrt(NULL, VGA_CRTC_UNDERLINE, 0);
-        vga_wcrt(NULL, VGA_CRTC_MODE, 0xE3);
+        svga_wcrt_mask(regbase, 0x03, 0x80, 0x80);      /* Enable vertical retrace EVRA */
+        vga_wcrt(regbase, VGA_CRTC_PRESET_ROW, 0);
+        svga_wcrt_mask(regbase, VGA_CRTC_MAX_SCAN, 0, 0x1F);
+        vga_wcrt(regbase, VGA_CRTC_UNDERLINE, 0);
+        vga_wcrt(regbase, VGA_CRTC_MODE, 0xE3);
 }
 
-void svga_set_textmode_vga_regs(void)
+void svga_set_textmode_vga_regs(void __iomem *regbase)
 {
-        /* svga_wseq_mask(0x1, 0x00, 0x01); */   /* Switch 8/9 pixel per char */
-        vga_wseq(NULL, VGA_SEQ_MEMORY_MODE,     VGA_SR04_EXT_MEM);
-        vga_wseq(NULL, VGA_SEQ_PLANE_WRITE,     0x03);
+        /* svga_wseq_mask(regbase, 0x1, 0x00, 0x01); */   /* Switch 8/9 pixel per char */
+        vga_wseq(regbase, VGA_SEQ_MEMORY_MODE, VGA_SR04_EXT_MEM);
+        vga_wseq(regbase, VGA_SEQ_PLANE_WRITE, 0x03);
 
-        vga_wcrt(NULL, VGA_CRTC_MAX_SCAN,       0x0f); /* 0x4f */
-        vga_wcrt(NULL, VGA_CRTC_UNDERLINE,      0x1f);
-        svga_wcrt_mask(VGA_CRTC_MODE,           0x23, 0x7f);
+        vga_wcrt(regbase, VGA_CRTC_MAX_SCAN, 0x0f); /* 0x4f */
+        vga_wcrt(regbase, VGA_CRTC_UNDERLINE, 0x1f);
+        svga_wcrt_mask(regbase, VGA_CRTC_MODE, 0x23, 0x7f);
 
-        vga_wcrt(NULL, VGA_CRTC_CURSOR_START,   0x0d);
-        vga_wcrt(NULL, VGA_CRTC_CURSOR_END,     0x0e);
-        vga_wcrt(NULL, VGA_CRTC_CURSOR_HI,      0x00);
-        vga_wcrt(NULL, VGA_CRTC_CURSOR_LO,      0x00);
+        vga_wcrt(regbase, VGA_CRTC_CURSOR_START, 0x0d);
+        vga_wcrt(regbase, VGA_CRTC_CURSOR_END, 0x0e);
+        vga_wcrt(regbase, VGA_CRTC_CURSOR_HI, 0x00);
+        vga_wcrt(regbase, VGA_CRTC_CURSOR_LO, 0x00);
 
-        vga_wgfx(NULL, VGA_GFX_MODE,            0x10); /* Odd/even memory mode */
-        vga_wgfx(NULL, VGA_GFX_MISC,            0x0E); /* Misc graphics register - text mode enable */
-        vga_wgfx(NULL, VGA_GFX_COMPARE_MASK,    0x00);
+        vga_wgfx(regbase, VGA_GFX_MODE, 0x10); /* Odd/even memory mode */
+        vga_wgfx(regbase, VGA_GFX_MISC, 0x0E); /* Misc graphics register - text mode enable */
+        vga_wgfx(regbase, VGA_GFX_COMPARE_MASK, 0x00);
 
-        vga_r(NULL, 0x3DA);
-        vga_w(NULL, VGA_ATT_W, 0x00);
+        vga_r(regbase, 0x3DA);
+        vga_w(regbase, VGA_ATT_W, 0x00);
 
-        svga_wattr(0x10, 0x0C);                 /* Attribute Mode Control Register - text mode, blinking and line graphics */
-        svga_wattr(0x13, 0x08);                 /* Horizontal Pixel Panning Register  */
+        svga_wattr(regbase, 0x10, 0x0C);                        /* Attribute Mode Control Register - text mode, blinking and line graphics */
+        svga_wattr(regbase, 0x13, 0x08);                        /* Horizontal Pixel Panning Register  */
 
-        vga_r(NULL, 0x3DA);
-        vga_w(NULL, VGA_ATT_W, 0x20);
+        vga_r(regbase, 0x3DA);
+        vga_w(regbase, VGA_ATT_W, 0x20);
 }
 
 #if 0
@@ -299,7 +299,7 @@ void svga_tileblit(struct fb_info *info, struct fb_tileblit *blit)
 }
 
 /* Set cursor in text (tileblit) mode */
-void svga_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
+void svga_tilecursor(void __iomem *regbase, struct fb_info *info, struct fb_tilecursor *cursor)
 {
         u8 cs = 0x0d;
         u8 ce = 0x0e;
@@ -310,7 +310,7 @@ void svga_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
         if (! cursor -> mode)
                 return;
 
-        svga_wcrt_mask(0x0A, 0x20, 0x20); /* disable cursor */
+        svga_wcrt_mask(regbase, 0x0A, 0x20, 0x20); /* disable cursor */
 
         if (cursor -> shape == FB_TILE_CURSOR_NONE)
                 return;
@@ -334,11 +334,11 @@ void svga_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
         }
 
         /* set cursor position */
-        vga_wcrt(NULL, 0x0E, pos >> 8);
-        vga_wcrt(NULL, 0x0F, pos & 0xFF);
+        vga_wcrt(regbase, 0x0E, pos >> 8);
+        vga_wcrt(regbase, 0x0F, pos & 0xFF);
 
-        vga_wcrt(NULL, 0x0B, ce); /* set cursor end */
-        vga_wcrt(NULL, 0x0A, cs); /* set cursor start and enable it */
+        vga_wcrt(regbase, 0x0B, ce); /* set cursor end */
+        vga_wcrt(regbase, 0x0A, cs); /* set cursor start and enable it */
 }
 
 int svga_get_tilemax(struct fb_info *info)
@@ -507,8 +507,9 @@ int svga_check_timings(const struct svga_timing_regs *tm, struct fb_var_screenin
 }
 
 /* Set CRT timing registers */
-void svga_set_timings(const struct svga_timing_regs *tm, struct fb_var_screeninfo *var,
-                        u32 hmul, u32 hdiv, u32 vmul, u32 vdiv, u32 hborder, int node)
+void svga_set_timings(void __iomem *regbase, const struct svga_timing_regs *tm,
+                      struct fb_var_screeninfo *var,
+                      u32 hmul, u32 hdiv, u32 vmul, u32 vdiv, u32 hborder, int node)
 {
         u8 regval;
         u32 value;
@@ -516,66 +517,66 @@ void svga_set_timings(const struct svga_timing_regs *tm, struct fb_var_screeninf
         value = var->xres + var->left_margin + var->right_margin + var->hsync_len;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal total      : %d\n", node, value);
-        svga_wcrt_multi(tm->h_total_regs, (value / 8) - 5);
+        svga_wcrt_multi(regbase, tm->h_total_regs, (value / 8) - 5);
 
         value = var->xres;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal display    : %d\n", node, value);
-        svga_wcrt_multi(tm->h_display_regs, (value / 8) - 1);
+        svga_wcrt_multi(regbase, tm->h_display_regs, (value / 8) - 1);
 
         value = var->xres;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal blank start: %d\n", node, value);
-        svga_wcrt_multi(tm->h_blank_start_regs, (value / 8) - 1 + hborder);
+        svga_wcrt_multi(regbase, tm->h_blank_start_regs, (value / 8) - 1 + hborder);
 
         value = var->xres + var->left_margin + var->right_margin + var->hsync_len;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal blank end  : %d\n", node, value);
-        svga_wcrt_multi(tm->h_blank_end_regs, (value / 8) - 1 - hborder);
+        svga_wcrt_multi(regbase, tm->h_blank_end_regs, (value / 8) - 1 - hborder);
 
         value = var->xres + var->right_margin;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal sync start : %d\n", node, value);
-        svga_wcrt_multi(tm->h_sync_start_regs, (value / 8));
+        svga_wcrt_multi(regbase, tm->h_sync_start_regs, (value / 8));
 
         value = var->xres + var->right_margin + var->hsync_len;
         value = (value * hmul) / hdiv;
         pr_debug("fb%d: horizontal sync end   : %d\n", node, value);
-        svga_wcrt_multi(tm->h_sync_end_regs, (value / 8));
+        svga_wcrt_multi(regbase, tm->h_sync_end_regs, (value / 8));
 
         value = var->yres + var->upper_margin + var->lower_margin + var->vsync_len;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical total        : %d\n", node, value);
-        svga_wcrt_multi(tm->v_total_regs, value - 2);
+        svga_wcrt_multi(regbase, tm->v_total_regs, value - 2);
 
         value = var->yres;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical display      : %d\n", node, value);
-        svga_wcrt_multi(tm->v_display_regs, value - 1);
+        svga_wcrt_multi(regbase, tm->v_display_regs, value - 1);
 
         value = var->yres;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical blank start  : %d\n", node, value);
-        svga_wcrt_multi(tm->v_blank_start_regs, value);
+        svga_wcrt_multi(regbase, tm->v_blank_start_regs, value);
 
         value = var->yres + var->upper_margin + var->lower_margin + var->vsync_len;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical blank end    : %d\n", node, value);
-        svga_wcrt_multi(tm->v_blank_end_regs, value - 2);
+        svga_wcrt_multi(regbase, tm->v_blank_end_regs, value - 2);
 
         value = var->yres + var->lower_margin;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical sync start   : %d\n", node, value);
-        svga_wcrt_multi(tm->v_sync_start_regs, value);
+        svga_wcrt_multi(regbase, tm->v_sync_start_regs, value);
 
         value = var->yres + var->lower_margin + var->vsync_len;
         value = (value * vmul) / vdiv;
         pr_debug("fb%d: vertical sync end     : %d\n", node, value);
-        svga_wcrt_multi(tm->v_sync_end_regs, value);
+        svga_wcrt_multi(regbase, tm->v_sync_end_regs, value);
 
         /* Set horizontal and vertical sync pulse polarity in misc register */
 
-        regval = vga_r(NULL, VGA_MIS_R);
+        regval = vga_r(regbase, VGA_MIS_R);
         if (var->sync & FB_SYNC_HOR_HIGH_ACT) {
                 pr_debug("fb%d: positive horizontal sync\n", node);
                 regval = regval & ~0x80;
@@ -590,7 +591,7 @@ void svga_set_timings(const struct svga_timing_regs *tm, struct fb_var_screeninf
                 pr_debug("fb%d: negative vertical sync\n\n", node);
                 regval = regval | 0x40;
         }
-        vga_w(NULL, VGA_MIS_W, regval);
+        vga_w(regbase, VGA_MIS_W, regval);
 }
 
 
diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c
index 855b71993f61..07c66e946634 100644
--- a/drivers/video/tcx.c
+++ b/drivers/video/tcx.c
@@ -480,6 +480,7 @@ out_dealloc_cmap:
 
 out_unmap_regs:
         tcx_unmap_regs(op, info, par);
+        framebuffer_release(info);
 
 out_err:
         return err;
diff --git a/drivers/video/tdfxfb.c b/drivers/video/tdfxfb.c
index 3ee5e63cfa4f..a99b994c9b6b 100644
--- a/drivers/video/tdfxfb.c
+++ b/drivers/video/tdfxfb.c
@@ -877,12 +877,12 @@ static void tdfxfb_fillrect(struct fb_info *info,
         else
                 tdfx_rop = TDFX_ROP_XOR;
 
-        /* asume always rect->height < 4096 */
+        /* assume always rect->height < 4096 */
         if (dy + rect->height > 4095) {
                 dstbase = stride * dy;
                 dy = 0;
         }
-        /* asume always rect->width < 4096 */
+        /* assume always rect->width < 4096 */
         if (dx + rect->width > 4095) {
                 dstbase += dx * bpp >> 3;
                 dx = 0;
@@ -915,22 +915,22 @@ static void tdfxfb_copyarea(struct fb_info *info,
         u32 dstbase = 0;
         u32 srcbase = 0;
 
-        /* asume always area->height < 4096 */
+        /* assume always area->height < 4096 */
         if (sy + area->height > 4095) {
                 srcbase = stride * sy;
                 sy = 0;
         }
-        /* asume always area->width < 4096 */
+        /* assume always area->width < 4096 */
         if (sx + area->width > 4095) {
                 srcbase += sx * bpp >> 3;
                 sx = 0;
         }
-        /* asume always area->height < 4096 */
+        /* assume always area->height < 4096 */
         if (dy + area->height > 4095) {
                 dstbase = stride * dy;
                 dy = 0;
         }
-        /* asume always area->width < 4096 */
+        /* assume always area->width < 4096 */
         if (dx + area->width > 4095) {
                 dstbase += dx * bpp >> 3;
                 dx = 0;
@@ -1003,12 +1003,12 @@ static void tdfxfb_imageblit(struct fb_info *info, const struct fb_image *image)
 #else
         srcfmt = 0x400000;
 #endif
-        /* asume always image->height < 4096 */
+        /* assume always image->height < 4096 */
         if (dy + image->height > 4095) {
                 dstbase = stride * dy;
                 dy = 0;
         }
-        /* asume always image->width < 4096 */
+        /* assume always image->width < 4096 */
         if (dx + image->width > 4095) {
                 dstbase += dx * bpp >> 3;
                 dx = 0;
@@ -1124,7 +1124,7 @@ static int tdfxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
                  * lower half (least significant 64 bits) of a 128 bit word
                  * and pattern 1 the upper half. If you examine the data of
                  * the cursor image the graphics card uses then from the
-                 * begining you see line one of pattern 0, line one of
+                 * beginning you see line one of pattern 0, line one of
                  * pattern 1, line two of pattern 0, line two of pattern 1,
                  * etc etc. The linear stride for the cursor is always 16 bytes
                  * (128 bits) which is the maximum cursor width times two for
diff --git a/drivers/video/tmiofb.c b/drivers/video/tmiofb.c
index dfef88c803d4..0c341d739604 100644
--- a/drivers/video/tmiofb.c
+++ b/drivers/video/tmiofb.c
@@ -250,8 +250,7 @@ static irqreturn_t tmiofb_irq(int irq, void *__info)
  */
 static int tmiofb_hw_stop(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
-        struct tmio_fb_data *data = cell->driver_data;
+        struct tmio_fb_data *data = mfd_get_data(dev);
         struct fb_info *info = platform_get_drvdata(dev);
         struct tmiofb_par *par = info->par;
 
@@ -268,7 +267,7 @@ static int tmiofb_hw_stop(struct platform_device *dev)
  */
 static int tmiofb_hw_init(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct fb_info *info = platform_get_drvdata(dev);
         struct tmiofb_par *par = info->par;
         const struct resource *nlcr = &cell->resources[0];
@@ -312,8 +311,7 @@ static int tmiofb_hw_init(struct platform_device *dev)
  */
 static void tmiofb_hw_mode(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
-        struct tmio_fb_data *data = cell->driver_data;
+        struct tmio_fb_data *data = mfd_get_data(dev);
         struct fb_info *info = platform_get_drvdata(dev);
         struct fb_videomode *mode = info->mode;
         struct tmiofb_par *par = info->par;
@@ -361,7 +359,7 @@ tmiofb_acc_wait(struct fb_info *info, unsigned int ccs)
 {
         struct tmiofb_par *par = info->par;
         /*
-         * This code can be called whith interrupts disabled.
+         * This code can be called with interrupts disabled.
          * So instead of relaying on irq to trigger the event,
          * poll the state till the necessary command is executed.
          */
@@ -559,9 +557,8 @@ static int tmiofb_ioctl(struct fb_info *fbi,
 static struct fb_videomode *
 tmiofb_find_mode(struct fb_info *info, struct fb_var_screeninfo *var)
 {
-        struct mfd_cell *cell =
-                info->device->platform_data;
-        struct tmio_fb_data *data = cell->driver_data;
+        struct tmio_fb_data *data =
+                        mfd_get_data(to_platform_device(info->device));
         struct fb_videomode *best = NULL;
         int i;
 
@@ -581,9 +578,8 @@ static int tmiofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
 
         struct fb_videomode *mode;
-        struct mfd_cell *cell =
-                info->device->platform_data;
-        struct tmio_fb_data *data = cell->driver_data;
+        struct tmio_fb_data *data =
+                        mfd_get_data(to_platform_device(info->device));
 
         mode = tmiofb_find_mode(info, var);
         if (!mode || var->bits_per_pixel > 16)
@@ -683,8 +679,8 @@ static struct fb_ops tmiofb_ops = {
 
 static int __devinit tmiofb_probe(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
-        struct tmio_fb_data *data = cell->driver_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
+        struct tmio_fb_data *data = mfd_get_data(dev);
         struct resource *ccr = platform_get_resource(dev, IORESOURCE_MEM, 1);
         struct resource *lcr = platform_get_resource(dev, IORESOURCE_MEM, 0);
         struct resource *vram = platform_get_resource(dev, IORESOURCE_MEM, 2);
@@ -811,7 +807,7 @@ err_ioremap_ccr:
 
 static int __devexit tmiofb_remove(struct platform_device *dev)
 {
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         struct fb_info *info = platform_get_drvdata(dev);
         int irq = platform_get_irq(dev, 0);
         struct tmiofb_par *par;
@@ -941,7 +937,7 @@ static int tmiofb_suspend(struct platform_device *dev, pm_message_t state)
 #ifdef CONFIG_FB_TMIO_ACCELL
         struct tmiofb_par *par = info->par;
 #endif
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         int retval = 0;
 
         console_lock();
@@ -973,7 +969,7 @@ static int tmiofb_suspend(struct platform_device *dev, pm_message_t state)
 static int tmiofb_resume(struct platform_device *dev)
 {
         struct fb_info *info = platform_get_drvdata(dev);
-        struct mfd_cell *cell = dev->dev.platform_data;
+        const struct mfd_cell *cell = mfd_get_cell(dev);
         int retval = 0;
 
         console_lock();
diff --git a/drivers/video/udlfb.c b/drivers/video/udlfb.c
index 2c8364e9b632..68041d9dc260 100644
--- a/drivers/video/udlfb.c
+++ b/drivers/video/udlfb.c
@@ -769,7 +769,7 @@ static int dlfb_ops_ioctl(struct fb_info *info, unsigned int cmd,
 
                 /*
                  * 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.
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c
index 5180a215d781..7f8472cc993b 100644
--- a/drivers/video/uvesafb.c
+++ b/drivers/video/uvesafb.c
@@ -1552,8 +1552,7 @@ static void __devinit uvesafb_init_mtrr(struct fb_info *info)
                         int rc;
 
                         /* Find the largest power-of-two */
-                        while (temp_size & (temp_size - 1))
-                                temp_size &= (temp_size - 1);
+                        temp_size = roundup_pow_of_two(temp_size);
 
                         /* Try and find a power of two to add */
                         do {
@@ -1566,6 +1565,28 @@ static void __devinit uvesafb_init_mtrr(struct fb_info *info)
 #endif /* CONFIG_MTRR */
 }
 
+static void __devinit uvesafb_ioremap(struct fb_info *info)
+{
+#ifdef CONFIG_X86
+        switch (mtrr) {
+        case 1: /* uncachable */
+                info->screen_base = ioremap_nocache(info->fix.smem_start, info->fix.smem_len);
+                break;
+        case 2: /* write-back */
+                info->screen_base = ioremap_cache(info->fix.smem_start, info->fix.smem_len);
+                break;
+        case 3: /* write-combining */
+                info->screen_base = ioremap_wc(info->fix.smem_start, info->fix.smem_len);
+                break;
+        case 4: /* write-through */
+        default:
+                info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
+                break;
+        }
+#else
+        info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
+#endif /* CONFIG_X86 */
+}
 
 static ssize_t uvesafb_show_vbe_ver(struct device *dev,
                 struct device_attribute *attr, char *buf)
@@ -1736,15 +1757,22 @@ static int __devinit uvesafb_probe(struct platform_device *dev)
 
         uvesafb_init_info(info, mode);
 
+        if (!request_region(0x3c0, 32, "uvesafb")) {
+                printk(KERN_ERR "uvesafb: request region 0x3c0-0x3e0 failed\n");
+                err = -EIO;
+                goto out_mode;
+        }
+
         if (!request_mem_region(info->fix.smem_start, info->fix.smem_len,
                                 "uvesafb")) {
                 printk(KERN_ERR "uvesafb: cannot reserve video memory at "
                                 "0x%lx\n", info->fix.smem_start);
                 err = -EIO;
-                goto out_mode;
+                goto out_reg;
         }
 
-        info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
+        uvesafb_init_mtrr(info);
+        uvesafb_ioremap(info);
 
         if (!info->screen_base) {
                 printk(KERN_ERR
@@ -1755,20 +1783,13 @@ static int __devinit uvesafb_probe(struct platform_device *dev)
                 goto out_mem;
         }
 
-        if (!request_region(0x3c0, 32, "uvesafb")) {
-                printk(KERN_ERR "uvesafb: request region 0x3c0-0x3e0 failed\n");
-                err = -EIO;
-                goto out_unmap;
-        }
-
-        uvesafb_init_mtrr(info);
         platform_set_drvdata(dev, info);
 
         if (register_framebuffer(info) < 0) {
                 printk(KERN_ERR
                         "uvesafb: failed to register framebuffer device\n");
                 err = -EINVAL;
-                goto out_reg;
+                goto out_unmap;
         }
 
         printk(KERN_INFO "uvesafb: framebuffer at 0x%lx, mapped to 0x%p, "
@@ -1785,12 +1806,12 @@ static int __devinit uvesafb_probe(struct platform_device *dev)
 
         return 0;
 
-out_reg:
-        release_region(0x3c0, 32);
 out_unmap:
         iounmap(info->screen_base);
 out_mem:
         release_mem_region(info->fix.smem_start, info->fix.smem_len);
+out_reg:
+        release_region(0x3c0, 32);
 out_mode:
         if (!list_empty(&info->modelist))
                 fb_destroy_modelist(&info->modelist);
diff --git a/drivers/video/vermilion/vermilion.c b/drivers/video/vermilion/vermilion.c
index 931a567f9aff..970e43d13f52 100644
--- a/drivers/video/vermilion/vermilion.c
+++ b/drivers/video/vermilion/vermilion.c
@@ -891,8 +891,7 @@ static int vmlfb_set_par(struct fb_info *info)
         int ret;
 
         mutex_lock(&vml_mutex);
-        list_del(&vinfo->head);
-        list_add(&vinfo->head, (subsys) ? &global_has_mode : &global_no_mode);
+        list_move(&vinfo->head, (subsys) ? &global_has_mode : &global_no_mode);
         ret = vmlfb_set_par_locked(vinfo);
 
         mutex_unlock(&vml_mutex);
diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c
index 6a069d047914..a99bbe86db13 100644
--- a/drivers/video/vesafb.c
+++ b/drivers/video/vesafb.c
@@ -303,19 +303,6 @@ static int __init vesafb_probe(struct platform_device *dev)
         info->apertures->ranges[0].base = screen_info.lfb_base;
         info->apertures->ranges[0].size = size_total;
 
-        info->screen_base = ioremap(vesafb_fix.smem_start, vesafb_fix.smem_len);
-        if (!info->screen_base) {
-                printk(KERN_ERR
-                       "vesafb: abort, cannot ioremap video memory 0x%x @ 0x%lx\n",
-                        vesafb_fix.smem_len, vesafb_fix.smem_start);
-                err = -EIO;
-                goto err;
-        }
-
-        printk(KERN_INFO "vesafb: framebuffer at 0x%lx, mapped to 0x%p, "
-               "using %dk, total %dk\n",
-               vesafb_fix.smem_start, info->screen_base,
-               size_remap/1024, size_total/1024);
         printk(KERN_INFO "vesafb: mode is %dx%dx%d, linelength=%d, pages=%d\n",
                vesafb_defined.xres, vesafb_defined.yres, vesafb_defined.bits_per_pixel, vesafb_fix.line_length, screen_info.pages);
 
@@ -438,8 +425,7 @@ static int __init vesafb_probe(struct platform_device *dev)
                         int rc;
 
                         /* Find the largest power-of-two */
-                        while (temp_size & (temp_size - 1))
-                                temp_size &= (temp_size - 1);
+                        temp_size = roundup_pow_of_two(temp_size);
 
                         /* Try and find a power of two to add */
                         do {
@@ -451,6 +437,34 @@ static int __init vesafb_probe(struct platform_device *dev)
         }
 #endif
         
+        switch (mtrr) {
+        case 1: /* uncachable */
+                info->screen_base = ioremap_nocache(vesafb_fix.smem_start, vesafb_fix.smem_len);
+                break;
+        case 2: /* write-back */
+                info->screen_base = ioremap_cache(vesafb_fix.smem_start, vesafb_fix.smem_len);
+                break;
+        case 3: /* write-combining */
+                info->screen_base = ioremap_wc(vesafb_fix.smem_start, vesafb_fix.smem_len);
+                break;
+        case 4: /* write-through */
+        default:
+                info->screen_base = ioremap(vesafb_fix.smem_start, vesafb_fix.smem_len);
+                break;
+        }
+        if (!info->screen_base) {
+                printk(KERN_ERR
+                       "vesafb: abort, cannot ioremap video memory 0x%x @ 0x%lx\n",
+                        vesafb_fix.smem_len, vesafb_fix.smem_start);
+                err = -EIO;
+                goto err;
+        }
+
+        printk(KERN_INFO "vesafb: framebuffer at 0x%lx, mapped to 0x%p, "
+               "using %dk, total %dk\n",
+               vesafb_fix.smem_start, info->screen_base,
+               size_remap/1024, size_total/1024);
+
         info->fbops = &vesafb_ops;
         info->var = vesafb_defined;
         info->fix = vesafb_fix;
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index 28ccab44a391..53b2c5aae067 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -152,7 +152,7 @@ static inline int setop(int op)
 }
 
 /* Set the Enable Set/Reset Register and return its old value.  
-   The code here always uses value 0xf for thsi register. */
+   The code here always uses value 0xf for this register. */
 static inline int setsr(int sr)
 {
         int oldsr;
diff --git a/drivers/video/via/chip.h b/drivers/video/via/chip.h
index 781f3aa66b42..29d70244a21f 100644
--- a/drivers/video/via/chip.h
+++ b/drivers/video/via/chip.h
@@ -139,7 +139,6 @@ struct chip_information {
 
 struct crt_setting_information {
         int iga_path;
-        int refresh_rate;
 };
 
 struct tmds_setting_information {
diff --git a/drivers/video/via/hw.c b/drivers/video/via/hw.c
index 5728fd76bc11..dc4c778877ce 100644
--- a/drivers/video/via/hw.c
+++ b/drivers/video/via/hw.c
@@ -2002,13 +2002,15 @@ void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
         int i;
         int index = 0;
         int h_addr, v_addr;
-        u32 pll_D_N, clock;
+        u32 pll_D_N, clock, refresh = viafb_refresh;
+
+        if (viafb_SAMM_ON && set_iga == IGA2)
+                refresh = viafb_refresh1;
 
         for (i = 0; i < video_mode->mode_array; i++) {
                 index = i;
 
-                if (crt_table[i].refresh_rate == viaparinfo->
-                        crt_setting_info->refresh_rate)
+                if (crt_table[i].refresh_rate == refresh)
                         break;
         }
 
@@ -2019,7 +2021,7 @@ void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
         if ((viafb_LCD_ON | viafb_DVI_ON)
             && video_mode->crtc[0].crtc.hor_addr == 640
             && video_mode->crtc[0].crtc.ver_addr == 480
-            && viaparinfo->crt_setting_info->refresh_rate == 60) {
+            && refresh == 60) {
                 /* The border is 8 pixels. */
                 crt_reg.hor_blank_start = crt_reg.hor_blank_start - 8;
 
@@ -2070,7 +2072,6 @@ void __devinit viafb_init_chip_info(int chip_type)
         init_lvds_chip_info();
 
         viaparinfo->crt_setting_info->iga_path = IGA1;
-        viaparinfo->crt_setting_info->refresh_rate = viafb_refresh;
 
         /*Set IGA path for each device */
         viafb_set_iga_path();
@@ -2083,13 +2084,9 @@ void __devinit viafb_init_chip_info(int chip_type)
                 viaparinfo->lvds_setting_info->lcd_mode;
 }
 
-void viafb_update_device_setting(int hres, int vres,
-        int bpp, int vmode_refresh, int flag)
+void viafb_update_device_setting(int hres, int vres, int bpp, int flag)
 {
         if (flag == 0) {
-                viaparinfo->crt_setting_info->refresh_rate =
-                        vmode_refresh;
-
                 viaparinfo->tmds_setting_info->h_active = hres;
                 viaparinfo->tmds_setting_info->v_active = vres;
 
diff --git a/drivers/video/via/hw.h b/drivers/video/via/hw.h
index 7295263299f7..8858593405aa 100644
--- a/drivers/video/via/hw.h
+++ b/drivers/video/via/hw.h
@@ -949,8 +949,7 @@ void __devinit viafb_init_chip_info(int chip_type);
 void __devinit viafb_init_dac(int set_iga);
 int viafb_get_pixclock(int hres, int vres, int vmode_refresh);
 int viafb_get_refresh(int hres, int vres, u32 float_refresh);
-void viafb_update_device_setting(int hres, int vres, int bpp,
-                           int vmode_refresh, int flag);
+void viafb_update_device_setting(int hres, int vres, int bpp, int flag);
 
 void viafb_set_iga_path(void);
 void viafb_set_primary_color_register(u8 index, u8 red, u8 green, u8 blue);
diff --git a/drivers/video/via/via_utility.c b/drivers/video/via/via_utility.c
index d05ccb62b55f..35458a5eadc8 100644
--- a/drivers/video/via/via_utility.c
+++ b/drivers/video/via/via_utility.c
@@ -174,7 +174,7 @@ void viafb_set_gamma_table(int bpp, unsigned int *gamma_table)
         }
 
         /* If adjust Gamma value in SAMM, fill IGA1,
-           IGA2 Gamma table simultanous. */
+           IGA2 Gamma table simultaneous. */
         /* Switch to IGA2 Gamma Table */
         if ((active_device_amount > 1) &&
                 !((viaparinfo->chip_info->gfx_chip_name ==
diff --git a/drivers/video/via/via_utility.h b/drivers/video/via/via_utility.h
index 1670ba82143f..f23be1708c14 100644
--- a/drivers/video/via/via_utility.h
+++ b/drivers/video/via/via_utility.h
@@ -21,7 +21,7 @@
 #ifndef __VIAUTILITY_H__
 #define __VIAUTILITY_H__
 
-/* These functions are used to get infomation about device's state */
+/* These functions are used to get information about device's state */
 void viafb_get_device_support_state(u32 *support_state);
 void viafb_get_device_connect_state(u32 *connect_state);
 bool viafb_lcd_get_support_expand_state(u32 xres, u32 yres);
diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c
index f555b891cc72..a542bed086e2 100644
--- a/drivers/video/via/viafbdev.c
+++ b/drivers/video/via/viafbdev.c
@@ -182,13 +182,24 @@ static int viafb_release(struct fb_info *info, int user)
         return 0;
 }
 
+static inline int get_var_refresh(struct fb_var_screeninfo *var)
+{
+        u32 htotal, vtotal;
+
+        htotal = var->left_margin + var->xres + var->right_margin
+                + var->hsync_len;
+        vtotal = var->upper_margin + var->yres + var->lower_margin
+                + var->vsync_len;
+        return PICOS2KHZ(var->pixclock) * 1000 / (htotal * vtotal);
+}
+
 static int viafb_check_var(struct fb_var_screeninfo *var,
         struct fb_info *info)
 {
-        int htotal, vtotal, depth;
+        int depth, refresh;
         struct VideoModeTable *vmode_entry;
         struct viafb_par *ppar = info->par;
-        u32 long_refresh, line;
+        u32 line;
 
         DEBUG_MSG(KERN_INFO "viafb_check_var!\n");
         /* Sanity check */
@@ -231,17 +242,11 @@ static int viafb_check_var(struct fb_var_screeninfo *var,
         /* Based on var passed in to calculate the refresh,
          * because our driver use some modes special.
          */
-        htotal = var->xres + var->left_margin +
-        var->right_margin + var->hsync_len;
-        vtotal = var->yres + var->upper_margin +
-                var->lower_margin + var->vsync_len;
-        long_refresh = 1000000000UL / var->pixclock * 1000;
-        long_refresh /= (htotal * vtotal);
-
-        viafb_refresh = viafb_get_refresh(var->xres, var->yres, long_refresh);
+        refresh = viafb_get_refresh(var->xres, var->yres,
+                get_var_refresh(var));
 
         /* Adjust var according to our driver's own table */
-        viafb_fill_var_timing_info(var, viafb_refresh, vmode_entry);
+        viafb_fill_var_timing_info(var, refresh, vmode_entry);
         if (var->accel_flags & FB_ACCELF_TEXT &&
                 !ppar->shared->vdev->engine_mmio)
                 var->accel_flags = 0;
@@ -253,12 +258,13 @@ static int viafb_set_par(struct fb_info *info)
 {
         struct viafb_par *viapar = info->par;
         struct VideoModeTable *vmode_entry, *vmode_entry1 = NULL;
+        int refresh;
         DEBUG_MSG(KERN_INFO "viafb_set_par!\n");
 
         viafb_update_fix(info);
         viapar->depth = fb_get_color_depth(&info->var, &info->fix);
         viafb_update_device_setting(viafbinfo->var.xres, viafbinfo->var.yres,
-                viafbinfo->var.bits_per_pixel, viafb_refresh, 0);
+                viafbinfo->var.bits_per_pixel, 0);
 
         vmode_entry = viafb_get_mode(viafbinfo->var.xres, viafbinfo->var.yres);
         if (viafb_dual_fb) {
@@ -266,7 +272,7 @@ static int viafb_set_par(struct fb_info *info)
                         viafbinfo1->var.yres);
                 viafb_update_device_setting(viafbinfo1->var.xres,
                         viafbinfo1->var.yres, viafbinfo1->var.bits_per_pixel,
-                        viafb_refresh1, 1);
+                        1);
         } else if (viafb_SAMM_ON == 1) {
                 DEBUG_MSG(KERN_INFO
                 "viafb_second_xres = %d, viafb_second_yres = %d, bpp = %d\n",
@@ -275,14 +281,19 @@ static int viafb_set_par(struct fb_info *info)
                         viafb_second_yres);
 
                 viafb_update_device_setting(viafb_second_xres,
-                        viafb_second_yres, viafb_bpp1, viafb_refresh1, 1);
+                        viafb_second_yres, viafb_bpp1, 1);
         }
 
+        refresh = viafb_get_refresh(info->var.xres, info->var.yres,
+                get_var_refresh(&info->var));
         if (vmode_entry) {
-                if (viafb_dual_fb && viapar->iga_path == IGA2)
+                if (viafb_dual_fb && viapar->iga_path == IGA2) {
                         viafb_bpp1 = info->var.bits_per_pixel;
-                else
+                        viafb_refresh1 = refresh;
+                } else {
                         viafb_bpp = info->var.bits_per_pixel;
+                        viafb_refresh = refresh;
+                }
 
                 if (info->var.accel_flags & FB_ACCELF_TEXT)
                         info->flags &= ~FBINFO_HWACCEL_DISABLED;
@@ -1795,14 +1806,9 @@ int __devinit via_fb_pci_probe(struct viafb_dev *vdev)
         default_var.xres_virtual = default_xres;
         default_var.yres_virtual = default_yres;
         default_var.bits_per_pixel = viafb_bpp;
-        default_var.pixclock =
-            viafb_get_pixclock(default_xres, default_yres, viafb_refresh);
-        default_var.left_margin = (default_xres >> 3) & 0xf8;
-        default_var.right_margin = 32;
-        default_var.upper_margin = 16;
-        default_var.lower_margin = 4;
-        default_var.hsync_len = default_var.left_margin;
-        default_var.vsync_len = 4;
+        viafb_fill_var_timing_info(&default_var, viafb_get_refresh(
+                default_var.xres, default_var.yres, viafb_refresh),
+                viafb_get_mode(default_var.xres, default_var.yres));
         viafb_setup_fixinfo(&viafbinfo->fix, viaparinfo);
         viafbinfo->var = default_var;
 
@@ -1841,15 +1847,9 @@ int __devinit via_fb_pci_probe(struct viafb_dev *vdev)
                 default_var.xres_virtual = viafb_second_virtual_xres;
                 default_var.yres_virtual = viafb_second_virtual_yres;
                 default_var.bits_per_pixel = viafb_bpp1;
-                default_var.pixclock =
-                    viafb_get_pixclock(viafb_second_xres, viafb_second_yres,
-                    viafb_refresh);
-                default_var.left_margin = (viafb_second_xres >> 3) & 0xf8;
-                default_var.right_margin = 32;
-                default_var.upper_margin = 16;
-                default_var.lower_margin = 4;
-                default_var.hsync_len = default_var.left_margin;
-                default_var.vsync_len = 4;
+                viafb_fill_var_timing_info(&default_var, viafb_get_refresh(
+                        default_var.xres, default_var.yres, viafb_refresh1),
+                        viafb_get_mode(default_var.xres, default_var.yres));
 
                 viafb_setup_fixinfo(&viafbinfo1->fix, viaparinfo1);
                 viafb_check_var(&default_var, viafbinfo1);
@@ -2004,22 +2004,24 @@ static int __init viafb_setup(char *options)
  */
 int __init viafb_init(void)
 {
-        u32 dummy;
+        u32 dummy_x, dummy_y;
 #ifndef MODULE
         char *option = NULL;
         if (fb_get_options("viafb", &option))
                 return -ENODEV;
         viafb_setup(option);
 #endif
-        if (parse_mode(viafb_mode, &dummy, &dummy)
-                || parse_mode(viafb_mode1, &dummy, &dummy)
+        if (parse_mode(viafb_mode, &dummy_x, &dummy_y)
+                || !viafb_get_mode(dummy_x, dummy_y)
+                || parse_mode(viafb_mode1, &dummy_x, &dummy_y)
+                || !viafb_get_mode(dummy_x, dummy_y)
                 || viafb_bpp < 0 || viafb_bpp > 32
                 || viafb_bpp1 < 0 || viafb_bpp1 > 32
                 || parse_active_dev())
                 return -EINVAL;
 
         printk(KERN_INFO
-       "VIA Graphics Intergration Chipset framebuffer %d.%d initializing\n",
+       "VIA Graphics Integration Chipset framebuffer %d.%d initializing\n",
                VERSION_MAJOR, VERSION_MINOR);
         return 0;
 }
diff --git a/drivers/video/via/viafbdev.h b/drivers/video/via/viafbdev.h
index d66f963e930e..137996dc547e 100644
--- a/drivers/video/via/viafbdev.h
+++ b/drivers/video/via/viafbdev.h
@@ -94,9 +94,6 @@ extern int viafb_LCD_ON;
 extern int viafb_DVI_ON;
 extern int viafb_hotplug;
 
-extern int strict_strtoul(const char *cp, unsigned int base,
-        unsigned long *res);
-
 u8 viafb_gpio_i2c_read_lvds(struct lvds_setting_information
         *plvds_setting_info, struct lvds_chip_information
         *plvds_chip_info, u8 index);
diff --git a/drivers/video/vt8623fb.c b/drivers/video/vt8623fb.c
index a2965ab92cfb..f9b3e3dc2421 100644
--- a/drivers/video/vt8623fb.c
+++ b/drivers/video/vt8623fb.c
@@ -121,13 +121,19 @@ MODULE_PARM_DESC(mtrr, "Enable write-combining with MTRR (1=enable, 0=disable, d
 
 /* ------------------------------------------------------------------------- */
 
+static void vt8623fb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
+{
+        struct vt8623fb_info *par = info->par;
+
+        svga_tilecursor(par->state.vgabase, info, cursor);
+}
 
 static struct fb_tile_ops vt8623fb_tile_ops = {
         .fb_settile     = svga_settile,
         .fb_tilecopy    = svga_tilecopy,
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
-        .fb_tilecursor  = svga_tilecursor,
+        .fb_tilecursor  = vt8623fb_tilecursor,
         .fb_get_tilemax = svga_get_tilemax,
 };
 
@@ -253,6 +259,7 @@ static void vt8623fb_fillrect(struct fb_info *info, const struct fb_fillrect *re
 
 static void vt8623_set_pixclock(struct fb_info *info, u32 pixclock)
 {
+        struct vt8623fb_info *par = info->par;
         u16 m, n, r;
         u8 regval;
         int rv;
@@ -264,18 +271,18 @@ static void vt8623_set_pixclock(struct fb_info *info, u32 pixclock)
         }
 
         /* Set VGA misc register  */
-        regval = vga_r(NULL, VGA_MIS_R);
-        vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
+        regval = vga_r(par->state.vgabase, VGA_MIS_R);
+        vga_w(par->state.vgabase, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
 
         /* Set clock registers */
-        vga_wseq(NULL, 0x46, (n  | (r << 6)));
-        vga_wseq(NULL, 0x47, m);
+        vga_wseq(par->state.vgabase, 0x46, (n  | (r << 6)));
+        vga_wseq(par->state.vgabase, 0x47, m);
 
         udelay(1000);
 
         /* PLL reset */
-        svga_wseq_mask(0x40, 0x02, 0x02);
-        svga_wseq_mask(0x40, 0x00, 0x02);
+        svga_wseq_mask(par->state.vgabase, 0x40, 0x02, 0x02);
+        svga_wseq_mask(par->state.vgabase, 0x40, 0x00, 0x02);
 }
 
 
@@ -285,7 +292,10 @@ static int vt8623fb_open(struct fb_info *info, int user)
 
         mutex_lock(&(par->open_lock));
         if (par->ref_count == 0) {
+                void __iomem *vgabase = par->state.vgabase;
+
                 memset(&(par->state), 0, sizeof(struct vgastate));
+                par->state.vgabase = vgabase;
                 par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS | VGA_SAVE_CMAP;
                 par->state.num_crtc = 0xA2;
                 par->state.num_seq = 0x50;
@@ -373,6 +383,7 @@ static int vt8623fb_check_var(struct fb_var_screeninfo *var, struct fb_info *inf
 static int vt8623fb_set_par(struct fb_info *info)
 {
         u32 mode, offset_value, fetch_value, screen_size;
+        struct vt8623fb_info *par = info->par;
         u32 bpp = info->var.bits_per_pixel;
 
         if (bpp != 0) {
@@ -414,82 +425,82 @@ static int vt8623fb_set_par(struct fb_info *info)
         info->var.activate = FB_ACTIVATE_NOW;
 
         /* Unlock registers */
-        svga_wseq_mask(0x10, 0x01, 0x01);
-        svga_wcrt_mask(0x11, 0x00, 0x80);
-        svga_wcrt_mask(0x47, 0x00, 0x01);
+        svga_wseq_mask(par->state.vgabase, 0x10, 0x01, 0x01);
+        svga_wcrt_mask(par->state.vgabase, 0x11, 0x00, 0x80);
+        svga_wcrt_mask(par->state.vgabase, 0x47, 0x00, 0x01);
 
         /* Device, screen and sync off */
-        svga_wseq_mask(0x01, 0x20, 0x20);
-        svga_wcrt_mask(0x36, 0x30, 0x30);
-        svga_wcrt_mask(0x17, 0x00, 0x80);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x36, 0x30, 0x30);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x00, 0x80);
 
         /* Set default values */
-        svga_set_default_gfx_regs();
-        svga_set_default_atc_regs();
-        svga_set_default_seq_regs();
-        svga_set_default_crt_regs();
-        svga_wcrt_multi(vt8623_line_compare_regs, 0xFFFFFFFF);
-        svga_wcrt_multi(vt8623_start_address_regs, 0);
+        svga_set_default_gfx_regs(par->state.vgabase);
+        svga_set_default_atc_regs(par->state.vgabase);
+        svga_set_default_seq_regs(par->state.vgabase);
+        svga_set_default_crt_regs(par->state.vgabase);
+        svga_wcrt_multi(par->state.vgabase, vt8623_line_compare_regs, 0xFFFFFFFF);
+        svga_wcrt_multi(par->state.vgabase, vt8623_start_address_regs, 0);
 
-        svga_wcrt_multi(vt8623_offset_regs, offset_value);
-        svga_wseq_multi(vt8623_fetch_count_regs, fetch_value);
+        svga_wcrt_multi(par->state.vgabase, vt8623_offset_regs, offset_value);
+        svga_wseq_multi(par->state.vgabase, vt8623_fetch_count_regs, fetch_value);
 
         /* Clear H/V Skew */
-        svga_wcrt_mask(0x03, 0x00, 0x60);
-        svga_wcrt_mask(0x05, 0x00, 0x60);
+        svga_wcrt_mask(par->state.vgabase, 0x03, 0x00, 0x60);
+        svga_wcrt_mask(par->state.vgabase, 0x05, 0x00, 0x60);
 
         if (info->var.vmode & FB_VMODE_DOUBLE)
-                svga_wcrt_mask(0x09, 0x80, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x80, 0x80);
         else
-                svga_wcrt_mask(0x09, 0x00, 0x80);
+                svga_wcrt_mask(par->state.vgabase, 0x09, 0x00, 0x80);
 
-        svga_wseq_mask(0x1E, 0xF0, 0xF0); // DI/DVP bus
-        svga_wseq_mask(0x2A, 0x0F, 0x0F); // DI/DVP bus
-        svga_wseq_mask(0x16, 0x08, 0xBF); // FIFO read threshold
-        vga_wseq(NULL, 0x17, 0x1F);       // FIFO depth
-        vga_wseq(NULL, 0x18, 0x4E);
-        svga_wseq_mask(0x1A, 0x08, 0x08); // enable MMIO ?
+        svga_wseq_mask(par->state.vgabase, 0x1E, 0xF0, 0xF0); // DI/DVP bus
+        svga_wseq_mask(par->state.vgabase, 0x2A, 0x0F, 0x0F); // DI/DVP bus
+        svga_wseq_mask(par->state.vgabase, 0x16, 0x08, 0xBF); // FIFO read threshold
+        vga_wseq(par->state.vgabase, 0x17, 0x1F);       // FIFO depth
+        vga_wseq(par->state.vgabase, 0x18, 0x4E);
+        svga_wseq_mask(par->state.vgabase, 0x1A, 0x08, 0x08); // enable MMIO ?
 
-        vga_wcrt(NULL, 0x32, 0x00);
-        vga_wcrt(NULL, 0x34, 0x00);
-        vga_wcrt(NULL, 0x6A, 0x80);
-        vga_wcrt(NULL, 0x6A, 0xC0);
+        vga_wcrt(par->state.vgabase, 0x32, 0x00);
+        vga_wcrt(par->state.vgabase, 0x34, 0x00);
+        vga_wcrt(par->state.vgabase, 0x6A, 0x80);
+        vga_wcrt(par->state.vgabase, 0x6A, 0xC0);
 
-        vga_wgfx(NULL, 0x20, 0x00);
-        vga_wgfx(NULL, 0x21, 0x00);
-        vga_wgfx(NULL, 0x22, 0x00);
+        vga_wgfx(par->state.vgabase, 0x20, 0x00);
+        vga_wgfx(par->state.vgabase, 0x21, 0x00);
+        vga_wgfx(par->state.vgabase, 0x22, 0x00);
 
         /* Set SR15 according to number of bits per pixel */
         mode = svga_match_format(vt8623fb_formats, &(info->var), &(info->fix));
         switch (mode) {
         case 0:
                 pr_debug("fb%d: text mode\n", info->node);
-                svga_set_textmode_vga_regs();
-                svga_wseq_mask(0x15, 0x00, 0xFE);
-                svga_wcrt_mask(0x11, 0x60, 0x70);
+                svga_set_textmode_vga_regs(par->state.vgabase);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0x00, 0xFE);
+                svga_wcrt_mask(par->state.vgabase, 0x11, 0x60, 0x70);
                 break;
         case 1:
                 pr_debug("fb%d: 4 bit pseudocolor\n", info->node);
-                vga_wgfx(NULL, VGA_GFX_MODE, 0x40);
-                svga_wseq_mask(0x15, 0x20, 0xFE);
-                svga_wcrt_mask(0x11, 0x00, 0x70);
+                vga_wgfx(par->state.vgabase, VGA_GFX_MODE, 0x40);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0x20, 0xFE);
+                svga_wcrt_mask(par->state.vgabase, 0x11, 0x00, 0x70);
                 break;
         case 2:
                 pr_debug("fb%d: 4 bit pseudocolor, planar\n", info->node);
-                svga_wseq_mask(0x15, 0x00, 0xFE);
-                svga_wcrt_mask(0x11, 0x00, 0x70);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0x00, 0xFE);
+                svga_wcrt_mask(par->state.vgabase, 0x11, 0x00, 0x70);
                 break;
         case 3:
                 pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
-                svga_wseq_mask(0x15, 0x22, 0xFE);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0x22, 0xFE);
                 break;
         case 4:
                 pr_debug("fb%d: 5/6/5 truecolor\n", info->node);
-                svga_wseq_mask(0x15, 0xB6, 0xFE);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0xB6, 0xFE);
                 break;
         case 5:
                 pr_debug("fb%d: 8/8/8 truecolor\n", info->node);
-                svga_wseq_mask(0x15, 0xAE, 0xFE);
+                svga_wseq_mask(par->state.vgabase, 0x15, 0xAE, 0xFE);
                 break;
         default:
                 printk(KERN_ERR "vt8623fb: unsupported mode - bug\n");
@@ -497,16 +508,16 @@ static int vt8623fb_set_par(struct fb_info *info)
         }
 
         vt8623_set_pixclock(info, info->var.pixclock);
-        svga_set_timings(&vt8623_timing_regs, &(info->var), 1, 1,
+        svga_set_timings(par->state.vgabase, &vt8623_timing_regs, &(info->var), 1, 1,
                          (info->var.vmode & FB_VMODE_DOUBLE) ? 2 : 1, 1,
                          1, info->node);
 
         memset_io(info->screen_base, 0x00, screen_size);
 
         /* Device and screen back on */
-        svga_wcrt_mask(0x17, 0x80, 0x80);
-        svga_wcrt_mask(0x36, 0x00, 0x30);
-        svga_wseq_mask(0x01, 0x00, 0x20);
+        svga_wcrt_mask(par->state.vgabase, 0x17, 0x80, 0x80);
+        svga_wcrt_mask(par->state.vgabase, 0x36, 0x00, 0x30);
+        svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
 
         return 0;
 }
@@ -569,31 +580,33 @@ static int vt8623fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 
 static int vt8623fb_blank(int blank_mode, struct fb_info *info)
 {
+        struct vt8623fb_info *par = info->par;
+
         switch (blank_mode) {
         case FB_BLANK_UNBLANK:
                 pr_debug("fb%d: unblank\n", info->node);
-                svga_wcrt_mask(0x36, 0x00, 0x30);
-                svga_wseq_mask(0x01, 0x00, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x36, 0x00, 0x30);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x00, 0x20);
                 break;
         case FB_BLANK_NORMAL:
                 pr_debug("fb%d: blank\n", info->node);
-                svga_wcrt_mask(0x36, 0x00, 0x30);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x36, 0x00, 0x30);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_HSYNC_SUSPEND:
                 pr_debug("fb%d: DPMS standby (hsync off)\n", info->node);
-                svga_wcrt_mask(0x36, 0x10, 0x30);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x36, 0x10, 0x30);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_VSYNC_SUSPEND:
                 pr_debug("fb%d: DPMS suspend (vsync off)\n", info->node);
-                svga_wcrt_mask(0x36, 0x20, 0x30);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x36, 0x20, 0x30);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         case FB_BLANK_POWERDOWN:
                 pr_debug("fb%d: DPMS off (no sync)\n", info->node);
-                svga_wcrt_mask(0x36, 0x30, 0x30);
-                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(par->state.vgabase, 0x36, 0x30, 0x30);
+                svga_wseq_mask(par->state.vgabase, 0x01, 0x20, 0x20);
                 break;
         }
 
@@ -603,6 +616,7 @@ static int vt8623fb_blank(int blank_mode, struct fb_info *info)
 
 static int vt8623fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 {
+        struct vt8623fb_info *par = info->par;
         unsigned int offset;
 
         /* Calculate the offset */
@@ -616,7 +630,7 @@ static int vt8623fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *i
         }
 
         /* Set the offset */
-        svga_wcrt_multi(vt8623_start_address_regs, offset);
+        svga_wcrt_multi(par->state.vgabase, vt8623_start_address_regs, offset);
 
         return 0;
 }
@@ -647,6 +661,8 @@ static struct fb_ops vt8623fb_ops = {
 
 static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
+        struct pci_bus_region bus_reg;
+        struct resource vga_res;
         struct fb_info *info;
         struct vt8623fb_info *par;
         unsigned int memsize1, memsize2;
@@ -705,9 +721,18 @@ static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_devi
                 goto err_iomap_2;
         }
 
+        bus_reg.start = 0;
+        bus_reg.end = 64 * 1024;
+
+        vga_res.flags = IORESOURCE_IO;
+
+        pcibios_bus_to_resource(dev, &vga_res, &bus_reg);
+
+        par->state.vgabase = (void __iomem *) vga_res.start;
+
         /* Find how many physical memory there is on card */
-        memsize1 = (vga_rseq(NULL, 0x34) + 1) >> 1;
-        memsize2 = vga_rseq(NULL, 0x39) << 2;
+        memsize1 = (vga_rseq(par->state.vgabase, 0x34) + 1) >> 1;
+        memsize2 = vga_rseq(par->state.vgabase, 0x39) << 2;
 
         if ((16 <= memsize1) && (memsize1 <= 64) && (memsize1 == memsize2))
                 info->screen_size = memsize1 << 20;
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index d8b12c32e3ef..c8be8af0cc6d 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -1306,7 +1306,7 @@ static void w100_init_lcd(struct w100fb_par *par)
         union graphic_v_disp_u graphic_v_disp;
         union crtc_total_u crtc_total;
 
-        /* w3200 doesnt like undefined bits being set so zero register values first */
+        /* w3200 doesn't like undefined bits being set so zero register values first */
 
         active_h_disp.val = 0;
         active_h_disp.f.active_h_start=mode->left_margin;