Merge commit 'v2.6.27-rc8' into x86/setup

110 files changed, 6232 insertions, 1560 deletions

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index d58509a67068..3773d7d89243 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1656,6 +1656,32 @@ config FB_PM3
           similar boards, 3DLabs Permedia3 Create!, Appian Jeronimo 2000
           and maybe other boards.
 
+config FB_CARMINE
+        tristate "Fujitsu carmine frame buffer support"
+        depends on FB && PCI
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This is the frame buffer device driver for the Fujitsu Carmine chip.
+          The driver provides two independent frame buffer devices.
+
+choice
+        depends on FB_CARMINE
+        prompt "DRAM timing"
+        default FB_CARMINE_DRAM_EVAL
+
+config FB_CARMINE_DRAM_EVAL
+        bool "Eval board timings"
+        help
+          Use timings which work on the eval card.
+
+config CARMINE_DRAM_CUSTOM
+        bool "Custom board timings"
+        help
+          Use custom board timings.
+endchoice
+
 config FB_AU1100
         bool "Au1100 LCD Driver"
         depends on (FB = y) && MIPS && SOC_AU1100
@@ -1838,6 +1864,16 @@ config FB_W100
 
           If unsure, say N.
 
+config FB_SH_MOBILE_LCDC
+        tristate "SuperH Mobile LCDC framebuffer support"
+        depends on FB && SUPERH
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        default m
+        ---help---
+          Frame buffer driver for the on-chip SH-Mobile LCD controller.
+
 config FB_S3C2410
         tristate "S3C2410 LCD framebuffer support"
         depends on FB && ARCH_S3C2410
@@ -1949,6 +1985,23 @@ config FB_AM200EPD
          This enables support for the Metronome display controller used on
          the E-Ink AM-200 EPD devkit.
 
+config FB_COBALT
+        tristate "Cobalt server LCD frame buffer support"
+        depends on FB && MIPS_COBALT
+
+config FB_SH7760
+       bool "SH7760/SH7763 LCDC support"
+       depends on FB && (CPU_SUBTYPE_SH7760 || CPU_SUBTYPE_SH7763)
+       select FB_CFB_FILLRECT
+       select FB_CFB_COPYAREA
+       select FB_CFB_IMAGEBLIT
+       help
+         Support for the SH7760/SH7763 integrated (D)STN/TFT LCD Controller.
+         Supports display resolutions up to 1024x1024 pixel, grayscale and
+         color operation, with depths ranging from 1 bpp to 8 bpp monochrome
+         and 8, 15 or 16 bpp color; 90 degrees clockwise display rotation for
+         panels <= 320 pixel horizontal resolution.
+
 config FB_VIRTUAL
         tristate "Virtual Frame Buffer support (ONLY FOR TESTING!)"
         depends on FB
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 04bca35403ff..a6b55297a7fb 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -106,17 +106,21 @@ obj-$(CONFIG_FB_PMAGB_B)	  += pmagb-b-fb.o
 obj-$(CONFIG_FB_MAXINE)           += maxinefb.o
 obj-$(CONFIG_FB_METRONOME)        += metronomefb.o
 obj-$(CONFIG_FB_S1D13XXX)         += s1d13xxxfb.o
+obj-$(CONFIG_FB_SH7760)           += sh7760fb.o
 obj-$(CONFIG_FB_IMX)              += imxfb.o
 obj-$(CONFIG_FB_S3C2410)          += s3c2410fb.o
 obj-$(CONFIG_FB_FSL_DIU)          += fsl-diu-fb.o
+obj-$(CONFIG_FB_COBALT)           += cobalt_lcdfb.o
 obj-$(CONFIG_FB_PNX4008_DUM)      += pnx4008/
 obj-$(CONFIG_FB_PNX4008_DUM_RGB)  += pnx4008/
 obj-$(CONFIG_FB_IBM_GXT4500)      += gxt4500.o
 obj-$(CONFIG_FB_PS3)              += ps3fb.o
 obj-$(CONFIG_FB_SM501)            += sm501fb.o
 obj-$(CONFIG_FB_XILINX)           += xilinxfb.o
+obj-$(CONFIG_FB_SH_MOBILE_LCDC)   += sh_mobile_lcdcfb.o
 obj-$(CONFIG_FB_OMAP)             += omap/
 obj-$(CONFIG_XEN_FBDEV_FRONTEND)  += xen-fbfront.o
+obj-$(CONFIG_FB_CARMINE)          += carminefb.o
 
 # Platform or fallback drivers go here
 obj-$(CONFIG_FB_UVESA)            += uvesafb.o
diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index eedb8285e32f..61c3d3f40fd1 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -23,12 +23,13 @@
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/fb.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/mach-types.h>
@@ -338,7 +339,7 @@ acornfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 #endif
 
 #ifdef HAS_VIDC20
-#include <asm/arch/acornfb.h>
+#include <mach/acornfb.h>
 
 #define MAX_SIZE        2*1024*1024
 
diff --git a/drivers/video/am200epd.c b/drivers/video/am200epd.c
index 51e26c1f5e8b..0c35b8b0160e 100644
--- a/drivers/video/am200epd.c
+++ b/drivers/video/am200epd.c
@@ -33,7 +33,7 @@
 
 #include <video/metronomefb.h>
 
-#include <asm/arch/pxa-regs.h>
+#include <mach/pxa-regs.h>
 
 /* register offsets for gpio control */
 #define LED_GPIO_PIN 51
@@ -221,7 +221,7 @@ static int am200_setup_irq(struct fb_info *info)
                 return retval;
         }
 
-        return set_irq_type(IRQ_GPIO(RDY_GPIO_PIN), IRQT_FALLING);
+        return set_irq_type(IRQ_GPIO(RDY_GPIO_PIN), IRQ_TYPE_EDGE_FALLING);
 }
 
 static void am200_set_rst(struct metronomefb_par *par, int state)
diff --git a/drivers/video/amifb.c b/drivers/video/amifb.c
index 05a328c11a8b..b8e9a8682f2d 100644
--- a/drivers/video/amifb.c
+++ b/drivers/video/amifb.c
@@ -1136,7 +1136,6 @@ static int amifb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg
          * Interface to the low level console driver
          */
 
-int amifb_init(void);
 static void amifb_deinit(void);
 
         /*
@@ -2048,13 +2047,16 @@ static void amifb_copyarea(struct fb_info *info,
         width = x2 - dx;
         height = y2 - dy;
 
+        if (area->sx + dx < area->dx || area->sy + dy < area->dy)
+                return;
+
         /* update sx,sy */
         sx = area->sx + (dx - area->dx);
         sy = area->sy + (dy - area->dy);
 
         /* the source must be completely inside the virtual screen */
-        if (sx < 0 || sy < 0 || (sx + width) > info->var.xres_virtual ||
-            (sy + height) > info->var.yres_virtual)
+        if (sx + width > info->var.xres_virtual ||
+                        sy + height > info->var.yres_virtual)
                 return;
 
         if (dy > sy || (dy == sy && dx > sx)) {
@@ -2245,7 +2247,7 @@ static inline void chipfree(void)
          * Initialisation
          */
 
-int __init amifb_init(void)
+static int __init amifb_init(void)
 {
         int tag, i, err = 0;
         u_long chipptr;
@@ -2383,6 +2385,9 @@ default_chipset:
                 goto amifb_error;
         }
 
+        fb_videomode_to_modelist(ami_modedb, NUM_TOTAL_MODES,
+                                 &fb_info.modelist);
+
         round_down_bpp = 0;
         chipptr = chipalloc(fb_info.fix.smem_len+
                             SPRITEMEMSIZE+
@@ -3787,16 +3792,14 @@ static void ami_rebuild_copper(void)
         }
 }
 
-
-module_init(amifb_init);
-
-#ifdef MODULE
-MODULE_LICENSE("GPL");
-
-void cleanup_module(void)
+static void __exit amifb_exit(void)
 {
         unregister_framebuffer(&fb_info);
         amifb_deinit();
         amifb_video_off();
 }
-#endif /* MODULE */
+
+module_init(amifb_init);
+module_exit(amifb_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/arkfb.c b/drivers/video/arkfb.c
index 5001bd4ef466..314d18694b6a 100644
--- a/drivers/video/arkfb.c
+++ b/drivers/video/arkfb.c
@@ -11,7 +11,6 @@
  *  Code is based on s3fb
  */
 
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -958,20 +957,20 @@ static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_
         /* Prepare PCI device */
         rc = pci_enable_device(dev);
         if (rc < 0) {
-                dev_err(info->dev, "cannot enable PCI device\n");
+                dev_err(info->device, "cannot enable PCI device\n");
                 goto err_enable_device;
         }
 
         rc = pci_request_regions(dev, "arkfb");
         if (rc < 0) {
-                dev_err(info->dev, "cannot reserve framebuffer region\n");
+                dev_err(info->device, "cannot reserve framebuffer region\n");
                 goto err_request_regions;
         }
 
         par->dac = ics5342_init(ark_dac_read_regs, ark_dac_write_regs, info);
         if (! par->dac) {
                 rc = -ENOMEM;
-                dev_err(info->dev, "RAMDAC initialization failed\n");
+                dev_err(info->device, "RAMDAC initialization failed\n");
                 goto err_dac;
         }
 
@@ -982,7 +981,7 @@ static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_
         info->screen_base = pci_iomap(dev, 0, 0);
         if (! info->screen_base) {
                 rc = -ENOMEM;
-                dev_err(info->dev, "iomap for framebuffer failed\n");
+                dev_err(info->device, "iomap for framebuffer failed\n");
                 goto err_iomap;
         }
 
@@ -1004,19 +1003,19 @@ static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_
         rc = fb_find_mode(&(info->var), info, mode_option, NULL, 0, NULL, 8);
         if (! ((rc == 1) || (rc == 2))) {
                 rc = -EINVAL;
-                dev_err(info->dev, "mode %s not found\n", mode_option);
+                dev_err(info->device, "mode %s not found\n", mode_option);
                 goto err_find_mode;
         }
 
         rc = fb_alloc_cmap(&info->cmap, 256, 0);
         if (rc < 0) {
-                dev_err(info->dev, "cannot allocate colormap\n");
+                dev_err(info->device, "cannot allocate colormap\n");
                 goto err_alloc_cmap;
         }
 
         rc = register_framebuffer(info);
         if (rc < 0) {
-                dev_err(info->dev, "cannot register framebugger\n");
+                dev_err(info->device, "cannot register framebugger\n");
                 goto err_reg_fb;
         }
 
@@ -1090,7 +1089,7 @@ static int ark_pci_suspend (struct pci_dev* dev, pm_message_t state)
         struct fb_info *info = pci_get_drvdata(dev);
         struct arkfb_info *par = info->par;
 
-        dev_info(info->dev, "suspend\n");
+        dev_info(info->device, "suspend\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
@@ -1121,16 +1120,13 @@ static int ark_pci_resume (struct pci_dev* dev)
         struct fb_info *info = pci_get_drvdata(dev);
         struct arkfb_info *par = info->par;
 
-        dev_info(info->dev, "resume\n");
+        dev_info(info->device, "resume\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
 
-        if (par->ref_count == 0) {
-                mutex_unlock(&(par->open_lock));
-                release_console_sem();
-                return 0;
-        }
+        if (par->ref_count == 0)
+                goto fail;
 
         pci_set_power_state(dev, PCI_D0);
         pci_restore_state(dev);
@@ -1143,8 +1139,8 @@ static int ark_pci_resume (struct pci_dev* dev)
         arkfb_set_par(info);
         fb_set_suspend(info, 0);
 
-        mutex_unlock(&(par->open_lock));
 fail:
+        mutex_unlock(&(par->open_lock));
         release_console_sem();
         return 0;
 }
diff --git a/drivers/video/atafb.c b/drivers/video/atafb.c
index dff35474b854..77eb8b34fbfa 100644
--- a/drivers/video/atafb.c
+++ b/drivers/video/atafb.c
@@ -2593,13 +2593,16 @@ static void atafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
         width = x2 - dx;
         height = y2 - dy;
 
+        if (area->sx + dx < area->dx || area->sy + dy < area->dy)
+                return;
+
         /* update sx,sy */
         sx = area->sx + (dx - area->dx);
         sy = area->sy + (dy - area->dy);
 
         /* the source must be completely inside the virtual screen */
-        if (sx < 0 || sy < 0 || (sx + width) > info->var.xres_virtual ||
-            (sy + height) > info->var.yres_virtual)
+        if (sx + width > info->var.xres_virtual ||
+                        sy + height > info->var.yres_virtual)
                 return;
 
         if (dy > sy || (dy == sy && dx > sx)) {
@@ -3110,7 +3113,7 @@ int __init atafb_init(void)
         printk("atafb_init: start\n");
 
         if (!MACH_IS_ATARI)
-                return -ENXIO;
+                return -ENODEV;
 
         do {
 #ifdef ATAFB_EXT
@@ -3230,6 +3233,9 @@ int __init atafb_init(void)
                 return -EINVAL;
         }
 
+        fb_videomode_to_modelist(atafb_modedb, NUM_TOTAL_MODES,
+                                 &fb_info.modelist);
+
         atafb_set_disp(&fb_info);
 
         fb_alloc_cmap(&(fb_info.cmap), 1 << fb_info.var.bits_per_pixel, 0);
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index b004036d4087..75dac578104f 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -18,9 +18,9 @@
 #include <linux/delay.h>
 #include <linux/backlight.h>
 
-#include <asm/arch/board.h>
-#include <asm/arch/cpu.h>
-#include <asm/arch/gpio.h>
+#include <mach/board.h>
+#include <mach/cpu.h>
+#include <mach/gpio.h>
 
 #include <video/atmel_lcdc.h>
 
@@ -39,7 +39,9 @@
 #endif
 
 #if defined(CONFIG_ARCH_AT91)
-#define ATMEL_LCDFB_FBINFO_DEFAULT      FBINFO_DEFAULT
+#define ATMEL_LCDFB_FBINFO_DEFAULT      (FBINFO_DEFAULT \
+                                         | FBINFO_PARTIAL_PAN_OK \
+                                         | FBINFO_HWACCEL_YPAN)
 
 static inline void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info *sinfo,
                                         struct fb_var_screeninfo *var)
@@ -177,7 +179,7 @@ static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
         .type           = FB_TYPE_PACKED_PIXELS,
         .visual         = FB_VISUAL_TRUECOLOR,
         .xpanstep       = 0,
-        .ypanstep       = 0,
+        .ypanstep       = 1,
         .ywrapstep      = 0,
         .accel          = FB_ACCEL_NONE,
 };
@@ -206,6 +208,36 @@ static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
         return value;
 }
 
+static void atmel_lcdfb_stop_nowait(struct atmel_lcdfb_info *sinfo)
+{
+        /* Turn off the LCD controller and the DMA controller */
+        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
+                        sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
+
+        /* Wait for the LCDC core to become idle */
+        while (lcdc_readl(sinfo, ATMEL_LCDC_PWRCON) & ATMEL_LCDC_BUSY)
+                msleep(10);
+
+        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
+}
+
+static void atmel_lcdfb_stop(struct atmel_lcdfb_info *sinfo)
+{
+        atmel_lcdfb_stop_nowait(sinfo);
+
+        /* Wait for DMA engine to become idle... */
+        while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
+                msleep(10);
+}
+
+static void atmel_lcdfb_start(struct atmel_lcdfb_info *sinfo)
+{
+        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
+        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
+                (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET)
+                | ATMEL_LCDC_PWR);
+}
+
 static void atmel_lcdfb_update_dma(struct fb_info *info,
                                struct fb_var_screeninfo *var)
 {
@@ -240,9 +272,11 @@ static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info *sinfo)
 {
         struct fb_info *info = sinfo->info;
         struct fb_var_screeninfo *var = &info->var;
+        unsigned int smem_len;
 
-        info->fix.smem_len = (var->xres_virtual * var->yres_virtual
-                            * ((var->bits_per_pixel + 7) / 8));
+        smem_len = (var->xres_virtual * var->yres_virtual
+                    * ((var->bits_per_pixel + 7) / 8));
+        info->fix.smem_len = max(smem_len, sinfo->smem_len);
 
         info->screen_base = dma_alloc_writecombine(info->device, info->fix.smem_len,
                                         (dma_addr_t *)&info->fix.smem_start, GFP_KERNEL);
@@ -256,6 +290,20 @@ static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info *sinfo)
         return 0;
 }
 
+static const struct fb_videomode *atmel_lcdfb_choose_mode(struct fb_var_screeninfo *var,
+                                                     struct fb_info *info)
+{
+        struct fb_videomode varfbmode;
+        const struct fb_videomode *fbmode = NULL;
+
+        fb_var_to_videomode(&varfbmode, var);
+        fbmode = fb_find_nearest_mode(&varfbmode, &info->modelist);
+        if (fbmode)
+                fb_videomode_to_var(var, fbmode);
+        return fbmode;
+}
+
+
 /**
  *      atmel_lcdfb_check_var - Validates a var passed in.
  *      @var: frame buffer variable screen structure
@@ -289,6 +337,15 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
         clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
 
         dev_dbg(dev, "%s:\n", __func__);
+
+        if (!(var->pixclock && var->bits_per_pixel)) {
+                /* choose a suitable mode if possible */
+                if (!atmel_lcdfb_choose_mode(var, info)) {
+                        dev_err(dev, "needed value not specified\n");
+                        return -EINVAL;
+                }
+        }
+
         dev_dbg(dev, "  resolution: %ux%u\n", var->xres, var->yres);
         dev_dbg(dev, "  pixclk:     %lu KHz\n", PICOS2KHZ(var->pixclock));
         dev_dbg(dev, "  bpp:        %u\n", var->bits_per_pixel);
@@ -299,6 +356,13 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
                 return -EINVAL;
         }
 
+        /* Do not allow to have real resoulution larger than virtual */
+        if (var->xres > var->xres_virtual)
+                var->xres_virtual = var->xres;
+
+        if (var->yres > var->yres_virtual)
+                var->yres_virtual = var->yres;
+
         /* Force same alignment for each line */
         var->xres = (var->xres + 3) & ~3UL;
         var->xres_virtual = (var->xres_virtual + 3) & ~3UL;
@@ -379,6 +443,17 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
         return 0;
 }
 
+/*
+ * LCD reset sequence
+ */
+static void atmel_lcdfb_reset(struct atmel_lcdfb_info *sinfo)
+{
+        might_sleep();
+
+        atmel_lcdfb_stop(sinfo);
+        atmel_lcdfb_start(sinfo);
+}
+
 /**
  *      atmel_lcdfb_set_par - Alters the hardware state.
  *      @info: frame buffer structure that represents a single frame buffer
@@ -401,19 +476,14 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         unsigned long clk_value_khz;
         unsigned long bits_per_line;
 
+        might_sleep();
+
         dev_dbg(info->device, "%s:\n", __func__);
         dev_dbg(info->device, "  * resolution: %ux%u (%ux%u virtual)\n",
                  info->var.xres, info->var.yres,
                  info->var.xres_virtual, info->var.yres_virtual);
 
-        /* Turn off the LCD controller and the DMA controller */
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON, sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
-
-        /* Wait for the LCDC core to become idle */
-        while (lcdc_readl(sinfo, ATMEL_LCDC_PWRCON) & ATMEL_LCDC_BUSY)
-                msleep(10);
-
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
+        atmel_lcdfb_stop_nowait(sinfo);
 
         if (info->var.bits_per_pixel == 1)
                 info->fix.visual = FB_VISUAL_MONO01;
@@ -511,18 +581,14 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
 
         /* Disable all interrupts */
         lcdc_writel(sinfo, ATMEL_LCDC_IDR, ~0UL);
+        /* Enable FIFO & DMA errors */
+        lcdc_writel(sinfo, ATMEL_LCDC_IER, ATMEL_LCDC_UFLWI | ATMEL_LCDC_OWRI | ATMEL_LCDC_MERI);
 
         /* ...wait for DMA engine to become idle... */
         while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
                 msleep(10);
 
-        dev_dbg(info->device, "  * re-enable DMA engine\n");
-        /* ...and enable it with updated configuration */
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
-
-        dev_dbg(info->device, "  * re-enable LCDC core\n");
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
-                (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET) | ATMEL_LCDC_PWR);
+        atmel_lcdfb_start(sinfo);
 
         dev_dbg(info->device, "  * DONE\n");
 
@@ -645,10 +711,26 @@ static irqreturn_t atmel_lcdfb_interrupt(int irq, void *dev_id)
         u32 status;
 
         status = lcdc_readl(sinfo, ATMEL_LCDC_ISR);
-        lcdc_writel(sinfo, ATMEL_LCDC_IDR, status);
+        if (status & ATMEL_LCDC_UFLWI) {
+                dev_warn(info->device, "FIFO underflow %#x\n", status);
+                /* reset DMA and FIFO to avoid screen shifting */
+                schedule_work(&sinfo->task);
+        }
+        lcdc_writel(sinfo, ATMEL_LCDC_ICR, status);
         return IRQ_HANDLED;
 }
 
+/*
+ * LCD controller task (to reset the LCD)
+ */
+static void atmel_lcdfb_task(struct work_struct *work)
+{
+        struct atmel_lcdfb_info *sinfo =
+                container_of(work, struct atmel_lcdfb_info, task);
+
+        atmel_lcdfb_reset(sinfo);
+}
+
 static int __init atmel_lcdfb_init_fbinfo(struct atmel_lcdfb_info *sinfo)
 {
         struct fb_info *info = sinfo->info;
@@ -691,6 +773,7 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
         struct fb_info *info;
         struct atmel_lcdfb_info *sinfo;
         struct atmel_lcdfb_info *pdata_sinfo;
+        struct fb_videomode fbmode;
         struct resource *regs = NULL;
         struct resource *map = NULL;
         int ret;
@@ -714,6 +797,7 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                 sinfo->default_monspecs = pdata_sinfo->default_monspecs;
                 sinfo->atmel_lcdfb_power_control = pdata_sinfo->atmel_lcdfb_power_control;
                 sinfo->guard_time = pdata_sinfo->guard_time;
+                sinfo->smem_len = pdata_sinfo->smem_len;
                 sinfo->lcdcon_is_backlight = pdata_sinfo->lcdcon_is_backlight;
                 sinfo->lcd_wiring_mode = pdata_sinfo->lcd_wiring_mode;
         } else {
@@ -824,6 +908,10 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                 goto unmap_mmio;
         }
 
+        /* Some operations on the LCDC might sleep and
+         * require a preemptible task context */
+        INIT_WORK(&sinfo->task, atmel_lcdfb_task);
+
         ret = atmel_lcdfb_init_fbinfo(sinfo);
         if (ret < 0) {
                 dev_err(dev, "init fbinfo failed: %d\n", ret);
@@ -850,9 +938,13 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
         ret = register_framebuffer(info);
         if (ret < 0) {
                 dev_err(dev, "failed to register framebuffer device: %d\n", ret);
-                goto free_cmap;
+                goto reset_drvdata;
         }
 
+        /* add selected videomode to modelist */
+        fb_var_to_videomode(&fbmode, &info->var);
+        fb_add_videomode(&fbmode, &info->modelist);
+
         /* Power up the LCDC screen */
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(1);
@@ -862,10 +954,12 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
 
         return 0;
 
-
+reset_drvdata:
+        dev_set_drvdata(dev, NULL);
 free_cmap:
         fb_dealloc_cmap(&info->cmap);
 unregister_irqs:
+        cancel_work_sync(&sinfo->task);
         free_irq(sinfo->irq_base, info);
 unmap_mmio:
         exit_backlight(sinfo);
@@ -898,11 +992,13 @@ static int __exit atmel_lcdfb_remove(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct fb_info *info = dev_get_drvdata(dev);
-        struct atmel_lcdfb_info *sinfo = info->par;
+        struct atmel_lcdfb_info *sinfo;
 
-        if (!sinfo)
+        if (!info || !info->par)
                 return 0;
+        sinfo = info->par;
 
+        cancel_work_sync(&sinfo->task);
         exit_backlight(sinfo);
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(0);
@@ -935,11 +1031,20 @@ static int atmel_lcdfb_suspend(struct platform_device *pdev, pm_message_t mesg)
         struct fb_info *info = platform_get_drvdata(pdev);
         struct atmel_lcdfb_info *sinfo = info->par;
 
+        /*
+         * We don't want to handle interrupts while the clock is
+         * stopped. It may take forever.
+         */
+        lcdc_writel(sinfo, ATMEL_LCDC_IDR, ~0UL);
+
         sinfo->saved_lcdcon = lcdc_readl(sinfo, ATMEL_LCDC_CONTRAST_VAL);
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, 0);
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(0);
+
+        atmel_lcdfb_stop(sinfo);
         atmel_lcdfb_stop_clock(sinfo);
+
         return 0;
 }
 
@@ -949,9 +1054,15 @@ static int atmel_lcdfb_resume(struct platform_device *pdev)
         struct atmel_lcdfb_info *sinfo = info->par;
 
         atmel_lcdfb_start_clock(sinfo);
+        atmel_lcdfb_start(sinfo);
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(1);
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, sinfo->saved_lcdcon);
+
+        /* Enable FIFO & DMA errors */
+        lcdc_writel(sinfo, ATMEL_LCDC_IER, ATMEL_LCDC_UFLWI
+                        | ATMEL_LCDC_OWRI | ATMEL_LCDC_MERI);
+
         return 0;
 }
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 24ee96c4e9e9..243ea4ab20c8 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1339,10 +1339,8 @@ static int aty128_var_to_pll(u32 period_in_ps, struct aty128_pll *pll,
         if (vclk * 12 < c.ppll_min)
                 vclk = c.ppll_min/12;
 
-        pll->post_divider = -1;
-
         /* now, find an acceptable divider */
-        for (i = 0; i < sizeof(post_dividers); i++) {
+        for (i = 0; i < ARRAY_SIZE(post_dividers); i++) {
                 output_freq = post_dividers[i] * vclk;
                 if (output_freq >= c.ppll_min && output_freq <= c.ppll_max) {
                         pll->post_divider = post_dividers[i];
@@ -1350,7 +1348,7 @@ static int aty128_var_to_pll(u32 period_in_ps, struct aty128_pll *pll,
                 }
         }
 
-        if (pll->post_divider < 0)
+        if (i == ARRAY_SIZE(post_dividers))
                 return -EINVAL;
 
         /* calculate feedback divider */
@@ -1872,7 +1870,7 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
         struct fb_info *info = pci_get_drvdata(pdev);
         struct aty128fb_par *par = info->par;
         struct fb_var_screeninfo var;
-        char video_card[DEVICE_NAME_SIZE];
+        char video_card[50];
         u8 chip_rev;
         u32 dac;
 
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index bd4ac0bafecb..cc6b470073da 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -244,7 +244,7 @@ static int atyfb_sync(struct fb_info *info);
      */
 
 static int aty_init(struct fb_info *info);
-static void aty_resume_chip(struct fb_info *info);
+
 #ifdef CONFIG_ATARI
 static int store_video_par(char *videopar, unsigned char m64_num);
 #endif
@@ -424,7 +424,6 @@ static struct {
 #endif /* CONFIG_FB_ATY_CT */
 };
 
-/* can not fail */
 static int __devinit correct_chipset(struct atyfb_par *par)
 {
         u8 rev;
@@ -437,6 +436,9 @@ static int __devinit correct_chipset(struct atyfb_par *par)
                 if (par->pci_id == aty_chips[i].pci_id)
                         break;
 
+        if (i < 0)
+                return -ENODEV;
+
         name = aty_chips[i].name;
         par->pll_limits.pll_max = aty_chips[i].pll;
         par->pll_limits.mclk = aty_chips[i].mclk;
@@ -2021,6 +2023,20 @@ static int atyfb_pci_suspend(struct pci_dev *pdev, pm_message_t state)
         return 0;
 }
 
+static void aty_resume_chip(struct fb_info *info)
+{
+        struct atyfb_par *par = info->par;
+
+        aty_st_le32(MEM_CNTL, par->mem_cntl, par);
+
+        if (par->pll_ops->resume_pll)
+                par->pll_ops->resume_pll(info, &par->pll);
+
+        if (par->aux_start)
+                aty_st_le32(BUS_CNTL,
+                        aty_ld_le32(BUS_CNTL, par) | BUS_APER_REG_DIS, par);
+}
+
 static int atyfb_pci_resume(struct pci_dev *pdev)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
@@ -2229,6 +2245,7 @@ static int __devinit aty_init(struct fb_info *info)
         const char *ramname = NULL, *xtal;
         int gtb_memsize, has_var = 0;
         struct fb_var_screeninfo var;
+        int ret;
 
         init_waitqueue_head(&par->vblank.wait);
         spin_lock_init(&par->int_lock);
@@ -2610,7 +2627,8 @@ static int __devinit aty_init(struct fb_info *info)
                         var.yres_virtual = var.yres;
         }
 
-        if (atyfb_check_var(&var, info)) {
+        ret = atyfb_check_var(&var, info);
+        if (ret) {
                 PRINTKE("can't set default video mode\n");
                 goto aty_init_exit;
         }
@@ -2621,10 +2639,12 @@ static int __devinit aty_init(struct fb_info *info)
 #endif /* CONFIG_FB_ATY_CT */
         info->var = var;
 
-        if (fb_alloc_cmap(&info->cmap, 256, 0) < 0)
+        ret = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (ret < 0)
                 goto aty_init_exit;
 
-        if (register_framebuffer(info) < 0) {
+        ret = register_framebuffer(info);
+        if (ret < 0) {
                 fb_dealloc_cmap(&info->cmap);
                 goto aty_init_exit;
         }
@@ -2650,20 +2670,7 @@ aty_init_exit:
             par->mtrr_aper = -1;
         }
 #endif
-        return -1;
-}
-
-static void aty_resume_chip(struct fb_info *info)
-{
-        struct atyfb_par *par = info->par;
-
-        aty_st_le32(MEM_CNTL, par->mem_cntl, par);
-
-        if (par->pll_ops->resume_pll)
-                par->pll_ops->resume_pll(info, &par->pll);
-
-        if (par->aux_start)
-                aty_st_le32(BUS_CNTL, aty_ld_le32(BUS_CNTL, par) | BUS_APER_REG_DIS, par);
+        return ret;
 }
 
 #ifdef CONFIG_ATARI
@@ -2709,8 +2716,7 @@ static int atyfb_blank(int blank, struct fb_info *info)
         if (par->lock_blank || par->asleep)
                 return 0;
 
-#ifdef CONFIG_FB_ATY_BACKLIGHT
-#elif defined(CONFIG_FB_ATY_GENERIC_LCD)
+#ifdef CONFIG_FB_ATY_GENERIC_LCD
         if (par->lcd_table && blank > FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
                 u32 pm = aty_ld_lcd(POWER_MANAGEMENT, par);
@@ -2739,8 +2745,7 @@ static int atyfb_blank(int blank, struct fb_info *info)
         }
         aty_st_le32(CRTC_GEN_CNTL, gen_cntl, par);
 
-#ifdef CONFIG_FB_ATY_BACKLIGHT
-#elif defined(CONFIG_FB_ATY_GENERIC_LCD)
+#ifdef CONFIG_FB_ATY_GENERIC_LCD
         if (par->lcd_table && blank <= FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
                 u32 pm = aty_ld_lcd(POWER_MANAGEMENT, par);
@@ -3331,7 +3336,7 @@ static int __devinit init_from_bios(struct atyfb_par *par)
                 PRINTKE("no BIOS frequency table found, use parameters\n");
                 ret = -ENXIO;
         }
-        iounmap((void* __iomem )bios_base);
+        iounmap((void __iomem *)bios_base);
 
         return ret;
 }
@@ -3418,14 +3423,7 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         struct fb_info *info;
         struct resource *rp;
         struct atyfb_par *par;
-        int i, rc = -ENOMEM;
-
-        for (i = ARRAY_SIZE(aty_chips) - 1; i >= 0; i--)
-                if (pdev->device == aty_chips[i].pci_id)
-                        break;
-
-        if (i < 0)
-                return -ENODEV;
+        int rc = -ENOMEM;
 
         /* Enable device in PCI config */
         if (pci_enable_device(pdev)) {
@@ -3456,7 +3454,7 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         par = info->par;
         info->fix = atyfb_fix;
         info->device = &pdev->dev;
-        par->pci_id = aty_chips[i].pci_id;
+        par->pci_id = pdev->device;
         par->res_start = res_start;
         par->res_size = res_size;
         par->irq = pdev->irq;
@@ -3474,7 +3472,8 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         pci_set_drvdata(pdev, info);
 
         /* Init chip & register framebuffer */
-        if (aty_init(info))
+        rc = aty_init(info);
+        if (rc)
                 goto err_release_io;
 
 #ifdef __sparc__
@@ -3655,18 +3654,62 @@ static void __devexit atyfb_pci_remove(struct pci_dev *pdev)
         atyfb_remove(info);
 }
 
-/*
- * This driver uses its own matching table. That will be more difficult
- * to fix, so for now, we just match against any ATI ID and let the
- * probe() function find out what's up. That also mean we don't have
- * a module ID table though.
- */
 static struct pci_device_id atyfb_pci_tbl[] = {
-        { PCI_VENDOR_ID_ATI, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
-          PCI_BASE_CLASS_DISPLAY << 16, 0xff0000, 0 },
-        { 0, }
+#ifdef CONFIG_FB_ATY_GX
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GX) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64CX) },
+#endif /* CONFIG_FB_ATY_GX */
+
+#ifdef CONFIG_FB_ATY_CT
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64CT) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64ET) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LT) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64VT) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GT) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64VU) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GU) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LG) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64VV) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GV) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GW) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GY) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GZ) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GB) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GD) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GI) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GP) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GQ) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LB) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LD) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LI) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LP) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LQ) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GM) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GN) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GO) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GL) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GR) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64GS) },
+
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LM) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LN) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LR) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_CHIP_MACH64LS) },
+#endif /* CONFIG_FB_ATY_CT */
+        { }
 };
 
+MODULE_DEVICE_TABLE(pci, atyfb_pci_tbl);
+
 static struct pci_driver atyfb_driver = {
         .name           = "atyfb",
         .id_table       = atyfb_pci_tbl,
diff --git a/drivers/video/aty/radeon_accel.c b/drivers/video/aty/radeon_accel.c
index 3ca27cb13caa..aa95f8350242 100644
--- a/drivers/video/aty/radeon_accel.c
+++ b/drivers/video/aty/radeon_accel.c
@@ -55,6 +55,10 @@ static void radeonfb_prim_fillrect(struct radeonfb_info *rinfo,
         OUTREG(DP_WRITE_MSK, 0xffffffff);
         OUTREG(DP_CNTL, (DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM));
 
+        radeon_fifo_wait(2);
+        OUTREG(DSTCACHE_CTLSTAT, RB2D_DC_FLUSH_ALL);
+        OUTREG(WAIT_UNTIL, (WAIT_2D_IDLECLEAN | WAIT_DMA_GUI_IDLE));
+
         radeon_fifo_wait(2);  
         OUTREG(DST_Y_X, (region->dy << 16) | region->dx);
         OUTREG(DST_WIDTH_HEIGHT, (region->width << 16) | region->height);
@@ -116,6 +120,10 @@ static void radeonfb_prim_copyarea(struct radeonfb_info *rinfo,
         OUTREG(DP_CNTL, (xdir>=0 ? DST_X_LEFT_TO_RIGHT : 0)
                         | (ydir>=0 ? DST_Y_TOP_TO_BOTTOM : 0));
 
+        radeon_fifo_wait(2);
+        OUTREG(DSTCACHE_CTLSTAT, RB2D_DC_FLUSH_ALL);
+        OUTREG(WAIT_UNTIL, (WAIT_2D_IDLECLEAN | WAIT_DMA_GUI_IDLE));
+
         radeon_fifo_wait(3);
         OUTREG(SRC_Y_X, (sy << 16) | sx);
         OUTREG(DST_Y_X, (dy << 16) | dx);
@@ -241,8 +249,8 @@ void radeonfb_engine_reset(struct radeonfb_info *rinfo)
         INREG(HOST_PATH_CNTL);
         OUTREG(HOST_PATH_CNTL, host_path_cntl);
 
-        if (rinfo->family != CHIP_FAMILY_R300 ||
-            rinfo->family != CHIP_FAMILY_R350 ||
+        if (rinfo->family != CHIP_FAMILY_R300 &&
+            rinfo->family != CHIP_FAMILY_R350 &&
             rinfo->family != CHIP_FAMILY_RV350)
                 OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset);
 
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 400e9264e456..652273e9f5f9 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -2098,15 +2098,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
 
 static ssize_t radeon_show_one_edid(char *buf, loff_t off, size_t count, const u8 *edid)
 {
-        if (off > EDID_LENGTH)
-                return 0;
-
-        if (off + count > EDID_LENGTH)
-                count = EDID_LENGTH - off;
-
-        memcpy(buf, edid + off, count);
-
-        return count;
+        return memory_read_from_buffer(buf, count, &off, edid, EDID_LENGTH);
 }
 
 
@@ -2161,6 +2153,7 @@ static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
         struct radeonfb_info *rinfo;
         int ret;
         unsigned char c1, c2;
+        int err = 0;
 
         pr_debug("radeonfb_pci_register BEGIN\n");
         
@@ -2340,9 +2333,14 @@ static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
 
         /* Register some sysfs stuff (should be done better) */
         if (rinfo->mon1_EDID)
-                sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
+                err |= sysfs_create_bin_file(&rinfo->pdev->dev.kobj,
+                                                &edid1_attr);
         if (rinfo->mon2_EDID)
-                sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
+                err |= sysfs_create_bin_file(&rinfo->pdev->dev.kobj,
+                                                &edid2_attr);
+        if (err)
+                pr_warning("%s() Creating sysfs files failed, continuing\n",
+                           __func__);
 
         /* save current mode regs before we switch into the new one
          * so we can restore this upon __exit
diff --git a/drivers/video/aty/radeon_i2c.c b/drivers/video/aty/radeon_i2c.c
index f9e7c29ad9bf..8c8fa35f1b7c 100644
--- a/drivers/video/aty/radeon_i2c.c
+++ b/drivers/video/aty/radeon_i2c.c
@@ -69,7 +69,8 @@ static int radeon_setup_i2c_bus(struct radeon_i2c_chan *chan, const char *name)
 {
         int rc;
 
-        strcpy(chan->adapter.name, name);
+        snprintf(chan->adapter.name, sizeof(chan->adapter.name),
+                 "radeonfb %s", name);
         chan->adapter.owner             = THIS_MODULE;
         chan->adapter.id                = I2C_HW_B_RADEON;
         chan->adapter.algo_data         = &chan->algo;
diff --git a/drivers/video/aty/radeonfb.h b/drivers/video/aty/radeonfb.h
index c347e38cd0b0..ccbfffd12805 100644
--- a/drivers/video/aty/radeonfb.h
+++ b/drivers/video/aty/radeonfb.h
@@ -289,7 +289,7 @@ struct radeonfb_info {
         struct radeon_regs      state;
         struct radeon_regs      init_state;
 
-        char                    name[DEVICE_NAME_SIZE];
+        char                    name[50];
 
         unsigned long           mmio_base_phys;
         unsigned long           fb_base_phys;
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 30bf7f2f1635..452b770d8cc9 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -36,6 +36,30 @@ config LCD_LTV350QV
 
           The LTV350QV panel is present on all ATSTK1000 boards.
 
+config LCD_ILI9320
+        tristate
+        depends on LCD_CLASS_DEVICE && BACKLIGHT_LCD_SUPPORT
+        default n
+        help
+          If you have a panel based on the ILI9320 controller chip
+          then say y to include a power driver for it.
+
+config LCD_VGG2432A4
+        tristate "VGG2432A4 LCM device support"
+        depends on BACKLIGHT_LCD_SUPPORT && LCD_CLASS_DEVICE && SPI_MASTER
+        select LCD_ILI9320
+        default n
+        help
+          If you have a VGG2432A4 panel based on the ILI9320 controller chip
+          then say y to include a power driver for it.
+
+config LCD_PLATFORM
+        tristate "Platform LCD controls"
+        depends on LCD_CLASS_DEVICE
+        help
+          This driver provides a platform-device registered LCD power
+          control interface.
+
 #
 # Backlight
 #
@@ -63,6 +87,18 @@ config BACKLIGHT_ATMEL_LCDC
           If in doubt, it's safe to enable this option; it doesn't kick
           in unless the board's description says it's wired that way.
 
+config BACKLIGHT_ATMEL_PWM
+        tristate "Atmel PWM backlight control"
+        depends on BACKLIGHT_CLASS_DEVICE && ATMEL_PWM
+        default n
+        help
+          Say Y here if you want to use the PWM peripheral in Atmel AT91 and
+          AVR32 devices. This driver will need additional platform data to know
+          which PWM instance to use and how to configure it.
+
+          To compile this driver as a module, choose M here: the module will be
+          called atmel-pwm-bl.
+
 config BACKLIGHT_CORGI
         tristate "Generic (aka Sharp Corgi) Backlight Driver"
         depends on BACKLIGHT_CLASS_DEVICE
@@ -119,3 +155,12 @@ config BACKLIGHT_PWM
         help
           If you have a LCD backlight adjustable by PWM, say Y to enable
           this driver.
+
+config BACKLIGHT_MBP_NVIDIA
+       tristate "MacBook Pro Nvidia Backlight Driver"
+       depends on BACKLIGHT_CLASS_DEVICE && X86
+       default n
+       help
+         If you have an Apple Macbook Pro with Nvidia graphics hardware say Y
+         to enable a driver for its backlight
+
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index b51a7cd12500..b405aace803f 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -1,9 +1,13 @@
 # Backlight & LCD drivers
 
 obj-$(CONFIG_LCD_CLASS_DEVICE)     += lcd.o
-obj-$(CONFIG_LCD_LTV350QV)      += ltv350qv.o
+obj-$(CONFIG_LCD_LTV350QV)         += ltv350qv.o
+obj-$(CONFIG_LCD_ILI9320)          += ili9320.o
+obj-$(CONFIG_LCD_PLATFORM)         += platform_lcd.o
+obj-$(CONFIG_LCD_VGG2432A4)        += vgg2432a4.o
 
 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
+obj-$(CONFIG_BACKLIGHT_ATMEL_PWM)    += atmel-pwm-bl.o
 obj-$(CONFIG_BACKLIGHT_CORGI)   += corgi_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
@@ -11,3 +15,5 @@ obj-$(CONFIG_BACKLIGHT_OMAP1)	+= omap1_bl.o
 obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
 obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
 obj-$(CONFIG_BACKLIGHT_PWM)     += pwm_bl.o
+obj-$(CONFIG_BACKLIGHT_MBP_NVIDIA) += mbp_nvidia_bl.o
+
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
new file mode 100644
index 000000000000..505c0823a105
--- /dev/null
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2008 Atmel Corporation
+ *
+ * Backlight driver using Atmel PWM peripheral.
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/fb.h>
+#include <linux/clk.h>
+#include <linux/gpio.h>
+#include <linux/backlight.h>
+#include <linux/atmel_pwm.h>
+#include <linux/atmel-pwm-bl.h>
+
+struct atmel_pwm_bl {
+        const struct atmel_pwm_bl_platform_data *pdata;
+        struct backlight_device                 *bldev;
+        struct platform_device                  *pdev;
+        struct pwm_channel                      pwmc;
+        int                                     gpio_on;
+};
+
+static int atmel_pwm_bl_set_intensity(struct backlight_device *bd)
+{
+        struct atmel_pwm_bl *pwmbl = bl_get_data(bd);
+        int intensity = bd->props.brightness;
+        int pwm_duty;
+
+        if (bd->props.power != FB_BLANK_UNBLANK)
+                intensity = 0;
+        if (bd->props.fb_blank != FB_BLANK_UNBLANK)
+                intensity = 0;
+
+        if (pwmbl->pdata->pwm_active_low)
+                pwm_duty = pwmbl->pdata->pwm_duty_min + intensity;
+        else
+                pwm_duty = pwmbl->pdata->pwm_duty_max - intensity;
+
+        if (pwm_duty > pwmbl->pdata->pwm_duty_max)
+                pwm_duty = pwmbl->pdata->pwm_duty_max;
+        if (pwm_duty < pwmbl->pdata->pwm_duty_min)
+                pwm_duty = pwmbl->pdata->pwm_duty_min;
+
+        if (!intensity) {
+                if (pwmbl->gpio_on != -1) {
+                        gpio_set_value(pwmbl->gpio_on,
+                                        0 ^ pwmbl->pdata->on_active_low);
+                }
+                pwm_channel_writel(&pwmbl->pwmc, PWM_CUPD, pwm_duty);
+                pwm_channel_disable(&pwmbl->pwmc);
+        } else {
+                pwm_channel_enable(&pwmbl->pwmc);
+                pwm_channel_writel(&pwmbl->pwmc, PWM_CUPD, pwm_duty);
+                if (pwmbl->gpio_on != -1) {
+                        gpio_set_value(pwmbl->gpio_on,
+                                        1 ^ pwmbl->pdata->on_active_low);
+                }
+        }
+
+        return 0;
+}
+
+static int atmel_pwm_bl_get_intensity(struct backlight_device *bd)
+{
+        struct atmel_pwm_bl *pwmbl = bl_get_data(bd);
+        u8 intensity;
+
+        if (pwmbl->pdata->pwm_active_low) {
+                intensity = pwm_channel_readl(&pwmbl->pwmc, PWM_CDTY) -
+                        pwmbl->pdata->pwm_duty_min;
+        } else {
+                intensity = pwmbl->pdata->pwm_duty_max -
+                        pwm_channel_readl(&pwmbl->pwmc, PWM_CDTY);
+        }
+
+        return intensity;
+}
+
+static int atmel_pwm_bl_init_pwm(struct atmel_pwm_bl *pwmbl)
+{
+        unsigned long pwm_rate = pwmbl->pwmc.mck;
+        unsigned long prescale = DIV_ROUND_UP(pwm_rate,
+                        (pwmbl->pdata->pwm_frequency *
+                         pwmbl->pdata->pwm_compare_max)) - 1;
+
+        /*
+         * Prescale must be power of two and maximum 0xf in size because of
+         * hardware limit. PWM speed will be:
+         *      PWM module clock speed / (2 ^ prescale).
+         */
+        prescale = fls(prescale);
+        if (prescale > 0xf)
+                prescale = 0xf;
+
+        pwm_channel_writel(&pwmbl->pwmc, PWM_CMR, prescale);
+        pwm_channel_writel(&pwmbl->pwmc, PWM_CDTY,
+                        pwmbl->pdata->pwm_duty_min +
+                        pwmbl->bldev->props.brightness);
+        pwm_channel_writel(&pwmbl->pwmc, PWM_CPRD,
+                        pwmbl->pdata->pwm_compare_max);
+
+        dev_info(&pwmbl->pdev->dev, "Atmel PWM backlight driver "
+                        "(%lu Hz)\n", pwmbl->pwmc.mck /
+                        pwmbl->pdata->pwm_compare_max /
+                        (1 << prescale));
+
+        return pwm_channel_enable(&pwmbl->pwmc);
+}
+
+static struct backlight_ops atmel_pwm_bl_ops = {
+        .get_brightness = atmel_pwm_bl_get_intensity,
+        .update_status  = atmel_pwm_bl_set_intensity,
+};
+
+static int atmel_pwm_bl_probe(struct platform_device *pdev)
+{
+        const struct atmel_pwm_bl_platform_data *pdata;
+        struct backlight_device *bldev;
+        struct atmel_pwm_bl *pwmbl;
+        int retval;
+
+        pwmbl = kzalloc(sizeof(struct atmel_pwm_bl), GFP_KERNEL);
+        if (!pwmbl)
+                return -ENOMEM;
+
+        pwmbl->pdev = pdev;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                retval = -ENODEV;
+                goto err_free_mem;
+        }
+
+        if (pdata->pwm_compare_max < pdata->pwm_duty_max ||
+                        pdata->pwm_duty_min > pdata->pwm_duty_max ||
+                        pdata->pwm_frequency == 0) {
+                retval = -EINVAL;
+                goto err_free_mem;
+        }
+
+        pwmbl->pdata = pdata;
+        pwmbl->gpio_on = pdata->gpio_on;
+
+        retval = pwm_channel_alloc(pdata->pwm_channel, &pwmbl->pwmc);
+        if (retval)
+                goto err_free_mem;
+
+        if (pwmbl->gpio_on != -1) {
+                retval = gpio_request(pwmbl->gpio_on, "gpio_atmel_pwm_bl");
+                if (retval) {
+                        pwmbl->gpio_on = -1;
+                        goto err_free_pwm;
+                }
+
+                /* Turn display off by defatult. */
+                retval = gpio_direction_output(pwmbl->gpio_on,
+                                0 ^ pdata->on_active_low);
+                if (retval)
+                        goto err_free_gpio;
+        }
+
+        bldev = backlight_device_register("atmel-pwm-bl",
+                        &pdev->dev, pwmbl, &atmel_pwm_bl_ops);
+        if (IS_ERR(bldev)) {
+                retval = PTR_ERR(bldev);
+                goto err_free_gpio;
+        }
+
+        pwmbl->bldev = bldev;
+
+        platform_set_drvdata(pdev, pwmbl);
+
+        /* Power up the backlight by default at middle intesity. */
+        bldev->props.power = FB_BLANK_UNBLANK;
+        bldev->props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
+        bldev->props.brightness = bldev->props.max_brightness / 2;
+
+        retval = atmel_pwm_bl_init_pwm(pwmbl);
+        if (retval)
+                goto err_free_bl_dev;
+
+        atmel_pwm_bl_set_intensity(bldev);
+
+        return 0;
+
+err_free_bl_dev:
+        platform_set_drvdata(pdev, NULL);
+        backlight_device_unregister(bldev);
+err_free_gpio:
+        if (pwmbl->gpio_on != -1)
+                gpio_free(pwmbl->gpio_on);
+err_free_pwm:
+        pwm_channel_free(&pwmbl->pwmc);
+err_free_mem:
+        kfree(pwmbl);
+        return retval;
+}
+
+static int __exit atmel_pwm_bl_remove(struct platform_device *pdev)
+{
+        struct atmel_pwm_bl *pwmbl = platform_get_drvdata(pdev);
+
+        if (pwmbl->gpio_on != -1) {
+                gpio_set_value(pwmbl->gpio_on, 0);
+                gpio_free(pwmbl->gpio_on);
+        }
+        pwm_channel_disable(&pwmbl->pwmc);
+        pwm_channel_free(&pwmbl->pwmc);
+        backlight_device_unregister(pwmbl->bldev);
+        platform_set_drvdata(pdev, NULL);
+        kfree(pwmbl);
+
+        return 0;
+}
+
+static struct platform_driver atmel_pwm_bl_driver = {
+        .driver = {
+                .name = "atmel-pwm-bl",
+        },
+        /* REVISIT add suspend() and resume() */
+        .remove = __exit_p(atmel_pwm_bl_remove),
+};
+
+static int __init atmel_pwm_bl_init(void)
+{
+        return platform_driver_probe(&atmel_pwm_bl_driver, atmel_pwm_bl_probe);
+}
+module_init(atmel_pwm_bl_init);
+
+static void __exit atmel_pwm_bl_exit(void)
+{
+        platform_driver_unregister(&atmel_pwm_bl_driver);
+}
+module_exit(atmel_pwm_bl_exit);
+
+MODULE_AUTHOR("Hans-Christian egtvedt <hans-christian.egtvedt@atmel.com>");
+MODULE_DESCRIPTION("Atmel PWM backlight driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 39394757679c..fab0bc874b58 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -191,6 +191,7 @@ static struct device_attribute bl_device_attributes[] = {
  *   backlight_device class.
  * @name: the name of the new object(must be the same as the name of the
  *   respective framebuffer device).
+ * @parent: a pointer to the parent device
  * @devdata: an optional pointer to be stored for private driver use. The
  *   methods may retrieve it by using bl_get_data(bd).
  * @ops: the backlight operations structure.
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index fbea2bd129c7..6fa0b9d5559a 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -18,7 +18,7 @@
 #include <linux/fb.h>
 #include <linux/backlight.h>
 
-#include <asm/cpu/dac.h>
+#include <cpu/dac.h>
 #include <asm/hp6xx.h>
 #include <asm/hd64461.h>
 
diff --git a/drivers/video/backlight/ili9320.c b/drivers/video/backlight/ili9320.c
new file mode 100644
index 000000000000..ba89b41b639c
--- /dev/null
+++ b/drivers/video/backlight/ili9320.c
@@ -0,0 +1,330 @@
+/* drivers/video/backlight/ili9320.c
+ *
+ * ILI9320 LCD controller driver core.
+ *
+ * Copyright 2007 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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.
+*/
+
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/lcd.h>
+#include <linux/module.h>
+
+#include <linux/spi/spi.h>
+
+#include <video/ili9320.h>
+
+#include "ili9320.h"
+
+
+static inline int ili9320_write_spi(struct ili9320 *ili,
+                                    unsigned int reg,
+                                    unsigned int value)
+{
+        struct ili9320_spi *spi = &ili->access.spi;
+        unsigned char *addr = spi->buffer_addr;
+        unsigned char *data = spi->buffer_data;
+
+        /* spi message consits of:
+         * first byte: ID and operation
+         */
+
+        addr[0] = spi->id | ILI9320_SPI_INDEX | ILI9320_SPI_WRITE;
+        addr[1] = reg >> 8;
+        addr[2] = reg;
+
+        /* second message is the data to transfer */
+
+        data[0] = spi->id | ILI9320_SPI_DATA  | ILI9320_SPI_WRITE;
+        data[1] = value >> 8;
+        data[2] = value;
+
+        return spi_sync(spi->dev, &spi->message);
+}
+
+int ili9320_write(struct ili9320 *ili, unsigned int reg, unsigned int value)
+{
+        dev_dbg(ili->dev, "write: reg=%02x, val=%04x\n", reg, value);
+        return ili->write(ili, reg, value);
+}
+
+EXPORT_SYMBOL_GPL(ili9320_write);
+
+int ili9320_write_regs(struct ili9320 *ili,
+                       struct ili9320_reg *values,
+                       int nr_values)
+{
+        int index;
+        int ret;
+
+        for (index = 0; index < nr_values; index++, values++) {
+                ret = ili9320_write(ili, values->address, values->value);
+                if (ret != 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(ili9320_write_regs);
+
+static void ili9320_reset(struct ili9320 *lcd)
+{
+        struct ili9320_platdata *cfg = lcd->platdata;
+
+        cfg->reset(1);
+        mdelay(50);
+
+        cfg->reset(0);
+        mdelay(50);
+
+        cfg->reset(1);
+        mdelay(100);
+}
+
+static inline int ili9320_init_chip(struct ili9320 *lcd)
+{
+        int ret;
+
+        ili9320_reset(lcd);
+
+        ret = lcd->client->init(lcd, lcd->platdata);
+        if (ret != 0) {
+                dev_err(lcd->dev, "failed to initialise display\n");
+                return ret;
+        }
+
+        lcd->initialised = 1;
+        return 0;
+}
+
+static inline int ili9320_power_on(struct ili9320 *lcd)
+{
+        if (!lcd->initialised)
+                ili9320_init_chip(lcd);
+
+        lcd->display1 |= (ILI9320_DISPLAY1_D(3) | ILI9320_DISPLAY1_BASEE);
+        ili9320_write(lcd, ILI9320_DISPLAY1, lcd->display1);
+
+        return 0;
+}
+
+static inline int ili9320_power_off(struct ili9320 *lcd)
+{
+        lcd->display1 &= ~(ILI9320_DISPLAY1_D(3) | ILI9320_DISPLAY1_BASEE);
+        ili9320_write(lcd, ILI9320_DISPLAY1, lcd->display1);
+
+        return 0;
+}
+
+#define POWER_IS_ON(pwr)        ((pwr) <= FB_BLANK_NORMAL)
+
+static int ili9320_power(struct ili9320 *lcd, int power)
+{
+        int ret = 0;
+
+        dev_dbg(lcd->dev, "power %d => %d\n", lcd->power, power);
+
+        if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
+                ret = ili9320_power_on(lcd);
+        else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
+                ret = ili9320_power_off(lcd);
+
+        if (ret == 0)
+                lcd->power = power;
+        else
+                dev_warn(lcd->dev, "failed to set power mode %d\n", power);
+
+        return ret;
+}
+
+static inline struct ili9320 *to_our_lcd(struct lcd_device *lcd)
+{
+        return lcd_get_data(lcd);
+}
+
+static int ili9320_set_power(struct lcd_device *ld, int power)
+{
+        struct ili9320 *lcd = to_our_lcd(ld);
+
+        return ili9320_power(lcd, power);
+}
+
+static int ili9320_get_power(struct lcd_device *ld)
+{
+        struct ili9320 *lcd = to_our_lcd(ld);
+
+        return lcd->power;
+}
+
+static struct lcd_ops ili9320_ops = {
+        .get_power      = ili9320_get_power,
+        .set_power      = ili9320_set_power,
+};
+
+static void __devinit ili9320_setup_spi(struct ili9320 *ili,
+                                        struct spi_device *dev)
+{
+        struct ili9320_spi *spi = &ili->access.spi;
+
+        ili->write = ili9320_write_spi;
+        spi->dev = dev;
+
+        /* fill the two messages we are going to use to send the data
+         * with, the first the address followed by the data. The datasheet
+         * says they should be done as two distinct cycles of the SPI CS line.
+         */
+
+        spi->xfer[0].tx_buf = spi->buffer_addr;
+        spi->xfer[1].tx_buf = spi->buffer_data;
+        spi->xfer[0].len = 3;
+        spi->xfer[1].len = 3;
+        spi->xfer[0].bits_per_word = 8;
+        spi->xfer[1].bits_per_word = 8;
+        spi->xfer[0].cs_change = 1;
+
+        spi_message_init(&spi->message);
+        spi_message_add_tail(&spi->xfer[0], &spi->message);
+        spi_message_add_tail(&spi->xfer[1], &spi->message);
+}
+
+int __devinit ili9320_probe_spi(struct spi_device *spi,
+                                struct ili9320_client *client)
+{
+        struct ili9320_platdata *cfg = spi->dev.platform_data;
+        struct device *dev = &spi->dev;
+        struct ili9320 *ili;
+        struct lcd_device *lcd;
+        int ret = 0;
+
+        /* verify we where given some information */
+
+        if (cfg == NULL) {
+                dev_err(dev, "no platform data supplied\n");
+                return -EINVAL;
+        }
+
+        if (cfg->hsize <= 0 || cfg->vsize <= 0 || cfg->reset == NULL) {
+                dev_err(dev, "invalid platform data supplied\n");
+                return -EINVAL;
+        }
+
+        /* allocate and initialse our state */
+
+        ili = kzalloc(sizeof(struct ili9320), GFP_KERNEL);
+        if (ili == NULL) {
+                dev_err(dev, "no memory for device\n");
+                return -ENOMEM;
+        }
+
+        ili->access.spi.id = ILI9320_SPI_IDCODE | ILI9320_SPI_ID(1);
+
+        ili->dev = dev;
+        ili->client = client;
+        ili->power = FB_BLANK_POWERDOWN;
+        ili->platdata = cfg;
+
+        dev_set_drvdata(&spi->dev, ili);
+
+        ili9320_setup_spi(ili, spi);
+
+        lcd = lcd_device_register("ili9320", dev, ili, &ili9320_ops);
+        if (IS_ERR(lcd)) {
+                dev_err(dev, "failed to register lcd device\n");
+                ret = PTR_ERR(lcd);
+                goto err_free;
+        }
+
+        ili->lcd = lcd;
+
+        dev_info(dev, "initialising %s\n", client->name);
+
+        ret = ili9320_power(ili, FB_BLANK_UNBLANK);
+        if (ret != 0) {
+                dev_err(dev, "failed to set lcd power state\n");
+                goto err_unregister;
+        }
+
+        return 0;
+
+ err_unregister:
+        lcd_device_unregister(lcd);
+
+ err_free:
+        kfree(ili);
+
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(ili9320_probe_spi);
+
+int __devexit ili9320_remove(struct ili9320 *ili)
+{
+        ili9320_power(ili, FB_BLANK_POWERDOWN);
+
+        lcd_device_unregister(ili->lcd);
+        kfree(ili);
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(ili9320_remove);
+
+#ifdef CONFIG_PM
+int ili9320_suspend(struct ili9320 *lcd, pm_message_t state)
+{
+        int ret;
+
+        dev_dbg(lcd->dev, "%s: event %d\n", __func__, state.event);
+
+        if (state.event == PM_EVENT_SUSPEND) {
+                ret = ili9320_power(lcd, FB_BLANK_POWERDOWN);
+
+                if (lcd->platdata->suspend == ILI9320_SUSPEND_DEEP) {
+                        ili9320_write(lcd, ILI9320_POWER1, lcd->power1 |
+                                      ILI9320_POWER1_SLP |
+                                      ILI9320_POWER1_DSTB);
+                        lcd->initialised = 0;
+                }
+
+                return ret;
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(ili9320_suspend);
+
+int ili9320_resume(struct ili9320 *lcd)
+{
+        dev_info(lcd->dev, "resuming from power state %d\n", lcd->power);
+
+        if (lcd->platdata->suspend == ILI9320_SUSPEND_DEEP) {
+                ili9320_write(lcd, ILI9320_POWER1, 0x00);
+        }
+
+        return ili9320_power(lcd, FB_BLANK_UNBLANK);
+}
+
+EXPORT_SYMBOL_GPL(ili9320_resume);
+#endif
+
+/* Power down all displays on reboot, poweroff or halt */
+void ili9320_shutdown(struct ili9320 *lcd)
+{
+        ili9320_power(lcd, FB_BLANK_POWERDOWN);
+}
+
+EXPORT_SYMBOL_GPL(ili9320_shutdown);
+
+MODULE_AUTHOR("Ben Dooks <ben-linux@fluff.org>");
+MODULE_DESCRIPTION("ILI9320 LCD Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/backlight/ili9320.h b/drivers/video/backlight/ili9320.h
new file mode 100644
index 000000000000..e388eca7cac5
--- /dev/null
+++ b/drivers/video/backlight/ili9320.h
@@ -0,0 +1,80 @@
+/* drivers/video/backlight/ili9320.h
+ *
+ * ILI9320 LCD controller driver core.
+ *
+ * Copyright 2007 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * http://armlinux.simtec.co.uk/
+ *
+ * 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.
+*/
+
+/* Holder for register and value pairs. */
+struct ili9320_reg {
+        unsigned short          address;
+        unsigned short          value;
+};
+
+struct ili9320;
+
+struct ili9320_client {
+        const char      *name;
+        int     (*init)(struct ili9320 *ili, struct ili9320_platdata *cfg);
+
+};
+/* Device attached via an SPI bus. */
+struct  ili9320_spi {
+        struct spi_device       *dev;
+        struct spi_message      message;
+        struct spi_transfer     xfer[2];
+
+        unsigned char           id;
+        unsigned char           buffer_addr[4];
+        unsigned char           buffer_data[4];
+};
+
+/* ILI9320 device state. */
+struct ili9320 {
+        union {
+                struct ili9320_spi      spi;    /* SPI attachged device. */
+        } access;                               /* Register access method. */
+
+        struct device                   *dev;
+        struct lcd_device               *lcd;   /* LCD device we created. */
+        struct ili9320_client           *client;
+        struct ili9320_platdata         *platdata;
+
+        int                              power; /* current power state. */
+        int                              initialised;
+
+        unsigned short                   display1;
+        unsigned short                   power1;
+
+        int (*write)(struct ili9320 *ili, unsigned int reg, unsigned int val);
+};
+
+
+/* ILI9320 register access routines */
+
+extern int ili9320_write(struct ili9320 *ili,
+                         unsigned int reg, unsigned int value);
+
+extern int ili9320_write_regs(struct ili9320 *ili,
+                              struct ili9320_reg *values,
+                              int nr_values);
+
+/* Device probe */
+
+extern int ili9320_probe_spi(struct spi_device *spi,
+                             struct ili9320_client *cli);
+
+extern int ili9320_remove(struct ili9320 *lcd);
+extern void ili9320_shutdown(struct ili9320 *lcd);
+
+/* PM */
+
+extern int ili9320_suspend(struct ili9320 *lcd, pm_message_t state);
+extern int ili9320_resume(struct ili9320 *lcd);
diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c
index 299fd318dd45..b15b2b84a6f7 100644
--- a/drivers/video/backlight/lcd.c
+++ b/drivers/video/backlight/lcd.c
@@ -33,7 +33,7 @@ static int fb_notifier_callback(struct notifier_block *self,
         ld = container_of(self, struct lcd_device, fb_notif);
         mutex_lock(&ld->ops_lock);
         if (ld->ops)
-                if (!ld->ops->check_fb || ld->ops->check_fb(evdata->info))
+                if (!ld->ops->check_fb || ld->ops->check_fb(ld, evdata->info))
                         ld->ops->set_power(ld, *(int *)evdata->data);
         mutex_unlock(&ld->ops_lock);
         return 0;
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
new file mode 100644
index 000000000000..385cba40ea87
--- /dev/null
+++ b/drivers/video/backlight/mbp_nvidia_bl.c
@@ -0,0 +1,116 @@
+/*
+ *  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;
+
+static struct dmi_system_id __initdata mbp_device_table[] = {
+        {
+                .ident = "3,1",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3,1"),
+                },
+        },
+        {
+                .ident = "3,2",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3,2"),
+                },
+        },
+        {
+                .ident = "4,1",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4,1"),
+                },
+        },
+        { }
+};
+
+static int mbp_send_intensity(struct backlight_device *bd)
+{
+        int intensity = bd->props.brightness;
+
+        outb(0x04 | (intensity << 4), 0xb3);
+        outb(0xbf, 0xb2);
+
+        return 0;
+}
+
+static int mbp_get_intensity(struct backlight_device *bd)
+{
+        outb(0x03, 0xb3);
+        outb(0xbf, 0xb2);
+        return inb(0xb3) >> 4;
+}
+
+static struct backlight_ops mbp_ops = {
+        .get_brightness = mbp_get_intensity,
+        .update_status  = mbp_send_intensity,
+};
+
+static int __init mbp_init(void)
+{
+        if (!dmi_check_system(mbp_device_table))
+                return -ENODEV;
+
+        if (!request_region(0xb2, 2, "Macbook Pro backlight"))
+                return -ENXIO;
+
+        mbp_backlight_device = backlight_device_register("mbp_backlight",
+                                                         NULL, NULL,
+                                                         &mbp_ops);
+        if (IS_ERR(mbp_backlight_device)) {
+                release_region(0xb2, 2);
+                return PTR_ERR(mbp_backlight_device);
+        }
+
+        mbp_backlight_device->props.max_brightness = 15;
+        mbp_backlight_device->props.brightness =
+                mbp_get_intensity(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(0xb2, 2);
+}
+
+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_ALIAS("svnAppleInc.:pnMacBookPro3,1");
+MODULE_ALIAS("svnAppleInc.:pnMacBookPro3,2");
+MODULE_ALIAS("svnAppleInc.:pnMacBookPro4,1");
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index 891875d53a49..cbad67e89826 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -25,9 +25,9 @@
 #include <linux/fb.h>
 #include <linux/backlight.h>
 
-#include <asm/arch/hardware.h>
-#include <asm/arch/board.h>
-#include <asm/arch/mux.h>
+#include <mach/hardware.h>
+#include <mach/board.h>
+#include <mach/mux.h>
 
 #define OMAPBL_MAX_INTENSITY            0xff
 
diff --git a/drivers/video/backlight/platform_lcd.c b/drivers/video/backlight/platform_lcd.c
new file mode 100644
index 000000000000..738694d23889
--- /dev/null
+++ b/drivers/video/backlight/platform_lcd.c
@@ -0,0 +1,174 @@
+/* drivers/video/backlight/platform_lcd.c
+ *
+ * Copyright 2008 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * Generic platform-device LCD power control interface.
+ *
+ * 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.
+ *
+*/
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/lcd.h>
+
+#include <video/platform_lcd.h>
+
+struct platform_lcd {
+        struct device           *us;
+        struct lcd_device       *lcd;
+        struct plat_lcd_data    *pdata;
+
+        unsigned int             power;
+        unsigned int             suspended : 1;
+};
+
+static inline struct platform_lcd *to_our_lcd(struct lcd_device *lcd)
+{
+        return lcd_get_data(lcd);
+}
+
+static int platform_lcd_get_power(struct lcd_device *lcd)
+{
+        struct platform_lcd *plcd = to_our_lcd(lcd);
+
+        return plcd->power;
+}
+
+static int platform_lcd_set_power(struct lcd_device *lcd, int power)
+{
+        struct platform_lcd *plcd = to_our_lcd(lcd);
+        int lcd_power = 1;
+
+        if (power == FB_BLANK_POWERDOWN || plcd->suspended)
+                lcd_power = 0;
+
+        plcd->pdata->set_power(plcd->pdata, lcd_power);
+        plcd->power = power;
+
+        return 0;
+}
+
+static int platform_lcd_match(struct lcd_device *lcd, struct fb_info *info)
+{
+        struct platform_lcd *plcd = to_our_lcd(lcd);
+        struct plat_lcd_data *pdata = plcd->pdata;
+
+        if (pdata->match_fb)
+                return pdata->match_fb(pdata, info);
+
+        return plcd->us->parent == info->device;
+}
+
+static struct lcd_ops platform_lcd_ops = {
+        .get_power      = platform_lcd_get_power,
+        .set_power      = platform_lcd_set_power,
+        .check_fb       = platform_lcd_match,
+};
+
+static int __devinit platform_lcd_probe(struct platform_device *pdev)
+{
+        struct plat_lcd_data *pdata;
+        struct platform_lcd *plcd;
+        struct device *dev = &pdev->dev;
+        int err;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(dev, "no platform data supplied\n");
+                return -EINVAL;
+        }
+
+        plcd = kzalloc(sizeof(struct platform_lcd), GFP_KERNEL);
+        if (!plcd) {
+                dev_err(dev, "no memory for state\n");
+                return -ENOMEM;
+        }
+
+        plcd->us = dev;
+        plcd->pdata = pdata;
+        plcd->lcd = lcd_device_register(dev_name(dev), dev,
+                                        plcd, &platform_lcd_ops);
+        if (IS_ERR(plcd->lcd)) {
+                dev_err(dev, "cannot register lcd device\n");
+                err = PTR_ERR(plcd->lcd);
+                goto err_mem;
+        }
+
+        platform_set_drvdata(pdev, plcd);
+        platform_lcd_set_power(plcd->lcd, FB_BLANK_NORMAL);
+
+        return 0;
+
+ err_mem:
+        kfree(plcd);
+        return err;
+}
+
+static int __devexit platform_lcd_remove(struct platform_device *pdev)
+{
+        struct platform_lcd *plcd = platform_get_drvdata(pdev);
+
+        lcd_device_unregister(plcd->lcd);
+        kfree(plcd);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int platform_lcd_suspend(struct platform_device *pdev, pm_message_t st)
+{
+        struct platform_lcd *plcd = platform_get_drvdata(pdev);
+
+        plcd->suspended = 1;
+        platform_lcd_set_power(plcd->lcd, plcd->power);
+
+        return 0;
+}
+
+static int platform_lcd_resume(struct platform_device *pdev)
+{
+        struct platform_lcd *plcd = platform_get_drvdata(pdev);
+
+        plcd->suspended = 0;
+        platform_lcd_set_power(plcd->lcd, plcd->power);
+
+        return 0;
+}
+#else
+#define platform_lcd_suspend NULL
+#define platform_lcd_resume NULL
+#endif
+
+static struct platform_driver platform_lcd_driver = {
+        .driver         = {
+                .name   = "platform-lcd",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = platform_lcd_probe,
+        .remove         = __devexit_p(platform_lcd_remove),
+        .suspend        = platform_lcd_suspend,
+        .resume         = platform_lcd_resume,
+};
+
+static int __init platform_lcd_init(void)
+{
+        return platform_driver_register(&platform_lcd_driver);
+}
+
+static void __exit platform_lcd_cleanup(void)
+{
+        platform_driver_unregister(&platform_lcd_driver);
+}
+
+module_init(platform_lcd_init);
+module_exit(platform_lcd_cleanup);
+
+MODULE_AUTHOR("Ben Dooks <ben-linux@fluff.org>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:platform-lcd");
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 6338d0e2fe07..ea07258565f0 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -68,8 +68,10 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         struct pwm_bl_data *pb;
         int ret;
 
-        if (!data)
+        if (!data) {
+                dev_err(&pdev->dev, "failed to find platform data\n");
                 return -EINVAL;
+        }
 
         if (data->init) {
                 ret = data->init(&pdev->dev);
@@ -79,6 +81,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
 
         pb = kzalloc(sizeof(*pb), GFP_KERNEL);
         if (!pb) {
+                dev_err(&pdev->dev, "no memory for state\n");
                 ret = -ENOMEM;
                 goto err_alloc;
         }
@@ -91,7 +94,8 @@ static int pwm_backlight_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "unable to request PWM for backlight\n");
                 ret = PTR_ERR(pb->pwm);
                 goto err_pwm;
-        }
+        } else
+                dev_dbg(&pdev->dev, "got pwm for backlight\n");
 
         bl = backlight_device_register(pdev->name, &pdev->dev,
                         pb, &pwm_backlight_ops);
@@ -183,3 +187,5 @@ module_exit(pwm_backlight_exit);
 
 MODULE_DESCRIPTION("PWM based Backlight Driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pwm-backlight");
+
diff --git a/drivers/video/backlight/vgg2432a4.c b/drivers/video/backlight/vgg2432a4.c
new file mode 100644
index 000000000000..593c7687d54a
--- /dev/null
+++ b/drivers/video/backlight/vgg2432a4.c
@@ -0,0 +1,284 @@
+/* drivers/video/backlight/vgg2432a4.c
+ *
+ * VGG2432A4 (ILI9320) LCD controller driver.
+ *
+ * Copyright 2007 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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.
+*/
+
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/lcd.h>
+#include <linux/module.h>
+
+#include <linux/spi/spi.h>
+
+#include <video/ili9320.h>
+
+#include "ili9320.h"
+
+/* Device initialisation sequences */
+
+static struct ili9320_reg vgg_init1[] = {
+        {
+                .address = ILI9320_POWER1,
+                .value   = ILI9320_POWER1_AP(0) | ILI9320_POWER1_BT(0),
+        }, {
+                .address = ILI9320_POWER2,
+                .value   = (ILI9320_POWER2_VC(7) |
+                            ILI9320_POWER2_DC0(0) | ILI9320_POWER2_DC1(0)),
+        }, {
+                .address = ILI9320_POWER3,
+                .value   = ILI9320_POWER3_VRH(0),
+        }, {
+                .address = ILI9320_POWER4,
+                .value   = ILI9320_POWER4_VREOUT(0),
+        },
+};
+
+static struct ili9320_reg vgg_init2[] = {
+        {
+                .address = ILI9320_POWER1,
+                .value   = (ILI9320_POWER1_AP(3) | ILI9320_POWER1_APE |
+                            ILI9320_POWER1_BT(7) | ILI9320_POWER1_SAP),
+        }, {
+                .address = ILI9320_POWER2,
+                .value   = ILI9320_POWER2_VC(7) | ILI9320_POWER2_DC0(3),
+        }
+};
+
+static struct ili9320_reg vgg_gamma[] = {
+        {
+                .address = ILI9320_GAMMA1,
+                .value   = 0x0000,
+        }, {
+                .address = ILI9320_GAMMA2,
+                .value   = 0x0505,
+        }, {
+                .address = ILI9320_GAMMA3,
+                .value   = 0x0004,
+        }, {
+                .address = ILI9320_GAMMA4,
+                .value   = 0x0006,
+        }, {
+                .address = ILI9320_GAMMA5,
+                .value   = 0x0707,
+        }, {
+                .address = ILI9320_GAMMA6,
+                .value   = 0x0105,
+        }, {
+                .address = ILI9320_GAMMA7,
+                .value   = 0x0002,
+        }, {
+                .address = ILI9320_GAMMA8,
+                .value   = 0x0707,
+        }, {
+                .address = ILI9320_GAMMA9,
+                .value   = 0x0704,
+        }, {
+                .address = ILI9320_GAMMA10,
+                .value   = 0x807,
+        }
+
+};
+
+static struct ili9320_reg vgg_init0[] = {
+        [0]     = {
+                /* set direction and scan mode gate */
+                .address = ILI9320_DRIVER,
+                .value   = ILI9320_DRIVER_SS,
+        }, {
+                .address = ILI9320_DRIVEWAVE,
+                .value   = (ILI9320_DRIVEWAVE_MUSTSET |
+                            ILI9320_DRIVEWAVE_EOR | ILI9320_DRIVEWAVE_BC),
+        }, {
+                .address = ILI9320_ENTRYMODE,
+                .value   = ILI9320_ENTRYMODE_ID(3) | ILI9320_ENTRYMODE_BGR,
+        }, {
+                .address = ILI9320_RESIZING,
+                .value   = 0x0,
+        },
+};
+
+
+static int vgg2432a4_lcd_init(struct ili9320 *lcd,
+                              struct ili9320_platdata *cfg)
+{
+        unsigned int addr;
+        int ret;
+
+        /* Set VCore before anything else (VGG243237-6UFLWA) */
+        ret = ili9320_write(lcd, 0x00e5, 0x8000);
+        if (ret)
+                goto err_initial;
+
+        /* Start the oscillator up before we can do anything else. */
+        ret = ili9320_write(lcd, ILI9320_OSCILATION, ILI9320_OSCILATION_OSC);
+        if (ret)
+                goto err_initial;
+
+        /* must wait at-lesat 10ms after starting */
+        mdelay(15);
+
+        ret = ili9320_write_regs(lcd, vgg_init0, ARRAY_SIZE(vgg_init0));
+        if (ret != 0)
+                goto err_initial;
+
+        ili9320_write(lcd, ILI9320_DISPLAY2, cfg->display2);
+        ili9320_write(lcd, ILI9320_DISPLAY3, cfg->display3);
+        ili9320_write(lcd, ILI9320_DISPLAY4, cfg->display4);
+
+        ili9320_write(lcd, ILI9320_RGB_IF1, cfg->rgb_if1);
+        ili9320_write(lcd, ILI9320_FRAMEMAKER, 0x0);
+        ili9320_write(lcd, ILI9320_RGB_IF2, ILI9320_RGBIF2_DPL);
+
+        ret = ili9320_write_regs(lcd, vgg_init1, ARRAY_SIZE(vgg_init1));
+        if (ret != 0)
+                goto err_vgg;
+
+        mdelay(300);
+
+        ret = ili9320_write_regs(lcd, vgg_init2, ARRAY_SIZE(vgg_init2));
+        if (ret != 0)
+                goto err_vgg2;
+
+        mdelay(100);
+
+        ili9320_write(lcd, ILI9320_POWER3, 0x13c);
+
+        mdelay(100);
+
+        ili9320_write(lcd, ILI9320_POWER4, 0x1c00);
+        ili9320_write(lcd, ILI9320_POWER7, 0x000e);
+
+        mdelay(100);
+
+        ili9320_write(lcd, ILI9320_GRAM_HORIZ_ADDR, 0x00);
+        ili9320_write(lcd, ILI9320_GRAM_VERT_ADD, 0x00);
+
+        ret = ili9320_write_regs(lcd, vgg_gamma, ARRAY_SIZE(vgg_gamma));
+        if (ret != 0)
+                goto err_vgg3;
+
+        ili9320_write(lcd, ILI9320_HORIZ_START, 0x0);
+        ili9320_write(lcd, ILI9320_HORIZ_END, cfg->hsize - 1);
+        ili9320_write(lcd, ILI9320_VERT_START, 0x0);
+        ili9320_write(lcd, ILI9320_VERT_END, cfg->vsize - 1);
+
+        ili9320_write(lcd, ILI9320_DRIVER2,
+                      ILI9320_DRIVER2_NL(((cfg->vsize - 240) / 8) + 0x1D));
+
+        ili9320_write(lcd, ILI9320_BASE_IMAGE, 0x1);
+        ili9320_write(lcd, ILI9320_VERT_SCROLL, 0x00);
+
+        for (addr = ILI9320_PARTIAL1_POSITION; addr <= ILI9320_PARTIAL2_END;
+             addr++) {
+                ili9320_write(lcd, addr, 0x0);
+        }
+
+        ili9320_write(lcd, ILI9320_INTERFACE1, 0x10);
+        ili9320_write(lcd, ILI9320_INTERFACE2, cfg->interface2);
+        ili9320_write(lcd, ILI9320_INTERFACE3, cfg->interface3);
+        ili9320_write(lcd, ILI9320_INTERFACE4, cfg->interface4);
+        ili9320_write(lcd, ILI9320_INTERFACE5, cfg->interface5);
+        ili9320_write(lcd, ILI9320_INTERFACE6, cfg->interface6);
+
+        lcd->display1 = (ILI9320_DISPLAY1_D(3) | ILI9320_DISPLAY1_DTE |
+                         ILI9320_DISPLAY1_GON | ILI9320_DISPLAY1_BASEE |
+                         0x40);
+
+        ili9320_write(lcd, ILI9320_DISPLAY1, lcd->display1);
+
+        return 0;
+
+ err_vgg3:
+ err_vgg2:
+ err_vgg:
+ err_initial:
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int vgg2432a4_suspend(struct spi_device *spi, pm_message_t state)
+{
+        return ili9320_suspend(dev_get_drvdata(&spi->dev), state);
+}
+
+static int vgg2432a4_resume(struct spi_device *spi)
+{
+        return ili9320_resume(dev_get_drvdata(&spi->dev));
+}
+#else
+#define vgg2432a4_suspend       NULL
+#define vgg2432a4_resume        NULL
+#endif
+
+static struct ili9320_client vgg2432a4_client = {
+        .name   = "VGG2432A4",
+        .init   = vgg2432a4_lcd_init,
+};
+
+/* Device probe */
+
+static int __devinit vgg2432a4_probe(struct spi_device *spi)
+{
+        int ret;
+
+        ret = ili9320_probe_spi(spi, &vgg2432a4_client);
+        if (ret != 0) {
+                dev_err(&spi->dev, "failed to initialise ili9320\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int __devexit vgg2432a4_remove(struct spi_device *spi)
+{
+        return ili9320_remove(dev_get_drvdata(&spi->dev));
+}
+
+static void vgg2432a4_shutdown(struct spi_device *spi)
+{
+        ili9320_shutdown(dev_get_drvdata(&spi->dev));
+}
+
+static struct spi_driver vgg2432a4_driver = {
+        .driver = {
+                .name           = "VGG2432A4",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = vgg2432a4_probe,
+        .remove         = __devexit_p(vgg2432a4_remove),
+        .shutdown       = vgg2432a4_shutdown,
+        .suspend        = vgg2432a4_suspend,
+        .resume         = vgg2432a4_resume,
+};
+
+/* Device driver initialisation */
+
+static int __init vgg2432a4_init(void)
+{
+        return spi_register_driver(&vgg2432a4_driver);
+}
+
+static void __exit vgg2432a4_exit(void)
+{
+        spi_unregister_driver(&vgg2432a4_driver);
+}
+
+module_init(vgg2432a4_init);
+module_exit(vgg2432a4_exit);
+
+MODULE_AUTHOR("Ben Dooks <ben-linux@fluff.org>");
+MODULE_DESCRIPTION("VGG2432A4 LCD Driver");
+MODULE_LICENSE("GPL v2");
+
+
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index 49834a67a623..7644ed249564 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -58,7 +58,7 @@
 #include <asm/gpio.h>
 #include <asm/portmux.h>
 
-#include <asm/mach/bf54x-lq043.h>
+#include <mach/bf54x-lq043.h>
 
 #define NO_BL_SUPPORT
 
@@ -478,7 +478,7 @@ static int bfin_lcd_set_contrast(struct lcd_device *dev, int contrast)
         return 0;
 }
 
-static int bfin_lcd_check_fb(struct fb_info *fi)
+static int bfin_lcd_check_fb(struct lcd_device *dev, struct fb_info *fi)
 {
         if (!fi || (fi == &bfin_bf54x_fb))
                 return 1;
@@ -733,7 +733,6 @@ static int bfin_bf54x_remove(struct platform_device *pdev)
 static int bfin_bf54x_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct fb_info *fbinfo = platform_get_drvdata(pdev);
-        struct bfin_bf54xfb_info *info = fbinfo->par;
 
         bfin_write_EPPI0_CONTROL(bfin_read_EPPI0_CONTROL() & ~EPPI_EN);
         disable_dma(CH_EPPI0);
@@ -747,8 +746,18 @@ static int bfin_bf54x_resume(struct platform_device *pdev)
         struct fb_info *fbinfo = platform_get_drvdata(pdev);
         struct bfin_bf54xfb_info *info = fbinfo->par;
 
-        enable_dma(CH_EPPI0);
-        bfin_write_EPPI0_CONTROL(bfin_read_EPPI0_CONTROL() | EPPI_EN);
+        if (info->lq043_open_cnt) {
+
+                bfin_write_EPPI0_CONTROL(0);
+                SSYNC();
+
+                config_dma(info);
+                config_ppi(info);
+
+                /* start dma */
+                enable_dma(CH_EPPI0);
+                bfin_write_EPPI0_CONTROL(bfin_read_EPPI0_CONTROL() | EPPI_EN);
+        }
 
         return 0;
 }
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index 135d6dd7e672..7d1b819e501c 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -396,7 +396,7 @@ static int bfin_lcd_set_contrast(struct lcd_device *dev, int contrast)
         return 0;
 }
 
-static int bfin_lcd_check_fb(struct fb_info *fi)
+static int bfin_lcd_check_fb(struct lcd_device *dev, struct fb_info *fi)
 {
         if (!fi || (fi == &bfin_t350mcqb_fb))
                 return 1;
diff --git a/drivers/video/c2p.c b/drivers/video/c2p.c
index 5c30bbd33054..376bc07ff952 100644
--- a/drivers/video/c2p.c
+++ b/drivers/video/c2p.c
@@ -12,6 +12,7 @@
  *  for more details.
  */
 
+#include <linux/module.h>
 #include <linux/string.h>
 #include "c2p.h"
 
@@ -226,4 +227,6 @@ void c2p(u8 *dst, const u8 *src, u32 dx, u32 dy, u32 width, u32 height,
         dst += dst_nextline;
     }
 }
+EXPORT_SYMBOL_GPL(c2p);
 
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/carminefb.c b/drivers/video/carminefb.c
new file mode 100644
index 000000000000..e15bb447440a
--- /dev/null
+++ b/drivers/video/carminefb.c
@@ -0,0 +1,790 @@
+/*
+ * Frame buffer driver for the Carmine GPU.
+ *
+ * The driver configures the GPU as follows
+ * - FB0 is display 0 with unique memory area
+ * - FB1 is display 1 with unique memory area
+ * - both display use 32 bit colors
+ */
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fb.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+
+#include "carminefb.h"
+#include "carminefb_regs.h"
+
+#if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
+#error  "The endianness of the target host has not been defined."
+#endif
+
+/*
+ * The initial video mode can be supplied via two different ways:
+ * - as a string that is passed to fb_find_mode() (module option fb_mode_str)
+ * - as an integer that picks the video mode from carmine_modedb[] (module
+ *   option fb_mode)
+ *
+ * If nothing is used than the initial video mode will be the
+ * CARMINEFB_DEFAULT_VIDEO_MODE member of the carmine_modedb[].
+ */
+#define CARMINEFB_DEFAULT_VIDEO_MODE    1
+
+static unsigned int fb_mode = CARMINEFB_DEFAULT_VIDEO_MODE;
+module_param(fb_mode, uint, 444);
+MODULE_PARM_DESC(fb_mode, "Initial video mode as integer.");
+
+static char *fb_mode_str;
+module_param(fb_mode_str, charp, 444);
+MODULE_PARM_DESC(fb_mode_str, "Initial video mode in characters.");
+
+/*
+ * Carminefb displays:
+ * 0b000 None
+ * 0b001 Display 0
+ * 0b010 Display 1
+ */
+static int fb_displays = CARMINE_USE_DISPLAY0 | CARMINE_USE_DISPLAY1;
+module_param(fb_displays, int, 444);
+MODULE_PARM_DESC(fb_displays, "Bit mode, which displays are used");
+
+struct carmine_hw {
+        void __iomem *v_regs;
+        void __iomem *screen_mem;
+        struct fb_info *fb[MAX_DISPLAY];
+};
+
+struct carmine_resolution {
+        u32 htp;
+        u32 hsp;
+        u32 hsw;
+        u32 hdp;
+        u32 vtr;
+        u32 vsp;
+        u32 vsw;
+        u32 vdp;
+        u32 disp_mode;
+};
+
+struct carmine_fb {
+        void __iomem *display_reg;
+        void __iomem *screen_base;
+        u32 smem_offset;
+        u32 cur_mode;
+        u32 new_mode;
+        struct carmine_resolution *res;
+        u32 pseudo_palette[16];
+};
+
+static struct fb_fix_screeninfo carminefb_fix __devinitdata = {
+        .id = "Carmine",
+        .type = FB_TYPE_PACKED_PIXELS,
+        .visual = FB_VISUAL_TRUECOLOR,
+        .accel = FB_ACCEL_NONE,
+};
+
+static const struct fb_videomode carmine_modedb[] = {
+        {
+                .name           = "640x480",
+                .xres           = 640,
+                .yres           = 480,
+        }, {
+                .name           = "800x600",
+                .xres           = 800,
+                .yres           = 600,
+        },
+};
+
+static struct carmine_resolution car_modes[] = {
+        {
+                /* 640x480 */
+                .htp = 800,
+                .hsp = 672,
+                .hsw = 96,
+                .hdp = 640,
+                .vtr = 525,
+                .vsp = 490,
+                .vsw = 2,
+                .vdp = 480,
+                .disp_mode = 0x1400,
+        },
+        {
+                /* 800x600 */
+                .htp = 1060,
+                .hsp = 864,
+                .hsw = 72,
+                .hdp = 800,
+                .vtr = 628,
+                .vsp = 601,
+                .vsw = 2,
+                .vdp = 600,
+                .disp_mode = 0x0d00,
+        }
+};
+
+static int carmine_find_mode(const struct fb_var_screeninfo *var)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(car_modes); i++)
+                if (car_modes[i].hdp == var->xres &&
+                    car_modes[i].vdp == var->yres)
+                        return i;
+        return -EINVAL;
+}
+
+static void c_set_disp_reg(const struct carmine_fb *par,
+                u32 offset, u32 val)
+{
+        writel(val, par->display_reg + offset);
+}
+
+static u32 c_get_disp_reg(const struct carmine_fb *par,
+                u32 offset)
+{
+        return readl(par->display_reg + offset);
+}
+
+static void c_set_hw_reg(const struct carmine_hw *hw,
+                u32 offset, u32 val)
+{
+        writel(val, hw->v_regs + offset);
+}
+
+static u32 c_get_hw_reg(const struct carmine_hw *hw,
+                u32 offset)
+{
+        return readl(hw->v_regs + offset);
+}
+
+static int carmine_setcolreg(unsigned regno, unsigned red, unsigned green,
+                unsigned blue, unsigned transp, struct fb_info *info)
+{
+        if (regno >= 16)
+                return 1;
+
+        red >>= 8;
+        green >>= 8;
+        blue >>= 8;
+        transp >>= 8;
+
+        ((u32 *)info->pseudo_palette)[regno] = be32_to_cpu(transp << 24 |
+                red << 0 | green << 8 | blue << 16);
+        return 0;
+}
+
+static int carmine_check_var(struct fb_var_screeninfo *var,
+                struct fb_info *info)
+{
+        int ret;
+
+        ret = carmine_find_mode(var);
+        if (ret < 0)
+                return ret;
+
+        if (var->grayscale || var->rotate || var->nonstd)
+                return -EINVAL;
+
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        var->bits_per_pixel = 32;
+
+#ifdef __BIG_ENDIAN
+        var->transp.offset = 24;
+        var->red.offset = 0;
+        var->green.offset = 8;
+        var->blue.offset = 16;
+#else
+        var->transp.offset = 24;
+        var->red.offset = 16;
+        var->green.offset = 8;
+        var->blue.offset = 0;
+#endif
+
+        var->red.length = 8;
+        var->green.length = 8;
+        var->blue.length = 8;
+        var->transp.length = 8;
+
+        var->red.msb_right = 0;
+        var->green.msb_right = 0;
+        var->blue.msb_right = 0;
+        var->transp.msb_right = 0;
+        return 0;
+}
+
+static void carmine_init_display_param(struct carmine_fb *par)
+{
+        u32 width;
+        u32 height;
+        u32 param;
+        u32 window_size;
+        u32 soffset = par->smem_offset;
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_C_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_MLMR_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_CURSOR_MODE,
+                        CARMINE_CURSOR0_PRIORITY_MASK |
+                        CARMINE_CURSOR1_PRIORITY_MASK |
+                        CARMINE_CURSOR_CUTZ_MASK);
+
+        /* Set default cursor position */
+        c_set_disp_reg(par, CARMINE_DISP_REG_CUR1_POS, 0 << 16 | 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_CUR2_POS, 0 << 16 | 0);
+
+        /* Set default display mode */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_EXT_MODE, CARMINE_WINDOW_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_EXT_MODE,
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_EXT_MODE, CARMINE_EXTEND_MODE |
+                        CARMINE_EXT_CMODE_DIRECT24_RGBA);
+
+        /* Set default frame size to layer mode register */
+        width = par->res->hdp * 4 / CARMINE_DISP_WIDTH_UNIT;
+        width = width << CARMINE_DISP_WIDTH_SHIFT;
+
+        height = par->res->vdp - 1;
+        param = width | height;
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_WIDTH, width);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_MODE_W_H, param);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_MODE_W_H, param);
+
+        /* Set default pos and size */
+        window_size = (par->res->vdp - 1) << CARMINE_DISP_WIN_H_SHIFT;
+        window_size |= par->res->hdp;
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_WIN_SIZE, window_size);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_WIN_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_WIN_SIZE, window_size);
+
+        /* Set default origin address */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_ORG_ADR, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_ORG_ADR, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_ORG_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_ORG_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_ORG_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_ORG_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_ORG_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_ORG_ADR1, soffset);
+
+        /* Set default display address */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_DISP_ADR, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_DISP_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_DISP_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_DISP_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_DISP_ADR1, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_DISP_ADR0, soffset);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_DISP_ADR0, soffset);
+
+        /* Set default display position */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_DISP_POS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_DISP_POS, 0);
+
+        /* Set default blend mode */
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L0, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L1, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L2, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L3, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L4, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L5, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L6, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_BLEND_MODE_L7, 0);
+
+        /* default transparency mode */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L1_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6_TRANS, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7_TRANS, 0);
+
+        /* Set default read skip parameter */
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6RM, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7RM, 0);
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6PX, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7PX, 0);
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_L0PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L2PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L3PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L4PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L5PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L6PY, 0);
+        c_set_disp_reg(par, CARMINE_DISP_REG_L7PY, 0);
+}
+
+static void set_display_parameters(struct carmine_fb *par)
+{
+        u32 mode;
+        u32 hdp, vdp, htp, hsp, hsw, vtr, vsp, vsw;
+
+        /*
+         * display timing. Parameters are decreased by one because hardware
+         * spec is 0 to (n - 1)
+         * */
+        hdp = par->res->hdp - 1;
+        vdp = par->res->vdp - 1;
+        htp = par->res->htp - 1;
+        hsp = par->res->hsp - 1;
+        hsw = par->res->hsw - 1;
+        vtr = par->res->vtr - 1;
+        vsp = par->res->vsp - 1;
+        vsw = par->res->vsw - 1;
+
+        c_set_disp_reg(par, CARMINE_DISP_REG_H_TOTAL,
+                        htp << CARMINE_DISP_HTP_SHIFT);
+        c_set_disp_reg(par, CARMINE_DISP_REG_H_PERIOD,
+                        (hdp << CARMINE_DISP_HDB_SHIFT) | hdp);
+        c_set_disp_reg(par, CARMINE_DISP_REG_V_H_W_H_POS,
+                        (vsw << CARMINE_DISP_VSW_SHIFT) |
+                        (hsw << CARMINE_DISP_HSW_SHIFT) |
+                        (hsp));
+        c_set_disp_reg(par, CARMINE_DISP_REG_V_TOTAL,
+                        vtr << CARMINE_DISP_VTR_SHIFT);
+        c_set_disp_reg(par, CARMINE_DISP_REG_V_PERIOD_POS,
+                        (vdp << CARMINE_DISP_VDP_SHIFT) | vsp);
+
+        /* clock */
+        mode = c_get_disp_reg(par, CARMINE_DISP_REG_DCM1);
+        mode = (mode & ~CARMINE_DISP_DCM_MASK) |
+                (par->res->disp_mode & CARMINE_DISP_DCM_MASK);
+        /* enable video output and layer 0 */
+        mode |= CARMINE_DEN | CARMINE_L0E;
+        c_set_disp_reg(par, CARMINE_DISP_REG_DCM1, mode);
+}
+
+static int carmine_set_par(struct fb_info *info)
+{
+        struct carmine_fb *par = info->par;
+        int ret;
+
+        ret = carmine_find_mode(&info->var);
+        if (ret < 0)
+                return ret;
+
+        par->new_mode = ret;
+        if (par->cur_mode != par->new_mode) {
+
+                par->cur_mode = par->new_mode;
+                par->res = &car_modes[par->new_mode];
+
+                carmine_init_display_param(par);
+                set_display_parameters(par);
+        }
+
+        info->fix.line_length = info->var.xres * info->var.bits_per_pixel / 8;
+        return 0;
+}
+
+static int init_hardware(struct carmine_hw *hw)
+{
+        u32 flags;
+        u32 loops;
+        u32 ret;
+
+        /* Initalize Carmine */
+        /* Sets internal clock */
+        c_set_hw_reg(hw, CARMINE_CTL_REG + CARMINE_CTL_REG_CLOCK_ENABLE,
+                        CARMINE_DFLT_IP_CLOCK_ENABLE);
+
+        /* Video signal output is turned off */
+        c_set_hw_reg(hw, CARMINE_DISP0_REG + CARMINE_DISP_REG_DCM1, 0);
+        c_set_hw_reg(hw, CARMINE_DISP1_REG + CARMINE_DISP_REG_DCM1, 0);
+
+        /* Software reset */
+        c_set_hw_reg(hw, CARMINE_CTL_REG + CARMINE_CTL_REG_SOFTWARE_RESET, 1);
+        c_set_hw_reg(hw, CARMINE_CTL_REG + CARMINE_CTL_REG_SOFTWARE_RESET, 0);
+
+        /* I/O mode settings */
+        flags = CARMINE_DFLT_IP_DCTL_IO_CONT1 << 16 |
+                CARMINE_DFLT_IP_DCTL_IO_CONT0;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_IOCONT1_IOCONT0,
+                        flags);
+
+        /* DRAM initial sequence */
+        flags = CARMINE_DFLT_IP_DCTL_MODE << 16 | CARMINE_DFLT_IP_DCTL_ADD;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_MODE_ADD,
+                        flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_SET_TIME1 << 16 |
+                CARMINE_DFLT_IP_DCTL_EMODE;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_SETTIME1_EMODE,
+                        flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_REFRESH << 16 |
+                CARMINE_DFLT_IP_DCTL_SET_TIME2;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_REFRESH_SETTIME2,
+                        flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_RESERVE2 << 16 |
+                CARMINE_DFLT_IP_DCTL_FIFO_DEPTH;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_RSV2_RSV1, flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_DDRIF2 << 16 | CARMINE_DFLT_IP_DCTL_DDRIF1;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_DDRIF2_DDRIF1,
+                        flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_RESERVE0 << 16 |
+                CARMINE_DFLT_IP_DCTL_STATES;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_RSV0_STATES,
+                        flags);
+
+        /* Executes DLL reset */
+        if (CARMINE_DCTL_DLL_RESET) {
+                for (loops = 0; loops < CARMINE_DCTL_INIT_WAIT_LIMIT; loops++) {
+
+                        ret = c_get_hw_reg(hw, CARMINE_DCTL_REG +
+                                        CARMINE_DCTL_REG_RSV0_STATES);
+                        ret &= CARMINE_DCTL_REG_STATES_MASK;
+                        if (!ret)
+                                break;
+
+                        mdelay(CARMINE_DCTL_INIT_WAIT_INTERVAL);
+                }
+
+                if (loops >= CARMINE_DCTL_INIT_WAIT_LIMIT) {
+                        printk(KERN_ERR "DRAM init failed\n");
+                        return -EIO;
+                }
+        }
+
+        flags = CARMINE_DFLT_IP_DCTL_MODE_AFT_RST << 16 |
+                CARMINE_DFLT_IP_DCTL_ADD;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_MODE_ADD, flags);
+
+        flags = CARMINE_DFLT_IP_DCTL_RESERVE0 << 16 |
+                CARMINE_DFLT_IP_DCTL_STATES_AFT_RST;
+        c_set_hw_reg(hw, CARMINE_DCTL_REG + CARMINE_DCTL_REG_RSV0_STATES,
+                        flags);
+
+        /* Initialize the write back register */
+        c_set_hw_reg(hw, CARMINE_WB_REG + CARMINE_WB_REG_WBM,
+                        CARMINE_WB_REG_WBM_DEFAULT);
+
+        /* Initialize the Kottos registers */
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_VRINTM, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_VRERRM, 0);
+
+        /* Set DC offsets */
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_PX, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_PY, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_LX, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_LY, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_TX, 0);
+        c_set_hw_reg(hw, CARMINE_GRAPH_REG + CARMINE_GRAPH_REG_DC_OFFSET_TY, 0);
+        return 0;
+}
+
+static struct fb_ops carminefb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+
+        .fb_check_var   = carmine_check_var,
+        .fb_set_par     = carmine_set_par,
+        .fb_setcolreg   = carmine_setcolreg,
+};
+
+static int alloc_carmine_fb(void __iomem *regs, void __iomem *smem_base,
+                int smem_offset, struct device *device, struct fb_info **rinfo)
+{
+        int ret;
+        struct fb_info *info;
+        struct carmine_fb *par;
+
+        info = framebuffer_alloc(sizeof *par, device);
+        if (!info)
+                return -ENOMEM;
+
+        par = info->par;
+        par->display_reg = regs;
+        par->smem_offset = smem_offset;
+
+        info->screen_base = smem_base + smem_offset;
+        info->screen_size = CARMINE_DISPLAY_MEM;
+        info->fbops = &carminefb_ops;
+
+        info->fix = carminefb_fix;
+        info->pseudo_palette = par->pseudo_palette;
+        info->flags = FBINFO_DEFAULT;
+
+        ret = fb_alloc_cmap(&info->cmap, 256, 1);
+        if (ret < 0)
+                goto err_free_fb;
+
+        if (fb_mode > ARRAY_SIZE(carmine_modedb))
+                fb_mode = CARMINEFB_DEFAULT_VIDEO_MODE;
+
+        par->cur_mode = par->new_mode = ~0;
+
+        ret = fb_find_mode(&info->var, info, fb_mode_str, carmine_modedb,
+                        ARRAY_SIZE(carmine_modedb),
+                        &carmine_modedb[fb_mode], 32);
+        if (!ret || ret == 4) {
+                ret = -EINVAL;
+                goto err_dealloc_cmap;
+        }
+
+        fb_videomode_to_modelist(carmine_modedb, ARRAY_SIZE(carmine_modedb),
+                        &info->modelist);
+
+        ret = register_framebuffer(info);
+        if (ret < 0)
+                goto err_dealloc_cmap;
+
+        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
+                        info->fix.id);
+
+        *rinfo = info;
+        return 0;
+
+err_dealloc_cmap:
+        fb_dealloc_cmap(&info->cmap);
+err_free_fb:
+        framebuffer_release(info);
+        return ret;
+}
+
+static void cleanup_fb_device(struct fb_info *info)
+{
+        if (info) {
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info->cmap);
+                framebuffer_release(info);
+        }
+}
+
+static int __devinit carminefb_probe(struct pci_dev *dev,
+                const struct pci_device_id *ent)
+{
+        struct carmine_hw *hw;
+        struct device *device = &dev->dev;
+        struct fb_info *info;
+        int ret;
+
+        ret = pci_enable_device(dev);
+        if (ret)
+                return ret;
+
+        ret = -ENOMEM;
+        hw = kzalloc(sizeof *hw, GFP_KERNEL);
+        if (!hw)
+                goto err_enable_pci;
+
+        carminefb_fix.mmio_start = pci_resource_start(dev, CARMINE_CONFIG_BAR);
+        carminefb_fix.mmio_len = pci_resource_len(dev, CARMINE_CONFIG_BAR);
+
+        if (!request_mem_region(carminefb_fix.mmio_start,
+                                carminefb_fix.mmio_len,
+                                "carminefb regbase")) {
+                printk(KERN_ERR "carminefb: Can't reserve regbase.\n");
+                ret = -EBUSY;
+                goto err_free_hw;
+        }
+        hw->v_regs = ioremap_nocache(carminefb_fix.mmio_start,
+                        carminefb_fix.mmio_len);
+        if (!hw->v_regs) {
+                printk(KERN_ERR "carminefb: Can't remap %s register.\n",
+                                carminefb_fix.id);
+                goto err_free_reg_mmio;
+        }
+
+        carminefb_fix.smem_start = pci_resource_start(dev, CARMINE_MEMORY_BAR);
+        carminefb_fix.smem_len = pci_resource_len(dev, CARMINE_MEMORY_BAR);
+
+        /* The memory area tends to be very large (256 MiB). Remap only what
+         * is required for that largest resolution to avoid remaps at run
+         * time
+         */
+        if (carminefb_fix.smem_len > CARMINE_TOTAL_DIPLAY_MEM)
+                carminefb_fix.smem_len = CARMINE_TOTAL_DIPLAY_MEM;
+
+        else if (carminefb_fix.smem_len < CARMINE_TOTAL_DIPLAY_MEM) {
+                printk(KERN_ERR "carminefb: Memory bar is only %d bytes, %d "
+                                "are required.", carminefb_fix.smem_len,
+                                CARMINE_TOTAL_DIPLAY_MEM);
+                goto err_free_reg_mmio;
+        }
+
+        if (!request_mem_region(carminefb_fix.smem_start,
+                                carminefb_fix.smem_len, "carminefb smem")) {
+                printk(KERN_ERR "carminefb: Can't reserve smem.\n");
+                goto err_unmap_vregs;
+        }
+
+        hw->screen_mem = ioremap_nocache(carminefb_fix.smem_start,
+                        carminefb_fix.smem_len);
+        if (!hw->screen_mem) {
+                printk(KERN_ERR "carmine: Can't ioremap smem area.\n");
+                release_mem_region(carminefb_fix.smem_start,
+                                carminefb_fix.smem_len);
+                goto err_reg_smem;
+        }
+
+        ret = init_hardware(hw);
+        if (ret)
+                goto err_unmap_screen;
+
+        info = NULL;
+        if (fb_displays & CARMINE_USE_DISPLAY0) {
+                ret = alloc_carmine_fb(hw->v_regs + CARMINE_DISP0_REG,
+                                hw->screen_mem, CARMINE_DISPLAY_MEM * 0,
+                                device, &info);
+                if (ret)
+                        goto err_deinit_hw;
+        }
+
+        hw->fb[0] = info;
+
+        info = NULL;
+        if (fb_displays & CARMINE_USE_DISPLAY1) {
+                ret = alloc_carmine_fb(hw->v_regs + CARMINE_DISP1_REG,
+                                hw->screen_mem, CARMINE_DISPLAY_MEM * 1,
+                                device, &info);
+                if (ret)
+                        goto err_cleanup_fb0;
+        }
+
+        hw->fb[1] = info;
+        info = NULL;
+
+        pci_set_drvdata(dev, hw);
+        return 0;
+
+err_cleanup_fb0:
+        cleanup_fb_device(hw->fb[0]);
+err_deinit_hw:
+        /* disable clock, etc */
+        c_set_hw_reg(hw, CARMINE_CTL_REG + CARMINE_CTL_REG_CLOCK_ENABLE, 0);
+err_unmap_screen:
+        iounmap(hw->screen_mem);
+err_reg_smem:
+        release_mem_region(carminefb_fix.mmio_start, carminefb_fix.mmio_len);
+err_unmap_vregs:
+        iounmap(hw->v_regs);
+err_free_reg_mmio:
+        release_mem_region(carminefb_fix.mmio_start, carminefb_fix.mmio_len);
+err_free_hw:
+        kfree(hw);
+err_enable_pci:
+        pci_disable_device(dev);
+        return ret;
+}
+
+static void __devexit carminefb_remove(struct pci_dev *dev)
+{
+        struct carmine_hw *hw = pci_get_drvdata(dev);
+        struct fb_fix_screeninfo fix;
+        int i;
+
+        /* in case we use only fb1 and not fb1 */
+        if (hw->fb[0])
+                fix = hw->fb[0]->fix;
+        else
+                fix = hw->fb[1]->fix;
+
+        /* deactivate display(s) and switch clocks */
+        c_set_hw_reg(hw, CARMINE_DISP0_REG + CARMINE_DISP_REG_DCM1, 0);
+        c_set_hw_reg(hw, CARMINE_DISP1_REG + CARMINE_DISP_REG_DCM1, 0);
+        c_set_hw_reg(hw, CARMINE_CTL_REG + CARMINE_CTL_REG_CLOCK_ENABLE, 0);
+
+        for (i = 0; i < MAX_DISPLAY; i++)
+                cleanup_fb_device(hw->fb[i]);
+
+        iounmap(hw->screen_mem);
+        release_mem_region(fix.smem_start, fix.smem_len);
+        iounmap(hw->v_regs);
+        release_mem_region(fix.mmio_start, fix.mmio_len);
+
+        pci_set_drvdata(dev, NULL);
+        pci_disable_device(dev);
+        kfree(hw);
+}
+
+#define PCI_VENDOR_ID_FUJITU_LIMITED 0x10cf
+static struct pci_device_id carmine_devices[] __devinitdata = {
+{
+        PCI_DEVICE(PCI_VENDOR_ID_FUJITU_LIMITED, 0x202b)},
+        {0, 0, 0, 0, 0, 0, 0}
+};
+
+MODULE_DEVICE_TABLE(pci, carmine_devices);
+
+static struct pci_driver carmine_pci_driver = {
+        .name           = "carminefb",
+        .id_table       = carmine_devices,
+        .probe          = carminefb_probe,
+        .remove         = __devexit_p(carminefb_remove),
+};
+
+static int __init carminefb_init(void)
+{
+        if (!(fb_displays &
+                (CARMINE_USE_DISPLAY0 | CARMINE_USE_DISPLAY1))) {
+                printk(KERN_ERR "If you disable both displays than you don't "
+                                "need the driver at all\n");
+                return -EINVAL;
+        }
+        return pci_register_driver(&carmine_pci_driver);
+}
+module_init(carminefb_init);
+
+static void __exit carminefb_cleanup(void)
+{
+        pci_unregister_driver(&carmine_pci_driver);
+}
+module_exit(carminefb_cleanup);
+
+MODULE_AUTHOR("Sebastian Siewior <bigeasy@linutronix.de>");
+MODULE_DESCRIPTION("Framebuffer driver for Fujitsu Carmine based devices");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/carminefb.h b/drivers/video/carminefb.h
new file mode 100644
index 000000000000..05306de0c6b6
--- /dev/null
+++ b/drivers/video/carminefb.h
@@ -0,0 +1,64 @@
+#ifndef CARMINE_CARMINE_H
+#define CARMINE_CARMINE_H
+
+#define CARMINE_MEMORY_BAR      2
+#define CARMINE_CONFIG_BAR      3
+
+#define MAX_DISPLAY     2
+#define CARMINE_DISPLAY_MEM     (800 * 600 * 4)
+#define CARMINE_TOTAL_DIPLAY_MEM        (CARMINE_DISPLAY_MEM * MAX_DISPLAY)
+
+#define CARMINE_USE_DISPLAY0    (1 << 0)
+#define CARMINE_USE_DISPLAY1    (1 << 1)
+
+/*
+ * This values work on the eval card. Custom boards may use different timings,
+ * here an example :)
+ */
+
+/* DRAM initialization values */
+#ifdef CONFIG_FB_CARMINE_DRAM_EVAL
+
+#define CARMINE_DFLT_IP_CLOCK_ENABLE            (0x03ff)
+#define CARMINE_DFLT_IP_DCTL_ADD                (0x05c3)
+#define CARMINE_DFLT_IP_DCTL_MODE               (0x0121)
+#define CARMINE_DFLT_IP_DCTL_EMODE              (0x8000)
+#define CARMINE_DFLT_IP_DCTL_SET_TIME1          (0x4749)
+#define CARMINE_DFLT_IP_DCTL_SET_TIME2          (0x2a22)
+#define CARMINE_DFLT_IP_DCTL_REFRESH            (0x0042)
+#define CARMINE_DFLT_IP_DCTL_STATES             (0x0003)
+#define CARMINE_DFLT_IP_DCTL_RESERVE0           (0x0020)
+#define CARMINE_DFLT_IP_DCTL_FIFO_DEPTH         (0x000f)
+#define CARMINE_DFLT_IP_DCTL_RESERVE2           (0x0000)
+#define CARMINE_DFLT_IP_DCTL_DDRIF1             (0x6646)
+#define CARMINE_DFLT_IP_DCTL_DDRIF2             (0x0055)
+#define CARMINE_DFLT_IP_DCTL_MODE_AFT_RST       (0x0021)
+#define CARMINE_DFLT_IP_DCTL_STATES_AFT_RST     (0x0002)
+#define CARMINE_DFLT_IP_DCTL_IO_CONT0           (0x0555)
+#define CARMINE_DFLT_IP_DCTL_IO_CONT1           (0x0555)
+#define CARMINE_DCTL_DLL_RESET                  (1)
+#endif
+
+#ifdef CONFIG_CARMINE_DRAM_CUSTOM
+
+#define CARMINE_DFLT_IP_CLOCK_ENABLE            (0x03ff)
+#define CARMINE_DFLT_IP_DCTL_ADD                (0x03b2)
+#define CARMINE_DFLT_IP_DCTL_MODE               (0x0161)
+#define CARMINE_DFLT_IP_DCTL_EMODE              (0x8000)
+#define CARMINE_DFLT_IP_DCTL_SET_TIME1          (0x2628)
+#define CARMINE_DFLT_IP_DCTL_SET_TIME2          (0x1a09)
+#define CARMINE_DFLT_IP_DCTL_REFRESH            (0x00fe)
+#define CARMINE_DFLT_IP_DCTL_STATES             (0x0003)
+#define CARMINE_DFLT_IP_DCTL_RESERVE0           (0x0020)
+#define CARMINE_DFLT_IP_DCTL_FIFO_DEPTH         (0x000f)
+#define CARMINE_DFLT_IP_DCTL_RESERVE2           (0x0000)
+#define CARMINE_DFLT_IP_DCTL_DDRIF1             (0x0646)
+#define CARMINE_DFLT_IP_DCTL_DDRIF2             (0x55aa)
+#define CARMINE_DFLT_IP_DCTL_MODE_AFT_RST       (0x0061)
+#define CARMINE_DFLT_IP_DCTL_STATES_AFT_RST     (0x0002)
+#define CARMINE_DFLT_IP_DCTL_IO_CONT0           (0x0555)
+#define CARMINE_DFLT_IP_DCTL_IO_CONT1           (0x0555)
+#define CARMINE_DCTL_DLL_RESET                  (1)
+#endif
+
+#endif
diff --git a/drivers/video/carminefb_regs.h b/drivers/video/carminefb_regs.h
new file mode 100644
index 000000000000..045215600b73
--- /dev/null
+++ b/drivers/video/carminefb_regs.h
@@ -0,0 +1,159 @@
+#ifndef _CARMINEFB_REGS_H
+#define _CARMINEFB_REGS_H
+
+#define CARMINE_OVERLAY_EXT_MODE        (0x00000002)
+#define CARMINE_GRAPH_REG               (0x00000000)
+#define CARMINE_DISP0_REG               (0x00100000)
+#define CARMINE_DISP1_REG               (0x00140000)
+#define CARMINE_WB_REG                  (0x00180000)
+#define CARMINE_DCTL_REG                (0x00300000)
+#define CARMINE_CTL_REG                 (0x00400000)
+#define CARMINE_WINDOW_MODE             (0x00000001)
+#define CARMINE_EXTEND_MODE             (CARMINE_WINDOW_MODE | \
+                                        CARMINE_OVERLAY_EXT_MODE)
+#define CARMINE_L0E                     (1 << 16)
+#define CARMINE_L2E                     (1 << 18)
+#define CARMINE_DEN                     (1 << 31)
+
+#define CARMINE_EXT_CMODE_DIRECT24_RGBA         (0xC0000000)
+#define CARMINE_DCTL_REG_MODE_ADD               (0x00)
+#define CARMINE_DCTL_REG_SETTIME1_EMODE         (0x04)
+#define CARMINE_DCTL_REG_REFRESH_SETTIME2       (0x08)
+#define CARMINE_DCTL_REG_RSV0_STATES            (0x0C)
+#define CARMINE_DCTL_REG_RSV2_RSV1              (0x10)
+#define CARMINE_DCTL_REG_DDRIF2_DDRIF1          (0x14)
+#define CARMINE_DCTL_REG_IOCONT1_IOCONT0        (0x24)
+#define CARMINE_DCTL_REG_STATES_MASK            (0x000F)
+#define CARMINE_DCTL_INIT_WAIT_INTERVAL         (1)
+#define CARMINE_DCTL_INIT_WAIT_LIMIT            (5000)
+#define CARMINE_WB_REG_WBM_DEFAULT              (0x0001c020)
+#define CARMINE_DISP_REG_L0RM                   (0x1880)
+#define CARMINE_DISP_REG_L0PX                   (0x1884)
+#define CARMINE_DISP_REG_L0PY                   (0x1888)
+#define CARMINE_DISP_REG_L2RM                   (0x18A0)
+#define CARMINE_DISP_REG_L2PX                   (0x18A4)
+#define CARMINE_DISP_REG_L2PY                   (0x18A8)
+#define CARMINE_DISP_REG_L3RM                   (0x18B0)
+#define CARMINE_DISP_REG_L3PX                   (0x18B4)
+#define CARMINE_DISP_REG_L3PY                   (0x18B8)
+#define CARMINE_DISP_REG_L4RM                   (0x18C0)
+#define CARMINE_DISP_REG_L4PX                   (0x18C4)
+#define CARMINE_DISP_REG_L4PY                   (0x18C8)
+#define CARMINE_DISP_REG_L5RM                   (0x18D0)
+#define CARMINE_DISP_REG_L5PX                   (0x18D4)
+#define CARMINE_DISP_REG_L5PY                   (0x18D8)
+#define CARMINE_DISP_REG_L6RM                   (0x1924)
+#define CARMINE_DISP_REG_L6PX                   (0x1928)
+#define CARMINE_DISP_REG_L6PY                   (0x192C)
+#define CARMINE_DISP_REG_L7RM                   (0x1964)
+#define CARMINE_DISP_REG_L7PX                   (0x1968)
+#define CARMINE_DISP_REG_L7PY                   (0x196C)
+#define CARMINE_WB_REG_WBM                      (0x0004)
+#define CARMINE_DISP_HTP_SHIFT                  (16)
+#define CARMINE_DISP_HDB_SHIFT                  (16)
+#define CARMINE_DISP_HSW_SHIFT                  (16)
+#define CARMINE_DISP_VSW_SHIFT                  (24)
+#define CARMINE_DISP_VTR_SHIFT                  (16)
+#define CARMINE_DISP_VDP_SHIFT                  (16)
+#define CARMINE_CURSOR_CUTZ_MASK                (0x00000100)
+#define CARMINE_CURSOR0_PRIORITY_MASK           (0x00010000)
+#define CARMINE_CURSOR1_PRIORITY_MASK           (0x00020000)
+#define CARMINE_DISP_WIDTH_SHIFT                (16)
+#define CARMINE_DISP_WIN_H_SHIFT                (16)
+#define CARMINE_DISP_REG_H_TOTAL                (0x0004)
+#define CARMINE_DISP_REG_H_PERIOD               (0x0008)
+#define CARMINE_DISP_REG_V_H_W_H_POS            (0x000C)
+#define CARMINE_DISP_REG_V_TOTAL                (0x0010)
+#define CARMINE_DISP_REG_V_PERIOD_POS           (0x0014)
+#define CARMINE_DISP_REG_L0_MODE_W_H            (0x0020)
+#define CARMINE_DISP_REG_L0_ORG_ADR             (0x0024)
+#define CARMINE_DISP_REG_L0_DISP_ADR            (0x0028)
+#define CARMINE_DISP_REG_L0_DISP_POS            (0x002C)
+#define CARMINE_DISP_REG_L1_WIDTH               (0x0030)
+#define CARMINE_DISP_REG_L1_ORG_ADR             (0x0034)
+#define CARMINE_DISP_REG_L2_MODE_W_H            (0x0040)
+#define CARMINE_DISP_REG_L2_ORG_ADR1            (0x0044)
+#define CARMINE_DISP_REG_L2_DISP_ADR1           (0x0048)
+#define CARMINE_DISP_REG_L2_DISP_POS            (0x0054)
+#define CARMINE_DISP_REG_L3_MODE_W_H            (0x0058)
+#define CARMINE_DISP_REG_L3_ORG_ADR1            (0x005C)
+#define CARMINE_DISP_REG_L3_DISP_ADR1           (0x0060)
+#define CARMINE_DISP_REG_L3_DISP_POS            (0x006C)
+#define CARMINE_DISP_REG_L4_MODE_W_H            (0x0070)
+#define CARMINE_DISP_REG_L4_ORG_ADR1            (0x0074)
+#define CARMINE_DISP_REG_L4_DISP_ADR1           (0x0078)
+#define CARMINE_DISP_REG_L4_DISP_POS            (0x0084)
+#define CARMINE_DISP_REG_L5_MODE_W_H            (0x0088)
+#define CARMINE_DISP_REG_L5_ORG_ADR1            (0x008C)
+#define CARMINE_DISP_REG_L5_DISP_ADR1           (0x0090)
+#define CARMINE_DISP_REG_L5_DISP_POS            (0x009C)
+#define CARMINE_DISP_REG_CURSOR_MODE            (0x00A0)
+#define CARMINE_DISP_REG_CUR1_POS               (0x00A8)
+#define CARMINE_DISP_REG_CUR2_POS               (0x00B0)
+#define CARMINE_DISP_REG_C_TRANS                (0x00BC)
+#define CARMINE_DISP_REG_MLMR_TRANS             (0x00C0)
+#define CARMINE_DISP_REG_L0_EXT_MODE            (0x0110)
+#define CARMINE_DISP_REG_L0_WIN_POS             (0x0114)
+#define CARMINE_DISP_REG_L0_WIN_SIZE            (0x0118)
+#define CARMINE_DISP_REG_L1_EXT_MODE            (0x0120)
+#define CARMINE_DISP_REG_L1_WIN_POS             (0x0124)
+#define CARMINE_DISP_REG_L1_WIN_SIZE            (0x0128)
+#define CARMINE_DISP_REG_L2_EXT_MODE            (0x0130)
+#define CARMINE_DISP_REG_L2_WIN_POS             (0x0134)
+#define CARMINE_DISP_REG_L2_WIN_SIZE            (0x0138)
+#define CARMINE_DISP_REG_L3_EXT_MODE            (0x0140)
+#define CARMINE_DISP_REG_L3_WIN_POS             (0x0144)
+#define CARMINE_DISP_REG_L3_WIN_SIZE            (0x0148)
+#define CARMINE_DISP_REG_L4_EXT_MODE            (0x0150)
+#define CARMINE_DISP_REG_L4_WIN_POS             (0x0154)
+#define CARMINE_DISP_REG_L4_WIN_SIZE            (0x0158)
+#define CARMINE_DISP_REG_L5_EXT_MODE            (0x0160)
+#define CARMINE_DISP_REG_L5_WIN_POS             (0x0164)
+#define CARMINE_DISP_REG_L5_WIN_SIZE            (0x0168)
+#define CARMINE_DISP_REG_L6_EXT_MODE            (0x1918)
+#define CARMINE_DISP_REG_L6_WIN_POS             (0x191c)
+#define CARMINE_DISP_REG_L6_WIN_SIZE            (0x1920)
+#define CARMINE_DISP_REG_L7_EXT_MODE            (0x1958)
+#define CARMINE_DISP_REG_L7_WIN_POS             (0x195c)
+#define CARMINE_DISP_REG_L7_WIN_SIZE            (0x1960)
+#define CARMINE_DISP_REG_BLEND_MODE_L0          (0x00B4)
+#define CARMINE_DISP_REG_BLEND_MODE_L1          (0x0188)
+#define CARMINE_DISP_REG_BLEND_MODE_L2          (0x018C)
+#define CARMINE_DISP_REG_BLEND_MODE_L3          (0x0190)
+#define CARMINE_DISP_REG_BLEND_MODE_L4          (0x0194)
+#define CARMINE_DISP_REG_BLEND_MODE_L5          (0x0198)
+#define CARMINE_DISP_REG_BLEND_MODE_L6          (0x1990)
+#define CARMINE_DISP_REG_BLEND_MODE_L7          (0x1994)
+#define CARMINE_DISP_REG_L0_TRANS               (0x01A0)
+#define CARMINE_DISP_REG_L1_TRANS               (0x01A4)
+#define CARMINE_DISP_REG_L2_TRANS               (0x01A8)
+#define CARMINE_DISP_REG_L3_TRANS               (0x01AC)
+#define CARMINE_DISP_REG_L4_TRANS               (0x01B0)
+#define CARMINE_DISP_REG_L5_TRANS               (0x01B4)
+#define CARMINE_DISP_REG_L6_TRANS               (0x1998)
+#define CARMINE_DISP_REG_L7_TRANS               (0x199c)
+#define CARMINE_EXTEND_MODE_MASK                (0x00000003)
+#define CARMINE_DISP_DCM_MASK                   (0x0000FFFF)
+#define CARMINE_DISP_REG_DCM1                   (0x0100)
+#define CARMINE_DISP_WIDTH_UNIT                 (64)
+#define CARMINE_DISP_REG_L6_MODE_W_H            (0x1900)
+#define CARMINE_DISP_REG_L6_ORG_ADR1            (0x1904)
+#define CARMINE_DISP_REG_L6_DISP_ADR0           (0x1908)
+#define CARMINE_DISP_REG_L6_DISP_POS            (0x1914)
+#define CARMINE_DISP_REG_L7_MODE_W_H            (0x1940)
+#define CARMINE_DISP_REG_L7_ORG_ADR1            (0x1944)
+#define CARMINE_DISP_REG_L7_DISP_ADR0           (0x1948)
+#define CARMINE_DISP_REG_L7_DISP_POS            (0x1954)
+#define CARMINE_CTL_REG_CLOCK_ENABLE            (0x000C)
+#define CARMINE_CTL_REG_SOFTWARE_RESET          (0x0010)
+#define CARMINE_CTL_REG_IST_MASK_ALL            (0x07FFFFFF)
+#define CARMINE_GRAPH_REG_VRINTM                (0x00028064)
+#define CARMINE_GRAPH_REG_VRERRM                (0x0002806C)
+#define CARMINE_GRAPH_REG_DC_OFFSET_PX          (0x0004005C)
+#define CARMINE_GRAPH_REG_DC_OFFSET_PY          (0x00040060)
+#define CARMINE_GRAPH_REG_DC_OFFSET_LX          (0x00040064)
+#define CARMINE_GRAPH_REG_DC_OFFSET_LY          (0x00040068)
+#define CARMINE_GRAPH_REG_DC_OFFSET_TX          (0x0004006C)
+#define CARMINE_GRAPH_REG_DC_OFFSET_TY          (0x00040070)
+
+#endif
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index c14b2435d23e..e729fb279645 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -628,27 +628,18 @@ static long cirrusfb_get_mclk(long freq, int bpp, long *div)
 static int cirrusfb_check_var(struct fb_var_screeninfo *var,
                               struct fb_info *info)
 {
-        int nom, den;           /* translyting from pixels->bytes */
-        int yres, i;
-        static struct { int xres, yres; } modes[] =
-        { { 1600, 1280 },
-          { 1280, 1024 },
-          { 1024, 768 },
-          { 800, 600 },
-          { 640, 480 },
-          { -1, -1 } };
+        int yres;
+        /* memory size in pixels */
+        unsigned pixels = info->screen_size * 8 / var->bits_per_pixel;
 
         switch (var->bits_per_pixel) {
         case 1:
-                nom = 4;
-                den = 8;
+                pixels /= 4;
                 break;          /* 8 pixel per byte, only 1/4th of mem usable */
         case 8:
         case 16:
         case 24:
         case 32:
-                nom = var->bits_per_pixel / 8;
-                den = 1;
                 break;          /* 1 pixel == 1 byte */
         default:
                 printk(KERN_ERR "cirrusfb: mode %dx%dx%d rejected..."
@@ -658,43 +649,29 @@ static int cirrusfb_check_var(struct fb_var_screeninfo *var,
                 return -EINVAL;
         }
 
-        if (var->xres * nom / den * var->yres > info->screen_size) {
-                printk(KERN_ERR "cirrusfb: mode %dx%dx%d rejected..."
-                        "resolution too high to fit into video memory!\n",
-                        var->xres, var->yres, var->bits_per_pixel);
-                DPRINTK("EXIT - EINVAL error\n");
-                return -EINVAL;
-        }
-
+        if (var->xres_virtual < var->xres)
+                var->xres_virtual = var->xres;
         /* use highest possible virtual resolution */
-        if (var->xres_virtual == -1 &&
-            var->yres_virtual == -1) {
-                printk(KERN_INFO
-                     "cirrusfb: using maximum available virtual resolution\n");
-                for (i = 0; modes[i].xres != -1; i++) {
-                        int size = modes[i].xres * nom / den * modes[i].yres;
-                        if (size < info->screen_size / 2)
-                                break;
-                }
-                if (modes[i].xres == -1) {
-                        printk(KERN_ERR "cirrusfb: could not find a virtual "
-                                "resolution that fits into video memory!!\n");
-                        DPRINTK("EXIT - EINVAL error\n");
-                        return -EINVAL;
-                }
-                var->xres_virtual = modes[i].xres;
-                var->yres_virtual = modes[i].yres;
+        if (var->yres_virtual == -1) {
+                var->yres_virtual = pixels / var->xres_virtual;
 
                 printk(KERN_INFO "cirrusfb: virtual resolution set to "
                         "maximum of %dx%d\n", var->xres_virtual,
                         var->yres_virtual);
         }
-
-        if (var->xres_virtual < var->xres)
-                var->xres_virtual = var->xres;
         if (var->yres_virtual < var->yres)
                 var->yres_virtual = var->yres;
 
+        if (var->xres_virtual * var->yres_virtual > pixels) {
+                printk(KERN_ERR "cirrusfb: mode %dx%dx%d rejected... "
+                      "virtual resolution too high to fit into video memory!\n",
+                        var->xres_virtual, var->yres_virtual,
+                        var->bits_per_pixel);
+                DPRINTK("EXIT - EINVAL error\n");
+                return -EINVAL;
+        }
+
+
         if (var->xoffset < 0)
                 var->xoffset = 0;
         if (var->yoffset < 0)
diff --git a/drivers/video/clps711xfb.c b/drivers/video/clps711xfb.c
index 9f8a389dc7ae..16f5db471ab5 100644
--- a/drivers/video/clps711xfb.c
+++ b/drivers/video/clps711xfb.c
@@ -27,12 +27,12 @@
 #include <linux/proc_fs.h>
 #include <linux/delay.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/mach-types.h>
 #include <linux/uaccess.h>
 
 #include <asm/hardware/clps7111.h>
-#include <asm/arch/syspld.h>
+#include <mach/syspld.h>
 
 struct fb_info  *cfb;
 
diff --git a/drivers/video/cobalt_lcdfb.c b/drivers/video/cobalt_lcdfb.c
new file mode 100644
index 000000000000..7bad24ed04ef
--- /dev/null
+++ b/drivers/video/cobalt_lcdfb.c
@@ -0,0 +1,371 @@
+/*
+ *  Cobalt server LCD frame buffer driver.
+ *
+ *  Copyright (C) 2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/uaccess.h>
+#include <linux/platform_device.h>
+
+/*
+ * Cursor position address
+ * \X  0    1    2  ...  14   15
+ * Y+----+----+----+---+----+----+
+ * 0|0x00|0x01|0x02|...|0x0e|0x0f|
+ *  +----+----+----+---+----+----+
+ * 1|0x40|0x41|0x42|...|0x4e|0x4f|
+ *  +----+----+----+---+----+----+
+ */
+#define LCD_DATA_REG_OFFSET     0x10
+#define LCD_XRES_MAX            16
+#define LCD_YRES_MAX            2
+#define LCD_CHARS_MAX           32
+
+#define LCD_CLEAR               0x01
+#define LCD_CURSOR_MOVE_HOME    0x02
+#define LCD_RESET               0x06
+#define LCD_OFF                 0x08
+#define LCD_CURSOR_OFF          0x0c
+#define LCD_CURSOR_BLINK_OFF    0x0e
+#define LCD_CURSOR_ON           0x0f
+#define LCD_ON                  LCD_CURSOR_ON
+#define LCD_CURSOR_MOVE_LEFT    0x10
+#define LCD_CURSOR_MOVE_RIGHT   0x14
+#define LCD_DISPLAY_LEFT        0x18
+#define LCD_DISPLAY_RIGHT       0x1c
+#define LCD_PRERESET            0x3f    /* execute 4 times continuously */
+#define LCD_BUSY                0x80
+
+#define LCD_GRAPHIC_MODE        0x40
+#define LCD_TEXT_MODE           0x80
+#define LCD_CUR_POS_MASK        0x7f
+
+#define LCD_CUR_POS(x)          ((x) & LCD_CUR_POS_MASK)
+#define LCD_TEXT_POS(x)         ((x) | LCD_TEXT_MODE)
+
+static inline void lcd_write_control(struct fb_info *info, u8 control)
+{
+        writel((u32)control << 24, info->screen_base);
+}
+
+static inline u8 lcd_read_control(struct fb_info *info)
+{
+        return readl(info->screen_base) >> 24;
+}
+
+static inline void lcd_write_data(struct fb_info *info, u8 data)
+{
+        writel((u32)data << 24, info->screen_base + LCD_DATA_REG_OFFSET);
+}
+
+static inline u8 lcd_read_data(struct fb_info *info)
+{
+        return readl(info->screen_base + LCD_DATA_REG_OFFSET) >> 24;
+}
+
+static int lcd_busy_wait(struct fb_info *info)
+{
+        u8 val = 0;
+        int timeout = 10, retval = 0;
+
+        do {
+                val = lcd_read_control(info);
+                val &= LCD_BUSY;
+                if (val != LCD_BUSY)
+                        break;
+
+                if (msleep_interruptible(1))
+                        return -EINTR;
+
+                timeout--;
+        } while (timeout);
+
+        if (val == LCD_BUSY)
+                retval = -EBUSY;
+
+        return retval;
+}
+
+static void lcd_clear(struct fb_info *info)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                udelay(150);
+
+                lcd_write_control(info, LCD_PRERESET);
+        }
+
+        udelay(150);
+
+        lcd_write_control(info, LCD_CLEAR);
+
+        udelay(150);
+
+        lcd_write_control(info, LCD_RESET);
+}
+
+static struct fb_fix_screeninfo cobalt_lcdfb_fix __initdata = {
+        .id             = "cobalt-lcd",
+        .type           = FB_TYPE_TEXT,
+        .type_aux       = FB_AUX_TEXT_MDA,
+        .visual         = FB_VISUAL_MONO01,
+        .line_length    = LCD_XRES_MAX,
+        .accel          = FB_ACCEL_NONE,
+};
+
+static ssize_t cobalt_lcdfb_read(struct fb_info *info, char __user *buf,
+                                 size_t count, loff_t *ppos)
+{
+        char src[LCD_CHARS_MAX];
+        unsigned long pos;
+        int len, retval = 0;
+
+        pos = *ppos;
+        if (pos >= LCD_CHARS_MAX || count == 0)
+                return 0;
+
+        if (count > LCD_CHARS_MAX)
+                count = LCD_CHARS_MAX;
+
+        if (pos + count > LCD_CHARS_MAX)
+                count = LCD_CHARS_MAX - pos;
+
+        for (len = 0; len < count; len++) {
+                retval = lcd_busy_wait(info);
+                if (retval < 0)
+                        break;
+
+                lcd_write_control(info, LCD_TEXT_POS(pos));
+
+                retval = lcd_busy_wait(info);
+                if (retval < 0)
+                        break;
+
+                src[len] = lcd_read_data(info);
+                if (pos == 0x0f)
+                        pos = 0x40;
+                else
+                        pos++;
+        }
+
+        if (retval < 0 && signal_pending(current))
+                return -ERESTARTSYS;
+
+        if (copy_to_user(buf, src, len))
+                return -EFAULT;
+
+        *ppos += len;
+
+        return len;
+}
+
+static ssize_t cobalt_lcdfb_write(struct fb_info *info, const char __user *buf,
+                                  size_t count, loff_t *ppos)
+{
+        char dst[LCD_CHARS_MAX];
+        unsigned long pos;
+        int len, retval = 0;
+
+        pos = *ppos;
+        if (pos >= LCD_CHARS_MAX || count == 0)
+                return 0;
+
+        if (count > LCD_CHARS_MAX)
+                count = LCD_CHARS_MAX;
+
+        if (pos + count > LCD_CHARS_MAX)
+                count = LCD_CHARS_MAX - pos;
+
+        if (copy_from_user(dst, buf, count))
+                return -EFAULT;
+
+        for (len = 0; len < count; len++) {
+                retval = lcd_busy_wait(info);
+                if (retval < 0)
+                        break;
+
+                lcd_write_control(info, LCD_TEXT_POS(pos));
+
+                retval = lcd_busy_wait(info);
+                if (retval < 0)
+                        break;
+
+                lcd_write_data(info, dst[len]);
+                if (pos == 0x0f)
+                        pos = 0x40;
+                else
+                        pos++;
+        }
+
+        if (retval < 0 && signal_pending(current))
+                return -ERESTARTSYS;
+
+        *ppos += len;
+
+        return len;
+}
+
+static int cobalt_lcdfb_blank(int blank_mode, struct fb_info *info)
+{
+        int retval;
+
+        retval = lcd_busy_wait(info);
+        if (retval < 0)
+                return retval;
+
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                lcd_write_control(info, LCD_ON);
+                break;
+        default:
+                lcd_write_control(info, LCD_OFF);
+                break;
+        }
+
+        return 0;
+}
+
+static int cobalt_lcdfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
+{
+        u32 x, y;
+        int retval;
+
+        switch (cursor->set) {
+        case FB_CUR_SETPOS:
+                x = cursor->image.dx;
+                y = cursor->image.dy;
+                if (x >= LCD_XRES_MAX || y >= LCD_YRES_MAX)
+                        return -EINVAL;
+
+                retval = lcd_busy_wait(info);
+                if (retval < 0)
+                        return retval;
+
+                lcd_write_control(info,
+                                  LCD_TEXT_POS(info->fix.line_length * y + x));
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        retval = lcd_busy_wait(info);
+        if (retval < 0)
+                return retval;
+
+        if (cursor->enable)
+                lcd_write_control(info, LCD_CURSOR_ON);
+        else
+                lcd_write_control(info, LCD_CURSOR_OFF);
+
+        return 0;
+}
+
+static struct fb_ops cobalt_lcd_fbops = {
+        .owner          = THIS_MODULE,
+        .fb_read        = cobalt_lcdfb_read,
+        .fb_write       = cobalt_lcdfb_write,
+        .fb_blank       = cobalt_lcdfb_blank,
+        .fb_cursor      = cobalt_lcdfb_cursor,
+};
+
+static int __init cobalt_lcdfb_probe(struct platform_device *dev)
+{
+        struct fb_info *info;
+        struct resource *res;
+        int retval;
+
+        info = framebuffer_alloc(0, &dev->dev);
+        if (!info)
+                return -ENOMEM;
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res) {
+                framebuffer_release(info);
+                return -EBUSY;
+        }
+
+        info->screen_size = res->end - res->start + 1;
+        info->screen_base = ioremap(res->start, info->screen_size);
+        info->fbops = &cobalt_lcd_fbops;
+        info->fix = cobalt_lcdfb_fix;
+        info->fix.smem_start = res->start;
+        info->fix.smem_len = info->screen_size;
+        info->pseudo_palette = NULL;
+        info->par = NULL;
+        info->flags = FBINFO_DEFAULT;
+
+        retval = register_framebuffer(info);
+        if (retval < 0) {
+                iounmap(info->screen_base);
+                framebuffer_release(info);
+                return retval;
+        }
+
+        platform_set_drvdata(dev, info);
+
+        lcd_clear(info);
+
+        printk(KERN_INFO "fb%d: Cobalt server LCD frame buffer device\n",
+                info->node);
+
+        return 0;
+}
+
+static int __devexit cobalt_lcdfb_remove(struct platform_device *dev)
+{
+        struct fb_info *info;
+
+        info = platform_get_drvdata(dev);
+        if (info) {
+                iounmap(info->screen_base);
+                unregister_framebuffer(info);
+                framebuffer_release(info);
+        }
+
+        return 0;
+}
+
+static struct platform_driver cobalt_lcdfb_driver = {
+        .probe  = cobalt_lcdfb_probe,
+        .remove = __devexit_p(cobalt_lcdfb_remove),
+        .driver = {
+                .name   = "cobalt-lcd",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init cobalt_lcdfb_init(void)
+{
+        return platform_driver_register(&cobalt_lcdfb_driver);
+}
+
+static void __exit cobalt_lcdfb_exit(void)
+{
+        platform_driver_unregister(&cobalt_lcdfb_driver);
+}
+
+module_init(cobalt_lcdfb_init);
+module_exit(cobalt_lcdfb_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Yoichi Yuasa");
+MODULE_DESCRIPTION("Cobalt server LCD frame buffer driver");
diff --git a/drivers/video/console/.gitignore b/drivers/video/console/.gitignore
new file mode 100644
index 000000000000..0c258b45439c
--- /dev/null
+++ b/drivers/video/console/.gitignore
@@ -0,0 +1,2 @@
+# conmakehash generated file
+promcon_tbl.c
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 97aff8db10bf..c6299e8a041d 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -107,9 +107,7 @@ static struct display fb_display[MAX_NR_CONSOLES];
 
 static signed char con2fb_map[MAX_NR_CONSOLES];
 static signed char con2fb_map_boot[MAX_NR_CONSOLES];
-#ifndef MODULE
-static int logo_height;
-#endif
+
 static int logo_lines;
 /* logo_shown is an index to vc_cons when >= 0; otherwise follows FBCON_LOGO
    enums.  */
@@ -607,6 +605,7 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
         struct fbcon_ops *ops = info->fbcon_par;
         int cnt, erase = vc->vc_video_erase_char, step;
         unsigned short *save = NULL, *r, *q;
+        int logo_height;
 
         if (info->flags & FBINFO_MODULE) {
                 logo_shown = FBCON_LOGO_DONTSHOW;
@@ -1312,6 +1311,9 @@ static void fbcon_clear(struct vc_data *vc, int sy, int sx, int height,
         if (!height || !width)
                 return;
 
+        if (sy < vc->vc_top && vc->vc_top == logo_lines)
+                vc->vc_top = 0;
+
         /* Split blits that cross physical y_wrap boundary */
 
         y_break = p->vrows - p->yscroll;
@@ -2516,7 +2518,7 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h,
                         c = vc->vc_video_erase_char;
                         vc->vc_video_erase_char =
                             ((c & 0xfe00) >> 1) | (c & 0xff);
-                        c = vc->vc_def_color;
+                        c = vc->vc_scrl_erase_char;
                         vc->vc_scrl_erase_char =
                             ((c & 0xFE00) >> 1) | (c & 0xFF);
                         vc->vc_attr >>= 1;
@@ -2549,7 +2551,7 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h,
                         if (vc->vc_can_do_color) {
                                 vc->vc_video_erase_char =
                                     ((c & 0xff00) << 1) | (c & 0xff);
-                                c = vc->vc_def_color;
+                                c = vc->vc_scrl_erase_char;
                                 vc->vc_scrl_erase_char =
                                     ((c & 0xFF00) << 1) | (c & 0xFF);
                                 vc->vc_attr <<= 1;
@@ -3586,7 +3588,8 @@ static int __init fb_console_init(void)
 
         acquire_console_sem();
         fb_register_client(&fbcon_event_notifier);
-        fbcon_device = device_create(fb_class, NULL, MKDEV(0, 0), "fbcon");
+        fbcon_device = device_create_drvdata(fb_class, NULL, MKDEV(0, 0),
+                                             NULL, "fbcon");
 
         if (IS_ERR(fbcon_device)) {
                 printk(KERN_WARNING "Unable to create device "
diff --git a/drivers/video/console/fbcon.h b/drivers/video/console/fbcon.h
index 0135e0395456..a6e38e9ea73f 100644
--- a/drivers/video/console/fbcon.h
+++ b/drivers/video/console/fbcon.h
@@ -146,10 +146,8 @@ static inline int attr_col_ec(int shift, struct vc_data *vc,
         return is_fg ? fg : bg;
 }
 
-#define attr_bgcol_ec(bgshift,vc,info)          \
-        attr_col_ec(bgshift,vc,info,0);
-#define attr_fgcol_ec(fgshift,vc,info)          \
-        attr_col_ec(fgshift,vc,info,1);
+#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
+#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
 
 /* Font */
 #define REFCOUNT(fd)    (((int *)(fd))[-1])
diff --git a/drivers/video/console/mdacon.c b/drivers/video/console/mdacon.c
index 38a296bbdfc9..9901064199bd 100644
--- a/drivers/video/console/mdacon.c
+++ b/drivers/video/console/mdacon.c
@@ -71,13 +71,15 @@ static char *mda_type_name;
 
 /* console information */
 
-static int      mda_first_vc = 1;
+static int      mda_first_vc = 13;
 static int      mda_last_vc  = 16;
 
 static struct vc_data   *mda_display_fg = NULL;
 
 module_param(mda_first_vc, int, 0);
+MODULE_PARM_DESC(mda_first_vc, "First virtual console. Default: 13");
 module_param(mda_last_vc, int, 0);
+MODULE_PARM_DESC(mda_last_vc, "Last virtual console. Default: 16");
 
 /* MDA register values
  */
diff --git a/drivers/video/console/sticon.c b/drivers/video/console/sticon.c
index a11cc2fdd4cd..4055dbdd1b42 100644
--- a/drivers/video/console/sticon.c
+++ b/drivers/video/console/sticon.c
@@ -370,7 +370,7 @@ static const struct consw sti_con = {
 
 
 
-int __init sticonsole_init(void)
+static int __init sticonsole_init(void)
 {
     /* already initialized ? */
     if (sticon_sti)
diff --git a/drivers/video/console/sticore.c b/drivers/video/console/sticore.c
index e9ab657f0bb7..ef7870f5ea08 100644
--- a/drivers/video/console/sticore.c
+++ b/drivers/video/console/sticore.c
@@ -24,12 +24,13 @@
 #include <asm/hardware.h>
 #include <asm/parisc-device.h>
 #include <asm/cacheflush.h>
+#include <asm/grfioctl.h>
 
 #include "../sticore.h"
 
 #define STI_DRIVERVERSION "Version 0.9a"
 
-struct sti_struct *default_sti __read_mostly;
+static struct sti_struct *default_sti __read_mostly;
 
 /* number of STI ROMS found and their ptrs to each struct */
 static int num_sti_roms __read_mostly;
@@ -68,8 +69,7 @@ static const struct sti_init_flags default_init_flags = {
         .init_cmap_tx = 1,
 };
 
-int
-sti_init_graph(struct sti_struct *sti) 
+static int sti_init_graph(struct sti_struct *sti)
 {
         struct sti_init_inptr_ext inptr_ext = { 0, };
         struct sti_init_inptr inptr = {
@@ -100,8 +100,7 @@ static const struct sti_conf_flags default_conf_flags = {
         .wait   = STI_WAIT,
 };
 
-void
-sti_inq_conf(struct sti_struct *sti)
+static void sti_inq_conf(struct sti_struct *sti)
 {
         struct sti_conf_inptr inptr = { 0, };
         unsigned long flags;
@@ -237,8 +236,8 @@ static void sti_flush(unsigned long start, unsigned long end)
         flush_icache_range(start, end);
 }
 
-void __devinit
-sti_rom_copy(unsigned long base, unsigned long count, void *dest)
+static void __devinit sti_rom_copy(unsigned long base, unsigned long count,
+                                   void *dest)
 {
         unsigned long dest_start = (unsigned long) dest;
 
@@ -478,8 +477,8 @@ sti_init_glob_cfg(struct sti_struct *sti,
 }
 
 #ifdef CONFIG_FB
-struct sti_cooked_font * __devinit
-sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
+static struct sti_cooked_font __devinit
+*sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
         const struct font_desc *fbfont;
         unsigned int size, bpc;
@@ -534,16 +533,16 @@ sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
         return cooked_font;
 }
 #else
-struct sti_cooked_font * __devinit
-sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
+static struct sti_cooked_font __devinit
+*sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
         return NULL;
 }
 #endif
 
-struct sti_cooked_font * __devinit
-sti_select_font(struct sti_cooked_rom *rom,
-            int (*search_font_fnc) (struct sti_cooked_rom *,int,int) )
+static struct sti_cooked_font __devinit
+*sti_select_font(struct sti_cooked_rom *rom,
+                 int (*search_font_fnc)(struct sti_cooked_rom *, int, int))
 {
         struct sti_cooked_font *font;
         int i;
@@ -707,8 +706,7 @@ sti_get_bmode_rom (unsigned long address)
         return raw;
 }
 
-struct sti_rom * __devinit
-sti_get_wmode_rom (unsigned long address)
+static struct sti_rom __devinit *sti_get_wmode_rom(unsigned long address)
 {
         struct sti_rom *raw;
         unsigned long size;
@@ -723,11 +721,12 @@ sti_get_wmode_rom (unsigned long address)
         return raw;
 }
 
-int __devinit
-sti_read_rom(int wordmode, struct sti_struct *sti, unsigned long address)
+static int __devinit sti_read_rom(int wordmode, struct sti_struct *sti,
+                                  unsigned long address)
 {
         struct sti_cooked_rom *cooked;
         struct sti_rom *raw = NULL;
+        unsigned long revno;
 
         cooked = kmalloc(sizeof *cooked, GFP_KERNEL);
         if (!cooked)
@@ -770,9 +769,35 @@ sti_read_rom(int wordmode, struct sti_struct *sti, unsigned long address)
         sti->graphics_id[1] = raw->graphics_id[1];
         
         sti_dump_rom(raw);
-        
+
+        /* check if the ROM routines in this card are compatible */
+        if (wordmode || sti->graphics_id[1] != 0x09A02587)
+                goto ok;
+
+        revno = (raw->revno[0] << 8) | raw->revno[1];
+
+        switch (sti->graphics_id[0]) {
+        case S9000_ID_HCRX:
+                /* HyperA or HyperB ? */
+                if (revno == 0x8408 || revno == 0x840b)
+                        goto msg_not_supported;
+                break;
+        case CRT_ID_THUNDER:
+                if (revno == 0x8509)
+                        goto msg_not_supported;
+                break;
+        case CRT_ID_THUNDER2:
+                if (revno == 0x850c)
+                        goto msg_not_supported;
+        }
+ok:
         return 1;
 
+msg_not_supported:
+        printk(KERN_ERR "Sorry, this GSC/STI card is not yet supported.\n");
+        printk(KERN_ERR "Please see http://parisc-linux.org/faq/"
+                        "graphics-howto.html for more info.\n");
+        /* fall through */
 out_err:
         kfree(raw);
         kfree(cooked);
diff --git a/drivers/video/cyber2000fb.c b/drivers/video/cyber2000fb.c
index d0e4cb618269..41d62632dcdb 100644
--- a/drivers/video/cyber2000fb.c
+++ b/drivers/video/cyber2000fb.c
@@ -1425,7 +1425,7 @@ static void cyberpro_common_resume(struct cfb_info *cfb)
 
 #ifdef CONFIG_ARCH_SHARK
 
-#include <asm/arch/hardware.h>
+#include <mach/hardware.h>
 
 static int __devinit cyberpro_vl_probe(void)
 {
diff --git a/drivers/video/epson1355fb.c b/drivers/video/epson1355fb.c
index cc2810ef5de5..2735b79e52a1 100644
--- a/drivers/video/epson1355fb.c
+++ b/drivers/video/epson1355fb.c
@@ -71,7 +71,7 @@ struct epson1355_par {
 #if defined(CONFIG_ARM)
 
 # ifdef CONFIG_ARCH_CEIVA
-#  include <asm/arch/hardware.h>
+#  include <mach/hardware.h>
 #  define EPSON1355FB_BASE_PHYS (CEIVA_PHYS_SED1355)
 # endif
 
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 59df132cc375..4835bdc4e9f1 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -114,6 +114,17 @@ static struct vm_operations_struct fb_deferred_io_vm_ops = {
         .page_mkwrite   = fb_deferred_io_mkwrite,
 };
 
+static int fb_deferred_io_set_page_dirty(struct page *page)
+{
+        if (!PageDirty(page))
+                SetPageDirty(page);
+        return 0;
+}
+
+static const struct address_space_operations fb_deferred_io_aops = {
+        .set_page_dirty = fb_deferred_io_set_page_dirty,
+};
+
 static int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         vma->vm_ops = &fb_deferred_io_vm_ops;
@@ -163,6 +174,14 @@ void fb_deferred_io_init(struct fb_info *info)
 }
 EXPORT_SYMBOL_GPL(fb_deferred_io_init);
 
+void fb_deferred_io_open(struct fb_info *info,
+                         struct inode *inode,
+                         struct file *file)
+{
+        file->f_mapping->a_ops = &fb_deferred_io_aops;
+}
+EXPORT_SYMBOL_GPL(fb_deferred_io_open);
+
 void fb_deferred_io_cleanup(struct fb_info *info)
 {
         void *screen_base = (void __force *) info->screen_base;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 33ebdb198daf..98843c2ecf73 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -848,9 +848,8 @@ int
 fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
 {
         struct fb_fix_screeninfo *fix = &info->fix;
-        int xoffset = var->xoffset;
-        int yoffset = var->yoffset;
-        int err = 0, yres = info->var.yres;
+        unsigned int yres = info->var.yres;
+        int err = 0;
 
         if (var->yoffset > 0) {
                 if (var->vmode & FB_VMODE_YWRAP) {
@@ -866,8 +865,8 @@ fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
                                  (var->xoffset % fix->xpanstep)))
                 err = -EINVAL;
 
-        if (err || !info->fbops->fb_pan_display || xoffset < 0 ||
-            yoffset < 0 || var->yoffset + yres > info->var.yres_virtual ||
+        if (err || !info->fbops->fb_pan_display ||
+            var->yoffset + yres > info->var.yres_virtual ||
             var->xoffset + info->var.xres > info->var.xres_virtual)
                 return -EINVAL;
 
@@ -1345,6 +1344,10 @@ fb_open(struct inode *inode, struct file *file)
                 if (res)
                         module_put(info->fbops->owner);
         }
+#ifdef CONFIG_FB_DEFERRED_IO
+        if (info->fbdefio)
+                fb_deferred_io_open(info, inode, file);
+#endif
 out:
         unlock_kernel();
         return res;
@@ -1439,8 +1442,9 @@ register_framebuffer(struct fb_info *fb_info)
                         break;
         fb_info->node = i;
 
-        fb_info->dev = device_create(fb_class, fb_info->device,
-                                     MKDEV(FB_MAJOR, i), "fb%d", i);
+        fb_info->dev = device_create_drvdata(fb_class, fb_info->device,
+                                             MKDEV(FB_MAJOR, i), NULL,
+                                             "fb%d", i);
         if (IS_ERR(fb_info->dev)) {
                 /* Not fatal */
                 printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 052e18058498..6a0aa180c266 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -879,7 +879,7 @@ int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
                 if (edid_is_timing_block(block)) {
                         var->xres = var->xres_virtual = H_ACTIVE;
                         var->yres = var->yres_virtual = V_ACTIVE;
-                        var->height = var->width = -1;
+                        var->height = var->width = 0;
                         var->right_margin = H_SYNC_OFFSET;
                         var->left_margin = (H_ACTIVE + H_BLANKING) -
                                 (H_ACTIVE + H_SYNC_OFFSET + H_SYNC_WIDTH);
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index 09d7e22c6fef..fb51197d1c98 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -279,58 +279,42 @@ static struct diu_hw dr = {
 
 static struct diu_pool pool;
 
-/*      To allocate memory for framebuffer. First try __get_free_pages(). If it
- *      fails, try rh_alloc. The reason is __get_free_pages() cannot allocate
- *      very large memory (more than 4MB). We don't want to allocate all memory
- *      in rheap since small memory allocation/deallocation will fragment the
- *      rheap and make the furture large allocation fail.
+/**
+ * fsl_diu_alloc - allocate memory for the DIU
+ * @size: number of bytes to allocate
+ * @param: returned physical address of memory
+ *
+ * This function allocates a physically-contiguous block of memory.
  */
-
-static void *fsl_diu_alloc(unsigned long size, phys_addr_t *phys)
+static void *fsl_diu_alloc(size_t size, phys_addr_t *phys)
 {
         void *virt;
 
-        pr_debug("size=%lu\n", size);
+        pr_debug("size=%zu\n", size);
 
-        virt = (void *)__get_free_pages(GFP_DMA | __GFP_ZERO, get_order(size));
+        virt = alloc_pages_exact(size, GFP_DMA | __GFP_ZERO);
         if (virt) {
                 *phys = virt_to_phys(virt);
-                pr_debug("virt %p, phys=%llx\n", virt, (uint64_t) *phys);
-                return virt;
+                pr_debug("virt=%p phys=%llx\n", virt,
+                        (unsigned long long)*phys);
         }
-        if (!diu_ops.diu_mem) {
-                printk(KERN_INFO "%s: no diu_mem."
-                        " To reserve more memory, put 'diufb=15M' "
-                        "in the command line\n", __func__);
-                return NULL;
-        }
-
-        virt = (void *)rh_alloc(&diu_ops.diu_rh_info, size, "DIU");
-        if (virt) {
-                *phys = virt_to_bus(virt);
-                memset(virt, 0, size);
-        }
-
-        pr_debug("rh virt=%p phys=%llx\n", virt, (unsigned long long)*phys);
 
         return virt;
 }
 
-static void fsl_diu_free(void *p, unsigned long size)
+/**
+ * fsl_diu_free - release DIU memory
+ * @virt: pointer returned by fsl_diu_alloc()
+ * @size: number of bytes allocated by fsl_diu_alloc()
+ *
+ * This function releases memory allocated by fsl_diu_alloc().
+ */
+static void fsl_diu_free(void *virt, size_t size)
 {
-        pr_debug("p=%p size=%lu\n", p, size);
-
-        if (!p)
-                return;
+        pr_debug("virt=%p size=%zu\n", virt, size);
 
-        if ((p >= diu_ops.diu_mem) &&
-            (p < (diu_ops.diu_mem + diu_ops.diu_size))) {
-                pr_debug("rh\n");
-                rh_free(&diu_ops.diu_rh_info, (unsigned long) p);
-        } else {
-                pr_debug("dma\n");
-                free_pages((unsigned long)p, get_order(size));
-        }
+        if (virt && size)
+                free_pages_exact(virt, size);
 }
 
 static int fsl_diu_enable_panel(struct fb_info *info)
@@ -495,6 +479,10 @@ static void adjust_aoi_size_position(struct fb_var_screeninfo *var,
         base_plane_width = machine_data->fsl_diu_info[0]->var.xres;
         base_plane_height = machine_data->fsl_diu_info[0]->var.yres;
 
+        if (mfbi->x_aoi_d < 0)
+                mfbi->x_aoi_d = 0;
+        if (mfbi->y_aoi_d < 0)
+                mfbi->y_aoi_d = 0;
         switch (index) {
         case 0:
                 if (mfbi->x_aoi_d != 0)
@@ -794,6 +782,22 @@ static void unmap_video_memory(struct fb_info *info)
 }
 
 /*
+ * Using the fb_var_screeninfo in fb_info we set the aoi of this
+ * particular framebuffer. It is a light version of fsl_diu_set_par.
+ */
+static int fsl_diu_set_aoi(struct fb_info *info)
+{
+        struct fb_var_screeninfo *var = &info->var;
+        struct mfb_info *mfbi = info->par;
+        struct diu_ad *ad = mfbi->ad;
+
+        /* AOI should not be greater than display size */
+        ad->offset_xyi = cpu_to_le32((var->yoffset << 16) | var->xoffset);
+        ad->offset_xyd = cpu_to_le32((mfbi->y_aoi_d << 16) | mfbi->x_aoi_d);
+        return 0;
+}
+
+/*
  * Using the fb_var_screeninfo in fb_info we set the resolution of this
  * particular framebuffer. This function alters the fb_fix_screeninfo stored
  * in fb_info. It does not alter var in fb_info since we are using that
@@ -833,11 +837,11 @@ static int fsl_diu_set_par(struct fb_info *info)
                 diu_ops.get_pixel_format(var->bits_per_pixel,
                                          machine_data->monitor_port);
         ad->addr    = cpu_to_le32(info->fix.smem_start);
-        ad->src_size_g_alpha = cpu_to_le32((var->yres << 12) |
-                                var->xres) | mfbi->g_alpha;
-        /* fix me. AOI should not be greater than display size */
+        ad->src_size_g_alpha = cpu_to_le32((var->yres_virtual << 12) |
+                                var->xres_virtual) | mfbi->g_alpha;
+        /* AOI should not be greater than display size */
         ad->aoi_size    = cpu_to_le32((var->yres << 16) | var->xres);
-        ad->offset_xyi = 0;
+        ad->offset_xyi = cpu_to_le32((var->yoffset << 16) | var->xoffset);
         ad->offset_xyd = cpu_to_le32((mfbi->y_aoi_d << 16) | mfbi->x_aoi_d);
 
         /* Disable chroma keying function */
@@ -937,6 +941,8 @@ static int fsl_diu_pan_display(struct fb_var_screeninfo *var,
         else
                 info->var.vmode &= ~FB_VMODE_YWRAP;
 
+        fsl_diu_set_aoi(info);
+
         return 0;
 }
 
@@ -1005,7 +1011,7 @@ static int fsl_diu_ioctl(struct fb_info *info, unsigned int cmd,
                 pr_debug("set AOI display offset of index %d to (%d,%d)\n",
                                  mfbi->index, aoi_d.x_aoi_d, aoi_d.y_aoi_d);
                 fsl_diu_check_var(&info->var, info);
-                fsl_diu_set_par(info);
+                fsl_diu_set_aoi(info);
                 break;
         case MFB_GET_AOID:
                 aoi_d.x_aoi_d = mfbi->x_aoi_d;
@@ -1665,8 +1671,10 @@ static int __init fsl_diu_init(void)
         }
 
         prop = of_get_property(np, "d-cache-size", NULL);
-        if (prop == NULL)
+        if (prop == NULL) {
+                of_node_put(np);
                 return -ENODEV;
+        }
 
         /* Freescale PLRU requires 13/8 times the cache size to do a proper
            displacement flush
@@ -1675,8 +1683,10 @@ static int __init fsl_diu_init(void)
         coherence_data_size /= 8;
 
         prop = of_get_property(np, "d-cache-line-size", NULL);
-        if (prop == NULL)
+        if (prop == NULL) {
+                of_node_put(np);
                 return -ENODEV;
+        }
         d_cache_line_size = *prop;
 
         of_node_put(np);
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 2e552d5bbb5d..f89c3cce1e0c 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -87,6 +87,8 @@ static int gbe_revision;
 static int ypan, ywrap;
 
 static uint32_t pseudo_palette[16];
+static uint32_t gbe_cmap[256];
+static int gbe_turned_on; /* 0 turned off, 1 turned on */
 
 static char *mode_option __initdata = NULL;
 
@@ -208,6 +210,8 @@ void gbe_turn_off(void)
         int i;
         unsigned int val, x, y, vpixen_off;
 
+        gbe_turned_on = 0;
+
         /* check if pixel counter is on */
         val = gbe->vt_xy;
         if (GET_GBE_FIELD(VT_XY, FREEZE, val) == 1)
@@ -371,6 +375,22 @@ static void gbe_turn_on(void)
         }
         if (i == 10000)
                 printk(KERN_ERR "gbefb: turn on DMA timed out\n");
+
+        gbe_turned_on = 1;
+}
+
+static void gbe_loadcmap(void)
+{
+        int i, j;
+
+        for (i = 0; i < 256; i++) {
+                for (j = 0; j < 1000 && gbe->cm_fifo >= 63; j++)
+                        udelay(10);
+                if (j == 1000)
+                        printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
+
+                gbe->cmap[i] = gbe_cmap[i];
+        }
 }
 
 /*
@@ -382,6 +402,7 @@ static int gbefb_blank(int blank, struct fb_info *info)
         switch (blank) {
         case FB_BLANK_UNBLANK:          /* unblank */
                 gbe_turn_on();
+                gbe_loadcmap();
                 break;
 
         case FB_BLANK_NORMAL:           /* blank */
@@ -796,16 +817,10 @@ static int gbefb_set_par(struct fb_info *info)
                 gbe->gmap[i] = (i << 24) | (i << 16) | (i << 8);
 
         /* Initialize the color map */
-        for (i = 0; i < 256; i++) {
-                int j;
-
-                for (j = 0; j < 1000 && gbe->cm_fifo >= 63; j++)
-                        udelay(10);
-                if (j == 1000)
-                        printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
+        for (i = 0; i < 256; i++)
+                gbe_cmap[i] = (i << 8) | (i << 16) | (i << 24);
 
-                gbe->cmap[i] = (i << 8) | (i << 16) | (i << 24);
-        }
+        gbe_loadcmap();
 
         return 0;
 }
@@ -855,14 +870,17 @@ static int gbefb_setcolreg(unsigned regno, unsigned red, unsigned green,
         blue >>= 8;
 
         if (info->var.bits_per_pixel <= 8) {
-                /* wait for the color map FIFO to have a free entry */
-                for (i = 0; i < 1000 && gbe->cm_fifo >= 63; i++)
-                        udelay(10);
-                if (i == 1000) {
-                        printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
-                        return 1;
+                gbe_cmap[regno] = (red << 24) | (green << 16) | (blue << 8);
+                if (gbe_turned_on) {
+                        /* wait for the color map FIFO to have a free entry */
+                        for (i = 0; i < 1000 && gbe->cm_fifo >= 63; i++)
+                                udelay(10);
+                        if (i == 1000) {
+                                printk(KERN_ERR "gbefb: cmap FIFO timeout\n");
+                                return 1;
+                        }
+                        gbe->cmap[regno] = gbe_cmap[regno];
                 }
-                gbe->cmap[regno] = (red << 24) | (green << 16) | (blue << 8);
         } else if (regno < 16) {
                 switch (info->var.bits_per_pixel) {
                 case 15:
diff --git a/drivers/video/geode/lxfb.h b/drivers/video/geode/lxfb.h
index 3b9416f4ee20..6a51448fd3f7 100644
--- a/drivers/video/geode/lxfb.h
+++ b/drivers/video/geode/lxfb.h
@@ -51,8 +51,6 @@ static inline unsigned int lx_get_pitch(unsigned int xres, int bpp)
 }
 
 void lx_set_mode(struct fb_info *);
-void lx_get_gamma(struct fb_info *, unsigned int *, int);
-void lx_set_gamma(struct fb_info *, unsigned int *, int);
 unsigned int lx_framebuffer_size(void);
 int lx_blank_display(struct fb_info *, int);
 void lx_set_palette_reg(struct fb_info *, unsigned int, unsigned int,
diff --git a/drivers/video/geode/lxfb_ops.c b/drivers/video/geode/lxfb_ops.c
index aaef9165ec9b..b1cd49c99356 100644
--- a/drivers/video/geode/lxfb_ops.c
+++ b/drivers/video/geode/lxfb_ops.c
@@ -517,25 +517,25 @@ void lx_set_palette_reg(struct fb_info *info, unsigned regno,
 int lx_blank_display(struct fb_info *info, int blank_mode)
 {
         struct lxfb_par *par = info->par;
-        u32 dcfg, fp_pm;
-        int blank, hsync, vsync, crt;
+        u32 dcfg, misc, fp_pm;
+        int blank, hsync, vsync;
 
         /* CRT power saving modes. */
         switch (blank_mode) {
         case FB_BLANK_UNBLANK:
-                blank = 0; hsync = 1; vsync = 1; crt = 1;
+                blank = 0; hsync = 1; vsync = 1;
                 break;
         case FB_BLANK_NORMAL:
-                blank = 1; hsync = 1; vsync = 1; crt = 1;
+                blank = 1; hsync = 1; vsync = 1;
                 break;
         case FB_BLANK_VSYNC_SUSPEND:
-                blank = 1; hsync = 1; vsync = 0; crt = 1;
+                blank = 1; hsync = 1; vsync = 0;
                 break;
         case FB_BLANK_HSYNC_SUSPEND:
-                blank = 1; hsync = 0; vsync = 1; crt = 1;
+                blank = 1; hsync = 0; vsync = 1;
                 break;
         case FB_BLANK_POWERDOWN:
-                blank = 1; hsync = 0; vsync = 0; crt = 0;
+                blank = 1; hsync = 0; vsync = 0;
                 break;
         default:
                 return -EINVAL;
@@ -545,15 +545,23 @@ int lx_blank_display(struct fb_info *info, int blank_mode)
         dcfg &= ~(VP_DCFG_DAC_BL_EN | VP_DCFG_HSYNC_EN | VP_DCFG_VSYNC_EN |
                         VP_DCFG_CRT_EN);
         if (!blank)
-                dcfg |= VP_DCFG_DAC_BL_EN;
+                dcfg |= VP_DCFG_DAC_BL_EN | VP_DCFG_CRT_EN;
         if (hsync)
                 dcfg |= VP_DCFG_HSYNC_EN;
         if (vsync)
                 dcfg |= VP_DCFG_VSYNC_EN;
-        if (crt)
-                dcfg |= VP_DCFG_CRT_EN;
+
         write_vp(par, VP_DCFG, dcfg);
 
+        misc = read_vp(par, VP_MISC);
+
+        if (vsync && hsync)
+                misc &= ~VP_MISC_DACPWRDN;
+        else
+                misc |= VP_MISC_DACPWRDN;
+
+        write_vp(par, VP_MISC, misc);
+
         /* Power on/off flat panel */
 
         if (par->output & OUTPUT_PANEL) {
diff --git a/drivers/video/hgafb.c b/drivers/video/hgafb.c
index c18880d9db1f..0129c044f6d6 100644
--- a/drivers/video/hgafb.c
+++ b/drivers/video/hgafb.c
@@ -551,7 +551,7 @@ static struct fb_ops hgafb_ops = {
          *  Initialization
          */
 
-static int __init hgafb_probe(struct device *device)
+static int __init hgafb_probe(struct platform_device *pdev)
 {
         struct fb_info *info;
 
@@ -565,7 +565,7 @@ static int __init hgafb_probe(struct device *device)
         printk(KERN_INFO "hgafb: %s with %ldK of memory detected.\n",
                 hga_type_name, hga_vram_len/1024);
 
-        info = framebuffer_alloc(0, NULL);
+        info = framebuffer_alloc(0, &pdev->dev);
         if (!info) {
                 iounmap(hga_vram);
                 return -ENOMEM;
@@ -593,13 +593,13 @@ static int __init hgafb_probe(struct device *device)
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
                info->node, info->fix.id);
-        dev_set_drvdata(device, info);
+        platform_set_drvdata(pdev, info);
         return 0;
 }
 
-static int hgafb_remove(struct device *device)
+static int hgafb_remove(struct platform_device *pdev)
 {
-        struct fb_info *info = dev_get_drvdata(device);
+        struct fb_info *info = platform_get_drvdata(pdev);
 
         hga_txt_mode();
         hga_clear_screen();
@@ -620,16 +620,15 @@ static int hgafb_remove(struct device *device)
         return 0;
 }
 
-static struct device_driver hgafb_driver = {
-        .name = "hgafb",
-        .bus  = &platform_bus_type,
+static struct platform_driver hgafb_driver = {
         .probe = hgafb_probe,
         .remove = hgafb_remove,
+        .driver = {
+                .name = "hgafb",
+        },
 };
 
-static struct platform_device hgafb_device = {
-        .name = "hgafb",
-};
+static struct platform_device *hgafb_device;
 
 static int __init hgafb_init(void)
 {
@@ -638,12 +637,15 @@ static int __init hgafb_init(void)
         if (fb_get_options("hgafb", NULL))
                 return -ENODEV;
 
-        ret = driver_register(&hgafb_driver);
+        ret = platform_driver_register(&hgafb_driver);
 
         if (!ret) {
-                ret = platform_device_register(&hgafb_device);
-                if (ret)
-                        driver_unregister(&hgafb_driver);
+                hgafb_device = platform_device_register_simple("hgafb", 0, NULL, 0);
+
+                if (IS_ERR(hgafb_device)) {
+                        platform_driver_unregister(&hgafb_driver);
+                        ret = PTR_ERR(hgafb_device);
+                }
         }
 
         return ret;
@@ -651,8 +653,8 @@ static int __init hgafb_init(void)
 
 static void __exit hgafb_exit(void)
 {
-        platform_device_unregister(&hgafb_device);
-        driver_unregister(&hgafb_driver);
+        platform_device_unregister(hgafb_device);
+        platform_driver_unregister(&hgafb_driver);
 }
 
 /* -------------------------------------------------------------------------
diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c
index 392a8be6aa76..e6467cf9f19f 100644
--- a/drivers/video/hitfb.c
+++ b/drivers/video/hitfb.c
@@ -27,7 +27,7 @@
 #include <asm/pgtable.h>
 #include <asm/io.h>
 #include <asm/hd64461.h>
-#include <asm/cpu/dac.h>
+#include <cpu/dac.h>
 
 #define WIDTH 640
 
diff --git a/drivers/video/imxfb.c b/drivers/video/imxfb.c
index 94e4d3ac1a05..ccd986140c95 100644
--- a/drivers/video/imxfb.c
+++ b/drivers/video/imxfb.c
@@ -24,6 +24,7 @@
 #include <linux/string.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/fb.h>
 #include <linux/delay.h>
 #include <linux/init.h>
@@ -32,9 +33,9 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/io.h>
-#include <asm/arch/imxfb.h>
+#include <mach/imxfb.h>
 
 /*
  * Complain if VAR is out of range.
diff --git a/drivers/video/macfb.c b/drivers/video/macfb.c
index aa8c714d6245..b790ddff76f9 100644
--- a/drivers/video/macfb.c
+++ b/drivers/video/macfb.c
@@ -596,7 +596,7 @@ static struct fb_ops macfb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-void __init macfb_setup(char *options)
+static void __init macfb_setup(char *options)
 {
         char *this_opt;
         
diff --git a/drivers/video/matrox/i2c-matroxfb.c b/drivers/video/matrox/i2c-matroxfb.c
index 75ee5a12e549..c14e3e2212b3 100644
--- a/drivers/video/matrox/i2c-matroxfb.c
+++ b/drivers/video/matrox/i2c-matroxfb.c
@@ -87,13 +87,7 @@ static int matroxfb_gpio_getscl(void* data) {
         return (matroxfb_read_gpio(b->minfo) & b->mask.clock) ? 1 : 0;
 }
 
-static struct i2c_adapter matrox_i2c_adapter_template =
-{
-        .owner =        THIS_MODULE,
-        .id =           I2C_HW_B_G400,
-};
-
-static struct i2c_algo_bit_data matrox_i2c_algo_template =
+static const struct i2c_algo_bit_data matrox_i2c_algo_template =
 {
         .setsda         = matroxfb_gpio_setsda,
         .setscl         = matroxfb_gpio_setscl,
@@ -112,7 +106,7 @@ static int i2c_bus_reg(struct i2c_bit_adapter* b, struct matrox_fb_info* minfo,
         b->minfo = minfo;
         b->mask.data = data;
         b->mask.clock = clock;
-        b->adapter = matrox_i2c_adapter_template;
+        b->adapter.owner = THIS_MODULE;
         snprintf(b->adapter.name, sizeof(b->adapter.name), name,
                 minfo->fbcon.node);
         i2c_set_adapdata(&b->adapter, b);
@@ -187,6 +181,17 @@ static void* i2c_matroxfb_probe(struct matrox_fb_info* minfo) {
                                   MAT_DATA, MAT_CLK, "MAVEN:fb%u", 0);
                 if (err)
                         printk(KERN_INFO "i2c-matroxfb: Could not register Maven i2c bus. Continuing anyway.\n");
+                else {
+                        struct i2c_board_info maven_info = {
+                                I2C_BOARD_INFO("maven", 0x1b),
+                        };
+                        unsigned short const addr_list[2] = {
+                                0x1b, I2C_CLIENT_END
+                        };
+
+                        i2c_new_probed_device(&m2info->maven.adapter,
+                                              &maven_info, addr_list);
+                }
         }
         return m2info;
 fail_ddc1:;
diff --git a/drivers/video/matrox/matroxfb_base.c b/drivers/video/matrox/matroxfb_base.c
index 54e82f35353d..c02136202792 100644
--- a/drivers/video/matrox/matroxfb_base.c
+++ b/drivers/video/matrox/matroxfb_base.c
@@ -2536,7 +2536,7 @@ module_param(fh, int, 0);
 MODULE_PARM_DESC(fh, "Startup horizontal frequency, 0-999kHz, 1000-INF Hz");
 module_param(fv, int, 0);
 MODULE_PARM_DESC(fv, "Startup vertical frequency, 0-INF Hz\n"
-"You should specify \"fv:max_monitor_vsync,fh:max_monitor_hsync,maxclk:max_monitor_dotclock\"\n");
+"You should specify \"fv:max_monitor_vsync,fh:max_monitor_hsync,maxclk:max_monitor_dotclock\"");
 module_param(grayscale, int, 0);
 MODULE_PARM_DESC(grayscale, "Sets display into grayscale. Works perfectly with paletized videomode (4, 8bpp), some limitations apply to 16, 24 and 32bpp videomodes (default=nograyscale)");
 module_param(cross4MB, int, 0);
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index 89da27bd5c49..042408a8c631 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -19,8 +19,6 @@
 #include <linux/matroxfb.h>
 #include <asm/div64.h>
 
-#define MAVEN_I2CID     (0x1B)
-
 #define MGATVO_B        1
 #define MGATVO_C        2
 
@@ -128,7 +126,7 @@ static int get_ctrl_id(__u32 v4l2_id) {
 
 struct maven_data {
         struct matrox_fb_info*          primary_head;
-        struct i2c_client               client;
+        struct i2c_client               *client;
         int                             version;
 };
 
@@ -974,7 +972,7 @@ static inline int maven_compute_timming(struct maven_data* md,
 
 static int maven_program_timming(struct maven_data* md,
                 const struct mavenregs* m) {
-        struct i2c_client* c = &md->client;
+        struct i2c_client *c = md->client;
 
         if (m->mode == MATROXFB_OUTPUT_MODE_MONITOR) {
                 LR(0x80);
@@ -1011,7 +1009,7 @@ static int maven_program_timming(struct maven_data* md,
 }
 
 static inline int maven_resync(struct maven_data* md) {
-        struct i2c_client* c = &md->client;
+        struct i2c_client *c = md->client;
         maven_set_reg(c, 0x95, 0x20);   /* start whole thing */
         return 0;
 }
@@ -1069,48 +1067,48 @@ static int maven_set_control (struct maven_data* md,
                   maven_compute_bwlevel(md, &blacklevel, &whitelevel);
                   blacklevel = (blacklevel >> 2) | ((blacklevel & 3) << 8);
                   whitelevel = (whitelevel >> 2) | ((whitelevel & 3) << 8);
-                  maven_set_reg_pair(&md->client, 0x0e, blacklevel);
-                  maven_set_reg_pair(&md->client, 0x1e, whitelevel);
+                  maven_set_reg_pair(md->client, 0x0e, blacklevel);
+                  maven_set_reg_pair(md->client, 0x1e, whitelevel);
                 }
                 break;
                 case V4L2_CID_SATURATION:
                 {
-                  maven_set_reg(&md->client, 0x20, p->value);
-                  maven_set_reg(&md->client, 0x22, p->value);
+                  maven_set_reg(md->client, 0x20, p->value);
+                  maven_set_reg(md->client, 0x22, p->value);
                 }
                 break;
                 case V4L2_CID_HUE:
                 {
-                  maven_set_reg(&md->client, 0x25, p->value);
+                  maven_set_reg(md->client, 0x25, p->value);
                 }
                 break;
                 case V4L2_CID_GAMMA:
                 {
                   const struct maven_gamma* g;
                   g = maven_compute_gamma(md);
-                  maven_set_reg(&md->client, 0x83, g->reg83);
-                  maven_set_reg(&md->client, 0x84, g->reg84);
-                  maven_set_reg(&md->client, 0x85, g->reg85);
-                  maven_set_reg(&md->client, 0x86, g->reg86);
-                  maven_set_reg(&md->client, 0x87, g->reg87);
-                  maven_set_reg(&md->client, 0x88, g->reg88);
-                  maven_set_reg(&md->client, 0x89, g->reg89);
-                  maven_set_reg(&md->client, 0x8a, g->reg8a);
-                  maven_set_reg(&md->client, 0x8b, g->reg8b);
+                  maven_set_reg(md->client, 0x83, g->reg83);
+                  maven_set_reg(md->client, 0x84, g->reg84);
+                  maven_set_reg(md->client, 0x85, g->reg85);
+                  maven_set_reg(md->client, 0x86, g->reg86);
+                  maven_set_reg(md->client, 0x87, g->reg87);
+                  maven_set_reg(md->client, 0x88, g->reg88);
+                  maven_set_reg(md->client, 0x89, g->reg89);
+                  maven_set_reg(md->client, 0x8a, g->reg8a);
+                  maven_set_reg(md->client, 0x8b, g->reg8b);
                 }
                 break;
                 case MATROXFB_CID_TESTOUT:
                 {
                         unsigned char val 
-                          = maven_get_reg(&md->client,0x8d);
+                          = maven_get_reg(md->client, 0x8d);
                         if (p->value) val |= 0x10;
                         else          val &= ~0x10;
-                        maven_set_reg(&md->client, 0x8d, val);
+                        maven_set_reg(md->client, 0x8d, val);
                 }
                 break;
                 case MATROXFB_CID_DEFLICKER:
                 {
-                  maven_set_reg(&md->client, 0x93, maven_compute_deflicker(md));
+                  maven_set_reg(md->client, 0x93, maven_compute_deflicker(md));
                 }
                 break;
         }
@@ -1189,6 +1187,7 @@ static int maven_init_client(struct i2c_client* clnt) {
         MINFO_FROM(container_of(clnt->adapter, struct i2c_bit_adapter, adapter)->minfo);
 
         md->primary_head = MINFO;
+        md->client = clnt;
         down_write(&ACCESS_FBINFO(altout.lock));
         ACCESS_FBINFO(outputs[1]).output = &maven_altout;
         ACCESS_FBINFO(outputs[1]).src = ACCESS_FBINFO(outputs[1]).default_src;
@@ -1232,14 +1231,11 @@ static int maven_shutdown_client(struct i2c_client* clnt) {
         return 0;
 }
 
-static const unsigned short normal_i2c[] = { MAVEN_I2CID, I2C_CLIENT_END };
-I2C_CLIENT_INSMOD;
-
-static struct i2c_driver maven_driver;
-
-static int maven_detect_client(struct i2c_adapter* adapter, int address, int kind) {
-        int err = 0;
-        struct i2c_client* new_client;
+static int maven_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = client->adapter;
+        int err = -ENODEV;
         struct maven_data* data;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_WORD_DATA |
@@ -1250,50 +1246,37 @@ static int maven_detect_client(struct i2c_adapter* adapter, int address, int kin
                 err = -ENOMEM;
                 goto ERROR0;
         }
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &maven_driver;
-        new_client->flags = 0;
-        strlcpy(new_client->name, "maven", I2C_NAME_SIZE);
-        if ((err = i2c_attach_client(new_client)))
-                goto ERROR3;
-        err = maven_init_client(new_client);
+        i2c_set_clientdata(client, data);
+        err = maven_init_client(client);
         if (err)
                 goto ERROR4;
         return 0;
 ERROR4:;
-        i2c_detach_client(new_client);
-ERROR3:;
-        kfree(new_client);
+        kfree(data);
 ERROR0:;
         return err;
 }
 
-static int maven_attach_adapter(struct i2c_adapter* adapter) {
-        if (adapter->id == I2C_HW_B_G400)
-                return i2c_probe(adapter, &addr_data, &maven_detect_client);
-        return 0;
-}
-
-static int maven_detach_client(struct i2c_client* client) {
-        int err;
-
-        if ((err = i2c_detach_client(client)))
-                return err;
+static int maven_remove(struct i2c_client *client)
+{
         maven_shutdown_client(client);
         kfree(i2c_get_clientdata(client));
         return 0;
 }
 
+static const struct i2c_device_id maven_id[] = {
+        { "maven", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, maven_id);
+
 static struct i2c_driver maven_driver={
         .driver = {
                 .name   = "maven",
         },
-        .id             = I2C_DRIVERID_MGATVO,
-        .attach_adapter = maven_attach_adapter,
-        .detach_client  = maven_detach_client,
+        .probe          = maven_probe,
+        .remove         = maven_remove,
+        .id_table       = maven_id,
 };
 
 static int __init matroxfb_maven_init(void)
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index 5246b0402d76..25172b2a2a94 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -201,7 +201,6 @@ static int neoFindMode(int xres, int yres, int depth)
  *
  * Determine the closest clock frequency to the one requested.
  */
-#define REF_FREQ 0xe517         /* 14.31818 in 20.12 fixed point */
 #define MAX_N 127
 #define MAX_D 31
 #define MAX_F 1
@@ -211,27 +210,24 @@ static void neoCalcVCLK(const struct fb_info *info,
 {
         int n, d, f;
         int n_best = 0, d_best = 0, f_best = 0;
-        long f_best_diff = (0x7ffff << 12);     /* 20.12 */
-        long f_target = (freq << 12) / 1000;    /* 20.12 */
+        long f_best_diff = 0x7ffff;
 
         for (f = 0; f <= MAX_F; f++)
-                for (n = 0; n <= MAX_N; n++)
-                        for (d = 0; d <= MAX_D; d++) {
-                                long f_out;     /* 20.12 */
-                                long f_diff;    /* 20.12 */
-
-                                f_out =
-                                    ((((n + 1) << 12) / ((d +
-                                                          1) *
-                                                         (1 << f))) >> 12)
-                                    * REF_FREQ;
-                                f_diff = abs(f_out - f_target);
-                                if (f_diff < f_best_diff) {
+                for (d = 0; d <= MAX_D; d++)
+                        for (n = 0; n <= MAX_N; n++) {
+                                long f_out;
+                                long f_diff;
+
+                                f_out = ((14318 * (n + 1)) / (d + 1)) >> f;
+                                f_diff = abs(f_out - freq);
+                                if (f_diff <= f_best_diff) {
                                         f_best_diff = f_diff;
                                         n_best = n;
                                         d_best = d;
                                         f_best = f;
                                 }
+                                if (f_out > freq)
+                                        break;
                         }
 
         if (info->fix.accel == FB_ACCEL_NEOMAGIC_NM2200 ||
@@ -248,11 +244,11 @@ static void neoCalcVCLK(const struct fb_info *info,
         par->VCLK3Denominator = d_best;
 
 #ifdef NEOFB_DEBUG
-        printk("neoVCLK: f:%d NumLow=%d NumHi=%d Den=%d Df=%d\n",
-               f_target >> 12,
+        printk(KERN_DEBUG "neoVCLK: f:%ld NumLow=%d NumHi=%d Den=%d Df=%ld\n",
+               freq,
                par->VCLK3NumeratorLow,
                par->VCLK3NumeratorHigh,
-               par->VCLK3Denominator, f_best_diff >> 12);
+               par->VCLK3Denominator, f_best_diff);
 #endif
 }
 
@@ -263,15 +259,20 @@ static void neoCalcVCLK(const struct fb_info *info,
  */
 
 static int vgaHWInit(const struct fb_var_screeninfo *var,
-                     const struct fb_info *info,
-                     struct neofb_par *par, struct xtimings *timings)
+                     struct neofb_par *par)
 {
+        int hsync_end = var->xres + var->right_margin + var->hsync_len;
+        int htotal = (hsync_end + var->left_margin) >> 3;
+        int vsync_start = var->yres + var->lower_margin;
+        int vsync_end = vsync_start + var->vsync_len;
+        int vtotal = vsync_end + var->upper_margin;
+
         par->MiscOutReg = 0x23;
 
-        if (!(timings->sync & FB_SYNC_HOR_HIGH_ACT))
+        if (!(var->sync & FB_SYNC_HOR_HIGH_ACT))
                 par->MiscOutReg |= 0x40;
 
-        if (!(timings->sync & FB_SYNC_VERT_HIGH_ACT))
+        if (!(var->sync & FB_SYNC_VERT_HIGH_ACT))
                 par->MiscOutReg |= 0x80;
 
         /*
@@ -286,25 +287,25 @@ static int vgaHWInit(const struct fb_var_screeninfo *var,
         /*
          * CRTC Controller
          */
-        par->CRTC[0] = (timings->HTotal >> 3) - 5;
-        par->CRTC[1] = (timings->HDisplay >> 3) - 1;
-        par->CRTC[2] = (timings->HDisplay >> 3) - 1;
-        par->CRTC[3] = (((timings->HTotal >> 3) - 1) & 0x1F) | 0x80;
-        par->CRTC[4] = (timings->HSyncStart >> 3);
-        par->CRTC[5] = ((((timings->HTotal >> 3) - 1) & 0x20) << 2)
-            | (((timings->HSyncEnd >> 3)) & 0x1F);
-        par->CRTC[6] = (timings->VTotal - 2) & 0xFF;
-        par->CRTC[7] = (((timings->VTotal - 2) & 0x100) >> 8)
-            | (((timings->VDisplay - 1) & 0x100) >> 7)
-            | ((timings->VSyncStart & 0x100) >> 6)
-            | (((timings->VDisplay - 1) & 0x100) >> 5)
-            | 0x10 | (((timings->VTotal - 2) & 0x200) >> 4)
-            | (((timings->VDisplay - 1) & 0x200) >> 3)
-            | ((timings->VSyncStart & 0x200) >> 2);
+        par->CRTC[0] = htotal - 5;
+        par->CRTC[1] = (var->xres >> 3) - 1;
+        par->CRTC[2] = (var->xres >> 3) - 1;
+        par->CRTC[3] = ((htotal - 1) & 0x1F) | 0x80;
+        par->CRTC[4] = ((var->xres + var->right_margin) >> 3);
+        par->CRTC[5] = (((htotal - 1) & 0x20) << 2)
+            | (((hsync_end >> 3)) & 0x1F);
+        par->CRTC[6] = (vtotal - 2) & 0xFF;
+        par->CRTC[7] = (((vtotal - 2) & 0x100) >> 8)
+            | (((var->yres - 1) & 0x100) >> 7)
+            | ((vsync_start & 0x100) >> 6)
+            | (((var->yres - 1) & 0x100) >> 5)
+            | 0x10 | (((vtotal - 2) & 0x200) >> 4)
+            | (((var->yres - 1) & 0x200) >> 3)
+            | ((vsync_start & 0x200) >> 2);
         par->CRTC[8] = 0x00;
-        par->CRTC[9] = (((timings->VDisplay - 1) & 0x200) >> 4) | 0x40;
+        par->CRTC[9] = (((var->yres - 1) & 0x200) >> 4) | 0x40;
 
-        if (timings->dblscan)
+        if (var->vmode & FB_VMODE_DOUBLE)
                 par->CRTC[9] |= 0x80;
 
         par->CRTC[10] = 0x00;
@@ -313,13 +314,13 @@ static int vgaHWInit(const struct fb_var_screeninfo *var,
         par->CRTC[13] = 0x00;
         par->CRTC[14] = 0x00;
         par->CRTC[15] = 0x00;
-        par->CRTC[16] = timings->VSyncStart & 0xFF;
-        par->CRTC[17] = (timings->VSyncEnd & 0x0F) | 0x20;
-        par->CRTC[18] = (timings->VDisplay - 1) & 0xFF;
+        par->CRTC[16] = vsync_start & 0xFF;
+        par->CRTC[17] = (vsync_end & 0x0F) | 0x20;
+        par->CRTC[18] = (var->yres - 1) & 0xFF;
         par->CRTC[19] = var->xres_virtual >> 4;
         par->CRTC[20] = 0x00;
-        par->CRTC[21] = (timings->VDisplay - 1) & 0xFF;
-        par->CRTC[22] = (timings->VTotal - 1) & 0xFF;
+        par->CRTC[21] = (var->yres - 1) & 0xFF;
+        par->CRTC[22] = (vtotal - 1) & 0xFF;
         par->CRTC[23] = 0xC3;
         par->CRTC[24] = 0xFF;
 
@@ -483,7 +484,8 @@ static inline int neo2200_sync(struct fb_info *info)
 {
         struct neofb_par *par = info->par;
 
-        while (readl(&par->neo2200->bltStat) & 1);
+        while (readl(&par->neo2200->bltStat) & 1)
+                cpu_relax();
         return 0;
 }
 
@@ -591,34 +593,14 @@ static int
 neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
         struct neofb_par *par = info->par;
-        unsigned int pixclock = var->pixclock;
-        struct xtimings timings;
         int memlen, vramlen;
         int mode_ok = 0;
 
         DBG("neofb_check_var");
 
-        if (!pixclock)
-                pixclock = 10000;       /* 10ns = 100MHz */
-        timings.pixclock = 1000000000 / pixclock;
-        if (timings.pixclock < 1)
-                timings.pixclock = 1;
-
-        if (timings.pixclock > par->maxClock)
+        if (PICOS2KHZ(var->pixclock) > par->maxClock)
                 return -EINVAL;
 
-        timings.dblscan = var->vmode & FB_VMODE_DOUBLE;
-        timings.interlaced = var->vmode & FB_VMODE_INTERLACED;
-        timings.HDisplay = var->xres;
-        timings.HSyncStart = timings.HDisplay + var->right_margin;
-        timings.HSyncEnd = timings.HSyncStart + var->hsync_len;
-        timings.HTotal = timings.HSyncEnd + var->left_margin;
-        timings.VDisplay = var->yres;
-        timings.VSyncStart = timings.VDisplay + var->lower_margin;
-        timings.VSyncEnd = timings.VSyncStart + var->vsync_len;
-        timings.VTotal = timings.VSyncEnd + var->upper_margin;
-        timings.sync = var->sync;
-
         /* Is the mode larger than the LCD panel? */
         if (par->internal_display &&
             ((var->xres > par->NeoPanelWidth) ||
@@ -759,11 +741,11 @@ neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 static int neofb_set_par(struct fb_info *info)
 {
         struct neofb_par *par = info->par;
-        struct xtimings timings;
         unsigned char temp;
         int i, clock_hi = 0;
         int lcd_stretch;
         int hoffset, voffset;
+        int vsync_start, vtotal;
 
         DBG("neofb_set_par");
 
@@ -771,28 +753,15 @@ static int neofb_set_par(struct fb_info *info)
 
         vgaHWProtect(1);        /* Blank the screen */
 
-        timings.dblscan = info->var.vmode & FB_VMODE_DOUBLE;
-        timings.interlaced = info->var.vmode & FB_VMODE_INTERLACED;
-        timings.HDisplay = info->var.xres;
-        timings.HSyncStart = timings.HDisplay + info->var.right_margin;
-        timings.HSyncEnd = timings.HSyncStart + info->var.hsync_len;
-        timings.HTotal = timings.HSyncEnd + info->var.left_margin;
-        timings.VDisplay = info->var.yres;
-        timings.VSyncStart = timings.VDisplay + info->var.lower_margin;
-        timings.VSyncEnd = timings.VSyncStart + info->var.vsync_len;
-        timings.VTotal = timings.VSyncEnd + info->var.upper_margin;
-        timings.sync = info->var.sync;
-        timings.pixclock = PICOS2KHZ(info->var.pixclock);
-
-        if (timings.pixclock < 1)
-                timings.pixclock = 1;
+        vsync_start = info->var.yres + info->var.lower_margin;
+        vtotal = vsync_start + info->var.vsync_len + info->var.upper_margin;
 
         /*
          * This will allocate the datastructure and initialize all of the
          * generic VGA registers.
          */
 
-        if (vgaHWInit(&info->var, info, par, &timings))
+        if (vgaHWInit(&info->var, par))
                 return -EINVAL;
 
         /*
@@ -831,10 +800,10 @@ static int neofb_set_par(struct fb_info *info)
         par->ExtCRTDispAddr = 0x10;
 
         /* Vertical Extension */
-        par->VerticalExt = (((timings.VTotal - 2) & 0x400) >> 10)
-            | (((timings.VDisplay - 1) & 0x400) >> 9)
-            | (((timings.VSyncStart) & 0x400) >> 8)
-            | (((timings.VSyncStart) & 0x400) >> 7);
+        par->VerticalExt = (((vtotal - 2) & 0x400) >> 10)
+            | (((info->var.yres - 1) & 0x400) >> 9)
+            | (((vsync_start) & 0x400) >> 8)
+            | (((vsync_start) & 0x400) >> 7);
 
         /* Fast write bursts on unless disabled. */
         if (par->pci_burst)
@@ -995,7 +964,7 @@ static int neofb_set_par(struct fb_info *info)
          * Calculate the VCLK that most closely matches the requested dot
          * clock.
          */
-        neoCalcVCLK(info, par, timings.pixclock);
+        neoCalcVCLK(info, par, PICOS2KHZ(info->var.pixclock));
 
         /* Since we program the clocks ourselves, always use VCLK3. */
         par->MiscOutReg |= 0x0C;
@@ -1927,9 +1896,6 @@ static int __devinit neo_init_hw(struct fb_info *info)
         int maxClock = 65000;
         int CursorMem = 1024;
         int CursorOff = 0x100;
-        int linearSize = 1024;
-        int maxWidth = 1024;
-        int maxHeight = 1024;
 
         DBG("neo_init_hw");
 
@@ -1948,81 +1914,52 @@ static int __devinit neo_init_hw(struct fb_info *info)
         case FB_ACCEL_NEOMAGIC_NM2070:
                 videoRam = 896;
                 maxClock = 65000;
-                CursorMem = 2048;
-                CursorOff = 0x100;
-                linearSize = 1024;
-                maxWidth = 1024;
-                maxHeight = 1024;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2090:
         case FB_ACCEL_NEOMAGIC_NM2093:
-                videoRam = 1152;
-                maxClock = 80000;
-                CursorMem = 2048;
-                CursorOff = 0x100;
-                linearSize = 2048;
-                maxWidth = 1024;
-                maxHeight = 1024;
-                break;
         case FB_ACCEL_NEOMAGIC_NM2097:
                 videoRam = 1152;
                 maxClock = 80000;
-                CursorMem = 1024;
-                CursorOff = 0x100;
-                linearSize = 2048;
-                maxWidth = 1024;
-                maxHeight = 1024;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2160:
                 videoRam = 2048;
                 maxClock = 90000;
-                CursorMem = 1024;
-                CursorOff = 0x100;
-                linearSize = 2048;
-                maxWidth = 1024;
-                maxHeight = 1024;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2200:
                 videoRam = 2560;
                 maxClock = 110000;
-                CursorMem = 1024;
-                CursorOff = 0x1000;
-                linearSize = 4096;
-                maxWidth = 1280;
-                maxHeight = 1024;       /* ???? */
-
-                par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2230:
                 videoRam = 3008;
                 maxClock = 110000;
-                CursorMem = 1024;
-                CursorOff = 0x1000;
-                linearSize = 4096;
-                maxWidth = 1280;
-                maxHeight = 1024;       /* ???? */
-
-                par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2360:
                 videoRam = 4096;
                 maxClock = 110000;
-                CursorMem = 1024;
-                CursorOff = 0x1000;
-                linearSize = 4096;
-                maxWidth = 1280;
-                maxHeight = 1024;       /* ???? */
-
-                par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
                 break;
         case FB_ACCEL_NEOMAGIC_NM2380:
                 videoRam = 6144;
                 maxClock = 110000;
+                break;
+        }
+        switch (info->fix.accel) {
+        case FB_ACCEL_NEOMAGIC_NM2070:
+        case FB_ACCEL_NEOMAGIC_NM2090:
+        case FB_ACCEL_NEOMAGIC_NM2093:
+                CursorMem = 2048;
+                CursorOff = 0x100;
+                break;
+        case FB_ACCEL_NEOMAGIC_NM2097:
+        case FB_ACCEL_NEOMAGIC_NM2160:
+                CursorMem = 1024;
+                CursorOff = 0x100;
+                break;
+        case FB_ACCEL_NEOMAGIC_NM2200:
+        case FB_ACCEL_NEOMAGIC_NM2230:
+        case FB_ACCEL_NEOMAGIC_NM2360:
+        case FB_ACCEL_NEOMAGIC_NM2380:
                 CursorMem = 1024;
                 CursorOff = 0x1000;
-                linearSize = 8192;
-                maxWidth = 1280;
-                maxHeight = 1024;       /* ???? */
 
                 par->neo2200 = (Neo2200 __iomem *) par->mmio_vbase;
                 break;
@@ -2036,7 +1973,7 @@ static int __devinit neo_init_hw(struct fb_info *info)
 */
         par->maxClock = maxClock;
         par->cursorOff = CursorOff;
-        return ((videoRam * 1024));
+        return videoRam * 1024;
 }
 
 
diff --git a/drivers/video/offb.c b/drivers/video/offb.c
index d7b3dcc0dc43..e1d9eeb1aeaf 100644
--- a/drivers/video/offb.c
+++ b/drivers/video/offb.c
@@ -47,6 +47,7 @@ enum {
         cmap_M3B,               /* ATI Rage Mobility M3 Head B */
         cmap_radeon,            /* ATI Radeon */
         cmap_gxt2000,           /* IBM GXT2000 */
+        cmap_avivo,             /* ATI R5xx */
 };
 
 struct offb_par {
@@ -58,26 +59,36 @@ struct offb_par {
 
 struct offb_par default_par;
 
-    /*
-     *  Interface used by the world
-     */
-
-static int offb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
-                          u_int transp, struct fb_info *info);
-static int offb_blank(int blank, struct fb_info *info);
-
 #ifdef CONFIG_PPC32
 extern boot_infos_t *boot_infos;
 #endif
 
-static struct fb_ops offb_ops = {
-        .owner          = THIS_MODULE,
-        .fb_setcolreg   = offb_setcolreg,
-        .fb_blank       = offb_blank,
-        .fb_fillrect    = cfb_fillrect,
-        .fb_copyarea    = cfb_copyarea,
-        .fb_imageblit   = cfb_imageblit,
-};
+/* Definitions used by the Avivo palette hack */
+#define AVIVO_DC_LUT_RW_SELECT                  0x6480
+#define AVIVO_DC_LUT_RW_MODE                    0x6484
+#define AVIVO_DC_LUT_RW_INDEX                   0x6488
+#define AVIVO_DC_LUT_SEQ_COLOR                  0x648c
+#define AVIVO_DC_LUT_PWL_DATA                   0x6490
+#define AVIVO_DC_LUT_30_COLOR                   0x6494
+#define AVIVO_DC_LUT_READ_PIPE_SELECT           0x6498
+#define AVIVO_DC_LUT_WRITE_EN_MASK              0x649c
+#define AVIVO_DC_LUT_AUTOFILL                   0x64a0
+
+#define AVIVO_DC_LUTA_CONTROL                   0x64c0
+#define AVIVO_DC_LUTA_BLACK_OFFSET_BLUE         0x64c4
+#define AVIVO_DC_LUTA_BLACK_OFFSET_GREEN        0x64c8
+#define AVIVO_DC_LUTA_BLACK_OFFSET_RED          0x64cc
+#define AVIVO_DC_LUTA_WHITE_OFFSET_BLUE         0x64d0
+#define AVIVO_DC_LUTA_WHITE_OFFSET_GREEN        0x64d4
+#define AVIVO_DC_LUTA_WHITE_OFFSET_RED          0x64d8
+
+#define AVIVO_DC_LUTB_CONTROL                   0x6cc0
+#define AVIVO_DC_LUTB_BLACK_OFFSET_BLUE         0x6cc4
+#define AVIVO_DC_LUTB_BLACK_OFFSET_GREEN        0x6cc8
+#define AVIVO_DC_LUTB_BLACK_OFFSET_RED          0x6ccc
+#define AVIVO_DC_LUTB_WHITE_OFFSET_BLUE         0x6cd0
+#define AVIVO_DC_LUTB_WHITE_OFFSET_GREEN        0x6cd4
+#define AVIVO_DC_LUTB_WHITE_OFFSET_RED          0x6cd8
 
     /*
      *  Set a single color register. The values supplied are already
@@ -160,6 +171,17 @@ static int offb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                 out_le32(((unsigned __iomem *) par->cmap_adr) + regno,
                          (red << 16 | green << 8 | blue));
                 break;
+        case cmap_avivo:
+                /* Write to both LUTs for now */
+                writel(1, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                writeb(regno, par->cmap_adr + AVIVO_DC_LUT_RW_INDEX);
+                writel(((red) << 22) | ((green) << 12) | ((blue) << 2),
+                       par->cmap_adr + AVIVO_DC_LUT_30_COLOR);
+                writel(0, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                writeb(regno, par->cmap_adr + AVIVO_DC_LUT_RW_INDEX);
+                writel(((red) << 22) | ((green) << 12) | ((blue) << 2),
+                       par->cmap_adr + AVIVO_DC_LUT_30_COLOR);
+                break;
         }
 
         return 0;
@@ -216,12 +238,59 @@ static int offb_blank(int blank, struct fb_info *info)
                                 out_le32(((unsigned __iomem *) par->cmap_adr) + i,
                                          0);
                                 break;
+                        case cmap_avivo:
+                                writel(1, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                                writeb(i, par->cmap_adr + AVIVO_DC_LUT_RW_INDEX);
+                                writel(0, par->cmap_adr + AVIVO_DC_LUT_30_COLOR);
+                                writel(0, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                                writeb(i, par->cmap_adr + AVIVO_DC_LUT_RW_INDEX);
+                                writel(0, par->cmap_adr + AVIVO_DC_LUT_30_COLOR);
+                                break;
                         }
         } else
                 fb_set_cmap(&info->cmap, info);
         return 0;
 }
 
+static int offb_set_par(struct fb_info *info)
+{
+        struct offb_par *par = (struct offb_par *) info->par;
+
+        /* On avivo, initialize palette control */
+        if (par->cmap_type == cmap_avivo) {
+                writel(0, par->cmap_adr + AVIVO_DC_LUTA_CONTROL);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTA_BLACK_OFFSET_BLUE);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTA_BLACK_OFFSET_GREEN);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTA_BLACK_OFFSET_RED);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTA_WHITE_OFFSET_BLUE);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTA_WHITE_OFFSET_GREEN);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTA_WHITE_OFFSET_RED);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTB_CONTROL);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTB_BLACK_OFFSET_BLUE);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTB_BLACK_OFFSET_GREEN);
+                writel(0, par->cmap_adr + AVIVO_DC_LUTB_BLACK_OFFSET_RED);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTB_WHITE_OFFSET_BLUE);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTB_WHITE_OFFSET_GREEN);
+                writel(0x0000ffff, par->cmap_adr + AVIVO_DC_LUTB_WHITE_OFFSET_RED);
+                writel(1, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                writel(0, par->cmap_adr + AVIVO_DC_LUT_RW_MODE);
+                writel(0x0000003f, par->cmap_adr + AVIVO_DC_LUT_WRITE_EN_MASK);
+                writel(0, par->cmap_adr + AVIVO_DC_LUT_RW_SELECT);
+                writel(0, par->cmap_adr + AVIVO_DC_LUT_RW_MODE);
+                writel(0x0000003f, par->cmap_adr + AVIVO_DC_LUT_WRITE_EN_MASK);
+        }
+        return 0;
+}
+
+static struct fb_ops offb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_setcolreg   = offb_setcolreg,
+        .fb_set_par     = offb_set_par,
+        .fb_blank       = offb_blank,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+};
 
 static void __iomem *offb_map_reg(struct device_node *np, int index,
                                   unsigned long offset, unsigned long size)
@@ -245,6 +314,59 @@ static void __iomem *offb_map_reg(struct device_node *np, int index,
         return ioremap(taddr + offset, size);
 }
 
+static void offb_init_palette_hacks(struct fb_info *info, struct device_node *dp,
+                                    const char *name, unsigned long address)
+{
+        struct offb_par *par = (struct offb_par *) info->par;
+
+        if (dp && !strncmp(name, "ATY,Rage128", 11)) {
+                par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
+                if (par->cmap_adr)
+                        par->cmap_type = cmap_r128;
+        } else if (dp && (!strncmp(name, "ATY,RageM3pA", 12)
+                          || !strncmp(name, "ATY,RageM3p12A", 14))) {
+                par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
+                if (par->cmap_adr)
+                        par->cmap_type = cmap_M3A;
+        } else if (dp && !strncmp(name, "ATY,RageM3pB", 12)) {
+                par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
+                if (par->cmap_adr)
+                        par->cmap_type = cmap_M3B;
+        } else if (dp && !strncmp(name, "ATY,Rage6", 9)) {
+                par->cmap_adr = offb_map_reg(dp, 1, 0, 0x1fff);
+                if (par->cmap_adr)
+                        par->cmap_type = cmap_radeon;
+        } else if (!strncmp(name, "ATY,", 4)) {
+                unsigned long base = address & 0xff000000UL;
+                par->cmap_adr =
+                        ioremap(base + 0x7ff000, 0x1000) + 0xcc0;
+                par->cmap_data = par->cmap_adr + 1;
+                par->cmap_type = cmap_m64;
+        } else if (dp && (of_device_is_compatible(dp, "pci1014,b7") ||
+                          of_device_is_compatible(dp, "pci1014,21c"))) {
+                par->cmap_adr = offb_map_reg(dp, 0, 0x6000, 0x1000);
+                if (par->cmap_adr)
+                        par->cmap_type = cmap_gxt2000;
+        } else if (dp && !strncmp(name, "vga,Display-", 12)) {
+                /* Look for AVIVO initialized by SLOF */
+                struct device_node *pciparent = of_get_parent(dp);
+                const u32 *vid, *did;
+                vid = of_get_property(pciparent, "vendor-id", NULL);
+                did = of_get_property(pciparent, "device-id", NULL);
+                /* This will match most R5xx */
+                if (vid && did && *vid == 0x1002 &&
+                    ((*did >= 0x7100 && *did < 0x7800) ||
+                     (*did >= 0x9400))) {
+                        par->cmap_adr = offb_map_reg(pciparent, 2, 0, 0x10000);
+                        if (par->cmap_adr)
+                                par->cmap_type = cmap_avivo;
+                }
+                of_node_put(pciparent);
+        }
+        info->fix.visual = (par->cmap_type != cmap_unknown) ?
+                FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_STATIC_PSEUDOCOLOR;
+}
+
 static void __init offb_init_fb(const char *name, const char *full_name,
                                 int width, int height, int depth,
                                 int pitch, unsigned long address,
@@ -283,6 +405,7 @@ static void __init offb_init_fb(const char *name, const char *full_name,
 
         fix = &info->fix;
         var = &info->var;
+        info->par = par;
 
         strcpy(fix->id, "OFfb ");
         strncat(fix->id, name, sizeof(fix->id) - sizeof("OFfb "));
@@ -298,39 +421,9 @@ static void __init offb_init_fb(const char *name, const char *full_name,
         fix->type_aux = 0;
 
         par->cmap_type = cmap_unknown;
-        if (depth == 8) {
-                if (dp && !strncmp(name, "ATY,Rage128", 11)) {
-                        par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
-                        if (par->cmap_adr)
-                                par->cmap_type = cmap_r128;
-                } else if (dp && (!strncmp(name, "ATY,RageM3pA", 12)
-                                  || !strncmp(name, "ATY,RageM3p12A", 14))) {
-                        par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
-                        if (par->cmap_adr)
-                                par->cmap_type = cmap_M3A;
-                } else if (dp && !strncmp(name, "ATY,RageM3pB", 12)) {
-                        par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
-                        if (par->cmap_adr)
-                                par->cmap_type = cmap_M3B;
-                } else if (dp && !strncmp(name, "ATY,Rage6", 9)) {
-                        par->cmap_adr = offb_map_reg(dp, 1, 0, 0x1fff);
-                        if (par->cmap_adr)
-                                par->cmap_type = cmap_radeon;
-                } else if (!strncmp(name, "ATY,", 4)) {
-                        unsigned long base = address & 0xff000000UL;
-                        par->cmap_adr =
-                            ioremap(base + 0x7ff000, 0x1000) + 0xcc0;
-                        par->cmap_data = par->cmap_adr + 1;
-                        par->cmap_type = cmap_m64;
-                } else if (dp && (of_device_is_compatible(dp, "pci1014,b7") ||
-                                  of_device_is_compatible(dp, "pci1014,21c"))) {
-                        par->cmap_adr = offb_map_reg(dp, 0, 0x6000, 0x1000);
-                        if (par->cmap_adr)
-                                par->cmap_type = cmap_gxt2000;
-                }
-                fix->visual = (par->cmap_type != cmap_unknown) ?
-                        FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_STATIC_PSEUDOCOLOR;
-        } else
+        if (depth == 8)
+                offb_init_palette_hacks(info, dp, name, address);
+        else
                 fix->visual = FB_VISUAL_TRUECOLOR;
 
         var->xoffset = var->yoffset = 0;
@@ -395,7 +488,6 @@ static void __init offb_init_fb(const char *name, const char *full_name,
 
         info->fbops = &offb_ops;
         info->screen_base = ioremap(address, fix->smem_len);
-        info->par = par;
         info->pseudo_palette = (void *) (info + 1);
         info->flags = FBINFO_DEFAULT | foreign_endian;
 
diff --git a/drivers/video/omap/blizzard.c b/drivers/video/omap/blizzard.c
index 4d8ad9cd0e19..9dfcf39d3367 100644
--- a/drivers/video/omap/blizzard.c
+++ b/drivers/video/omap/blizzard.c
@@ -26,9 +26,9 @@
 #include <linux/delay.h>
 #include <linux/clk.h>
 
-#include <asm/arch/dma.h>
-#include <asm/arch/omapfb.h>
-#include <asm/arch/blizzard.h>
+#include <mach/dma.h>
+#include <mach/omapfb.h>
+#include <mach/blizzard.h>
 
 #include "dispc.h"
 
diff --git a/drivers/video/omap/dispc.c b/drivers/video/omap/dispc.c
index ab32ceb06178..6efcf89e7fbe 100644
--- a/drivers/video/omap/dispc.c
+++ b/drivers/video/omap/dispc.c
@@ -20,13 +20,14 @@
  */
 #include <linux/kernel.h>
 #include <linux/dma-mapping.h>
+#include <linux/mm.h>
 #include <linux/vmalloc.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#include <asm/arch/sram.h>
-#include <asm/arch/omapfb.h>
-#include <asm/arch/board.h>
+#include <mach/sram.h>
+#include <mach/omapfb.h>
+#include <mach/board.h>
 
 #include "dispc.h"
 
diff --git a/drivers/video/omap/hwa742.c b/drivers/video/omap/hwa742.c
index 1e642b7a20fe..f24df0b54e1c 100644
--- a/drivers/video/omap/hwa742.c
+++ b/drivers/video/omap/hwa742.c
@@ -26,9 +26,9 @@
 #include <linux/delay.h>
 #include <linux/clk.h>
 
-#include <asm/arch/dma.h>
-#include <asm/arch/omapfb.h>
-#include <asm/arch/hwa742.h>
+#include <mach/dma.h>
+#include <mach/omapfb.h>
+#include <mach/hwa742.h>
 
 #define HWA742_REV_CODE_REG       0x0
 #define HWA742_CONFIG_REG         0x2
diff --git a/drivers/video/omap/lcd_h3.c b/drivers/video/omap/lcd_h3.c
index 31e978349a80..2486237ebba5 100644
--- a/drivers/video/omap/lcd_h3.c
+++ b/drivers/video/omap/lcd_h3.c
@@ -23,8 +23,8 @@
 #include <linux/platform_device.h>
 #include <linux/i2c/tps65010.h>
 
-#include <asm/arch/gpio.h>
-#include <asm/arch/omapfb.h>
+#include <mach/gpio.h>
+#include <mach/omapfb.h>
 
 #define MODULE_NAME     "omapfb-lcd_h3"
 
diff --git a/drivers/video/omap/lcd_h4.c b/drivers/video/omap/lcd_h4.c
index fd6f0eb16de1..88c19d424ef7 100644
--- a/drivers/video/omap/lcd_h4.c
+++ b/drivers/video/omap/lcd_h4.c
@@ -22,7 +22,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <asm/arch/omapfb.h>
+#include <mach/omapfb.h>
 
 static int h4_panel_init(struct lcd_panel *panel, struct omapfb_device *fbdev)
 {
diff --git a/drivers/video/omap/lcd_inn1510.c b/drivers/video/omap/lcd_inn1510.c
index 551f385861d1..6953ed4b5820 100644
--- a/drivers/video/omap/lcd_inn1510.c
+++ b/drivers/video/omap/lcd_inn1510.c
@@ -23,8 +23,8 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#include <asm/arch/fpga.h>
-#include <asm/arch/omapfb.h>
+#include <mach/fpga.h>
+#include <mach/omapfb.h>
 
 static int innovator1510_panel_init(struct lcd_panel *panel,
                                     struct omapfb_device *fbdev)
diff --git a/drivers/video/omap/lcd_inn1610.c b/drivers/video/omap/lcd_inn1610.c
index 5ef119c813e0..6a42c6a0cd99 100644
--- a/drivers/video/omap/lcd_inn1610.c
+++ b/drivers/video/omap/lcd_inn1610.c
@@ -22,8 +22,8 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <asm/arch/gpio.h>
-#include <asm/arch/omapfb.h>
+#include <mach/gpio.h>
+#include <mach/omapfb.h>
 
 #define MODULE_NAME     "omapfb-lcd_h3"
 
diff --git a/drivers/video/omap/lcd_osk.c b/drivers/video/omap/lcd_osk.c
index a38038840fd6..a4a725f427a4 100644
--- a/drivers/video/omap/lcd_osk.c
+++ b/drivers/video/omap/lcd_osk.c
@@ -23,9 +23,9 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <asm/arch/gpio.h>
-#include <asm/arch/mux.h>
-#include <asm/arch/omapfb.h>
+#include <mach/gpio.h>
+#include <mach/mux.h>
+#include <mach/omapfb.h>
 
 static int osk_panel_init(struct lcd_panel *panel, struct omapfb_device *fbdev)
 {
diff --git a/drivers/video/omap/lcd_palmte.c b/drivers/video/omap/lcd_palmte.c
index 52bdfdac42c9..218317366e6e 100644
--- a/drivers/video/omap/lcd_palmte.c
+++ b/drivers/video/omap/lcd_palmte.c
@@ -23,8 +23,8 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#include <asm/arch/fpga.h>
-#include <asm/arch/omapfb.h>
+#include <mach/fpga.h>
+#include <mach/omapfb.h>
 
 static int palmte_panel_init(struct lcd_panel *panel,
                                 struct omapfb_device *fbdev)
diff --git a/drivers/video/omap/lcd_palmtt.c b/drivers/video/omap/lcd_palmtt.c
index 4bb349f54356..57b0f6cf6a5a 100644
--- a/drivers/video/omap/lcd_palmtt.c
+++ b/drivers/video/omap/lcd_palmtt.c
@@ -29,8 +29,8 @@ GPIO13 - screen blanking
 #include <linux/module.h>
 #include <linux/io.h>
 
-#include <asm/arch/gpio.h>
-#include <asm/arch/omapfb.h>
+#include <mach/gpio.h>
+#include <mach/omapfb.h>
 
 static int palmtt_panel_init(struct lcd_panel *panel,
         struct omapfb_device *fbdev)
diff --git a/drivers/video/omap/lcd_palmz71.c b/drivers/video/omap/lcd_palmz71.c
index ea6170ddff35..d33d78b11723 100644
--- a/drivers/video/omap/lcd_palmz71.c
+++ b/drivers/video/omap/lcd_palmz71.c
@@ -24,7 +24,7 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#include <asm/arch/omapfb.h>
+#include <mach/omapfb.h>
 
 static int palmz71_panel_init(struct lcd_panel *panel,
                               struct omapfb_device *fbdev)
diff --git a/drivers/video/omap/lcd_sx1.c b/drivers/video/omap/lcd_sx1.c
index c4f306a4e5c9..caa6a896cb8b 100644
--- a/drivers/video/omap/lcd_sx1.c
+++ b/drivers/video/omap/lcd_sx1.c
@@ -23,10 +23,10 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 
-#include <asm/arch/gpio.h>
-#include <asm/arch/omapfb.h>
-#include <asm/arch/mcbsp.h>
-#include <asm/arch/mux.h>
+#include <mach/gpio.h>
+#include <mach/omapfb.h>
+#include <mach/mcbsp.h>
+#include <mach/mux.h>
 
 /*
  * OMAP310 GPIO registers
diff --git a/drivers/video/omap/lcdc.c b/drivers/video/omap/lcdc.c
index fb19ed4992db..83514f066712 100644
--- a/drivers/video/omap/lcdc.c
+++ b/drivers/video/omap/lcdc.c
@@ -29,8 +29,8 @@
 #include <linux/vmalloc.h>
 #include <linux/clk.h>
 
-#include <asm/arch/dma.h>
-#include <asm/arch/omapfb.h>
+#include <mach/dma.h>
+#include <mach/omapfb.h>
 
 #include <asm/mach-types.h>
 
diff --git a/drivers/video/omap/omapfb_main.c b/drivers/video/omap/omapfb_main.c
index 14d0f7a11145..51a138bd113c 100644
--- a/drivers/video/omap/omapfb_main.c
+++ b/drivers/video/omap/omapfb_main.c
@@ -25,11 +25,11 @@
  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #include <linux/platform_device.h>
+#include <linux/mm.h>
 #include <linux/uaccess.h>
 
-#include <asm/mach-types.h>
-#include <asm/arch/dma.h>
-#include <asm/arch/omapfb.h>
+#include <mach/dma.h>
+#include <mach/omapfb.h>
 
 #define MODULE_NAME     "omapfb"
 
diff --git a/drivers/video/omap/rfbi.c b/drivers/video/omap/rfbi.c
index 789cfd23c36b..4a6f13d3facf 100644
--- a/drivers/video/omap/rfbi.c
+++ b/drivers/video/omap/rfbi.c
@@ -27,7 +27,7 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#include <asm/arch/omapfb.h>
+#include <mach/omapfb.h>
 
 #include "dispc.h"
 
diff --git a/drivers/video/omap/sossi.c b/drivers/video/omap/sossi.c
index 81dbcf53cf0e..6359353c2c67 100644
--- a/drivers/video/omap/sossi.c
+++ b/drivers/video/omap/sossi.c
@@ -24,8 +24,8 @@
 #include <linux/irq.h>
 #include <linux/io.h>
 
-#include <asm/arch/dma.h>
-#include <asm/arch/omapfb.h>
+#include <mach/dma.h>
+#include <mach/omapfb.h>
 
 #include "lcdc.h"
 
@@ -646,7 +646,7 @@ static int sossi_init(struct omapfb_device *fbdev)
         sossi_write_reg(SOSSI_INIT1_REG, l);
 
         if ((r = request_irq(INT_1610_SoSSI_MATCH, sossi_match_irq,
-                             IRQT_FALLING,
+                             IRQ_TYPE_EDGE_FALLING,
              "sossi_match", sossi.fbdev->dev)) < 0) {
                 dev_err(sossi.fbdev->dev, "can't get SoSSI match IRQ\n");
                 goto err;
diff --git a/drivers/video/pm2fb.c b/drivers/video/pm2fb.c
index 3f1ca2adda3d..c6dd924976a4 100644
--- a/drivers/video/pm2fb.c
+++ b/drivers/video/pm2fb.c
@@ -1746,6 +1746,7 @@ static void __devexit pm2fb_remove(struct pci_dev *pdev)
         release_mem_region(fix->mmio_start, fix->mmio_len);
 
         pci_set_drvdata(pdev, NULL);
+        fb_dealloc_cmap(&info->cmap);
         kfree(info->pixmap.addr);
         kfree(info);
 }
diff --git a/drivers/video/pnx4008/dum.h b/drivers/video/pnx4008/dum.h
index d80a614d89ed..1234d4375d92 100644
--- a/drivers/video/pnx4008/dum.h
+++ b/drivers/video/pnx4008/dum.h
@@ -12,7 +12,7 @@
 #ifndef __PNX008_DUM_H__
 #define __PNX008_DUM_H__
 
-#include <asm/arch/platform.h>
+#include <mach/platform.h>
 
 #define PNX4008_DUMCONF_VA_BASE         IO_ADDRESS(PNX4008_DUMCONF_BASE)
 #define PNX4008_DUM_MAIN_VA_BASE        IO_ADDRESS(PNX4008_DUM_MAINCFG_BASE)
diff --git a/drivers/video/pnx4008/sdum.c b/drivers/video/pnx4008/sdum.c
index d23bf0d659b6..2aa09bce3944 100644
--- a/drivers/video/pnx4008/sdum.c
+++ b/drivers/video/pnx4008/sdum.c
@@ -30,7 +30,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <asm/uaccess.h>
-#include <asm/arch/gpio.h>
+#include <mach/gpio.h>
 
 #include "sdum.h"
 #include "fbcommon.h"
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index dc3af1c78c56..4b5d80771904 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1297,6 +1297,7 @@ static int ps3fb_shutdown(struct ps3_system_bus_device *dev)
 
 static struct ps3_system_bus_driver ps3fb_driver = {
         .match_id       = PS3_MATCH_ID_GRAPHICS,
+        .match_sub_id   = PS3_MATCH_SUB_ID_FB,
         .core.name      = DEVICE_NAME,
         .core.owner     = THIS_MODULE,
         .probe          = ps3fb_probe,
diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c
index 8c863a7f654b..0a0fd48a8566 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -58,18 +58,18 @@
 
 #ifdef CONFIG_SH_DREAMCAST
 #include <asm/machvec.h>
-#include <asm/mach/sysasic.h>
+#include <mach-dreamcast/mach/sysasic.h>
 #endif
 
 #ifdef CONFIG_SH_DMA
 #include <linux/pagemap.h>
-#include <asm/mach/dma.h>
+#include <mach/dma.h>
 #include <asm/dma.h>
 #endif
 
 #ifdef CONFIG_SH_STORE_QUEUES
 #include <linux/uaccess.h>
-#include <asm/cpu/sq.h>
+#include <cpu/sq.h>
 #endif
 
 #ifndef PCI_DEVICE_ID_NEC_NEON250
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index d0746261c957..97204497d9f7 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -30,6 +30,7 @@
 #include <linux/string.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/fb.h>
 #include <linux/delay.h>
 #include <linux/init.h>
@@ -40,17 +41,18 @@
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/completion.h>
+#include <linux/mutex.h>
 #include <linux/kthread.h>
 #include <linux/freezer.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/div64.h>
-#include <asm/arch/pxa-regs.h>
-#include <asm/arch/pxa2xx-gpio.h>
-#include <asm/arch/bitfield.h>
-#include <asm/arch/pxafb.h>
+#include <mach/pxa-regs.h>
+#include <mach/pxa2xx-gpio.h>
+#include <mach/bitfield.h>
+#include <mach/pxafb.h>
 
 /*
  * Complain if VAR is out of range.
@@ -227,6 +229,22 @@ static int pxafb_bpp_to_lccr3(struct fb_var_screeninfo *var)
         case 4:  ret = LCCR3_4BPP; break;
         case 8:  ret = LCCR3_8BPP; break;
         case 16: ret = LCCR3_16BPP; break;
+        case 24:
+                switch (var->red.length + var->green.length +
+                                var->blue.length + var->transp.length) {
+                case 18: ret = LCCR3_18BPP_P | LCCR3_PDFOR_3; break;
+                case 19: ret = LCCR3_19BPP_P; break;
+                }
+                break;
+        case 32:
+                switch (var->red.length + var->green.length +
+                                var->blue.length + var->transp.length) {
+                case 18: ret = LCCR3_18BPP | LCCR3_PDFOR_3; break;
+                case 19: ret = LCCR3_19BPP; break;
+                case 24: ret = LCCR3_24BPP | LCCR3_PDFOR_3; break;
+                case 25: ret = LCCR3_25BPP; break;
+                }
+                break;
         }
         return ret;
 }
@@ -345,6 +363,41 @@ static int pxafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
                 var->green.offset = 5;  var->green.length = 6;
                 var->blue.offset  = 0;  var->blue.length  = 5;
                 var->transp.offset = var->transp.length = 0;
+        } else if (var->bits_per_pixel > 16) {
+                struct pxafb_mode_info *mode;
+
+                mode = pxafb_getmode(inf, var);
+                if (!mode)
+                        return -EINVAL;
+
+                switch (mode->depth) {
+                case 18: /* RGB666 */
+                        var->transp.offset = var->transp.length     = 0;
+                        var->red.offset    = 12; var->red.length    = 6;
+                        var->green.offset  = 6;  var->green.length  = 6;
+                        var->blue.offset   = 0;  var->blue.length   = 6;
+                        break;
+                case 19: /* RGBT666 */
+                        var->transp.offset = 18; var->transp.length = 1;
+                        var->red.offset    = 12; var->red.length    = 6;
+                        var->green.offset  = 6;  var->green.length  = 6;
+                        var->blue.offset   = 0;  var->blue.length   = 6;
+                        break;
+                case 24: /* RGB888 */
+                        var->transp.offset = var->transp.length     = 0;
+                        var->red.offset    = 16; var->red.length    = 8;
+                        var->green.offset  = 8;  var->green.length  = 8;
+                        var->blue.offset   = 0;  var->blue.length   = 8;
+                        break;
+                case 25: /* RGBT888 */
+                        var->transp.offset = 24; var->transp.length = 1;
+                        var->red.offset    = 16; var->red.length    = 8;
+                        var->green.offset  = 8;  var->green.length  = 8;
+                        var->blue.offset   = 0;  var->blue.length   = 8;
+                        break;
+                default:
+                        return -EINVAL;
+                }
         } else {
                 var->red.offset = var->green.offset = 0;
                 var->blue.offset = var->transp.offset = 0;
@@ -376,7 +429,7 @@ static int pxafb_set_par(struct fb_info *info)
         struct pxafb_info *fbi = (struct pxafb_info *)info;
         struct fb_var_screeninfo *var = &info->var;
 
-        if (var->bits_per_pixel == 16)
+        if (var->bits_per_pixel >= 16)
                 fbi->fb.fix.visual = FB_VISUAL_TRUECOLOR;
         else if (!fbi->cmap_static)
                 fbi->fb.fix.visual = FB_VISUAL_PSEUDOCOLOR;
@@ -391,7 +444,7 @@ static int pxafb_set_par(struct fb_info *info)
 
         fbi->fb.fix.line_length = var->xres_virtual *
                                   var->bits_per_pixel / 8;
-        if (var->bits_per_pixel == 16)
+        if (var->bits_per_pixel >= 16)
                 fbi->palette_size = 0;
         else
                 fbi->palette_size = var->bits_per_pixel == 1 ?
@@ -404,7 +457,7 @@ static int pxafb_set_par(struct fb_info *info)
          */
         pxafb_set_truecolor(fbi->fb.fix.visual == FB_VISUAL_TRUECOLOR);
 
-        if (fbi->fb.var.bits_per_pixel == 16)
+        if (fbi->fb.var.bits_per_pixel >= 16)
                 fb_dealloc_cmap(&fbi->fb.cmap);
         else
                 fb_alloc_cmap(&fbi->fb.cmap, 1<<fbi->fb.var.bits_per_pixel, 0);
@@ -831,6 +884,8 @@ static int pxafb_activate_var(struct fb_var_screeninfo *var,
                 case 4:
                 case 8:
                 case 16:
+                case 24:
+                case 32:
                         break;
                 default:
                         printk(KERN_ERR "%s: invalid bit depth %d\n",
@@ -968,10 +1023,17 @@ static void pxafb_setup_gpio(struct pxafb_info *fbi)
 
         for (gpio = 58; ldd_bits; gpio++, ldd_bits--)
                 pxa_gpio_mode(gpio | GPIO_ALT_FN_2_OUT);
+        /* 18 bit interface */
+        if (fbi->fb.var.bits_per_pixel > 16) {
+                pxa_gpio_mode(86 | GPIO_ALT_FN_2_OUT);
+                pxa_gpio_mode(87 | GPIO_ALT_FN_2_OUT);
+        }
         pxa_gpio_mode(GPIO74_LCD_FCLK_MD);
         pxa_gpio_mode(GPIO75_LCD_LCLK_MD);
         pxa_gpio_mode(GPIO76_LCD_PCLK_MD);
-        pxa_gpio_mode(GPIO77_LCD_ACBIAS_MD);
+
+        if ((lccr0 & LCCR0_PAS) == 0)
+                pxa_gpio_mode(GPIO77_LCD_ACBIAS_MD);
 }
 
 static void pxafb_enable_controller(struct pxafb_info *fbi)
@@ -1058,7 +1120,7 @@ static void set_ctrlr_state(struct pxafb_info *fbi, u_int state)
 {
         u_int old_state;
 
-        down(&fbi->ctrlr_sem);
+        mutex_lock(&fbi->ctrlr_lock);
 
         old_state = fbi->state;
 
@@ -1146,7 +1208,7 @@ static void set_ctrlr_state(struct pxafb_info *fbi, u_int state)
                 }
                 break;
         }
-        up(&fbi->ctrlr_sem);
+        mutex_unlock(&fbi->ctrlr_lock);
 }
 
 /*
@@ -1276,7 +1338,7 @@ static int __devinit pxafb_map_video_memory(struct pxafb_info *fbi)
                 fbi->dma_buff_phys = fbi->map_dma;
                 fbi->palette_cpu = (u16 *) fbi->dma_buff->palette;
 
-                pr_debug("pxafb: palette_mem_size = 0x%08lx\n", fbi->palette_size*sizeof(u16));
+                pr_debug("pxafb: palette_mem_size = 0x%08x\n", fbi->palette_size*sizeof(u16));
 
 #ifdef CONFIG_FB_PXA_SMARTPANEL
                 fbi->smart_cmds = (uint16_t *) fbi->dma_buff->cmd_buff;
@@ -1340,6 +1402,8 @@ static void pxafb_decode_mach_info(struct pxafb_info *fbi,
         if (lcd_conn == LCD_MONO_STN_8BPP)
                 fbi->lccr0 |= LCCR0_DPD;
 
+        fbi->lccr0 |= (lcd_conn & LCD_ALTERNATE_MAPPING) ? LCCR0_LDDALT : 0;
+
         fbi->lccr3 = LCCR3_Acb((inf->lcd_conn >> 10) & 0xff);
         fbi->lccr3 |= (lcd_conn & LCD_BIAS_ACTIVE_LOW) ? LCCR3_OEP : 0;
         fbi->lccr3 |= (lcd_conn & LCD_PCLK_EDGE_FALL)  ? LCCR3_PCP : 0;
@@ -1399,7 +1463,7 @@ static struct pxafb_info * __devinit pxafb_init_fbinfo(struct device *dev)
 
         init_waitqueue_head(&fbi->ctrlr_wait);
         INIT_WORK(&fbi->task, pxafb_task);
-        init_MUTEX(&fbi->ctrlr_sem);
+        mutex_init(&fbi->ctrlr_lock);
         init_completion(&fbi->disable_done);
 #ifdef CONFIG_FB_PXA_SMARTPANEL
         init_completion(&fbi->command_done);
@@ -1613,53 +1677,63 @@ MODULE_PARM_DESC(options, "LCD parameters (see Documentation/fb/pxafb.txt)");
 #define pxafb_setup_options()           (0)
 #endif
 
-static int __devinit pxafb_probe(struct platform_device *dev)
-{
-        struct pxafb_info *fbi;
-        struct pxafb_mach_info *inf;
-        struct resource *r;
-        int irq, ret;
-
-        dev_dbg(&dev->dev, "pxafb_probe\n");
-
-        inf = dev->dev.platform_data;
-        ret = -ENOMEM;
-        fbi = NULL;
-        if (!inf)
-                goto failed;
-
-        ret = pxafb_parse_options(&dev->dev, g_options);
-        if (ret < 0)
-                goto failed;
-
 #ifdef DEBUG_VAR
-        /* Check for various illegal bit-combinations. Currently only
-         * a warning is given. */
+/* Check for various illegal bit-combinations. Currently only
+ * a warning is given. */
+static void __devinit pxafb_check_options(struct device *dev,
+                                          struct pxafb_mach_info *inf)
+{
+        if (inf->lcd_conn)
+                return;
 
         if (inf->lccr0 & LCCR0_INVALID_CONFIG_MASK)
-                dev_warn(&dev->dev, "machine LCCR0 setting contains "
+                dev_warn(dev, "machine LCCR0 setting contains "
                                 "illegal bits: %08x\n",
                         inf->lccr0 & LCCR0_INVALID_CONFIG_MASK);
         if (inf->lccr3 & LCCR3_INVALID_CONFIG_MASK)
-                dev_warn(&dev->dev, "machine LCCR3 setting contains "
+                dev_warn(dev, "machine LCCR3 setting contains "
                                 "illegal bits: %08x\n",
                         inf->lccr3 & LCCR3_INVALID_CONFIG_MASK);
         if (inf->lccr0 & LCCR0_DPD &&
             ((inf->lccr0 & LCCR0_PAS) != LCCR0_Pas ||
              (inf->lccr0 & LCCR0_SDS) != LCCR0_Sngl ||
              (inf->lccr0 & LCCR0_CMS) != LCCR0_Mono))
-                dev_warn(&dev->dev, "Double Pixel Data (DPD) mode is "
+                dev_warn(dev, "Double Pixel Data (DPD) mode is "
                                 "only valid in passive mono"
                                 " single panel mode\n");
         if ((inf->lccr0 & LCCR0_PAS) == LCCR0_Act &&
             (inf->lccr0 & LCCR0_SDS) == LCCR0_Dual)
-                dev_warn(&dev->dev, "Dual panel only valid in passive mode\n");
+                dev_warn(dev, "Dual panel only valid in passive mode\n");
         if ((inf->lccr0 & LCCR0_PAS) == LCCR0_Pas &&
              (inf->modes->upper_margin || inf->modes->lower_margin))
-                dev_warn(&dev->dev, "Upper and lower margins must be 0 in "
+                dev_warn(dev, "Upper and lower margins must be 0 in "
                                 "passive mode\n");
+}
+#else
+#define pxafb_check_options(...)        do {} while (0)
 #endif
 
+static int __devinit pxafb_probe(struct platform_device *dev)
+{
+        struct pxafb_info *fbi;
+        struct pxafb_mach_info *inf;
+        struct resource *r;
+        int irq, ret;
+
+        dev_dbg(&dev->dev, "pxafb_probe\n");
+
+        inf = dev->dev.platform_data;
+        ret = -ENOMEM;
+        fbi = NULL;
+        if (!inf)
+                goto failed;
+
+        ret = pxafb_parse_options(&dev->dev, g_options);
+        if (ret < 0)
+                goto failed;
+
+        pxafb_check_options(&dev->dev, inf);
+
         dev_dbg(&dev->dev, "got a %dx%dx%d LCD\n",
                         inf->modes->xres,
                         inf->modes->yres,
diff --git a/drivers/video/pxafb.h b/drivers/video/pxafb.h
index 8238dc826429..31541b86f13d 100644
--- a/drivers/video/pxafb.h
+++ b/drivers/video/pxafb.h
@@ -106,7 +106,7 @@ struct pxafb_info {
 
         volatile u_char         state;
         volatile u_char         task_state;
-        struct semaphore        ctrlr_sem;
+        struct mutex            ctrlr_lock;
         wait_queue_head_t       ctrlr_wait;
         struct work_struct      task;
 
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index f0598961c6b0..79cf0b1976aa 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -29,9 +29,9 @@
 #include <asm/div64.h>
 
 #include <asm/mach/map.h>
-#include <asm/arch/regs-lcd.h>
-#include <asm/arch/regs-gpio.h>
-#include <asm/arch/fb.h>
+#include <mach/regs-lcd.h>
+#include <mach/regs-gpio.h>
+#include <mach/fb.h>
 
 #ifdef CONFIG_PM
 #include <linux/pm.h>
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index 2972f112dbed..4dcec48a1d78 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -11,7 +11,6 @@
  * which is based on the code of neofb.
  */
 
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -903,13 +902,13 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
         /* Prepare PCI device */
         rc = pci_enable_device(dev);
         if (rc < 0) {
-                dev_err(info->dev, "cannot enable PCI device\n");
+                dev_err(info->device, "cannot enable PCI device\n");
                 goto err_enable_device;
         }
 
         rc = pci_request_regions(dev, "s3fb");
         if (rc < 0) {
-                dev_err(info->dev, "cannot reserve framebuffer region\n");
+                dev_err(info->device, "cannot reserve framebuffer region\n");
                 goto err_request_regions;
         }
 
@@ -921,7 +920,7 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
         info->screen_base = pci_iomap(dev, 0, 0);
         if (! info->screen_base) {
                 rc = -ENOMEM;
-                dev_err(info->dev, "iomap for framebuffer failed\n");
+                dev_err(info->device, "iomap for framebuffer failed\n");
                 goto err_iomap;
         }
 
@@ -965,19 +964,19 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
         rc = fb_find_mode(&(info->var), info, mode_option, NULL, 0, NULL, 8);
         if (! ((rc == 1) || (rc == 2))) {
                 rc = -EINVAL;
-                dev_err(info->dev, "mode %s not found\n", mode_option);
+                dev_err(info->device, "mode %s not found\n", mode_option);
                 goto err_find_mode;
         }
 
         rc = fb_alloc_cmap(&info->cmap, 256, 0);
         if (rc < 0) {
-                dev_err(info->dev, "cannot allocate colormap\n");
+                dev_err(info->device, "cannot allocate colormap\n");
                 goto err_alloc_cmap;
         }
 
         rc = register_framebuffer(info);
         if (rc < 0) {
-                dev_err(info->dev, "cannot register framebuffer\n");
+                dev_err(info->device, "cannot register framebuffer\n");
                 goto err_reg_fb;
         }
 
@@ -1053,7 +1052,7 @@ static int s3_pci_suspend(struct pci_dev* dev, pm_message_t state)
         struct fb_info *info = pci_get_drvdata(dev);
         struct s3fb_info *par = info->par;
 
-        dev_info(info->dev, "suspend\n");
+        dev_info(info->device, "suspend\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
@@ -1085,7 +1084,7 @@ static int s3_pci_resume(struct pci_dev* dev)
         struct s3fb_info *par = info->par;
         int err;
 
-        dev_info(info->dev, "resume\n");
+        dev_info(info->device, "resume\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
@@ -1102,7 +1101,7 @@ static int s3_pci_resume(struct pci_dev* dev)
         if (err) {
                 mutex_unlock(&(par->open_lock));
                 release_console_sem();
-                dev_err(info->dev, "error %d enabling device for resume\n", err);
+                dev_err(info->device, "error %d enabling device for resume\n", err);
                 return err;
         }
         pci_set_master(dev);
diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c
index ab2b2110478b..c052bd4c0b06 100644
--- a/drivers/video/sa1100fb.c
+++ b/drivers/video/sa1100fb.c
@@ -167,6 +167,7 @@
 #include <linux/string.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/fb.h>
 #include <linux/delay.h>
 #include <linux/init.h>
@@ -174,12 +175,13 @@
 #include <linux/cpufreq.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/mutex.h>
 
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/mach-types.h>
-#include <asm/arch/assabet.h>
-#include <asm/arch/shannon.h>
+#include <mach/assabet.h>
+#include <mach/shannon.h>
 
 /*
  * debugging?
@@ -1107,7 +1109,7 @@ static void set_ctrlr_state(struct sa1100fb_info *fbi, u_int state)
 {
         u_int old_state;
 
-        down(&fbi->ctrlr_sem);
+        mutex_lock(&fbi->ctrlr_lock);
 
         old_state = fbi->state;
 
@@ -1192,7 +1194,7 @@ static void set_ctrlr_state(struct sa1100fb_info *fbi, u_int state)
                 }
                 break;
         }
-        up(&fbi->ctrlr_sem);
+        mutex_unlock(&fbi->ctrlr_lock);
 }
 
 /*
@@ -1444,7 +1446,7 @@ static struct sa1100fb_info * __init sa1100fb_init_fbinfo(struct device *dev)
 
         init_waitqueue_head(&fbi->ctrlr_wait);
         INIT_WORK(&fbi->task, sa1100fb_task);
-        init_MUTEX(&fbi->ctrlr_sem);
+        mutex_init(&fbi->ctrlr_lock);
 
         return fbi;
 }
diff --git a/drivers/video/sa1100fb.h b/drivers/video/sa1100fb.h
index f465b27ed860..86831db9a042 100644
--- a/drivers/video/sa1100fb.h
+++ b/drivers/video/sa1100fb.h
@@ -100,7 +100,7 @@ struct sa1100fb_info {
 
         volatile u_char         state;
         volatile u_char         task_state;
-        struct semaphore        ctrlr_sem;
+        struct mutex            ctrlr_lock;
         wait_queue_head_t       ctrlr_wait;
         struct work_struct      task;
 
diff --git a/drivers/video/sh7760fb.c b/drivers/video/sh7760fb.c
new file mode 100644
index 000000000000..8d0212da4514
--- /dev/null
+++ b/drivers/video/sh7760fb.c
@@ -0,0 +1,659 @@
+/*
+ * SH7760/SH7763 LCDC Framebuffer driver.
+ *
+ * (c) 2006-2008 MSC Vertriebsges.m.b.H.,
+ *             Manuel Lauss <mano@roarinelk.homelinux.net>
+ * (c) 2008 Nobuhiro Iwamatsu <iwamatsu.nobuhiro@renesas.com>
+ *
+ *  This file is subject to the terms and conditions of the GNU General
+ *  Public License.  See the file COPYING in the main directory of this
+ *  archive for more details.
+ *
+ * PLEASE HAVE A LOOK AT Documentation/fb/sh7760fb.txt!
+ *
+ * Thanks to Siegfried Schaefer <s.schaefer at schaefer-edv.de>
+ *     for his original source and testing!
+ */
+
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/fb.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include <asm/sh7760fb.h>
+
+struct sh7760fb_par {
+        void __iomem *base;
+        int irq;
+
+        struct sh7760fb_platdata *pd;   /* display information */
+
+        dma_addr_t fbdma;       /* physical address */
+
+        int rot;                /* rotation enabled? */
+
+        u32 pseudo_palette[16];
+
+        struct platform_device *dev;
+        struct resource *ioarea;
+        struct completion vsync;        /* vsync irq event */
+};
+
+static irqreturn_t sh7760fb_irq(int irq, void *data)
+{
+        struct completion *c = data;
+
+        complete(c);
+
+        return IRQ_HANDLED;
+}
+
+static void sh7760fb_wait_vsync(struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+
+        if (par->pd->novsync)
+                return;
+
+        iowrite16(ioread16(par->base + LDINTR) & ~VINT_CHECK,
+                  par->base + LDINTR);
+
+        if (par->irq < 0) {
+                /* poll for vert. retrace: status bit is sticky */
+                while (!(ioread16(par->base + LDINTR) & VINT_CHECK))
+                        cpu_relax();
+        } else {
+                /* a "wait_for_irq_event(par->irq)" would be extremely nice */
+                init_completion(&par->vsync);
+                enable_irq(par->irq);
+                wait_for_completion(&par->vsync);
+                disable_irq_nosync(par->irq);
+        }
+}
+
+/* wait_for_lps - wait until power supply has reached a certain state. */
+static int wait_for_lps(struct sh7760fb_par *par, int val)
+{
+        int i = 100;
+        while (--i && ((ioread16(par->base + LDPMMR) & 3) != val))
+                msleep(1);
+
+        if (i <= 0)
+                return -ETIMEDOUT;
+
+        return 0;
+}
+
+/* en/disable the LCDC */
+static int sh7760fb_blank(int blank, struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+        struct sh7760fb_platdata *pd = par->pd;
+        unsigned short cntr = ioread16(par->base + LDCNTR);
+        unsigned short intr = ioread16(par->base + LDINTR);
+        int lps;
+
+        if (blank == FB_BLANK_UNBLANK) {
+                intr |= VINT_START;
+                cntr = LDCNTR_DON2 | LDCNTR_DON;
+                lps = 3;
+        } else {
+                intr &= ~VINT_START;
+                cntr = LDCNTR_DON2;
+                lps = 0;
+        }
+
+        if (pd->blank)
+                pd->blank(blank);
+
+        iowrite16(intr, par->base + LDINTR);
+        iowrite16(cntr, par->base + LDCNTR);
+
+        return wait_for_lps(par, lps);
+}
+
+/* set color registers */
+static int sh7760fb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+        u32 s = cmap->start;
+        u32 l = cmap->len;
+        u16 *r = cmap->red;
+        u16 *g = cmap->green;
+        u16 *b = cmap->blue;
+        u32 col, tmo;
+        int ret;
+
+        ret = 0;
+
+        sh7760fb_wait_vsync(info);
+
+        /* request palette access */
+        iowrite16(LDPALCR_PALEN, par->base + LDPALCR);
+
+        /* poll for access grant */
+        tmo = 100;
+        while (!(ioread16(par->base + LDPALCR) & LDPALCR_PALS) && (--tmo))
+                cpu_relax();
+
+        if (!tmo) {
+                ret = 1;
+                dev_dbg(info->dev, "no palette access!\n");
+                goto out;
+        }
+
+        while (l && (s < 256)) {
+                col = ((*r) & 0xff) << 16;
+                col |= ((*g) & 0xff) << 8;
+                col |= ((*b) & 0xff);
+                col &= SH7760FB_PALETTE_MASK;
+                iowrite32(col, par->base + LDPR(s));
+
+                if (s < 16)
+                        ((u32 *) (info->pseudo_palette))[s] = s;
+
+                s++;
+                l--;
+                r++;
+                g++;
+                b++;
+        }
+out:
+        iowrite16(0, par->base + LDPALCR);
+        return ret;
+}
+
+static void encode_fix(struct fb_fix_screeninfo *fix, struct fb_info *info,
+                       unsigned long stride)
+{
+        memset(fix, 0, sizeof(struct fb_fix_screeninfo));
+        strcpy(fix->id, "sh7760-lcdc");
+
+        fix->smem_start = (unsigned long)info->screen_base;
+        fix->smem_len = info->screen_size;
+
+        fix->line_length = stride;
+}
+
+static int sh7760fb_get_color_info(struct device *dev,
+                                   u16 lddfr, int *bpp, int *gray)
+{
+        int lbpp, lgray;
+
+        lgray = lbpp = 0;
+
+        switch (lddfr & LDDFR_COLOR_MASK) {
+        case LDDFR_1BPP_MONO:
+                lgray = 1;
+                lbpp = 1;
+                break;
+        case LDDFR_2BPP_MONO:
+                lgray = 1;
+                lbpp = 2;
+                break;
+        case LDDFR_4BPP_MONO:
+                lgray = 1;
+        case LDDFR_4BPP:
+                lbpp = 4;
+                break;
+        case LDDFR_6BPP_MONO:
+                lgray = 1;
+        case LDDFR_8BPP:
+                lbpp = 8;
+                break;
+        case LDDFR_16BPP_RGB555:
+        case LDDFR_16BPP_RGB565:
+                lbpp = 16;
+                lgray = 0;
+                break;
+        default:
+                dev_dbg(dev, "unsupported LDDFR bit depth.\n");
+                return -EINVAL;
+        }
+
+        if (bpp)
+                *bpp = lbpp;
+        if (gray)
+                *gray = lgray;
+
+        return 0;
+}
+
+static int sh7760fb_check_var(struct fb_var_screeninfo *var,
+                              struct fb_info *info)
+{
+        struct fb_fix_screeninfo *fix = &info->fix;
+        struct sh7760fb_par *par = info->par;
+        int ret, bpp;
+
+        /* get color info from register value */
+        ret = sh7760fb_get_color_info(info->dev, par->pd->lddfr, &bpp, NULL);
+        if (ret)
+                return ret;
+
+        var->bits_per_pixel = bpp;
+
+        if ((var->grayscale) && (var->bits_per_pixel == 1))
+                fix->visual = FB_VISUAL_MONO10;
+        else if (var->bits_per_pixel >= 15)
+                fix->visual = FB_VISUAL_TRUECOLOR;
+        else
+                fix->visual = FB_VISUAL_PSEUDOCOLOR;
+
+        /* TODO: add some more validation here */
+        return 0;
+}
+
+/*
+ * sh7760fb_set_par - set videomode.
+ *
+ * NOTE: The rotation, grayscale and DSTN codepaths are
+ *     totally untested!
+ */
+static int sh7760fb_set_par(struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+        struct fb_videomode *vm = par->pd->def_mode;
+        unsigned long sbase, dstn_off, ldsarl, stride;
+        unsigned short hsynp, hsynw, htcn, hdcn;
+        unsigned short vsynp, vsynw, vtln, vdln;
+        unsigned short lddfr, ldmtr;
+        int ret, bpp, gray;
+
+        par->rot = par->pd->rotate;
+
+        /* rotate only works with xres <= 320 */
+        if (par->rot && (vm->xres > 320)) {
+                dev_dbg(info->dev, "rotation disabled due to display size\n");
+                par->rot = 0;
+        }
+
+        /* calculate LCDC reg vals from display parameters */
+        hsynp = vm->right_margin + vm->xres;
+        hsynw = vm->hsync_len;
+        htcn = vm->left_margin + hsynp + hsynw;
+        hdcn = vm->xres;
+        vsynp = vm->lower_margin + vm->yres;
+        vsynw = vm->vsync_len;
+        vtln = vm->upper_margin + vsynp + vsynw;
+        vdln = vm->yres;
+
+        /* get color info from register value */
+        ret = sh7760fb_get_color_info(info->dev, par->pd->lddfr, &bpp, &gray);
+        if (ret)
+                return ret;
+
+        dev_dbg(info->dev, "%dx%d %dbpp %s (orientation %s)\n", hdcn,
+                vdln, bpp, gray ? "grayscale" : "color",
+                par->rot ? "rotated" : "normal");
+
+#ifdef CONFIG_CPU_LITTLE_ENDIAN
+        lddfr = par->pd->lddfr | (1 << 8);
+#else
+        lddfr = par->pd->lddfr & ~(1 << 8);
+#endif
+
+        ldmtr = par->pd->ldmtr;
+
+        if (!(vm->sync & FB_SYNC_HOR_HIGH_ACT))
+                ldmtr |= LDMTR_CL1POL;
+        if (!(vm->sync & FB_SYNC_VERT_HIGH_ACT))
+                ldmtr |= LDMTR_FLMPOL;
+
+        /* shut down LCDC before changing display parameters */
+        sh7760fb_blank(FB_BLANK_POWERDOWN, info);
+
+        iowrite16(par->pd->ldickr, par->base + LDICKR); /* pixclock */
+        iowrite16(ldmtr, par->base + LDMTR);    /* polarities */
+        iowrite16(lddfr, par->base + LDDFR);    /* color/depth */
+        iowrite16((par->rot ? 1 << 13 : 0), par->base + LDSMR); /* rotate */
+        iowrite16(par->pd->ldpmmr, par->base + LDPMMR); /* Power Management */
+        iowrite16(par->pd->ldpspr, par->base + LDPSPR); /* Power Supply Ctrl */
+
+        /* display resolution */
+        iowrite16(((htcn >> 3) - 1) | (((hdcn >> 3) - 1) << 8),
+                  par->base + LDHCNR);
+        iowrite16(vdln - 1, par->base + LDVDLNR);
+        iowrite16(vtln - 1, par->base + LDVTLNR);
+        /* h/v sync signals */
+        iowrite16((vsynp - 1) | ((vsynw - 1) << 12), par->base + LDVSYNR);
+        iowrite16(((hsynp >> 3) - 1) | (((hsynw >> 3) - 1) << 12),
+                  par->base + LDHSYNR);
+        /* AC modulation sig */
+        iowrite16(par->pd->ldaclnr, par->base + LDACLNR);
+
+        stride = (par->rot) ? vtln : hdcn;
+        if (!gray)
+                stride *= (bpp + 7) >> 3;
+        else {
+                if (bpp == 1)
+                        stride >>= 3;
+                else if (bpp == 2)
+                        stride >>= 2;
+                else if (bpp == 4)
+                        stride >>= 1;
+                /* 6 bpp == 8 bpp */
+        }
+
+        /* if rotated, stride must be power of 2 */
+        if (par->rot) {
+                unsigned long bit = 1 << 31;
+                while (bit) {
+                        if (stride & bit)
+                                break;
+                        bit >>= 1;
+                }
+                if (stride & ~bit)
+                        stride = bit << 1;      /* not P-o-2, round up */
+        }
+        iowrite16(stride, par->base + LDLAOR);
+
+        /* set display mem start address */
+        sbase = (unsigned long)par->fbdma;
+        if (par->rot)
+                sbase += (hdcn - 1) * stride;
+
+        iowrite32(sbase, par->base + LDSARU);
+
+        /*
+         * for DSTN need to set address for lower half.
+         * I (mlau) don't know which address to set it to,
+         * so I guessed at (stride * yres/2).
+         */
+        if (((ldmtr & 0x003f) >= LDMTR_DSTN_MONO_8) &&
+            ((ldmtr & 0x003f) <= LDMTR_DSTN_COLOR_16)) {
+
+                dev_dbg(info->dev, " ***** DSTN untested! *****\n");
+
+                dstn_off = stride;
+                if (par->rot)
+                        dstn_off *= hdcn >> 1;
+                else
+                        dstn_off *= vdln >> 1;
+
+                ldsarl = sbase + dstn_off;
+        } else
+                ldsarl = 0;
+
+        iowrite32(ldsarl, par->base + LDSARL);  /* mem for lower half of DSTN */
+
+        encode_fix(&info->fix, info, stride);
+        sh7760fb_check_var(&info->var, info);
+
+        sh7760fb_blank(FB_BLANK_UNBLANK, info); /* panel on! */
+
+        dev_dbg(info->dev, "hdcn  : %6d htcn  : %6d\n", hdcn, htcn);
+        dev_dbg(info->dev, "hsynw : %6d hsynp : %6d\n", hsynw, hsynp);
+        dev_dbg(info->dev, "vdln  : %6d vtln  : %6d\n", vdln, vtln);
+        dev_dbg(info->dev, "vsynw : %6d vsynp : %6d\n", vsynw, vsynp);
+        dev_dbg(info->dev, "clksrc: %6d clkdiv: %6d\n",
+                (par->pd->ldickr >> 12) & 3, par->pd->ldickr & 0x1f);
+        dev_dbg(info->dev, "ldpmmr: 0x%04x ldpspr: 0x%04x\n", par->pd->ldpmmr,
+                par->pd->ldpspr);
+        dev_dbg(info->dev, "ldmtr : 0x%04x lddfr : 0x%04x\n", ldmtr, lddfr);
+        dev_dbg(info->dev, "ldlaor: %ld\n", stride);
+        dev_dbg(info->dev, "ldsaru: 0x%08lx ldsarl: 0x%08lx\n", sbase, ldsarl);
+
+        return 0;
+}
+
+static struct fb_ops sh7760fb_ops = {
+        .owner = THIS_MODULE,
+        .fb_blank = sh7760fb_blank,
+        .fb_check_var = sh7760fb_check_var,
+        .fb_setcmap = sh7760fb_setcmap,
+        .fb_set_par = sh7760fb_set_par,
+        .fb_fillrect = cfb_fillrect,
+        .fb_copyarea = cfb_copyarea,
+        .fb_imageblit = cfb_imageblit,
+};
+
+static void sh7760fb_free_mem(struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+
+        if (!info->screen_base)
+                return;
+
+        dma_free_coherent(info->dev, info->screen_size,
+                          info->screen_base, par->fbdma);
+
+        par->fbdma = 0;
+        info->screen_base = NULL;
+        info->screen_size = 0;
+}
+
+/* allocate the framebuffer memory. This memory must be in Area3,
+ * (dictated by the DMA engine) and contiguous, at a 512 byte boundary.
+ */
+static int sh7760fb_alloc_mem(struct fb_info *info)
+{
+        struct sh7760fb_par *par = info->par;
+        void *fbmem;
+        unsigned long vram;
+        int ret, bpp;
+
+        if (info->screen_base)
+                return 0;
+
+        /* get color info from register value */
+        ret = sh7760fb_get_color_info(info->dev, par->pd->lddfr, &bpp, NULL);
+        if (ret) {
+                printk(KERN_ERR "colinfo\n");
+                return ret;
+        }
+
+        /* min VRAM: xres_min = 16, yres_min = 1, bpp = 1: 2byte -> 1 page
+           max VRAM: xres_max = 1024, yres_max = 1024, bpp = 16: 2MB */
+
+        vram = info->var.xres * info->var.yres;
+        if (info->var.grayscale) {
+                if (bpp == 1)
+                        vram >>= 3;
+                else if (bpp == 2)
+                        vram >>= 2;
+                else if (bpp == 4)
+                        vram >>= 1;
+        } else if (bpp > 8)
+                vram *= 2;
+        if ((vram < 1) || (vram > 1024 * 2048)) {
+                dev_dbg(info->dev, "too much VRAM required. Check settings\n");
+                return -ENODEV;
+        }
+
+        if (vram < PAGE_SIZE)
+                vram = PAGE_SIZE;
+
+        fbmem = dma_alloc_coherent(info->dev, vram, &par->fbdma, GFP_KERNEL);
+
+        if (!fbmem)
+                return -ENOMEM;
+
+        if ((par->fbdma & SH7760FB_DMA_MASK) != SH7760FB_DMA_MASK) {
+                sh7760fb_free_mem(info);
+                dev_err(info->dev, "kernel gave me memory at 0x%08lx, which is"
+                        "unusable for the LCDC\n", (unsigned long)par->fbdma);
+                return -ENOMEM;
+        }
+
+        info->screen_base = fbmem;
+        info->screen_size = vram;
+
+        return 0;
+}
+
+static int __devinit sh7760fb_probe(struct platform_device *pdev)
+{
+        struct fb_info *info;
+        struct resource *res;
+        struct sh7760fb_par *par;
+        int ret;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (unlikely(res == NULL)) {
+                dev_err(&pdev->dev, "invalid resource\n");
+                return -EINVAL;
+        }
+
+        info = framebuffer_alloc(sizeof(struct sh7760fb_par), &pdev->dev);
+        if (!info)
+                return -ENOMEM;
+
+        par = info->par;
+        par->dev = pdev;
+
+        par->pd = pdev->dev.platform_data;
+        if (!par->pd) {
+                dev_dbg(info->dev, "no display setup data!\n");
+                ret = -ENODEV;
+                goto out_fb;
+        }
+
+        par->ioarea = request_mem_region(res->start,
+                                         (res->end - res->start), 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);
+        if (!par->base) {
+                dev_err(&pdev->dev, "cannot remap\n");
+                ret = -ENODEV;
+                goto out_res;
+        }
+
+        iowrite16(0, par->base + LDINTR);       /* disable vsync irq */
+        par->irq = platform_get_irq(pdev, 0);
+        if (par->irq >= 0) {
+                ret = request_irq(par->irq, sh7760fb_irq, 0,
+                                  "sh7760-lcdc", &par->vsync);
+                if (ret) {
+                        dev_err(&pdev->dev, "cannot grab IRQ\n");
+                        par->irq = -ENXIO;
+                } else
+                        disable_irq_nosync(par->irq);
+        }
+
+        fb_videomode_to_var(&info->var, par->pd->def_mode);
+
+        ret = sh7760fb_alloc_mem(info);
+        if (ret) {
+                dev_dbg(info->dev, "framebuffer memory allocation failed!\n");
+                goto out_unmap;
+        }
+
+        info->pseudo_palette = par->pseudo_palette;
+
+        /* fixup color register bitpositions. These are fixed by hardware */
+        info->var.red.offset = 11;
+        info->var.red.length = 5;
+        info->var.red.msb_right = 0;
+
+        info->var.green.offset = 5;
+        info->var.green.length = 6;
+        info->var.green.msb_right = 0;
+
+        info->var.blue.offset = 0;
+        info->var.blue.length = 5;
+        info->var.blue.msb_right = 0;
+
+        info->var.transp.offset = 0;
+        info->var.transp.length = 0;
+        info->var.transp.msb_right = 0;
+
+        /* set the DON2 bit now, before cmap allocation, as it will randomize
+         * palette memory.
+         */
+        iowrite16(LDCNTR_DON2, par->base + LDCNTR);
+        info->fbops = &sh7760fb_ops;
+
+        ret = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (ret) {
+                dev_dbg(info->dev, "Unable to allocate cmap memory\n");
+                goto out_mem;
+        }
+
+        ret = register_framebuffer(info);
+        if (ret < 0) {
+                dev_dbg(info->dev, "cannot register fb!\n");
+                goto out_cmap;
+        }
+        platform_set_drvdata(pdev, info);
+
+        printk(KERN_INFO "%s: memory at phys 0x%08lx-0x%08lx, size %ld KiB\n",
+               pdev->name,
+               (unsigned long)par->fbdma,
+               (unsigned long)(par->fbdma + info->screen_size - 1),
+               info->screen_size >> 10);
+
+        return 0;
+
+out_cmap:
+        sh7760fb_blank(FB_BLANK_POWERDOWN, info);
+        fb_dealloc_cmap(&info->cmap);
+out_mem:
+        sh7760fb_free_mem(info);
+out_unmap:
+        if (par->irq >= 0)
+                free_irq(par->irq, &par->vsync);
+        iounmap(par->base);
+out_res:
+        release_resource(par->ioarea);
+        kfree(par->ioarea);
+out_fb:
+        framebuffer_release(info);
+        return ret;
+}
+
+static int __devexit sh7760fb_remove(struct platform_device *dev)
+{
+        struct fb_info *info = platform_get_drvdata(dev);
+        struct sh7760fb_par *par = info->par;
+
+        sh7760fb_blank(FB_BLANK_POWERDOWN, info);
+        unregister_framebuffer(info);
+        fb_dealloc_cmap(&info->cmap);
+        sh7760fb_free_mem(info);
+        if (par->irq >= 0)
+                free_irq(par->irq, par);
+        iounmap(par->base);
+        release_resource(par->ioarea);
+        kfree(par->ioarea);
+        framebuffer_release(info);
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver sh7760_lcdc_driver = {
+        .driver = {
+                   .name = "sh7760-lcdc",
+                   .owner = THIS_MODULE,
+                   },
+        .probe = sh7760fb_probe,
+        .remove = __devexit_p(sh7760fb_remove),
+};
+
+static int __init sh7760fb_init(void)
+{
+        return platform_driver_register(&sh7760_lcdc_driver);
+}
+
+static void __exit sh7760fb_exit(void)
+{
+        platform_driver_unregister(&sh7760_lcdc_driver);
+}
+
+module_init(sh7760fb_init);
+module_exit(sh7760fb_exit);
+
+MODULE_AUTHOR("Nobuhiro Iwamatsu, Manuel Lauss");
+MODULE_DESCRIPTION("FBdev for SH7760/63 integrated LCD Controller");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
new file mode 100644
index 000000000000..4c32c06579a0
--- /dev/null
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -0,0 +1,727 @@
+/*
+ * SuperH Mobile LCDC Framebuffer
+ *
+ * Copyright (c) 2008 Magnus Damm
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <asm/sh_mobile_lcdc.h>
+
+#define PALETTE_NR 16
+
+struct sh_mobile_lcdc_priv;
+struct sh_mobile_lcdc_chan {
+        struct sh_mobile_lcdc_priv *lcdc;
+        unsigned long *reg_offs;
+        unsigned long ldmt1r_value;
+        unsigned long enabled; /* ME and SE in LDCNT2R */
+        struct sh_mobile_lcdc_chan_cfg cfg;
+        u32 pseudo_palette[PALETTE_NR];
+        struct fb_info info;
+        dma_addr_t dma_handle;
+};
+
+struct sh_mobile_lcdc_priv {
+        void __iomem *base;
+        struct clk *clk;
+        unsigned long lddckr;
+        struct sh_mobile_lcdc_chan ch[2];
+};
+
+/* shared registers */
+#define _LDDCKR 0x410
+#define _LDDCKSTPR 0x414
+#define _LDINTR 0x468
+#define _LDSR 0x46c
+#define _LDCNT1R 0x470
+#define _LDCNT2R 0x474
+#define _LDDDSR 0x47c
+#define _LDDWD0R 0x800
+#define _LDDRDR 0x840
+#define _LDDWAR 0x900
+#define _LDDRAR 0x904
+
+/* per-channel registers */
+enum { LDDCKPAT1R, LDDCKPAT2R, LDMT1R, LDMT2R, LDMT3R, LDDFR, LDSM1R,
+       LDSA1R, LDMLSR, LDHCNR, LDHSYNR, LDVLNR, LDVSYNR, LDPMR };
+
+static unsigned long lcdc_offs_mainlcd[] = {
+        [LDDCKPAT1R] = 0x400,
+        [LDDCKPAT2R] = 0x404,
+        [LDMT1R] = 0x418,
+        [LDMT2R] = 0x41c,
+        [LDMT3R] = 0x420,
+        [LDDFR] = 0x424,
+        [LDSM1R] = 0x428,
+        [LDSA1R] = 0x430,
+        [LDMLSR] = 0x438,
+        [LDHCNR] = 0x448,
+        [LDHSYNR] = 0x44c,
+        [LDVLNR] = 0x450,
+        [LDVSYNR] = 0x454,
+        [LDPMR] = 0x460,
+};
+
+static unsigned long lcdc_offs_sublcd[] = {
+        [LDDCKPAT1R] = 0x408,
+        [LDDCKPAT2R] = 0x40c,
+        [LDMT1R] = 0x600,
+        [LDMT2R] = 0x604,
+        [LDMT3R] = 0x608,
+        [LDDFR] = 0x60c,
+        [LDSM1R] = 0x610,
+        [LDSA1R] = 0x618,
+        [LDMLSR] = 0x620,
+        [LDHCNR] = 0x624,
+        [LDHSYNR] = 0x628,
+        [LDVLNR] = 0x62c,
+        [LDVSYNR] = 0x630,
+        [LDPMR] = 0x63c,
+};
+
+#define START_LCDC      0x00000001
+#define LCDC_RESET      0x00000100
+#define DISPLAY_BEU     0x00000008
+#define LCDC_ENABLE     0x00000001
+
+static void lcdc_write_chan(struct sh_mobile_lcdc_chan *chan,
+                            int reg_nr, unsigned long data)
+{
+        iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr]);
+}
+
+static unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan *chan,
+                                    int reg_nr)
+{
+        return ioread32(chan->lcdc->base + chan->reg_offs[reg_nr]);
+}
+
+static void lcdc_write(struct sh_mobile_lcdc_priv *priv,
+                       unsigned long reg_offs, unsigned long data)
+{
+        iowrite32(data, priv->base + reg_offs);
+}
+
+static unsigned long lcdc_read(struct sh_mobile_lcdc_priv *priv,
+                               unsigned long reg_offs)
+{
+        return ioread32(priv->base + reg_offs);
+}
+
+static void lcdc_wait_bit(struct sh_mobile_lcdc_priv *priv,
+                          unsigned long reg_offs,
+                          unsigned long mask, unsigned long until)
+{
+        while ((lcdc_read(priv, reg_offs) & mask) != until)
+                cpu_relax();
+}
+
+static int lcdc_chan_is_sublcd(struct sh_mobile_lcdc_chan *chan)
+{
+        return chan->cfg.chan == LCDC_CHAN_SUBLCD;
+}
+
+static void lcdc_sys_write_index(void *handle, unsigned long data)
+{
+        struct sh_mobile_lcdc_chan *ch = handle;
+
+        lcdc_write(ch->lcdc, _LDDWD0R, data | 0x10000000);
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
+        lcdc_write(ch->lcdc, _LDDWAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
+}
+
+static void lcdc_sys_write_data(void *handle, unsigned long data)
+{
+        struct sh_mobile_lcdc_chan *ch = handle;
+
+        lcdc_write(ch->lcdc, _LDDWD0R, data | 0x11000000);
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
+        lcdc_write(ch->lcdc, _LDDWAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
+}
+
+static unsigned long lcdc_sys_read_data(void *handle)
+{
+        struct sh_mobile_lcdc_chan *ch = handle;
+
+        lcdc_write(ch->lcdc, _LDDRDR, 0x01000000);
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
+        lcdc_write(ch->lcdc, _LDDRAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
+        udelay(1);
+
+        return lcdc_read(ch->lcdc, _LDDRDR) & 0xffff;
+}
+
+struct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops = {
+        lcdc_sys_write_index,
+        lcdc_sys_write_data,
+        lcdc_sys_read_data,
+};
+
+static void sh_mobile_lcdc_start_stop(struct sh_mobile_lcdc_priv *priv,
+                                      int start)
+{
+        unsigned long tmp = lcdc_read(priv, _LDCNT2R);
+        int k;
+
+        /* start or stop the lcdc */
+        if (start)
+                lcdc_write(priv, _LDCNT2R, tmp | START_LCDC);
+        else
+                lcdc_write(priv, _LDCNT2R, tmp & ~START_LCDC);
+
+        /* wait until power is applied/stopped on all channels */
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++)
+                if (lcdc_read(priv, _LDCNT2R) & priv->ch[k].enabled)
+                        while (1) {
+                                tmp = lcdc_read_chan(&priv->ch[k], LDPMR) & 3;
+                                if (start && tmp == 3)
+                                        break;
+                                if (!start && tmp == 0)
+                                        break;
+                                cpu_relax();
+                        }
+
+        if (!start)
+                lcdc_write(priv, _LDDCKSTPR, 1); /* stop dotclock */
+}
+
+static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
+{
+        struct sh_mobile_lcdc_chan *ch;
+        struct fb_videomode *lcd_cfg;
+        struct sh_mobile_lcdc_board_cfg *board_cfg;
+        unsigned long tmp;
+        int k, m;
+        int ret = 0;
+
+        /* reset */
+        lcdc_write(priv, _LDCNT2R, lcdc_read(priv, _LDCNT2R) | LCDC_RESET);
+        lcdc_wait_bit(priv, _LDCNT2R, LCDC_RESET, 0);
+
+        /* enable LCDC channels */
+        tmp = lcdc_read(priv, _LDCNT2R);
+        tmp |= priv->ch[0].enabled;
+        tmp |= priv->ch[1].enabled;
+        lcdc_write(priv, _LDCNT2R, tmp);
+
+        /* read data from external memory, avoid using the BEU for now */
+        lcdc_write(priv, _LDCNT2R, lcdc_read(priv, _LDCNT2R) & ~DISPLAY_BEU);
+
+        /* stop the lcdc first */
+        sh_mobile_lcdc_start_stop(priv, 0);
+
+        /* configure clocks */
+        tmp = priv->lddckr;
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+
+                if (!priv->ch[k].enabled)
+                        continue;
+
+                m = ch->cfg.clock_divider;
+                if (!m)
+                        continue;
+
+                if (m == 1)
+                        m = 1 << 6;
+                tmp |= m << (lcdc_chan_is_sublcd(ch) ? 8 : 0);
+
+                lcdc_write_chan(ch, LDDCKPAT1R, 0x00000000);
+                lcdc_write_chan(ch, LDDCKPAT2R, (1 << (m/2)) - 1);
+        }
+
+        lcdc_write(priv, _LDDCKR, tmp);
+
+        /* start dotclock again */
+        lcdc_write(priv, _LDDCKSTPR, 0);
+        lcdc_wait_bit(priv, _LDDCKSTPR, ~0, 0);
+
+        /* interrupts are disabled */
+        lcdc_write(priv, _LDINTR, 0);
+
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+                lcd_cfg = &ch->cfg.lcd_cfg;
+
+                if (!ch->enabled)
+                        continue;
+
+                tmp = ch->ldmt1r_value;
+                tmp |= (lcd_cfg->sync & FB_SYNC_VERT_HIGH_ACT) ? 0 : 1 << 28;
+                tmp |= (lcd_cfg->sync & FB_SYNC_HOR_HIGH_ACT) ? 0 : 1 << 27;
+                lcdc_write_chan(ch, LDMT1R, tmp);
+
+                /* setup SYS bus */
+                lcdc_write_chan(ch, LDMT2R, ch->cfg.sys_bus_cfg.ldmt2r);
+                lcdc_write_chan(ch, LDMT3R, ch->cfg.sys_bus_cfg.ldmt3r);
+
+                /* horizontal configuration */
+                tmp = lcd_cfg->xres + lcd_cfg->hsync_len;
+                tmp += lcd_cfg->left_margin;
+                tmp += lcd_cfg->right_margin;
+                tmp /= 8; /* HTCN */
+                tmp |= (lcd_cfg->xres / 8) << 16; /* HDCN */
+                lcdc_write_chan(ch, LDHCNR, tmp);
+
+                tmp = lcd_cfg->xres;
+                tmp += lcd_cfg->right_margin;
+                tmp /= 8; /* HSYNP */
+                tmp |= (lcd_cfg->hsync_len / 8) << 16; /* HSYNW */
+                lcdc_write_chan(ch, LDHSYNR, tmp);
+
+                /* power supply */
+                lcdc_write_chan(ch, LDPMR, 0);
+
+                /* vertical configuration */
+                tmp = lcd_cfg->yres + lcd_cfg->vsync_len;
+                tmp += lcd_cfg->upper_margin;
+                tmp += lcd_cfg->lower_margin; /* VTLN */
+                tmp |= lcd_cfg->yres << 16; /* VDLN */
+                lcdc_write_chan(ch, LDVLNR, tmp);
+
+                tmp = lcd_cfg->yres;
+                tmp += lcd_cfg->lower_margin; /* VSYNP */
+                tmp |= lcd_cfg->vsync_len << 16; /* VSYNW */
+                lcdc_write_chan(ch, LDVSYNR, tmp);
+
+                board_cfg = &ch->cfg.board_cfg;
+                if (board_cfg->setup_sys)
+                        ret = board_cfg->setup_sys(board_cfg->board_data, ch,
+                                                   &sh_mobile_lcdc_sys_bus_ops);
+                if (ret)
+                        return ret;
+        }
+
+        /* --- display_lcdc_data() --- */
+        lcdc_write(priv, _LDINTR, 0x00000f00);
+
+        /* word and long word swap */
+        lcdc_write(priv, _LDDDSR, lcdc_read(priv, _LDDDSR) | 6);
+
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+
+                if (!priv->ch[k].enabled)
+                        continue;
+
+                /* set bpp format in PKF[4:0] */
+                tmp = lcdc_read_chan(ch, LDDFR);
+                tmp &= ~(0x0001001f);
+                tmp |= (priv->ch[k].info.var.bits_per_pixel == 16) ? 3 : 0;
+                lcdc_write_chan(ch, LDDFR, tmp);
+
+                /* point out our frame buffer */
+                lcdc_write_chan(ch, LDSA1R, ch->info.fix.smem_start);
+
+                /* set line size */
+                lcdc_write_chan(ch, LDMLSR, ch->info.fix.line_length);
+
+                /* continuous read mode */
+                lcdc_write_chan(ch, LDSM1R, 0);
+        }
+
+        /* display output */
+        lcdc_write(priv, _LDCNT1R, LCDC_ENABLE);
+
+        /* start the lcdc */
+        sh_mobile_lcdc_start_stop(priv, 1);
+
+        /* tell the board code to enable the panel */
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+                board_cfg = &ch->cfg.board_cfg;
+                if (board_cfg->display_on)
+                        board_cfg->display_on(board_cfg->board_data);
+        }
+
+        return 0;
+}
+
+static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
+{
+        struct sh_mobile_lcdc_chan *ch;
+        struct sh_mobile_lcdc_board_cfg *board_cfg;
+        int k;
+
+        /* tell the board code to disable the panel */
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+                board_cfg = &ch->cfg.board_cfg;
+                if (board_cfg->display_off)
+                        board_cfg->display_off(board_cfg->board_data);
+        }
+
+        /* stop the lcdc */
+        sh_mobile_lcdc_start_stop(priv, 0);
+}
+
+static int sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *ch)
+{
+        int ifm, miftyp;
+
+        switch (ch->cfg.interface_type) {
+        case RGB8: ifm = 0; miftyp = 0; break;
+        case RGB9: ifm = 0; miftyp = 4; break;
+        case RGB12A: ifm = 0; miftyp = 5; break;
+        case RGB12B: ifm = 0; miftyp = 6; break;
+        case RGB16: ifm = 0; miftyp = 7; break;
+        case RGB18: ifm = 0; miftyp = 10; break;
+        case RGB24: ifm = 0; miftyp = 11; break;
+        case SYS8A: ifm = 1; miftyp = 0; break;
+        case SYS8B: ifm = 1; miftyp = 1; break;
+        case SYS8C: ifm = 1; miftyp = 2; break;
+        case SYS8D: ifm = 1; miftyp = 3; break;
+        case SYS9: ifm = 1; miftyp = 4; break;
+        case SYS12: ifm = 1; miftyp = 5; break;
+        case SYS16A: ifm = 1; miftyp = 7; break;
+        case SYS16B: ifm = 1; miftyp = 8; break;
+        case SYS16C: ifm = 1; miftyp = 9; break;
+        case SYS18: ifm = 1; miftyp = 10; break;
+        case SYS24: ifm = 1; miftyp = 11; break;
+        default: goto bad;
+        }
+
+        /* SUBLCD only supports SYS interface */
+        if (lcdc_chan_is_sublcd(ch)) {
+                if (ifm == 0)
+                        goto bad;
+                else
+                        ifm = 0;
+        }
+
+        ch->ldmt1r_value = (ifm << 12) | miftyp;
+        return 0;
+ bad:
+        return -EINVAL;
+}
+
+static int sh_mobile_lcdc_setup_clocks(struct device *dev, int clock_source,
+                                       struct sh_mobile_lcdc_priv *priv)
+{
+        char *str;
+        int icksel;
+
+        switch (clock_source) {
+        case LCDC_CLK_BUS: str = "bus_clk"; icksel = 0; break;
+        case LCDC_CLK_PERIPHERAL: str = "peripheral_clk"; icksel = 1; break;
+        case LCDC_CLK_EXTERNAL: str = NULL; icksel = 2; break;
+        default:
+                return -EINVAL;
+        }
+
+        priv->lddckr = icksel << 16;
+
+        if (str) {
+                priv->clk = clk_get(dev, str);
+                if (IS_ERR(priv->clk)) {
+                        dev_err(dev, "cannot get clock %s\n", str);
+                        return PTR_ERR(priv->clk);
+                }
+
+                clk_enable(priv->clk);
+        }
+
+        return 0;
+}
+
+static int sh_mobile_lcdc_setcolreg(u_int regno,
+                                    u_int red, u_int green, u_int blue,
+                                    u_int transp, struct fb_info *info)
+{
+        u32 *palette = info->pseudo_palette;
+
+        if (regno >= PALETTE_NR)
+                return -EINVAL;
+
+        /* only FB_VISUAL_TRUECOLOR supported */
+
+        red >>= 16 - info->var.red.length;
+        green >>= 16 - info->var.green.length;
+        blue >>= 16 - info->var.blue.length;
+        transp >>= 16 - info->var.transp.length;
+
+        palette[regno] = (red << info->var.red.offset) |
+          (green << info->var.green.offset) |
+          (blue << info->var.blue.offset) |
+          (transp << info->var.transp.offset);
+
+        return 0;
+}
+
+static struct fb_fix_screeninfo sh_mobile_lcdc_fix  = {
+        .id =           "SH Mobile LCDC",
+        .type =         FB_TYPE_PACKED_PIXELS,
+        .visual =       FB_VISUAL_TRUECOLOR,
+        .accel =        FB_ACCEL_NONE,
+};
+
+static struct fb_ops sh_mobile_lcdc_ops = {
+        .fb_setcolreg   = sh_mobile_lcdc_setcolreg,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+};
+
+static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo *var, int bpp)
+{
+        switch (bpp) {
+        case 16: /* PKF[4:0] = 00011 - RGB 565 */
+                var->red.offset = 11;
+                var->red.length = 5;
+                var->green.offset = 5;
+                var->green.length = 6;
+                var->blue.offset = 0;
+                var->blue.length = 5;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                break;
+
+        case 32: /* PKF[4:0] = 00000 - RGB 888
+                  * sh7722 pdf says 00RRGGBB but reality is GGBB00RR
+                  * this may be because LDDDSR has word swap enabled..
+                  */
+                var->red.offset = 0;
+                var->red.length = 8;
+                var->green.offset = 24;
+                var->green.length = 8;
+                var->blue.offset = 16;
+                var->blue.length = 8;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+        var->bits_per_pixel = bpp;
+        var->red.msb_right = 0;
+        var->green.msb_right = 0;
+        var->blue.msb_right = 0;
+        var->transp.msb_right = 0;
+        return 0;
+}
+
+static int sh_mobile_lcdc_remove(struct platform_device *pdev);
+
+static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
+{
+        struct fb_info *info;
+        struct sh_mobile_lcdc_priv *priv;
+        struct sh_mobile_lcdc_info *pdata;
+        struct sh_mobile_lcdc_chan_cfg *cfg;
+        struct resource *res;
+        int error;
+        void *buf;
+        int i, j;
+
+        if (!pdev->dev.platform_data) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                error = -EINVAL;
+                goto err0;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "cannot find IO resource\n");
+                error = -ENOENT;
+                goto err0;
+        }
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "cannot allocate device data\n");
+                error = -ENOMEM;
+                goto err0;
+        }
+
+        platform_set_drvdata(pdev, priv);
+        pdata = pdev->dev.platform_data;
+
+        j = 0;
+        for (i = 0; i < ARRAY_SIZE(pdata->ch); i++) {
+                priv->ch[j].lcdc = priv;
+                memcpy(&priv->ch[j].cfg, &pdata->ch[i], sizeof(pdata->ch[i]));
+
+                error = sh_mobile_lcdc_check_interface(&priv->ch[i]);
+                if (error) {
+                        dev_err(&pdev->dev, "unsupported interface type\n");
+                        goto err1;
+                }
+
+                switch (pdata->ch[i].chan) {
+                case LCDC_CHAN_MAINLCD:
+                        priv->ch[j].enabled = 1 << 1;
+                        priv->ch[j].reg_offs = lcdc_offs_mainlcd;
+                        j++;
+                        break;
+                case LCDC_CHAN_SUBLCD:
+                        priv->ch[j].enabled = 1 << 2;
+                        priv->ch[j].reg_offs = lcdc_offs_sublcd;
+                        j++;
+                        break;
+                }
+        }
+
+        if (!j) {
+                dev_err(&pdev->dev, "no channels defined\n");
+                error = -EINVAL;
+                goto err1;
+        }
+
+        error = sh_mobile_lcdc_setup_clocks(&pdev->dev,
+                                            pdata->clock_source, priv);
+        if (error) {
+                dev_err(&pdev->dev, "unable to setup clocks\n");
+                goto err1;
+        }
+
+        priv->lddckr = pdata->lddckr;
+        priv->base = ioremap_nocache(res->start, (res->end - res->start) + 1);
+
+        for (i = 0; i < j; i++) {
+                info = &priv->ch[i].info;
+                cfg = &priv->ch[i].cfg;
+
+                info->fbops = &sh_mobile_lcdc_ops;
+                info->var.xres = info->var.xres_virtual = cfg->lcd_cfg.xres;
+                info->var.yres = info->var.yres_virtual = cfg->lcd_cfg.yres;
+                info->var.width = cfg->lcd_size_cfg.width;
+                info->var.height = cfg->lcd_size_cfg.height;
+                info->var.activate = FB_ACTIVATE_NOW;
+                error = sh_mobile_lcdc_set_bpp(&info->var, cfg->bpp);
+                if (error)
+                        break;
+
+                info->fix = sh_mobile_lcdc_fix;
+                info->fix.line_length = cfg->lcd_cfg.xres * (cfg->bpp / 8);
+                info->fix.smem_len = info->fix.line_length * cfg->lcd_cfg.yres;
+
+                buf = dma_alloc_coherent(&pdev->dev, info->fix.smem_len,
+                                         &priv->ch[i].dma_handle, GFP_KERNEL);
+                if (!buf) {
+                        dev_err(&pdev->dev, "unable to allocate buffer\n");
+                        error = -ENOMEM;
+                        break;
+                }
+
+                info->pseudo_palette = &priv->ch[i].pseudo_palette;
+                info->flags = FBINFO_FLAG_DEFAULT;
+
+                error = fb_alloc_cmap(&info->cmap, PALETTE_NR, 0);
+                if (error < 0) {
+                        dev_err(&pdev->dev, "unable to allocate cmap\n");
+                        dma_free_coherent(&pdev->dev, info->fix.smem_len,
+                                          buf, priv->ch[i].dma_handle);
+                        break;
+                }
+
+                memset(buf, 0, info->fix.smem_len);
+                info->fix.smem_start = priv->ch[i].dma_handle;
+                info->screen_base = buf;
+                info->device = &pdev->dev;
+        }
+
+        if (error)
+                goto err1;
+
+        error = sh_mobile_lcdc_start(priv);
+        if (error) {
+                dev_err(&pdev->dev, "unable to start hardware\n");
+                goto err1;
+        }
+
+        for (i = 0; i < j; i++) {
+                error = register_framebuffer(&priv->ch[i].info);
+                if (error < 0)
+                        goto err1;
+        }
+
+        for (i = 0; i < j; i++) {
+                info = &priv->ch[i].info;
+                dev_info(info->dev,
+                         "registered %s/%s as %dx%d %dbpp.\n",
+                         pdev->name,
+                         (priv->ch[i].cfg.chan == LCDC_CHAN_MAINLCD) ?
+                         "mainlcd" : "sublcd",
+                         (int) priv->ch[i].cfg.lcd_cfg.xres,
+                         (int) priv->ch[i].cfg.lcd_cfg.yres,
+                         priv->ch[i].cfg.bpp);
+        }
+
+        return 0;
+ err1:
+        sh_mobile_lcdc_remove(pdev);
+ err0:
+        return error;
+}
+
+static int sh_mobile_lcdc_remove(struct platform_device *pdev)
+{
+        struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev);
+        struct fb_info *info;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(priv->ch); i++)
+                if (priv->ch[i].info.dev)
+                        unregister_framebuffer(&priv->ch[i].info);
+
+        sh_mobile_lcdc_stop(priv);
+
+        for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
+                info = &priv->ch[i].info;
+
+                if (!info->device)
+                        continue;
+
+                dma_free_coherent(&pdev->dev, info->fix.smem_len,
+                                  info->screen_base, priv->ch[i].dma_handle);
+                fb_dealloc_cmap(&info->cmap);
+        }
+
+        if (priv->clk) {
+                clk_disable(priv->clk);
+                clk_put(priv->clk);
+        }
+
+        if (priv->base)
+                iounmap(priv->base);
+
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver sh_mobile_lcdc_driver = {
+        .driver         = {
+                .name           = "sh_mobile_lcdc_fb",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = sh_mobile_lcdc_probe,
+        .remove         = sh_mobile_lcdc_remove,
+};
+
+static int __init sh_mobile_lcdc_init(void)
+{
+        return platform_driver_register(&sh_mobile_lcdc_driver);
+}
+
+static void __exit sh_mobile_lcdc_exit(void)
+{
+        platform_driver_unregister(&sh_mobile_lcdc_driver);
+}
+
+module_init(sh_mobile_lcdc_init);
+module_exit(sh_mobile_lcdc_exit);
+
+MODULE_DESCRIPTION("SuperH Mobile LCDC Framebuffer driver");
+MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/sis/init.h b/drivers/video/sis/init.h
index f40a680df86f..b96005c39c67 100644
--- a/drivers/video/sis/init.h
+++ b/drivers/video/sis/init.h
@@ -73,7 +73,6 @@
 #ifdef SIS_CP
 #undef SIS_CP
 #endif
-#include <linux/version.h>
 #include <linux/types.h>
 #include <asm/io.h>
 #include <linux/fb.h>
diff --git a/drivers/video/sis/init301.h b/drivers/video/sis/init301.h
index 7708e1e1d99e..51d99222375d 100644
--- a/drivers/video/sis/init301.h
+++ b/drivers/video/sis/init301.h
@@ -67,7 +67,6 @@
 #ifdef SIS_CP
 #undef SIS_CP
 #endif
-#include <linux/version.h>
 #include <linux/types.h>
 #include <asm/io.h>
 #include <linux/fb.h>
diff --git a/drivers/video/sis/initextlfb.c b/drivers/video/sis/initextlfb.c
index 47a33501549d..99c04a4855d1 100644
--- a/drivers/video/sis/initextlfb.c
+++ b/drivers/video/sis/initextlfb.c
@@ -30,7 +30,6 @@
 #include "vgatypes.h"
 #include "vstruct.h"
 
-#include <linux/version.h>
 #include <linux/types.h>
 #include <linux/fb.h>
 
diff --git a/drivers/video/sis/osdef.h b/drivers/video/sis/osdef.h
index c1492782cb18..6ff8f988a1a7 100644
--- a/drivers/video/sis/osdef.h
+++ b/drivers/video/sis/osdef.h
@@ -87,7 +87,6 @@
 /**********************************************************************/
 
 #ifdef SIS_LINUX_KERNEL
-#include <linux/version.h>
 
 #ifdef CONFIG_FB_SIS_300
 #define SIS300
diff --git a/drivers/video/sis/sis.h b/drivers/video/sis/sis.h
index a14e82211037..7c5710e3fb56 100644
--- a/drivers/video/sis/sis.h
+++ b/drivers/video/sis/sis.h
@@ -24,8 +24,6 @@
 #ifndef _SIS_H_
 #define _SIS_H_
 
-#include <linux/version.h>
-
 #include "osdef.h"
 #include <video/sisfb.h>
 
@@ -42,16 +40,6 @@
 #define SIS_NEW_CONFIG_COMPAT
 #endif  /* CONFIG_COMPAT */
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
-#define SIS_IOTYPE1 void __iomem
-#define SIS_IOTYPE2 __iomem
-#define SISINITSTATIC static
-#else
-#define SIS_IOTYPE1 unsigned char
-#define SIS_IOTYPE2
-#define SISINITSTATIC
-#endif
-
 #undef SISFBDEBUG
 
 #ifdef SISFBDEBUG
@@ -505,8 +493,8 @@ struct sis_video_info {
 
         unsigned long   UMAsize, LFBsize;
 
-        SIS_IOTYPE1     *video_vbase;
-        SIS_IOTYPE1     *mmio_vbase;
+        void __iomem    *video_vbase;
+        void __iomem    *mmio_vbase;
 
         unsigned char   *bios_abase;
 
@@ -533,8 +521,8 @@ struct sis_video_info {
         int             sisfb_nocrt2rate;
 
         u32             heapstart;              /* offset  */
-        SIS_IOTYPE1     *sisfb_heap_start;      /* address */
-        SIS_IOTYPE1     *sisfb_heap_end;        /* address */
+        void __iomem    *sisfb_heap_start;      /* address */
+        void __iomem    *sisfb_heap_end;        /* address */
         u32             sisfb_heap_size;
         int             havenoheap;
 
@@ -612,7 +600,7 @@ struct sis_video_info {
         u8              detectedpdca;
         u8              detectedlcda;
 
-        SIS_IOTYPE1     *hwcursor_vbase;
+        void __iomem    *hwcursor_vbase;
 
         int             chronteltype;
         int             tvxpos, tvypos;
diff --git a/drivers/video/sis/sis_accel.c b/drivers/video/sis/sis_accel.c
index 7addf91d2fea..ceb434c95c0d 100644
--- a/drivers/video/sis/sis_accel.c
+++ b/drivers/video/sis/sis_accel.c
@@ -28,7 +28,6 @@
  *                      for more information and updates)
  */
 
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/fb.h>
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index b9343844cd1f..346d6458cf76 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -33,7 +33,6 @@
  *
  */
 
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kernel.h>
@@ -41,13 +40,7 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
-#include <linux/tty.h>
-#else
 #include <linux/screen_info.h>
-#endif
-
 #include <linux/slab.h>
 #include <linux/fb.h>
 #include <linux/selection.h>
@@ -1167,11 +1160,7 @@ sisfb_set_mode(struct sis_video_info *ivideo, int clrscrn)
         unsigned short modeno = ivideo->mode_no;
 
         /* >=2.6.12's fbcon clears the screen anyway */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
-        if(!clrscrn) modeno |= 0x80;
-#else
         modeno |= 0x80;
-#endif
 
         outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
 
@@ -1436,11 +1425,8 @@ sisfb_set_par(struct fb_info *info)
         if((err = sisfb_do_set_var(&info->var, 1, info)))
                 return err;
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
-        sisfb_get_fix(&info->fix, info->currcon, info);
-#else
         sisfb_get_fix(&info->fix, -1, info);
-#endif
+
         return 0;
 }
 
@@ -1676,14 +1662,8 @@ sisfb_blank(int blank, struct fb_info *info)
 
 /* ----------- FBDev related routines for all series ---------- */
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
 static int      sisfb_ioctl(struct fb_info *info, unsigned int cmd,
                             unsigned long arg)
-#else
-static int      sisfb_ioctl(struct inode *inode, struct file *file,
-                                unsigned int cmd, unsigned long arg,
-                                struct fb_info *info)
-#endif
 {
         struct sis_video_info   *ivideo = (struct sis_video_info *)info->par;
         struct sis_memreq       sismemreq;
@@ -3986,8 +3966,7 @@ sisfb_handle_command(struct sis_video_info *ivideo, struct sisfb_cmd *sisfb_comm
 }
 
 #ifndef MODULE
-SISINITSTATIC int __init
-sisfb_setup(char *options)
+static int __init sisfb_setup(char *options)
 {
         char *this_opt;
 
@@ -4086,9 +4065,9 @@ sisfb_setup(char *options)
 #endif
 
 static int __devinit
-sisfb_check_rom(SIS_IOTYPE1 *rom_base, struct sis_video_info *ivideo)
+sisfb_check_rom(void __iomem *rom_base, struct sis_video_info *ivideo)
 {
-        SIS_IOTYPE1 *rom;
+        void __iomem *rom;
         int romptr;
 
         if((readb(rom_base) != 0x55) || (readb(rom_base + 1) != 0xaa))
@@ -4117,10 +4096,9 @@ static unsigned char * __devinit
 sisfb_find_rom(struct pci_dev *pdev)
 {
         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
-        SIS_IOTYPE1 *rom_base;
+        void __iomem *rom_base;
         unsigned char *myrombase = NULL;
         u32 temp;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
         size_t romsize;
 
         /* First, try the official pci ROM functions (except
@@ -4151,7 +4129,6 @@ sisfb_find_rom(struct pci_dev *pdev)
         }
 
         if(myrombase) return myrombase;
-#endif
 
         /* Otherwise do it the conventional way. */
 
@@ -4225,7 +4202,7 @@ sisfb_post_map_vram(struct sis_video_info *ivideo, unsigned int *mapsize,
 static int __devinit
 sisfb_post_300_buswidth(struct sis_video_info *ivideo)
 {
-        SIS_IOTYPE1 *FBAddress = ivideo->video_vbase;
+        void __iomem *FBAddress = ivideo->video_vbase;
         unsigned short temp;
         unsigned char reg;
         int i, j;
@@ -4273,7 +4250,7 @@ sisfb_post_300_rwtest(struct sis_video_info *ivideo, int iteration, int buswidth
                         int PseudoRankCapacity, int PseudoAdrPinCount,
                         unsigned int mapsize)
 {
-        SIS_IOTYPE1 *FBAddr = ivideo->video_vbase;
+        void __iomem *FBAddr = ivideo->video_vbase;
         unsigned short sr14;
         unsigned int k, RankCapacity, PageCapacity, BankNumHigh, BankNumMid;
         unsigned int PhysicalAdrOtherPage, PhysicalAdrHigh, PhysicalAdrHalfPage;
@@ -5829,7 +5806,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         ivideo->engineok = 0;
 
         ivideo->sisfb_was_boot_device = 0;
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
+
         if(pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) {
                 if(ivideo->sisvga_enabled)
                         ivideo->sisfb_was_boot_device = 1;
@@ -5840,7 +5817,6 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                 "as the primary VGA device\n");
                 }
         }
-#endif
 
         ivideo->sisfb_parm_mem = sisfb_parm_mem;
         ivideo->sisfb_accel = sisfb_accel;
@@ -6010,7 +5986,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 ivideo->modeprechange = reg & 0x7f;
         } else if(ivideo->sisvga_enabled) {
 #if defined(__i386__) || defined(__x86_64__)
-                unsigned char SIS_IOTYPE2 *tt = ioremap(0x400, 0x100);
+                unsigned char __iomem *tt = ioremap(0x400, 0x100);
                 if(tt) {
                         ivideo->modeprechange = readb(tt + 0x49);
                         iounmap(tt);
@@ -6503,7 +6479,7 @@ static struct pci_driver sisfb_driver = {
         .remove         = __devexit_p(sisfb_remove)
 };
 
-SISINITSTATIC int __init sisfb_init(void)
+static int __init sisfb_init(void)
 {
 #ifndef MODULE
         char *options = NULL;
diff --git a/drivers/video/sis/sis_main.h b/drivers/video/sis/sis_main.h
index 3e3b7fa05d6c..9540e977270e 100644
--- a/drivers/video/sis/sis_main.h
+++ b/drivers/video/sis/sis_main.h
@@ -665,11 +665,11 @@ static struct _customttable {
 
 /* Interface used by the world */
 #ifndef MODULE
-SISINITSTATIC int sisfb_setup(char *options);
+static int sisfb_setup(char *options);
 #endif
 
 /* Interface to the low level console driver */
-SISINITSTATIC int sisfb_init(void);
+static int sisfb_init(void);
 
 /* fbdev routines */
 static int      sisfb_get_fix(struct fb_fix_screeninfo *fix, int con,
diff --git a/drivers/video/sis/vgatypes.h b/drivers/video/sis/vgatypes.h
index b532fbd2b04c..81a22eaabfde 100644
--- a/drivers/video/sis/vgatypes.h
+++ b/drivers/video/sis/vgatypes.h
@@ -53,10 +53,6 @@
 #ifndef _VGATYPES_H_
 #define _VGATYPES_H_
 
-#ifdef SIS_LINUX_KERNEL
-#include <linux/version.h>
-#endif
-
 #define SISIOMEMTYPE
 
 #ifdef SIS_LINUX_KERNEL
diff --git a/drivers/video/skeletonfb.c b/drivers/video/skeletonfb.c
index 62321458f71a..df5336561d13 100644
--- a/drivers/video/skeletonfb.c
+++ b/drivers/video/skeletonfb.c
@@ -675,13 +675,13 @@ static struct fb_ops xxxfb_ops = {
      *  Initialization
      */
 
-/* static int __init xxfb_probe (struct device *device) -- for platform devs */
+/* static int __init xxfb_probe (struct platform_device *pdev) -- for platform devs */
 static int __devinit xxxfb_probe(struct pci_dev *dev,
                               const struct pci_device_id *ent)
 {
     struct fb_info *info;
     struct xxx_par *par;
-    struct device* device = &dev->dev; /* for pci drivers */
+    struct device *device = &dev->dev; /* or &pdev->dev */
     int cmap_len, retval;       
    
     /*
@@ -824,18 +824,18 @@ static int __devinit xxxfb_probe(struct pci_dev *dev,
         return -EINVAL;
     printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
            info->fix.id);
-    pci_set_drvdata(dev, info); /* or dev_set_drvdata(device, info) */
+    pci_set_drvdata(dev, info); /* or platform_set_drvdata(pdev, info) */
     return 0;
 }
 
     /*
      *  Cleanup
      */
-/* static void __devexit xxxfb_remove(struct device *device) */
+/* static void __devexit xxxfb_remove(struct platform_device *pdev) */
 static void __devexit xxxfb_remove(struct pci_dev *dev)
 {
         struct fb_info *info = pci_get_drvdata(dev);
-        /* or dev_get_drvdata(device); */
+        /* or platform_get_drvdata(pdev); */
 
         if (info) {
                 unregister_framebuffer(info);
@@ -961,18 +961,17 @@ static int xxxfb_resume(struct platform_dev *dev)
 #define xxxfb_resume NULL
 #endif /* CONFIG_PM */
 
-static struct device_driver xxxfb_driver = {
-        .name = "xxxfb",
-        .bus  = &platform_bus_type,
+static struct platform_device_driver xxxfb_driver = {
         .probe = xxxfb_probe,
         .remove = xxxfb_remove,
         .suspend = xxxfb_suspend, /* optional but recommended */
         .resume = xxxfb_resume,   /* optional but recommended */
+        .driver = {
+                .name = "xxxfb",
+        },
 };
 
-static struct platform_device xxxfb_device = {
-        .name = "xxxfb",
-};
+static struct platform_device *xxxfb_device;
 
 #ifndef MODULE
     /*
@@ -1002,12 +1001,16 @@ static int __init xxxfb_init(void)
                 return -ENODEV;
         xxxfb_setup(option);
 #endif
-        ret = driver_register(&xxxfb_driver);
+        ret = platform_driver_register(&xxxfb_driver);
 
         if (!ret) {
-                ret = platform_device_register(&xxxfb_device);
-                if (ret)
-                        driver_unregister(&xxxfb_driver);
+                xxxfb_device = platform_device_register_simple("xxxfb", 0,
+                                                                NULL, 0);
+
+                if (IS_ERR(xxxfb_device)) {
+                        platform_driver_unregister(&xxxfb_driver);
+                        ret = PTR_ERR(xxxfb_device);
+                }
         }
 
         return ret;
@@ -1015,8 +1018,8 @@ static int __init xxxfb_init(void)
 
 static void __exit xxxfb_exit(void)
 {
-        platform_device_unregister(&xxxfb_device);
-        driver_unregister(&xxxfb_driver);
+        platform_device_unregister(xxxfb_device);
+        platform_driver_unregister(&xxxfb_driver);
 }
 #endif /* CONFIG_PCI */
 
diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c
index 15d4a768b1f6..f94ae84a58cd 100644
--- a/drivers/video/sm501fb.c
+++ b/drivers/video/sm501fb.c
@@ -48,10 +48,15 @@ enum sm501_controller {
         HEAD_PANEL      = 1,
 };
 
-/* SM501 memory address */
+/* SM501 memory address.
+ *
+ * This structure is used to track memory usage within the SM501 framebuffer
+ * allocation. The sm_addr field is stored as an offset as it is often used
+ * against both the physical and mapped addresses.
+ */
 struct sm501_mem {
         unsigned long    size;
-        unsigned long    sm_addr;
+        unsigned long    sm_addr;       /* offset from base of sm501 fb. */
         void __iomem    *k_addr;
 };
 
@@ -142,31 +147,68 @@ static inline void sm501fb_sync_regs(struct sm501fb_info *info)
 static int sm501_alloc_mem(struct sm501fb_info *inf, struct sm501_mem *mem,
                            unsigned int why, size_t size)
 {
-        unsigned int ptr = 0;
+        struct sm501fb_par *par;
+        struct fb_info *fbi;
+        unsigned int ptr;
+        unsigned int end;
 
         switch (why) {
         case SM501_MEMF_CURSOR:
                 ptr = inf->fbmem_len - size;
-                inf->fbmem_len = ptr;
+                inf->fbmem_len = ptr;   /* adjust available memory. */
                 break;
 
         case SM501_MEMF_PANEL:
                 ptr = inf->fbmem_len - size;
-                if (ptr < inf->fb[0]->fix.smem_len)
+                fbi = inf->fb[HEAD_CRT];
+
+                /* round down, some programs such as directfb do not draw
+                 * 0,0 correctly unless the start is aligned to a page start.
+                 */
+
+                if (ptr > 0)
+                        ptr &= ~(PAGE_SIZE - 1);
+
+                if (fbi && ptr < fbi->fix.smem_len)
+                        return -ENOMEM;
+
+                if (ptr < 0)
                         return -ENOMEM;
 
                 break;
 
         case SM501_MEMF_CRT:
                 ptr = 0;
+
+                /* check to see if we have panel memory allocated
+                 * which would put an limit on available memory. */
+
+                fbi = inf->fb[HEAD_PANEL];
+                if (fbi) {
+                        par = fbi->par;
+                        end = par->screen.k_addr ? par->screen.sm_addr : inf->fbmem_len;
+                } else
+                        end = inf->fbmem_len;
+
+                if ((ptr + size) > end)
+                        return -ENOMEM;
+
                 break;
 
         case SM501_MEMF_ACCEL:
-                ptr = inf->fb[0]->fix.smem_len;
+                fbi = inf->fb[HEAD_CRT];
+                ptr = fbi ? fbi->fix.smem_len : 0;
+
+                fbi = inf->fb[HEAD_PANEL];
+                if (fbi) {
+                        par = fbi->par;
+                        end = par->screen.sm_addr;
+                } else
+                        end = inf->fbmem_len;
 
-                if ((ptr + size) >
-                    (inf->fb[1]->fix.smem_start - inf->fbmem_res->start))
+                if ((ptr + size) > end)
                         return -ENOMEM;
+
                 break;
 
         default:
@@ -663,15 +705,25 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                 sm501fb_sync_regs(fbi);
                 mdelay(10);
 
+                /* VBIASEN */
+
                 if (!(pd->flags & SM501FB_FLAG_PANEL_NO_VBIASEN)) {
-                        control |= SM501_DC_PANEL_CONTROL_BIAS; /* VBIASEN */
+                        if (pd->flags & SM501FB_FLAG_PANEL_INV_VBIASEN)
+                                control &= ~SM501_DC_PANEL_CONTROL_BIAS;
+                        else
+                                control |= SM501_DC_PANEL_CONTROL_BIAS;
+
                         writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
 
                 if (!(pd->flags & SM501FB_FLAG_PANEL_NO_FPEN)) {
-                        control |= SM501_DC_PANEL_CONTROL_FPEN;
+                        if (pd->flags & SM501FB_FLAG_PANEL_INV_FPEN)
+                                control &= ~SM501_DC_PANEL_CONTROL_FPEN;
+                        else
+                                control |= SM501_DC_PANEL_CONTROL_FPEN;
+
                         writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
@@ -679,14 +731,22 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
         } else if (!to && (control & SM501_DC_PANEL_CONTROL_VDD) != 0) {
                 /* disable panel power */
                 if (!(pd->flags & SM501FB_FLAG_PANEL_NO_FPEN)) {
-                        control &= ~SM501_DC_PANEL_CONTROL_FPEN;
+                        if (pd->flags & SM501FB_FLAG_PANEL_INV_FPEN)
+                                control |= SM501_DC_PANEL_CONTROL_FPEN;
+                        else
+                                control &= ~SM501_DC_PANEL_CONTROL_FPEN;
+
                         writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
                 }
 
                 if (!(pd->flags & SM501FB_FLAG_PANEL_NO_VBIASEN)) {
-                        control &= ~SM501_DC_PANEL_CONTROL_BIAS;
+                        if (pd->flags & SM501FB_FLAG_PANEL_INV_VBIASEN)
+                                control |= SM501_DC_PANEL_CONTROL_BIAS;
+                        else
+                                control &= ~SM501_DC_PANEL_CONTROL_BIAS;
+
                         writel(control, ctrl_reg);
                         sm501fb_sync_regs(fbi);
                         mdelay(10);
@@ -1210,39 +1270,6 @@ static struct fb_ops sm501fb_ops_pnl = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-/* sm501fb_info_alloc
- *
- * creates and initialises an sm501fb_info structure
-*/
-
-static struct sm501fb_info *sm501fb_info_alloc(struct fb_info *fbinfo_crt,
-                                               struct fb_info *fbinfo_pnl)
-{
-        struct sm501fb_info *info;
-        struct sm501fb_par  *par;
-
-        info = kzalloc(sizeof(struct sm501fb_info), GFP_KERNEL);
-        if (info) {
-                /* set the references back */
-
-                par = fbinfo_crt->par;
-                par->info = info;
-                par->head = HEAD_CRT;
-                fbinfo_crt->pseudo_palette = &par->pseudo_palette;
-
-                par = fbinfo_pnl->par;
-                par->info = info;
-                par->head = HEAD_PANEL;
-                fbinfo_pnl->pseudo_palette = &par->pseudo_palette;
-
-                /* store the two fbs into our info */
-                info->fb[HEAD_CRT] = fbinfo_crt;
-                info->fb[HEAD_PANEL] = fbinfo_pnl;
-        }
-
-        return info;
-}
-
 /* sm501_init_cursor
  *
  * initialise hw cursor parameters
@@ -1250,10 +1277,16 @@ static struct sm501fb_info *sm501fb_info_alloc(struct fb_info *fbinfo_crt,
 
 static int sm501_init_cursor(struct fb_info *fbi, unsigned int reg_base)
 {
-        struct sm501fb_par *par = fbi->par;
-        struct sm501fb_info *info = par->info;
+        struct sm501fb_par *par;
+        struct sm501fb_info *info;
         int ret;
 
+        if (fbi == NULL)
+                return 0;
+
+        par = fbi->par;
+        info = par->info;
+
         par->cursor_regs = info->regs + reg_base;
 
         ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024);
@@ -1281,13 +1314,10 @@ static int sm501fb_start(struct sm501fb_info *info,
                          struct platform_device *pdev)
 {
         struct resource *res;
-        struct device *dev;
+        struct device *dev = &pdev->dev;
         int k;
         int ret;
 
-        info->dev = dev = &pdev->dev;
-        platform_set_drvdata(pdev, info);
-
         info->irq = ret = platform_get_irq(pdev, 0);
         if (ret < 0) {
                 /* we currently do not use the IRQ */
@@ -1390,11 +1420,6 @@ static void sm501fb_stop(struct sm501fb_info *info)
         kfree(info->regs_res);
 }
 
-static void sm501fb_info_release(struct sm501fb_info *info)
-{
-        kfree(info);
-}
-
 static int sm501fb_init_fb(struct fb_info *fb,
                            enum sm501_controller head,
                            const char *fbname)
@@ -1539,36 +1564,93 @@ static struct sm501_platdata_fb sm501fb_def_pdata = {
 static char driver_name_crt[] = "sm501fb-crt";
 static char driver_name_pnl[] = "sm501fb-panel";
 
-static int __init sm501fb_probe(struct platform_device *pdev)
+static int __devinit sm501fb_probe_one(struct sm501fb_info *info,
+                                       enum sm501_controller head)
 {
-        struct sm501fb_info *info;
-        struct device       *dev = &pdev->dev;
-        struct fb_info      *fbinfo_crt;
-        struct fb_info      *fbinfo_pnl;
-        int                  ret;
+        unsigned char *name = (head == HEAD_CRT) ? "crt" : "panel";
+        struct sm501_platdata_fbsub *pd;
+        struct sm501fb_par *par;
+        struct fb_info *fbi;
 
-        /* allocate our framebuffers */
+        pd = (head == HEAD_CRT) ? info->pdata->fb_crt : info->pdata->fb_pnl;
+
+        /* Do not initialise if we've not been given any platform data */
+        if (pd == NULL) {
+                dev_info(info->dev, "no data for fb %s (disabled)\n", name);
+                return 0;
+        }
 
-        fbinfo_crt = framebuffer_alloc(sizeof(struct sm501fb_par), dev);
-        if (fbinfo_crt == NULL) {
-                dev_err(dev, "cannot allocate crt framebuffer\n");
+        fbi = framebuffer_alloc(sizeof(struct sm501fb_par), info->dev);
+        if (fbi == NULL) {
+                dev_err(info->dev, "cannot allocate %s framebuffer\n", name);
                 return -ENOMEM;
         }
 
-        fbinfo_pnl = framebuffer_alloc(sizeof(struct sm501fb_par), dev);
-        if (fbinfo_pnl == NULL) {
-                dev_err(dev, "cannot allocate panel framebuffer\n");
-                ret = -ENOMEM;
-                goto fbinfo_crt_alloc_fail;
+        par = fbi->par;
+        par->info = info;
+        par->head = head;
+        fbi->pseudo_palette = &par->pseudo_palette;
+
+        info->fb[head] = fbi;
+
+        return 0;
+}
+
+/* Free up anything allocated by sm501fb_init_fb */
+
+static void sm501_free_init_fb(struct sm501fb_info *info,
+                                enum sm501_controller head)
+{
+        struct fb_info *fbi = info->fb[head];
+
+        fb_dealloc_cmap(&fbi->cmap);
+}
+
+static int __devinit sm501fb_start_one(struct sm501fb_info *info,
+                                       enum sm501_controller head,
+                                       const char *drvname)
+{
+        struct fb_info *fbi = info->fb[head];
+        int ret;
+
+        if (!fbi)
+                return 0;
+
+        ret = sm501fb_init_fb(info->fb[head], head, drvname);
+        if (ret) {
+                dev_err(info->dev, "cannot initialise fb %s\n", drvname);
+                return ret;
+        }
+
+        ret = register_framebuffer(info->fb[head]);
+        if (ret) {
+                dev_err(info->dev, "failed to register fb %s\n", drvname);
+                sm501_free_init_fb(info, head);
+                return ret;
         }
 
-        info = sm501fb_info_alloc(fbinfo_crt, fbinfo_pnl);
-        if (info == NULL) {
-                dev_err(dev, "cannot allocate par\n");
-                ret = -ENOMEM;
-                goto sm501fb_alloc_fail;
+        dev_info(info->dev, "fb%d: %s frame buffer\n", fbi->node, fbi->fix.id);
+
+        return 0;
+}
+
+static int __devinit sm501fb_probe(struct platform_device *pdev)
+{
+        struct sm501fb_info *info;
+        struct device *dev = &pdev->dev;
+        int ret;
+
+        /* allocate our framebuffers */
+
+        info = kzalloc(sizeof(struct sm501fb_info), GFP_KERNEL);
+        if (!info) {
+                dev_err(dev, "failed to allocate state\n");
+                return -ENOMEM;
         }
 
+        info->dev = dev = &pdev->dev;
+        platform_set_drvdata(pdev, info);
+
         if (dev->parent->platform_data) {
                 struct sm501_platdata *pd = dev->parent->platform_data;
                 info->pdata = pd->fb;
@@ -1579,90 +1661,88 @@ static int __init sm501fb_probe(struct platform_device *pdev)
                 info->pdata = &sm501fb_def_pdata;
         }
 
-        /* start the framebuffers */
+        /* probe for the presence of each panel */
 
-        ret = sm501fb_start(info, pdev);
-        if (ret) {
-                dev_err(dev, "cannot initialise SM501\n");
-                goto sm501fb_start_fail;
+        ret = sm501fb_probe_one(info, HEAD_CRT);
+        if (ret < 0) {
+                dev_err(dev, "failed to probe CRT\n");
+                goto err_alloc;
         }
 
-        /* CRT framebuffer setup */
+        ret = sm501fb_probe_one(info, HEAD_PANEL);
+        if (ret < 0) {
+                dev_err(dev, "failed to probe PANEL\n");
+                goto err_probed_crt;
+        }
 
-        ret = sm501fb_init_fb(fbinfo_crt, HEAD_CRT, driver_name_crt);
-        if (ret) {
-                dev_err(dev, "cannot initialise CRT fb\n");
-                goto sm501fb_start_fail;
+        if (info->fb[HEAD_PANEL] == NULL &&
+            info->fb[HEAD_CRT] == NULL) {
+                dev_err(dev, "no framebuffers found\n");
+                goto err_alloc;
         }
 
-        /* Panel framebuffer setup */
+        /* get the resources for both of the framebuffers */
 
-        ret = sm501fb_init_fb(fbinfo_pnl, HEAD_PANEL, driver_name_pnl);
+        ret = sm501fb_start(info, pdev);
         if (ret) {
-                dev_err(dev, "cannot initialise Panel fb\n");
-                goto sm501fb_start_fail;
+                dev_err(dev, "cannot initialise SM501\n");
+                goto err_probed_panel;
         }
 
-        /* register framebuffers */
-
-        ret = register_framebuffer(fbinfo_crt);
-        if (ret < 0) {
-                dev_err(dev, "failed to register CRT fb (%d)\n", ret);
-                goto register_crt_fail;
+        ret = sm501fb_start_one(info, HEAD_CRT, driver_name_crt);
+        if (ret) {
+                dev_err(dev, "failed to start CRT\n");
+                goto err_started;
         }
 
-        ret = register_framebuffer(fbinfo_pnl);
-        if (ret < 0) {
-                dev_err(dev, "failed to register panel fb (%d)\n", ret);
-                goto register_pnl_fail;
+        ret = sm501fb_start_one(info, HEAD_PANEL, driver_name_pnl);
+        if (ret) {
+                dev_err(dev, "failed to start Panel\n");
+                goto err_started_crt;
         }
 
-        dev_info(dev, "fb%d: %s frame buffer device\n",
-                 fbinfo_crt->node, fbinfo_crt->fix.id);
-
-        dev_info(dev, "fb%d: %s frame buffer device\n",
-               fbinfo_pnl->node, fbinfo_pnl->fix.id);
-
         /* create device files */
 
         ret = device_create_file(dev, &dev_attr_crt_src);
         if (ret)
-                goto crtsrc_fail;
+                goto err_started_panel;
 
         ret = device_create_file(dev, &dev_attr_fbregs_pnl);
         if (ret)
-                goto fbregs_pnl_fail;
+                goto err_attached_crtsrc_file;
 
         ret = device_create_file(dev, &dev_attr_fbregs_crt);
         if (ret)
-                goto fbregs_crt_fail;
+                goto err_attached_pnlregs_file;
 
         /* we registered, return ok */
         return 0;
 
- fbregs_crt_fail:
+err_attached_pnlregs_file:
         device_remove_file(dev, &dev_attr_fbregs_pnl);
 
- fbregs_pnl_fail:
+err_attached_crtsrc_file:
         device_remove_file(dev, &dev_attr_crt_src);
 
- crtsrc_fail:
-        unregister_framebuffer(fbinfo_pnl);
+err_started_panel:
+        unregister_framebuffer(info->fb[HEAD_PANEL]);
+        sm501_free_init_fb(info, HEAD_PANEL);
 
- register_pnl_fail:
-        unregister_framebuffer(fbinfo_crt);
+err_started_crt:
+        unregister_framebuffer(info->fb[HEAD_CRT]);
+        sm501_free_init_fb(info, HEAD_CRT);
 
- register_crt_fail:
+err_started:
         sm501fb_stop(info);
 
- sm501fb_start_fail:
-        sm501fb_info_release(info);
+err_probed_panel:
+        framebuffer_release(info->fb[HEAD_PANEL]);
 
- sm501fb_alloc_fail:
-        framebuffer_release(fbinfo_pnl);
+err_probed_crt:
+        framebuffer_release(info->fb[HEAD_CRT]);
 
- fbinfo_crt_alloc_fail:
-        framebuffer_release(fbinfo_crt);
+err_alloc:
+        kfree(info);
 
         return ret;
 }
@@ -1681,11 +1761,14 @@ static int sm501fb_remove(struct platform_device *pdev)
         device_remove_file(&pdev->dev, &dev_attr_fbregs_pnl);
         device_remove_file(&pdev->dev, &dev_attr_crt_src);
 
+        sm501_free_init_fb(info, HEAD_CRT);
+        sm501_free_init_fb(info, HEAD_PANEL);
+
         unregister_framebuffer(fbinfo_crt);
         unregister_framebuffer(fbinfo_pnl);
 
         sm501fb_stop(info);
-        sm501fb_info_release(info);
+        kfree(info);
 
         framebuffer_release(fbinfo_pnl);
         framebuffer_release(fbinfo_crt);
diff --git a/drivers/video/sticore.h b/drivers/video/sticore.h
index 1a9a60c74be3..7fe5be4bc70e 100644
--- a/drivers/video/sticore.h
+++ b/drivers/video/sticore.h
@@ -352,8 +352,6 @@ struct sti_struct *sti_get_rom(unsigned int index); /* 0: default sti */
 
 /* functions to call the STI ROM directly */
 
-int  sti_init_graph(struct sti_struct *sti);
-void sti_inq_conf(struct sti_struct *sti);
 void sti_putc(struct sti_struct *sti, int c, int y, int x);
 void sti_set(struct sti_struct *sti, int src_y, int src_x,
              int height, int width, u8 color);
diff --git a/drivers/video/stifb.c b/drivers/video/stifb.c
index 598d35eff935..166481402412 100644
--- a/drivers/video/stifb.c
+++ b/drivers/video/stifb.c
@@ -1078,8 +1078,7 @@ static struct fb_ops stifb_ops = {
  *  Initialization
  */
 
-int __init
-stifb_init_fb(struct sti_struct *sti, int bpp_pref)
+static int __init stifb_init_fb(struct sti_struct *sti, int bpp_pref)
 {
         struct fb_fix_screeninfo *fix;
         struct fb_var_screeninfo *var;
@@ -1315,8 +1314,7 @@ static int stifb_disabled __initdata;
 int __init
 stifb_setup(char *options);
 
-int __init
-stifb_init(void)
+static int __init stifb_init(void)
 {
         struct sti_struct *sti;
         struct sti_struct *def_sti;
diff --git a/drivers/video/tdfxfb.c b/drivers/video/tdfxfb.c
index ea9f19d25597..4599a4385bc9 100644
--- a/drivers/video/tdfxfb.c
+++ b/drivers/video/tdfxfb.c
@@ -95,7 +95,6 @@ static inline int mtrr_del(int reg, unsigned long base,
 #define VOODOO5_MAX_PIXCLOCK 350000
 
 static struct fb_fix_screeninfo tdfx_fix __devinitdata = {
-        .id =           "3Dfx",
         .type =         FB_TYPE_PACKED_PIXELS,
         .visual =       FB_VISUAL_PSEUDOCOLOR,
         .ypanstep =     1,
@@ -426,7 +425,7 @@ static unsigned long do_lfb_size(struct tdfx_par *par, unsigned short dev_id)
         if (dev_id < PCI_DEVICE_ID_3DFX_VOODOO5) {
                 /* Banshee/Voodoo3 */
                 chip_size = 2;
-                if (has_sgram && (draminit0 & DRAMINIT0_SGRAM_TYPE))
+                if (has_sgram && !(draminit0 & DRAMINIT0_SGRAM_TYPE))
                         chip_size = 1;
         } else {
                 /* Voodoo4/5 */
@@ -836,16 +835,12 @@ static int tdfxfb_pan_display(struct fb_var_screeninfo *var,
         struct tdfx_par *par = info->par;
         u32 addr = var->yoffset * info->fix.line_length;
 
-        if (nopan || var->xoffset || (var->yoffset > var->yres_virtual))
-                return -EINVAL;
-        if ((var->yoffset + var->yres > var->yres_virtual && nowrap))
+        if (nopan || var->xoffset)
                 return -EINVAL;
 
         banshee_make_room(par, 1);
         tdfx_outl(par, VIDDESKSTART, addr);
 
-        info->var.xoffset = var->xoffset;
-        info->var.yoffset = var->yoffset;
         return 0;
 }
 
@@ -1204,15 +1199,15 @@ static int __devinit tdfxfb_probe(struct pci_dev *pdev,
         /* Configure the default fb_fix_screeninfo first */
         switch (pdev->device) {
         case PCI_DEVICE_ID_3DFX_BANSHEE:
-                strcat(tdfx_fix.id, " Banshee");
+                strcpy(tdfx_fix.id, "3Dfx Banshee");
                 default_par->max_pixclock = BANSHEE_MAX_PIXCLOCK;
                 break;
         case PCI_DEVICE_ID_3DFX_VOODOO3:
-                strcat(tdfx_fix.id, " Voodoo3");
+                strcpy(tdfx_fix.id, "3Dfx Voodoo3");
                 default_par->max_pixclock = VOODOO3_MAX_PIXCLOCK;
                 break;
         case PCI_DEVICE_ID_3DFX_VOODOO5:
-                strcat(tdfx_fix.id, " Voodoo5");
+                strcpy(tdfx_fix.id, "3Dfx Voodoo5");
                 default_par->max_pixclock = VOODOO5_MAX_PIXCLOCK;
                 break;
         }
@@ -1426,6 +1421,8 @@ MODULE_LICENSE("GPL");
 module_param(hwcursor, int, 0644);
 MODULE_PARM_DESC(hwcursor, "Enable hardware cursor "
                         "(1=enable, 0=disable, default=1)");
+module_param(mode_option, charp, 0);
+MODULE_PARM_DESC(mode_option, "Initial video mode e.g. '648x480-8@60'");
 #ifdef CONFIG_MTRR
 module_param(nomtrr, bool, 0);
 MODULE_PARM_DESC(nomtrr, "Disable MTRR support (default: enabled)");
diff --git a/drivers/video/tridentfb.c b/drivers/video/tridentfb.c
index beefab2992c0..479b2e79ad68 100644
--- a/drivers/video/tridentfb.c
+++ b/drivers/video/tridentfb.c
@@ -1,5 +1,5 @@
 /*
- * Frame buffer driver for Trident Blade and Image series
+ * Frame buffer driver for Trident TGUI, Blade and Image series
  *
  * Copyright 2001, 2002 - Jani Monoses   <jani@iv.ro>
  *
@@ -13,7 +13,6 @@
  *      code, suggestions
  * TODO:
  *      timing value tweaking so it looks good on every monitor in every mode
- *      TGUI acceleration
  */
 
 #include <linux/module.h>
@@ -22,25 +21,26 @@
 #include <linux/pci.h>
 
 #include <linux/delay.h>
+#include <video/vga.h>
 #include <video/trident.h>
 
-#define VERSION         "0.7.8-NEWAPI"
-
 struct tridentfb_par {
         void __iomem *io_virt;  /* iospace virtual memory address */
+        u32 pseudo_pal[16];
+        int chip_id;
+        int flatpanel;
+        void (*init_accel) (struct tridentfb_par *, int, int);
+        void (*wait_engine) (struct tridentfb_par *);
+        void (*fill_rect)
+                (struct tridentfb_par *par, u32, u32, u32, u32, u32, u32);
+        void (*copy_rect)
+                (struct tridentfb_par *par, u32, u32, u32, u32, u32, u32);
+        void (*image_blit)
+                (struct tridentfb_par *par, const char*,
+                 u32, u32, u32, u32, u32, u32);
+        unsigned char eng_oper; /* engine operation... */
 };
 
-static unsigned char eng_oper;  /* engine operation... */
-static struct fb_ops tridentfb_ops;
-
-static struct tridentfb_par default_par;
-
-/* FIXME:kmalloc these 3 instead */
-static struct fb_info fb_info;
-static u32 pseudo_pal[16];
-
-static struct fb_var_screeninfo default_var;
-
 static struct fb_fix_screeninfo tridentfb_fix = {
         .id = "Trident",
         .type = FB_TYPE_PACKED_PIXELS,
@@ -49,27 +49,22 @@ static struct fb_fix_screeninfo tridentfb_fix = {
         .accel = FB_ACCEL_NONE,
 };
 
-static int chip_id;
-
-static int defaultaccel;
-static int displaytype;
-
 /* defaults which are normally overriden by user values */
 
 /* video mode */
-static char *mode_option __devinitdata = "640x480";
-static int bpp = 8;
+static char *mode_option __devinitdata = "640x480-8@60";
+static int bpp __devinitdata = 8;
 
-static int noaccel;
+static int noaccel __devinitdata;
 
 static int center;
 static int stretch;
 
-static int fp;
-static int crt;
+static int fp __devinitdata;
+static int crt __devinitdata;
 
-static int memsize;
-static int memdiff;
+static int memsize __devinitdata;
+static int memdiff __devinitdata;
 static int nativex;
 
 module_param(mode_option, charp, 0);
@@ -84,25 +79,53 @@ module_param(memsize, int, 0);
 module_param(memdiff, int, 0);
 module_param(nativex, int, 0);
 module_param(fp, int, 0);
+MODULE_PARM_DESC(fp, "Define if flatpanel is connected");
 module_param(crt, int, 0);
+MODULE_PARM_DESC(crt, "Define if CRT is connected");
+
+static inline int is_oldclock(int id)
+{
+        return  (id == TGUI9440) ||
+                (id == TGUI9660) ||
+                (id == CYBER9320);
+}
+
+static inline int is_oldprotect(int id)
+{
+        return  is_oldclock(id) ||
+                (id == PROVIDIA9685) ||
+                (id == CYBER9382) ||
+                (id == CYBER9385);
+}
+
+static inline int is_blade(int id)
+{
+        return  (id == BLADE3D) ||
+                (id == CYBERBLADEE4) ||
+                (id == CYBERBLADEi7) ||
+                (id == CYBERBLADEi7D) ||
+                (id == CYBERBLADEi1) ||
+                (id == CYBERBLADEi1D) ||
+                (id == CYBERBLADEAi1) ||
+                (id == CYBERBLADEAi1D);
+}
 
-static int chip3D;
-static int chipcyber;
+static inline int is_xp(int id)
+{
+        return  (id == CYBERBLADEXPAi1) ||
+                (id == CYBERBLADEXPm8) ||
+                (id == CYBERBLADEXPm16);
+}
 
-static int is3Dchip(int id)
+static inline int is3Dchip(int id)
 {
-        return ((id == BLADE3D) || (id == CYBERBLADEE4) ||
-                (id == CYBERBLADEi7) || (id == CYBERBLADEi7D) ||
+        return  is_blade(id) || is_xp(id) ||
                 (id == CYBER9397) || (id == CYBER9397DVD) ||
                 (id == CYBER9520) || (id == CYBER9525DVD) ||
-                (id == IMAGE975) || (id == IMAGE985) ||
-                (id == CYBERBLADEi1) || (id == CYBERBLADEi1D) ||
-                (id == CYBERBLADEAi1) || (id == CYBERBLADEAi1D) ||
-                (id == CYBERBLADEXPm8) || (id == CYBERBLADEXPm16) ||
-                (id == CYBERBLADEXPAi1));
+                (id == IMAGE975) || (id == IMAGE985);
 }
 
-static int iscyber(int id)
+static inline int iscyber(int id)
 {
         switch (id) {
         case CYBER9388:
@@ -122,12 +145,7 @@ static int iscyber(int id)
                 return 1;
 
         case CYBER9320:
-        case TGUI9660:
-        case IMAGE975:
-        case IMAGE985:
-        case BLADE3D:
         case CYBERBLADEi7:      /* VIA MPV4 integrated version */
-
         default:
                 /* case CYBERBLDAEXPm8:  Strange */
                 /* case CYBERBLDAEXPm16: Strange */
@@ -135,147 +153,110 @@ static int iscyber(int id)
         }
 }
 
-#define CRT 0x3D0               /* CRTC registers offset for color display */
-
-#ifndef TRIDENT_MMIO
-        #define TRIDENT_MMIO 1
-#endif
-
-#if TRIDENT_MMIO
-        #define t_outb(val, reg)        writeb(val,((struct tridentfb_par *)(fb_info.par))->io_virt + reg)
-        #define t_inb(reg)      readb(((struct tridentfb_par*)(fb_info.par))->io_virt + reg)
-#else
-        #define t_outb(val, reg) outb(val, reg)
-        #define t_inb(reg) inb(reg)
-#endif
+static inline void t_outb(struct tridentfb_par *p, u8 val, u16 reg)
+{
+        fb_writeb(val, p->io_virt + reg);
+}
 
+static inline u8 t_inb(struct tridentfb_par *p, u16 reg)
+{
+        return fb_readb(p->io_virt + reg);
+}
 
-static struct accel_switch {
-        void (*init_accel) (int, int);
-        void (*wait_engine) (void);
-        void (*fill_rect) (u32, u32, u32, u32, u32, u32);
-        void (*copy_rect) (u32, u32, u32, u32, u32, u32);
-} *acc;
+static inline void writemmr(struct tridentfb_par *par, u16 r, u32 v)
+{
+        fb_writel(v, par->io_virt + r);
+}
 
-#define writemmr(r, v)  writel(v, ((struct tridentfb_par *)fb_info.par)->io_virt + r)
-#define readmmr(r)      readl(((struct tridentfb_par *)fb_info.par)->io_virt + r)
+static inline u32 readmmr(struct tridentfb_par *par, u16 r)
+{
+        return fb_readl(par->io_virt + r);
+}
 
 /*
  * Blade specific acceleration.
  */
 
 #define point(x, y) ((y) << 16 | (x))
-#define STA     0x2120
-#define CMD     0x2144
-#define ROP     0x2148
-#define CLR     0x2160
-#define SR1     0x2100
-#define SR2     0x2104
-#define DR1     0x2108
-#define DR2     0x210C
-
-#define ROP_S   0xCC
-
-static void blade_init_accel(int pitch, int bpp)
+
+static void blade_init_accel(struct tridentfb_par *par, int pitch, int bpp)
 {
         int v1 = (pitch >> 3) << 20;
-        int tmp = 0, v2;
-        switch (bpp) {
-        case 8:
-                tmp = 0;
-                break;
-        case 15:
-                tmp = 5;
-                break;
-        case 16:
-                tmp = 1;
-                break;
-        case 24:
-        case 32:
-                tmp = 2;
-                break;
-        }
-        v2 = v1 | (tmp << 29);
-        writemmr(0x21C0, v2);
-        writemmr(0x21C4, v2);
-        writemmr(0x21B8, v2);
-        writemmr(0x21BC, v2);
-        writemmr(0x21D0, v1);
-        writemmr(0x21D4, v1);
-        writemmr(0x21C8, v1);
-        writemmr(0x21CC, v1);
-        writemmr(0x216C, 0);
+        int tmp = bpp == 24 ? 2 : (bpp >> 4);
+        int v2 = v1 | (tmp << 29);
+
+        writemmr(par, 0x21C0, v2);
+        writemmr(par, 0x21C4, v2);
+        writemmr(par, 0x21B8, v2);
+        writemmr(par, 0x21BC, v2);
+        writemmr(par, 0x21D0, v1);
+        writemmr(par, 0x21D4, v1);
+        writemmr(par, 0x21C8, v1);
+        writemmr(par, 0x21CC, v1);
+        writemmr(par, 0x216C, 0);
 }
 
-static void blade_wait_engine(void)
+static void blade_wait_engine(struct tridentfb_par *par)
 {
-        while (readmmr(STA) & 0xFA800000) ;
+        while (readmmr(par, STATUS) & 0xFA800000)
+                cpu_relax();
 }
 
-static void blade_fill_rect(u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
+static void blade_fill_rect(struct tridentfb_par *par,
+                            u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
 {
-        writemmr(CLR, c);
-        writemmr(ROP, rop ? 0x66 : ROP_S);
-        writemmr(CMD, 0x20000000 | 1 << 19 | 1 << 4 | 2 << 2);
+        writemmr(par, COLOR, c);
+        writemmr(par, ROP, rop ? ROP_X : ROP_S);
+        writemmr(par, CMD, 0x20000000 | 1 << 19 | 1 << 4 | 2 << 2);
 
-        writemmr(DR1, point(x, y));
-        writemmr(DR2, point(x + w - 1, y + h - 1));
+        writemmr(par, DST1, point(x, y));
+        writemmr(par, DST2, point(x + w - 1, y + h - 1));
 }
 
-static void blade_copy_rect(u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
+static void blade_image_blit(struct tridentfb_par *par, const char *data,
+                             u32 x, u32 y, u32 w, u32 h, u32 c, u32 b)
+{
+        unsigned size = ((w + 31) >> 5) * h;
+
+        writemmr(par, COLOR, c);
+        writemmr(par, BGCOLOR, b);
+        writemmr(par, CMD, 0xa0000000 | 3 << 19);
+
+        writemmr(par, DST1, point(x, y));
+        writemmr(par, DST2, point(x + w - 1, y + h - 1));
+
+        memcpy(par->io_virt + 0x10000, data, 4 * size);
+}
+
+static void blade_copy_rect(struct tridentfb_par *par,
+                            u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
 {
-        u32 s1, s2, d1, d2;
         int direction = 2;
-        s1 = point(x1, y1);
-        s2 = point(x1 + w - 1, y1 + h - 1);
-        d1 = point(x2, y2);
-        d2 = point(x2 + w - 1, y2 + h - 1);
+        u32 s1 = point(x1, y1);
+        u32 s2 = point(x1 + w - 1, y1 + h - 1);
+        u32 d1 = point(x2, y2);
+        u32 d2 = point(x2 + w - 1, y2 + h - 1);
 
         if ((y1 > y2) || ((y1 == y2) && (x1 > x2)))
                 direction = 0;
 
-        writemmr(ROP, ROP_S);
-        writemmr(CMD, 0xE0000000 | 1 << 19 | 1 << 4 | 1 << 2 | direction);
+        writemmr(par, ROP, ROP_S);
+        writemmr(par, CMD, 0xE0000000 | 1 << 19 | 1 << 4 | 1 << 2 | direction);
 
-        writemmr(SR1, direction ? s2 : s1);
-        writemmr(SR2, direction ? s1 : s2);
-        writemmr(DR1, direction ? d2 : d1);
-        writemmr(DR2, direction ? d1 : d2);
+        writemmr(par, SRC1, direction ? s2 : s1);
+        writemmr(par, SRC2, direction ? s1 : s2);
+        writemmr(par, DST1, direction ? d2 : d1);
+        writemmr(par, DST2, direction ? d1 : d2);
 }
 
-static struct accel_switch accel_blade = {
-        blade_init_accel,
-        blade_wait_engine,
-        blade_fill_rect,
-        blade_copy_rect,
-};
-
 /*
  * BladeXP specific acceleration functions
  */
 
-#define ROP_P 0xF0
-#define masked_point(x, y) ((y & 0xffff)<<16|(x & 0xffff))
-
-static void xp_init_accel(int pitch, int bpp)
+static void xp_init_accel(struct tridentfb_par *par, int pitch, int bpp)
 {
-        int tmp = 0, v1;
-        unsigned char x = 0;
-
-        switch (bpp) {
-        case 8:
-                x = 0;
-                break;
-        case 16:
-                x = 1;
-                break;
-        case 24:
-                x = 3;
-                break;
-        case 32:
-                x = 2;
-                break;
-        }
+        unsigned char x = bpp == 24 ? 3 : (bpp >> 4);
+        int v1 = pitch << (bpp == 24 ? 20 : (18 + x));
 
         switch (pitch << (bpp >> 3)) {
         case 8192:
@@ -293,42 +274,21 @@ static void xp_init_accel(int pitch, int bpp)
                 break;
         }
 
-        t_outb(x, 0x2125);
-
-        eng_oper = x | 0x40;
-
-        switch (bpp) {
-        case 8:
-                tmp = 18;
-                break;
-        case 15:
-        case 16:
-                tmp = 19;
-                break;
-        case 24:
-        case 32:
-                tmp = 20;
-                break;
-        }
+        t_outb(par, x, 0x2125);
 
-        v1 = pitch << tmp;
+        par->eng_oper = x | 0x40;
 
-        writemmr(0x2154, v1);
-        writemmr(0x2150, v1);
-        t_outb(3, 0x2126);
+        writemmr(par, 0x2154, v1);
+        writemmr(par, 0x2150, v1);
+        t_outb(par, 3, 0x2126);
 }
 
-static void xp_wait_engine(void)
+static void xp_wait_engine(struct tridentfb_par *par)
 {
-        int busy;
-        int count, timeout;
-
-        count = 0;
-        timeout = 0;
-        for (;;) {
-                busy = t_inb(STA) & 0x80;
-                if (busy != 0x80)
-                        return;
+        int count = 0;
+        int timeout = 0;
+
+        while (t_inb(par, STATUS) & 0x80) {
                 count++;
                 if (count == 10000000) {
                         /* Timeout */
@@ -336,30 +296,31 @@ static void xp_wait_engine(void)
                         timeout++;
                         if (timeout == 8) {
                                 /* Reset engine */
-                                t_outb(0x00, 0x2120);
+                                t_outb(par, 0x00, STATUS);
                                 return;
                         }
                 }
+                cpu_relax();
         }
 }
 
-static void xp_fill_rect(u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
+static void xp_fill_rect(struct tridentfb_par *par,
+                         u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
 {
-        writemmr(0x2127, ROP_P);
-        writemmr(0x2158, c);
-        writemmr(0x2128, 0x4000);
-        writemmr(0x2140, masked_point(h, w));
-        writemmr(0x2138, masked_point(y, x));
-        t_outb(0x01, 0x2124);
-        t_outb(eng_oper, 0x2125);
+        writemmr(par, 0x2127, ROP_P);
+        writemmr(par, 0x2158, c);
+        writemmr(par, DRAWFL, 0x4000);
+        writemmr(par, OLDDIM, point(h, w));
+        writemmr(par, OLDDST, point(y, x));
+        t_outb(par, 0x01, OLDCMD);
+        t_outb(par, par->eng_oper, 0x2125);
 }
 
-static void xp_copy_rect(u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
+static void xp_copy_rect(struct tridentfb_par *par,
+                         u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
 {
-        int direction;
         u32 x1_tmp, x2_tmp, y1_tmp, y2_tmp;
-
-        direction = 0x0004;
+        int direction = 0x0004;
 
         if ((x1 < x2) && (y1 == y2)) {
                 direction |= 0x0200;
@@ -379,103 +340,152 @@ static void xp_copy_rect(u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
                 y2_tmp = y2;
         }
 
-        writemmr(0x2128, direction);
-        t_outb(ROP_S, 0x2127);
-        writemmr(0x213C, masked_point(y1_tmp, x1_tmp));
-        writemmr(0x2138, masked_point(y2_tmp, x2_tmp));
-        writemmr(0x2140, masked_point(h, w));
-        t_outb(0x01, 0x2124);
+        writemmr(par, DRAWFL, direction);
+        t_outb(par, ROP_S, 0x2127);
+        writemmr(par, OLDSRC, point(y1_tmp, x1_tmp));
+        writemmr(par, OLDDST, point(y2_tmp, x2_tmp));
+        writemmr(par, OLDDIM, point(h, w));
+        t_outb(par, 0x01, OLDCMD);
 }
 
-static struct accel_switch accel_xp = {
-        xp_init_accel,
-        xp_wait_engine,
-        xp_fill_rect,
-        xp_copy_rect,
-};
-
 /*
  * Image specific acceleration functions
  */
-static void image_init_accel(int pitch, int bpp)
+static void image_init_accel(struct tridentfb_par *par, int pitch, int bpp)
 {
-        int tmp = 0;
-        switch (bpp) {
-        case 8:
-                tmp = 0;
-                break;
-        case 15:
-                tmp = 5;
-                break;
-        case 16:
-                tmp = 1;
-                break;
-        case 24:
-        case 32:
-                tmp = 2;
-                break;
-        }
-        writemmr(0x2120, 0xF0000000);
-        writemmr(0x2120, 0x40000000 | tmp);
-        writemmr(0x2120, 0x80000000);
-        writemmr(0x2144, 0x00000000);
-        writemmr(0x2148, 0x00000000);
-        writemmr(0x2150, 0x00000000);
-        writemmr(0x2154, 0x00000000);
-        writemmr(0x2120, 0x60000000 | (pitch << 16) | pitch);
-        writemmr(0x216C, 0x00000000);
-        writemmr(0x2170, 0x00000000);
-        writemmr(0x217C, 0x00000000);
-        writemmr(0x2120, 0x10000000);
-        writemmr(0x2130, (2047 << 16) | 2047);
+        int tmp = bpp == 24 ? 2: (bpp >> 4);
+
+        writemmr(par, 0x2120, 0xF0000000);
+        writemmr(par, 0x2120, 0x40000000 | tmp);
+        writemmr(par, 0x2120, 0x80000000);
+        writemmr(par, 0x2144, 0x00000000);
+        writemmr(par, 0x2148, 0x00000000);
+        writemmr(par, 0x2150, 0x00000000);
+        writemmr(par, 0x2154, 0x00000000);
+        writemmr(par, 0x2120, 0x60000000 | (pitch << 16) | pitch);
+        writemmr(par, 0x216C, 0x00000000);
+        writemmr(par, 0x2170, 0x00000000);
+        writemmr(par, 0x217C, 0x00000000);
+        writemmr(par, 0x2120, 0x10000000);
+        writemmr(par, 0x2130, (2047 << 16) | 2047);
 }
 
-static void image_wait_engine(void)
+static void image_wait_engine(struct tridentfb_par *par)
 {
-        while (readmmr(0x2164) & 0xF0000000) ;
+        while (readmmr(par, 0x2164) & 0xF0000000)
+                cpu_relax();
 }
 
-static void image_fill_rect(u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
+static void image_fill_rect(struct tridentfb_par *par,
+                            u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
 {
-        writemmr(0x2120, 0x80000000);
-        writemmr(0x2120, 0x90000000 | ROP_S);
+        writemmr(par, 0x2120, 0x80000000);
+        writemmr(par, 0x2120, 0x90000000 | ROP_S);
 
-        writemmr(0x2144, c);
+        writemmr(par, 0x2144, c);
 
-        writemmr(DR1, point(x, y));
-        writemmr(DR2, point(x + w - 1, y + h - 1));
+        writemmr(par, DST1, point(x, y));
+        writemmr(par, DST2, point(x + w - 1, y + h - 1));
 
-        writemmr(0x2124, 0x80000000 | 3 << 22 | 1 << 10 | 1 << 9);
+        writemmr(par, 0x2124, 0x80000000 | 3 << 22 | 1 << 10 | 1 << 9);
 }
 
-static void image_copy_rect(u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
+static void image_copy_rect(struct tridentfb_par *par,
+                            u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
 {
-        u32 s1, s2, d1, d2;
-        int direction = 2;
-        s1 = point(x1, y1);
-        s2 = point(x1 + w - 1, y1 + h - 1);
-        d1 = point(x2, y2);
-        d2 = point(x2 + w - 1, y2 + h - 1);
+        int direction = 0x4;
+        u32 s1 = point(x1, y1);
+        u32 s2 = point(x1 + w - 1, y1 + h - 1);
+        u32 d1 = point(x2, y2);
+        u32 d2 = point(x2 + w - 1, y2 + h - 1);
 
         if ((y1 > y2) || ((y1 == y2) && (x1 > x2)))
                 direction = 0;
 
-        writemmr(0x2120, 0x80000000);
-        writemmr(0x2120, 0x90000000 | ROP_S);
+        writemmr(par, 0x2120, 0x80000000);
+        writemmr(par, 0x2120, 0x90000000 | ROP_S);
 
-        writemmr(SR1, direction ? s2 : s1);
-        writemmr(SR2, direction ? s1 : s2);
-        writemmr(DR1, direction ? d2 : d1);
-        writemmr(DR2, direction ? d1 : d2);
-        writemmr(0x2124, 0x80000000 | 1 << 22 | 1 << 10 | 1 << 7 | direction);
+        writemmr(par, SRC1, direction ? s2 : s1);
+        writemmr(par, SRC2, direction ? s1 : s2);
+        writemmr(par, DST1, direction ? d2 : d1);
+        writemmr(par, DST2, direction ? d1 : d2);
+        writemmr(par, 0x2124,
+                 0x80000000 | 1 << 22 | 1 << 10 | 1 << 7 | direction);
 }
 
-static struct accel_switch accel_image = {
-        image_init_accel,
-        image_wait_engine,
-        image_fill_rect,
-        image_copy_rect,
-};
+/*
+ * TGUI 9440/96XX acceleration
+ */
+
+static void tgui_init_accel(struct tridentfb_par *par, int pitch, int bpp)
+{
+        unsigned char x = bpp == 24 ? 3 : (bpp >> 4);
+
+        /* disable clipping */
+        writemmr(par, 0x2148, 0);
+        writemmr(par, 0x214C, point(4095, 2047));
+
+        switch ((pitch * bpp) / 8) {
+        case 8192:
+        case 512:
+                x |= 0x00;
+                break;
+        case 1024:
+                x |= 0x04;
+                break;
+        case 2048:
+                x |= 0x08;
+                break;
+        case 4096:
+                x |= 0x0C;
+                break;
+        }
+
+        fb_writew(x, par->io_virt + 0x2122);
+}
+
+static void tgui_fill_rect(struct tridentfb_par *par,
+                           u32 x, u32 y, u32 w, u32 h, u32 c, u32 rop)
+{
+        t_outb(par, ROP_P, 0x2127);
+        writemmr(par, OLDCLR, c);
+        writemmr(par, DRAWFL, 0x4020);
+        writemmr(par, OLDDIM, point(w - 1, h - 1));
+        writemmr(par, OLDDST, point(x, y));
+        t_outb(par, 1, OLDCMD);
+}
+
+static void tgui_copy_rect(struct tridentfb_par *par,
+                           u32 x1, u32 y1, u32 x2, u32 y2, u32 w, u32 h)
+{
+        int flags = 0;
+        u16 x1_tmp, x2_tmp, y1_tmp, y2_tmp;
+
+        if ((x1 < x2) && (y1 == y2)) {
+                flags |= 0x0200;
+                x1_tmp = x1 + w - 1;
+                x2_tmp = x2 + w - 1;
+        } else {
+                x1_tmp = x1;
+                x2_tmp = x2;
+        }
+
+        if (y1 < y2) {
+                flags |= 0x0100;
+                y1_tmp = y1 + h - 1;
+                y2_tmp = y2 + h - 1;
+        } else {
+                y1_tmp = y1;
+                y2_tmp = y2;
+        }
+
+        writemmr(par, DRAWFL, 0x4 | flags);
+        t_outb(par, ROP_S, 0x2127);
+        writemmr(par, OLDSRC, point(x1_tmp, y1_tmp));
+        writemmr(par, OLDDST, point(x2_tmp, y2_tmp));
+        writemmr(par, OLDDIM, point(w - 1, h - 1));
+        t_outb(par, 1, OLDCMD);
+}
 
 /*
  * Accel functions called by the upper layers
@@ -484,129 +494,162 @@ static struct accel_switch accel_image = {
 static void tridentfb_fillrect(struct fb_info *info,
                                const struct fb_fillrect *fr)
 {
-        int bpp = info->var.bits_per_pixel;
-        int col = 0;
+        struct tridentfb_par *par = info->par;
+        int col;
 
-        switch (bpp) {
-        default:
-        case 8:
-                col |= fr->color;
+        if (info->flags & FBINFO_HWACCEL_DISABLED) {
+                cfb_fillrect(info, fr);
+                return;
+        }
+        if (info->var.bits_per_pixel == 8) {
+                col = fr->color;
                 col |= col << 8;
                 col |= col << 16;
-                break;
-        case 16:
+        } else
                 col = ((u32 *)(info->pseudo_palette))[fr->color];
-                break;
-        case 32:
-                col = ((u32 *)(info->pseudo_palette))[fr->color];
-                break;
+
+        par->wait_engine(par);
+        par->fill_rect(par, fr->dx, fr->dy, fr->width,
+                       fr->height, col, fr->rop);
+}
+
+static void tridentfb_imageblit(struct fb_info *info,
+                                const struct fb_image *img)
+{
+        struct tridentfb_par *par = info->par;
+        int col, bgcol;
+
+        if ((info->flags & FBINFO_HWACCEL_DISABLED) || img->depth != 1) {
+                cfb_imageblit(info, img);
+                return;
+        }
+        if (info->var.bits_per_pixel == 8) {
+                col = img->fg_color;
+                col |= col << 8;
+                col |= col << 16;
+                bgcol = img->bg_color;
+                bgcol |= bgcol << 8;
+                bgcol |= bgcol << 16;
+        } else {
+                col = ((u32 *)(info->pseudo_palette))[img->fg_color];
+                bgcol = ((u32 *)(info->pseudo_palette))[img->bg_color];
         }
 
-        acc->fill_rect(fr->dx, fr->dy, fr->width, fr->height, col, fr->rop);
-        acc->wait_engine();
+        par->wait_engine(par);
+        if (par->image_blit)
+                par->image_blit(par, img->data, img->dx, img->dy,
+                                img->width, img->height, col, bgcol);
+        else
+                cfb_imageblit(info, img);
 }
+
 static void tridentfb_copyarea(struct fb_info *info,
                                const struct fb_copyarea *ca)
 {
-        acc->copy_rect(ca->sx, ca->sy, ca->dx, ca->dy, ca->width, ca->height);
-        acc->wait_engine();
+        struct tridentfb_par *par = info->par;
+
+        if (info->flags & FBINFO_HWACCEL_DISABLED) {
+                cfb_copyarea(info, ca);
+                return;
+        }
+        par->wait_engine(par);
+        par->copy_rect(par, ca->sx, ca->sy, ca->dx, ca->dy,
+                       ca->width, ca->height);
+}
+
+static int tridentfb_sync(struct fb_info *info)
+{
+        struct tridentfb_par *par = info->par;
+
+        if (!(info->flags & FBINFO_HWACCEL_DISABLED))
+                par->wait_engine(par);
+        return 0;
 }
-#else /* !CONFIG_FB_TRIDENT_ACCEL */
+#else
 #define tridentfb_fillrect cfb_fillrect
 #define tridentfb_copyarea cfb_copyarea
+#define tridentfb_imageblit cfb_imageblit
 #endif /* CONFIG_FB_TRIDENT_ACCEL */
 
-
 /*
  * Hardware access functions
  */
 
-static inline unsigned char read3X4(int reg)
+static inline unsigned char read3X4(struct tridentfb_par *par, int reg)
 {
-        struct tridentfb_par *par = (struct tridentfb_par *)fb_info.par;
-        writeb(reg, par->io_virt + CRT + 4);
-        return readb(par->io_virt + CRT + 5);
+        return vga_mm_rcrt(par->io_virt, reg);
 }
 
-static inline void write3X4(int reg, unsigned char val)
+static inline void write3X4(struct tridentfb_par *par, int reg,
+                            unsigned char val)
 {
-        struct tridentfb_par *par = (struct tridentfb_par *)fb_info.par;
-        writeb(reg, par->io_virt + CRT + 4);
-        writeb(val, par->io_virt + CRT + 5);
+        vga_mm_wcrt(par->io_virt, reg, val);
 }
 
-static inline unsigned char read3C4(int reg)
+static inline unsigned char read3CE(struct tridentfb_par *par,
+                                    unsigned char reg)
 {
-        t_outb(reg, 0x3C4);
-        return t_inb(0x3C5);
+        return vga_mm_rgfx(par->io_virt, reg);
 }
 
-static inline void write3C4(int reg, unsigned char val)
+static inline void writeAttr(struct tridentfb_par *par, int reg,
+                             unsigned char val)
 {
-        t_outb(reg, 0x3C4);
-        t_outb(val, 0x3C5);
+        fb_readb(par->io_virt + VGA_IS1_RC);    /* flip-flop to index */
+        vga_mm_wattr(par->io_virt, reg, val);
 }
 
-static inline unsigned char read3CE(int reg)
+static inline void write3CE(struct tridentfb_par *par, int reg,
+                            unsigned char val)
 {
-        t_outb(reg, 0x3CE);
-        return t_inb(0x3CF);
+        vga_mm_wgfx(par->io_virt, reg, val);
 }
 
-static inline void writeAttr(int reg, unsigned char val)
-{
-        readb(((struct tridentfb_par *)fb_info.par)->io_virt + CRT + 0x0A);     /* flip-flop to index */
-        t_outb(reg, 0x3C0);
-        t_outb(val, 0x3C0);
-}
-
-static inline void write3CE(int reg, unsigned char val)
-{
-        t_outb(reg, 0x3CE);
-        t_outb(val, 0x3CF);
-}
-
-static void enable_mmio(void)
+static void enable_mmio(struct tridentfb_par *par)
 {
         /* Goto New Mode */
-        outb(0x0B, 0x3C4);
-        inb(0x3C5);
+        vga_io_rseq(0x0B);
 
         /* Unprotect registers */
-        outb(NewMode1, 0x3C4);
-        outb(0x80, 0x3C5);
+        vga_io_wseq(NewMode1, 0x80);
+        if (!is_oldprotect(par->chip_id))
+                vga_io_wseq(Protection, 0x92);
 
         /* Enable MMIO */
         outb(PCIReg, 0x3D4);
         outb(inb(0x3D5) | 0x01, 0x3D5);
 }
 
-static void disable_mmio(void)
+static void disable_mmio(struct tridentfb_par *par)
 {
         /* Goto New Mode */
-        t_outb(0x0B, 0x3C4);
-        t_inb(0x3C5);
+        vga_mm_rseq(par->io_virt, 0x0B);
 
         /* Unprotect registers */
-        t_outb(NewMode1, 0x3C4);
-        t_outb(0x80, 0x3C5);
+        vga_mm_wseq(par->io_virt, NewMode1, 0x80);
+        if (!is_oldprotect(par->chip_id))
+                vga_mm_wseq(par->io_virt, Protection, 0x92);
 
         /* Disable MMIO */
-        t_outb(PCIReg, 0x3D4);
-        t_outb(t_inb(0x3D5) & ~0x01, 0x3D5);
+        t_outb(par, PCIReg, 0x3D4);
+        t_outb(par, t_inb(par, 0x3D5) & ~0x01, 0x3D5);
 }
 
-#define crtc_unlock()   write3X4(CRTVSyncEnd, read3X4(CRTVSyncEnd) & 0x7F)
+static inline void crtc_unlock(struct tridentfb_par *par)
+{
+        write3X4(par, VGA_CRTC_V_SYNC_END,
+                 read3X4(par, VGA_CRTC_V_SYNC_END) & 0x7F);
+}
 
 /*  Return flat panel's maximum x resolution */
-static int __devinit get_nativex(void)
+static int __devinit get_nativex(struct tridentfb_par *par)
 {
         int x, y, tmp;
 
         if (nativex)
                 return nativex;
 
-        tmp = (read3CE(VertStretch) >> 4) & 3;
+        tmp = (read3CE(par, VertStretch) >> 4) & 3;
 
         switch (tmp) {
         case 0:
@@ -632,77 +675,92 @@ static int __devinit get_nativex(void)
 }
 
 /* Set pitch */
-static void set_lwidth(int width)
+static inline void set_lwidth(struct tridentfb_par *par, int width)
 {
-        write3X4(Offset, width & 0xFF);
-        write3X4(AddColReg,
-                 (read3X4(AddColReg) & 0xCF) | ((width & 0x300) >> 4));
+        write3X4(par, VGA_CRTC_OFFSET, width & 0xFF);
+        write3X4(par, AddColReg,
+                 (read3X4(par, AddColReg) & 0xCF) | ((width & 0x300) >> 4));
 }
 
 /* For resolutions smaller than FP resolution stretch */
-static void screen_stretch(void)
+static void screen_stretch(struct tridentfb_par *par)
 {
-        if (chip_id != CYBERBLADEXPAi1)
-                write3CE(BiosReg, 0);
+        if (par->chip_id != CYBERBLADEXPAi1)
+                write3CE(par, BiosReg, 0);
         else
-                write3CE(BiosReg, 8);
-        write3CE(VertStretch, (read3CE(VertStretch) & 0x7C) | 1);
-        write3CE(HorStretch, (read3CE(HorStretch) & 0x7C) | 1);
+                write3CE(par, BiosReg, 8);
+        write3CE(par, VertStretch, (read3CE(par, VertStretch) & 0x7C) | 1);
+        write3CE(par, HorStretch, (read3CE(par, HorStretch) & 0x7C) | 1);
 }
 
 /* For resolutions smaller than FP resolution center */
-static void screen_center(void)
+static inline void screen_center(struct tridentfb_par *par)
 {
-        write3CE(VertStretch, (read3CE(VertStretch) & 0x7C) | 0x80);
-        write3CE(HorStretch, (read3CE(HorStretch) & 0x7C) | 0x80);
+        write3CE(par, VertStretch, (read3CE(par, VertStretch) & 0x7C) | 0x80);
+        write3CE(par, HorStretch, (read3CE(par, HorStretch) & 0x7C) | 0x80);
 }
 
 /* Address of first shown pixel in display memory */
-static void set_screen_start(int base)
+static void set_screen_start(struct tridentfb_par *par, int base)
 {
-        write3X4(StartAddrLow, base & 0xFF);
-        write3X4(StartAddrHigh, (base & 0xFF00) >> 8);
-        write3X4(CRTCModuleTest,
-                 (read3X4(CRTCModuleTest) & 0xDF) | ((base & 0x10000) >> 11));
-        write3X4(CRTHiOrd,
-                 (read3X4(CRTHiOrd) & 0xF8) | ((base & 0xE0000) >> 17));
+        u8 tmp;
+        write3X4(par, VGA_CRTC_START_LO, base & 0xFF);
+        write3X4(par, VGA_CRTC_START_HI, (base & 0xFF00) >> 8);
+        tmp = read3X4(par, CRTCModuleTest) & 0xDF;
+        write3X4(par, CRTCModuleTest, tmp | ((base & 0x10000) >> 11));
+        tmp = read3X4(par, CRTHiOrd) & 0xF8;
+        write3X4(par, CRTHiOrd, tmp | ((base & 0xE0000) >> 17));
 }
 
 /* Set dotclock frequency */
-static void set_vclk(unsigned long freq)
+static void set_vclk(struct tridentfb_par *par, unsigned long freq)
 {
         int m, n, k;
-        unsigned long f, fi, d, di;
-        unsigned char lo = 0, hi = 0;
+        unsigned long fi, d, di;
+        unsigned char best_m = 0, best_n = 0, best_k = 0;
+        unsigned char hi, lo;
+        unsigned char shift = !is_oldclock(par->chip_id) ? 2 : 1;
 
         d = 20000;
-        for (k = 2; k >= 0; k--)
-                for (m = 0; m < 63; m++)
-                        for (n = 0; n < 128; n++) {
+        for (k = shift; k >= 0; k--)
+                for (m = 1; m < 32; m++) {
+                        n = ((m + 2) << shift) - 8;
+                        for (n = (n < 0 ? 0 : n); n < 122; n++) {
                                 fi = ((14318l * (n + 8)) / (m + 2)) >> k;
-                                if ((di = abs(fi - freq)) < d) {
+                                di = abs(fi - freq);
+                                if (di < d || (di == d && k == best_k)) {
                                         d = di;
-                                        f = fi;
-                                        lo = n;
-                                        hi = (k << 6) | m;
+                                        best_n = n;
+                                        best_m = m;
+                                        best_k = k;
                                 }
                                 if (fi > freq)
                                         break;
                         }
-        if (chip3D) {
-                write3C4(ClockHigh, hi);
-                write3C4(ClockLow, lo);
+                }
+
+        if (is_oldclock(par->chip_id)) {
+                lo = best_n | (best_m << 7);
+                hi = (best_m >> 1) | (best_k << 4);
         } else {
-                outb(lo, 0x43C8);
-                outb(hi, 0x43C9);
+                lo = best_n;
+                hi = best_m | (best_k << 6);
+        }
+
+        if (is3Dchip(par->chip_id)) {
+                vga_mm_wseq(par->io_virt, ClockHigh, hi);
+                vga_mm_wseq(par->io_virt, ClockLow, lo);
+        } else {
+                t_outb(par, lo, 0x43C8);
+                t_outb(par, hi, 0x43C9);
         }
         debug("VCLK = %X %X\n", hi, lo);
 }
 
 /* Set number of lines for flat panels*/
-static void set_number_of_lines(int lines)
+static void set_number_of_lines(struct tridentfb_par *par, int lines)
 {
-        int tmp = read3CE(CyberEnhance) & 0x8F;
+        int tmp = read3CE(par, CyberEnhance) & 0x8F;
         if (lines > 1024)
                 tmp |= 0x50;
         else if (lines > 768)
@@ -711,24 +769,24 @@ static void set_number_of_lines(int lines)
                 tmp |= 0x20;
         else if (lines > 480)
                 tmp |= 0x10;
-        write3CE(CyberEnhance, tmp);
+        write3CE(par, CyberEnhance, tmp);
 }
 
 /*
  * If we see that FP is active we assume we have one.
- * Otherwise we have a CRT display.User can override.
+ * Otherwise we have a CRT display. User can override.
  */
-static unsigned int __devinit get_displaytype(void)
+static int __devinit is_flatpanel(struct tridentfb_par *par)
 {
         if (fp)
-                return DISPLAY_FP;
-        if (crt || !chipcyber)
-                return DISPLAY_CRT;
-        return (read3CE(FPConfig) & 0x10) ? DISPLAY_FP : DISPLAY_CRT;
+                return 1;
+        if (crt || !iscyber(par->chip_id))
+                return 0;
+        return (read3CE(par, FPConfig) & 0x10) ? 1 : 0;
 }
 
 /* Try detecting the video memory size */
-static unsigned int __devinit get_memsize(void)
+static unsigned int __devinit get_memsize(struct tridentfb_par *par)
 {
         unsigned char tmp, tmp2;
         unsigned int k;
@@ -737,12 +795,12 @@ static unsigned int __devinit get_memsize(void)
         if (memsize)
                 k = memsize * Kb;
         else
-                switch (chip_id) {
+                switch (par->chip_id) {
                 case CYBER9525DVD:
                         k = 2560 * Kb;
                         break;
                 default:
-                        tmp = read3X4(SPR) & 0x0F;
+                        tmp = read3X4(par, SPR) & 0x0F;
                         switch (tmp) {
 
                         case 0x01:
@@ -774,7 +832,7 @@ static unsigned int __devinit get_memsize(void)
                                 break;
                         case 0x0E:              /* XP */
 
-                                tmp2 = read3C4(0xC1);
+                                tmp2 = vga_mm_rseq(par->io_virt, 0xC1);
                                 switch (tmp2) {
                                 case 0x00:
                                         k = 20 * Mb;
@@ -812,26 +870,67 @@ static unsigned int __devinit get_memsize(void)
 static int tridentfb_check_var(struct fb_var_screeninfo *var,
                                struct fb_info *info)
 {
+        struct tridentfb_par *par = info->par;
         int bpp = var->bits_per_pixel;
+        int line_length;
+        int ramdac = 230000; /* 230MHz for most 3D chips */
         debug("enter\n");
 
         /* check color depth */
         if (bpp == 24)
                 bpp = var->bits_per_pixel = 32;
+        if (bpp != 8 && bpp != 16 && bpp != 32)
+                return -EINVAL;
+        if (par->chip_id == TGUI9440 && bpp == 32)
+                return -EINVAL;
         /* check whether resolution fits on panel and in memory */
-        if (flatpanel && nativex && var->xres > nativex)
+        if (par->flatpanel && nativex && var->xres > nativex)
+                return -EINVAL;
+        /* various resolution checks */
+        var->xres = (var->xres + 7) & ~0x7;
+        if (var->xres > var->xres_virtual)
+                var->xres_virtual = var->xres;
+        if (var->yres > var->yres_virtual)
+                var->yres_virtual = var->yres;
+        if (var->xres_virtual > 4095 || var->yres > 2048)
                 return -EINVAL;
-        if (var->xres * var->yres_virtual * bpp / 8 > info->fix.smem_len)
+        /* prevent from position overflow for acceleration */
+        if (var->yres_virtual > 0xffff)
+                return -EINVAL;
+        line_length = var->xres_virtual * bpp / 8;
+
+        if (!is3Dchip(par->chip_id) &&
+            !(info->flags & FBINFO_HWACCEL_DISABLED)) {
+                /* acceleration requires line length to be power of 2 */
+                if (line_length <= 512)
+                        var->xres_virtual = 512 * 8 / bpp;
+                else if (line_length <= 1024)
+                        var->xres_virtual = 1024 * 8 / bpp;
+                else if (line_length <= 2048)
+                        var->xres_virtual = 2048 * 8 / bpp;
+                else if (line_length <= 4096)
+                        var->xres_virtual = 4096 * 8 / bpp;
+                else if (line_length <= 8192)
+                        var->xres_virtual = 8192 * 8 / bpp;
+                else
+                        return -EINVAL;
+
+                line_length = var->xres_virtual * bpp / 8;
+        }
+
+        /* datasheet specifies how to set panning only up to 4 MB */
+        if (line_length * (var->yres_virtual - var->yres) > (4 << 20))
+                var->yres_virtual = ((4 << 20) / line_length) + var->yres;
+
+        if (line_length * var->yres_virtual > info->fix.smem_len)
                 return -EINVAL;
 
         switch (bpp) {
         case 8:
                 var->red.offset = 0;
-                var->green.offset = 0;
-                var->blue.offset = 0;
-                var->red.length = 6;
-                var->green.length = 6;
-                var->blue.length = 6;
+                var->red.length = 8;
+                var->green = var->red;
+                var->blue = var->red;
                 break;
         case 16:
                 var->red.offset = 11;
@@ -852,6 +951,33 @@ static int tridentfb_check_var(struct fb_var_screeninfo *var,
         default:
                 return -EINVAL;
         }
+
+        if (is_xp(par->chip_id))
+                ramdac = 350000;
+
+        switch (par->chip_id) {
+        case TGUI9440:
+                ramdac = (bpp >= 16) ? 45000 : 90000;
+                break;
+        case CYBER9320:
+        case TGUI9660:
+                ramdac = 135000;
+                break;
+        case PROVIDIA9685:
+        case CYBER9388:
+        case CYBER9382:
+        case CYBER9385:
+                ramdac = 170000;
+                break;
+        }
+
+        /* The clock is doubled for 32 bpp */
+        if (bpp == 32)
+                ramdac /= 2;
+
+        if (PICOS2KHZ(var->pixclock) > ramdac)
+                return -EINVAL;
+
         debug("exit\n");
 
         return 0;
@@ -862,25 +988,31 @@ static int tridentfb_check_var(struct fb_var_screeninfo *var,
 static int tridentfb_pan_display(struct fb_var_screeninfo *var,
                                  struct fb_info *info)
 {
+        struct tridentfb_par *par = info->par;
         unsigned int offset;
 
         debug("enter\n");
-        offset = (var->xoffset + (var->yoffset * var->xres))
+        offset = (var->xoffset + (var->yoffset * var->xres_virtual))
                 * var->bits_per_pixel / 32;
-        info->var.xoffset = var->xoffset;
-        info->var.yoffset = var->yoffset;
-        set_screen_start(offset);
+        set_screen_start(par, offset);
         debug("exit\n");
         return 0;
 }
 
-#define shadowmode_on()  write3CE(CyberControl, read3CE(CyberControl) | 0x81)
-#define shadowmode_off() write3CE(CyberControl, read3CE(CyberControl) & 0x7E)
+static inline void shadowmode_on(struct tridentfb_par *par)
+{
+        write3CE(par, CyberControl, read3CE(par, CyberControl) | 0x81);
+}
+
+static inline void shadowmode_off(struct tridentfb_par *par)
+{
+        write3CE(par, CyberControl, read3CE(par, CyberControl) & 0x7E);
+}
 
 /* Set the hardware to the requested video mode */
 static int tridentfb_set_par(struct fb_info *info)
 {
-        struct tridentfb_par *par = (struct tridentfb_par *)(info->par);
+        struct tridentfb_par *par = info->par;
         u32 htotal, hdispend, hsyncstart, hsyncend, hblankstart, hblankend;
         u32 vtotal, vdispend, vsyncstart, vsyncend, vblankstart, vblankend;
         struct fb_var_screeninfo *var = &info->var;
@@ -891,58 +1023,73 @@ static int tridentfb_set_par(struct fb_info *info)
         debug("enter\n");
         hdispend = var->xres / 8 - 1;
         hsyncstart = (var->xres + var->right_margin) / 8;
-        hsyncend = var->hsync_len / 8;
-        htotal =
-                (var->xres + var->left_margin + var->right_margin +
-                 var->hsync_len) / 8 - 10;
+        hsyncend = (var->xres + var->right_margin + var->hsync_len) / 8;
+        htotal = (var->xres + var->left_margin + var->right_margin +
+                  var->hsync_len) / 8 - 5;
         hblankstart = hdispend + 1;
-        hblankend = htotal + 5;
+        hblankend = htotal + 3;
 
         vdispend = var->yres - 1;
         vsyncstart = var->yres + var->lower_margin;
-        vsyncend = var->vsync_len;
-        vtotal = var->upper_margin + vsyncstart + vsyncend - 2;
-        vblankstart = var->yres;
-        vblankend = vtotal + 2;
+        vsyncend = vsyncstart + var->vsync_len;
+        vtotal = var->upper_margin + vsyncend - 2;
+        vblankstart = vdispend + 1;
+        vblankend = vtotal;
+
+        if (info->var.vmode & FB_VMODE_INTERLACED) {
+                vtotal /= 2;
+                vdispend /= 2;
+                vsyncstart /= 2;
+                vsyncend /= 2;
+                vblankstart /= 2;
+                vblankend /= 2;
+        }
 
-        crtc_unlock();
-        write3CE(CyberControl, 8);
+        enable_mmio(par);
+        crtc_unlock(par);
+        write3CE(par, CyberControl, 8);
+        tmp = 0xEB;
+        if (var->sync & FB_SYNC_HOR_HIGH_ACT)
+                tmp &= ~0x40;
+        if (var->sync & FB_SYNC_VERT_HIGH_ACT)
+                tmp &= ~0x80;
 
-        if (flatpanel && var->xres < nativex) {
+        if (par->flatpanel && var->xres < nativex) {
                 /*
                  * on flat panels with native size larger
                  * than requested resolution decide whether
                  * we stretch or center
                  */
-                t_outb(0xEB, 0x3C2);
+                t_outb(par, tmp | 0xC0, VGA_MIS_W);
 
-                shadowmode_on();
+                shadowmode_on(par);
 
                 if (center)
-                        screen_center();
+                        screen_center(par);
                 else if (stretch)
-                        screen_stretch();
+                        screen_stretch(par);
 
         } else {
-                t_outb(0x2B, 0x3C2);
-                write3CE(CyberControl, 8);
+                t_outb(par, tmp, VGA_MIS_W);
+                write3CE(par, CyberControl, 8);
         }
 
         /* vertical timing values */
-        write3X4(CRTVTotal, vtotal & 0xFF);
-        write3X4(CRTVDispEnd, vdispend & 0xFF);
-        write3X4(CRTVSyncStart, vsyncstart & 0xFF);
-        write3X4(CRTVSyncEnd, (vsyncend & 0x0F));
-        write3X4(CRTVBlankStart, vblankstart & 0xFF);
-        write3X4(CRTVBlankEnd, 0 /* p->vblankend & 0xFF */ );
+        write3X4(par, VGA_CRTC_V_TOTAL, vtotal & 0xFF);
+        write3X4(par, VGA_CRTC_V_DISP_END, vdispend & 0xFF);
+        write3X4(par, VGA_CRTC_V_SYNC_START, vsyncstart & 0xFF);
+        write3X4(par, VGA_CRTC_V_SYNC_END, (vsyncend & 0x0F));
+        write3X4(par, VGA_CRTC_V_BLANK_START, vblankstart & 0xFF);
+        write3X4(par, VGA_CRTC_V_BLANK_END, vblankend & 0xFF);
 
         /* horizontal timing values */
-        write3X4(CRTHTotal, htotal & 0xFF);
-        write3X4(CRTHDispEnd, hdispend & 0xFF);
-        write3X4(CRTHSyncStart, hsyncstart & 0xFF);
-        write3X4(CRTHSyncEnd, (hsyncend & 0x1F) | ((hblankend & 0x20) << 2));
-        write3X4(CRTHBlankStart, hblankstart & 0xFF);
-        write3X4(CRTHBlankEnd, 0 /* (p->hblankend & 0x1F) */ );
+        write3X4(par, VGA_CRTC_H_TOTAL, htotal & 0xFF);
+        write3X4(par, VGA_CRTC_H_DISP, hdispend & 0xFF);
+        write3X4(par, VGA_CRTC_H_SYNC_START, hsyncstart & 0xFF);
+        write3X4(par, VGA_CRTC_H_SYNC_END,
+                 (hsyncend & 0x1F) | ((hblankend & 0x20) << 2));
+        write3X4(par, VGA_CRTC_H_BLANK_START, hblankstart & 0xFF);
+        write3X4(par, VGA_CRTC_H_BLANK_END, hblankend & 0x1F);
 
         /* higher bits of vertical timing values */
         tmp = 0x10;
@@ -954,39 +1101,43 @@ static int tridentfb_set_par(struct fb_info *info)
         if (vtotal & 0x200) tmp |= 0x20;
         if (vdispend & 0x200) tmp |= 0x40;
         if (vsyncstart & 0x200) tmp |= 0x80;
-        write3X4(CRTOverflow, tmp);
+        write3X4(par, VGA_CRTC_OVERFLOW, tmp);
 
-        tmp = read3X4(CRTHiOrd) | 0x08; /* line compare bit 10 */
+        tmp = read3X4(par, CRTHiOrd) & 0x07;
+        tmp |= 0x08;    /* line compare bit 10 */
         if (vtotal & 0x400) tmp |= 0x80;
         if (vblankstart & 0x400) tmp |= 0x40;
         if (vsyncstart & 0x400) tmp |= 0x20;
         if (vdispend & 0x400) tmp |= 0x10;
-        write3X4(CRTHiOrd, tmp);
+        write3X4(par, CRTHiOrd, tmp);
 
-        tmp = 0;
-        if (htotal & 0x800) tmp |= 0x800 >> 11;
-        if (hblankstart & 0x800) tmp |= 0x800 >> 7;
-        write3X4(HorizOverflow, tmp);
+        tmp = (htotal >> 8) & 0x01;
+        tmp |= (hdispend >> 7) & 0x02;
+        tmp |= (hsyncstart >> 5) & 0x08;
+        tmp |= (hblankstart >> 4) & 0x10;
+        write3X4(par, HorizOverflow, tmp);
 
         tmp = 0x40;
         if (vblankstart & 0x200) tmp |= 0x20;
 //FIXME if (info->var.vmode & FB_VMODE_DOUBLE) tmp |= 0x80;  /* double scan for 200 line modes */
-        write3X4(CRTMaxScanLine, tmp);
+        write3X4(par, VGA_CRTC_MAX_SCAN, tmp);
 
-        write3X4(CRTLineCompare, 0xFF);
-        write3X4(CRTPRowScan, 0);
-        write3X4(CRTModeControl, 0xC3);
+        write3X4(par, VGA_CRTC_LINE_COMPARE, 0xFF);
+        write3X4(par, VGA_CRTC_PRESET_ROW, 0);
+        write3X4(par, VGA_CRTC_MODE, 0xC3);
 
-        write3X4(LinearAddReg, 0x20);   /* enable linear addressing */
+        write3X4(par, LinearAddReg, 0x20);      /* enable linear addressing */
 
         tmp = (info->var.vmode & FB_VMODE_INTERLACED) ? 0x84 : 0x80;
-        write3X4(CRTCModuleTest, tmp);  /* enable access extended memory */
-
-        write3X4(GraphEngReg, 0x80);    /* enable GE for text acceleration */
+        /* enable access extended memory */
+        write3X4(par, CRTCModuleTest, tmp);
+        tmp = read3CE(par, MiscIntContReg) & ~0x4;
+        if (info->var.vmode & FB_VMODE_INTERLACED)
+                tmp |= 0x4;
+        write3CE(par, MiscIntContReg, tmp);
 
-#ifdef CONFIG_FB_TRIDENT_ACCEL
-        acc->init_accel(info->var.xres, bpp);
-#endif
+        /* enable GE for text acceleration */
+        write3X4(par, GraphEngReg, 0x80);
 
         switch (bpp) {
         case 8:
@@ -1003,57 +1154,59 @@ static int tridentfb_set_par(struct fb_info *info)
                 break;
         }
 
-        write3X4(PixelBusReg, tmp);
+        write3X4(par, PixelBusReg, tmp);
 
-        tmp = 0x10;
-        if (chipcyber)
+        tmp = read3X4(par, DRAMControl);
+        if (!is_oldprotect(par->chip_id))
+                tmp |= 0x10;
+        if (iscyber(par->chip_id))
                 tmp |= 0x20;
-        write3X4(DRAMControl, tmp);     /* both IO, linear enable */
-
-        write3X4(InterfaceSel, read3X4(InterfaceSel) | 0x40);
-        write3X4(Performance, 0x92);
-        write3X4(PCIReg, 0x07);         /* MMIO & PCI read and write burst enable */
+        write3X4(par, DRAMControl, tmp);        /* both IO, linear enable */
+
+        write3X4(par, InterfaceSel, read3X4(par, InterfaceSel) | 0x40);
+        if (!is_xp(par->chip_id))
+                write3X4(par, Performance, read3X4(par, Performance) | 0x10);
+        /* MMIO & PCI read and write burst enable */
+        if (par->chip_id != TGUI9440 && par->chip_id != IMAGE975)
+                write3X4(par, PCIReg, read3X4(par, PCIReg) | 0x06);
+
+        vga_mm_wseq(par->io_virt, 0, 3);
+        vga_mm_wseq(par->io_virt, 1, 1); /* set char clock 8 dots wide */
+        /* enable 4 maps because needed in chain4 mode */
+        vga_mm_wseq(par->io_virt, 2, 0x0F);
+        vga_mm_wseq(par->io_virt, 3, 0);
+        vga_mm_wseq(par->io_virt, 4, 0x0E); /* memory mode enable bitmaps ?? */
 
         /* convert from picoseconds to kHz */
         vclk = PICOS2KHZ(info->var.pixclock);
-        if (bpp == 32)
+
+        /* divide clock by 2 if 32bpp chain4 mode display and CPU path */
+        tmp = read3CE(par, MiscExtFunc) & 0xF0;
+        if (bpp == 32 || (par->chip_id == TGUI9440 && bpp == 16)) {
+                tmp |= 8;
                 vclk *= 2;
-        set_vclk(vclk);
-
-        write3C4(0, 3);
-        write3C4(1, 1);         /* set char clock 8 dots wide */
-        write3C4(2, 0x0F);      /* enable 4 maps because needed in chain4 mode */
-        write3C4(3, 0);
-        write3C4(4, 0x0E);      /* memory mode enable bitmaps ?? */
-
-        write3CE(MiscExtFunc, (bpp == 32) ? 0x1A : 0x12);       /* divide clock by 2 if 32bpp */
-                                                        /* chain4 mode display and CPU path */
-        write3CE(0x5, 0x40);    /* no CGA compat, allow 256 col */
-        write3CE(0x6, 0x05);    /* graphics mode */
-        write3CE(0x7, 0x0F);    /* planes? */
-
-        if (chip_id == CYBERBLADEXPAi1) {
-                /* This fixes snow-effect in 32 bpp */
-                write3X4(CRTHSyncStart, 0x84);
         }
+        set_vclk(par, vclk);
+        write3CE(par, MiscExtFunc, tmp | 0x12);
+        write3CE(par, 0x5, 0x40);       /* no CGA compat, allow 256 col */
+        write3CE(par, 0x6, 0x05);       /* graphics mode */
+        write3CE(par, 0x7, 0x0F);       /* planes? */
 
-        writeAttr(0x10, 0x41);  /* graphics mode and support 256 color modes */
-        writeAttr(0x12, 0x0F);  /* planes */
-        writeAttr(0x13, 0);     /* horizontal pel panning */
+        /* graphics mode and support 256 color modes */
+        writeAttr(par, 0x10, 0x41);
+        writeAttr(par, 0x12, 0x0F);     /* planes */
+        writeAttr(par, 0x13, 0);        /* horizontal pel panning */
 
         /* colors */
         for (tmp = 0; tmp < 0x10; tmp++)
-                writeAttr(tmp, tmp);
-        readb(par->io_virt + CRT + 0x0A);       /* flip-flop to index */
-        t_outb(0x20, 0x3C0);                    /* enable attr */
+                writeAttr(par, tmp, tmp);
+        fb_readb(par->io_virt + VGA_IS1_RC);    /* flip-flop to index */
+        t_outb(par, 0x20, VGA_ATT_W);           /* enable attr */
 
         switch (bpp) {
         case 8:
                 tmp = 0;
                 break;
-        case 15:
-                tmp = 0x10;
-                break;
         case 16:
                 tmp = 0x30;
                 break;
@@ -1063,19 +1216,23 @@ static int tridentfb_set_par(struct fb_info *info)
                 break;
         }
 
-        t_inb(0x3C8);
-        t_inb(0x3C6);
-        t_inb(0x3C6);
-        t_inb(0x3C6);
-        t_inb(0x3C6);
-        t_outb(tmp, 0x3C6);
-        t_inb(0x3C8);
-
-        if (flatpanel)
-                set_number_of_lines(info->var.yres);
-        set_lwidth(info->var.xres * bpp / (4 * 16));
+        t_inb(par, VGA_PEL_IW);
+        t_inb(par, VGA_PEL_MSK);
+        t_inb(par, VGA_PEL_MSK);
+        t_inb(par, VGA_PEL_MSK);
+        t_inb(par, VGA_PEL_MSK);
+        t_outb(par, tmp, VGA_PEL_MSK);
+        t_inb(par, VGA_PEL_IW);
+
+        if (par->flatpanel)
+                set_number_of_lines(par, info->var.yres);
+        info->fix.line_length = info->var.xres_virtual * bpp / 8;
+        set_lwidth(par, info->fix.line_length / 8);
+
+        if (!(info->flags & FBINFO_HWACCEL_DISABLED))
+                par->init_accel(par, info->var.xres_virtual, bpp);
+
         info->fix.visual = (bpp == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
-        info->fix.line_length = info->var.xres * (bpp >> 3);
         info->cmap.len = (bpp == 8) ? 256 : 16;
         debug("exit\n");
         return 0;
@@ -1087,17 +1244,18 @@ static int tridentfb_setcolreg(unsigned regno, unsigned red, unsigned green,
                                struct fb_info *info)
 {
         int bpp = info->var.bits_per_pixel;
+        struct tridentfb_par *par = info->par;
 
         if (regno >= info->cmap.len)
                 return 1;
 
         if (bpp == 8) {
-                t_outb(0xFF, 0x3C6);
-                t_outb(regno, 0x3C8);
+                t_outb(par, 0xFF, VGA_PEL_MSK);
+                t_outb(par, regno, VGA_PEL_IW);
 
-                t_outb(red >> 10, 0x3C9);
-                t_outb(green >> 10, 0x3C9);
-                t_outb(blue >> 10, 0x3C9);
+                t_outb(par, red >> 10, VGA_PEL_D);
+                t_outb(par, green >> 10, VGA_PEL_D);
+                t_outb(par, blue >> 10, VGA_PEL_D);
 
         } else if (regno < 16) {
                 if (bpp == 16) {        /* RGB 565 */
@@ -1108,28 +1266,28 @@ static int tridentfb_setcolreg(unsigned regno, unsigned red, unsigned green,
                         col |= col << 16;
                         ((u32 *)(info->pseudo_palette))[regno] = col;
                 } else if (bpp == 32)           /* ARGB 8888 */
-                        ((u32*)info->pseudo_palette)[regno] =
+                        ((u32 *)info->pseudo_palette)[regno] =
                                 ((transp & 0xFF00) << 16)       |
                                 ((red & 0xFF00) << 8)           |
                                 ((green & 0xFF00))              |
                                 ((blue & 0xFF00) >> 8);
         }
 
-/*      debug("exit\n"); */
         return 0;
 }
 
-/* Try blanking the screen.For flat panels it does nothing */
+/* Try blanking the screen. For flat panels it does nothing */
 static int tridentfb_blank(int blank_mode, struct fb_info *info)
 {
         unsigned char PMCont, DPMSCont;
+        struct tridentfb_par *par = info->par;
 
         debug("enter\n");
-        if (flatpanel)
+        if (par->flatpanel)
                 return 0;
-        t_outb(0x04, 0x83C8); /* Read DPMS Control */
-        PMCont = t_inb(0x83C6) & 0xFC;
-        DPMSCont = read3CE(PowerStatus) & 0xFC;
+        t_outb(par, 0x04, 0x83C8); /* Read DPMS Control */
+        PMCont = t_inb(par, 0x83C6) & 0xFC;
+        DPMSCont = read3CE(par, PowerStatus) & 0xFC;
         switch (blank_mode) {
         case FB_BLANK_UNBLANK:
                 /* Screen: On, HSync: On, VSync: On */
@@ -1155,9 +1313,9 @@ static int tridentfb_blank(int blank_mode, struct fb_info *info)
                 break;
         }
 
-        write3CE(PowerStatus, DPMSCont);
-        t_outb(4, 0x83C8);
-        t_outb(PMCont, 0x83C6);
+        write3CE(par, PowerStatus, DPMSCont);
+        t_outb(par, 4, 0x83C8);
+        t_outb(par, PMCont, 0x83C6);
 
         debug("exit\n");
 
@@ -1174,33 +1332,46 @@ static struct fb_ops tridentfb_ops = {
         .fb_set_par = tridentfb_set_par,
         .fb_fillrect = tridentfb_fillrect,
         .fb_copyarea = tridentfb_copyarea,
-        .fb_imageblit = cfb_imageblit,
+        .fb_imageblit = tridentfb_imageblit,
+#ifdef CONFIG_FB_TRIDENT_ACCEL
+        .fb_sync = tridentfb_sync,
+#endif
 };
 
-static int __devinit trident_pci_probe(struct pci_dev * dev,
-                                       const struct pci_device_id * id)
+static int __devinit trident_pci_probe(struct pci_dev *dev,
+                                       const struct pci_device_id *id)
 {
         int err;
         unsigned char revision;
+        struct fb_info *info;
+        struct tridentfb_par *default_par;
+        int chip3D;
+        int chip_id;
 
         err = pci_enable_device(dev);
         if (err)
                 return err;
 
-        chip_id = id->device;
+        info = framebuffer_alloc(sizeof(struct tridentfb_par), &dev->dev);
+        if (!info)
+                return -ENOMEM;
+        default_par = info->par;
 
-        if (chip_id == CYBERBLADEi1)
-                output("*** Please do use cyblafb, Cyberblade/i1 support "
-                       "will soon be removed from tridentfb!\n");
+        chip_id = id->device;
 
+#ifndef CONFIG_FB_TRIDENT_ACCEL
+        noaccel = 1;
+#endif
 
         /* If PCI id is 0x9660 then further detect chip type */
 
         if (chip_id == TGUI9660) {
-                outb(RevisionID, 0x3C4);
-                revision = inb(0x3C5);
+                revision = vga_io_rseq(RevisionID);
 
                 switch (revision) {
+                case 0x21:
+                        chip_id = PROVIDIA9685;
+                        break;
                 case 0x22:
                 case 0x23:
                         chip_id = CYBER9397;
@@ -1229,123 +1400,170 @@ static int __devinit trident_pci_probe(struct pci_dev * dev,
         }
 
         chip3D = is3Dchip(chip_id);
-        chipcyber = iscyber(chip_id);
 
         if (is_xp(chip_id)) {
-                acc = &accel_xp;
+                default_par->init_accel = xp_init_accel;
+                default_par->wait_engine = xp_wait_engine;
+                default_par->fill_rect = xp_fill_rect;
+                default_par->copy_rect = xp_copy_rect;
+                tridentfb_fix.accel = FB_ACCEL_TRIDENT_BLADEXP;
         } else if (is_blade(chip_id)) {
-                acc = &accel_blade;
-        } else {
-                acc = &accel_image;
+                default_par->init_accel = blade_init_accel;
+                default_par->wait_engine = blade_wait_engine;
+                default_par->fill_rect = blade_fill_rect;
+                default_par->copy_rect = blade_copy_rect;
+                default_par->image_blit = blade_image_blit;
+                tridentfb_fix.accel = FB_ACCEL_TRIDENT_BLADE3D;
+        } else if (chip3D) {                    /* 3DImage family left */
+                default_par->init_accel = image_init_accel;
+                default_par->wait_engine = image_wait_engine;
+                default_par->fill_rect = image_fill_rect;
+                default_par->copy_rect = image_copy_rect;
+                tridentfb_fix.accel = FB_ACCEL_TRIDENT_3DIMAGE;
+        } else {                                /* TGUI 9440/96XX family */
+                default_par->init_accel = tgui_init_accel;
+                default_par->wait_engine = xp_wait_engine;
+                default_par->fill_rect = tgui_fill_rect;
+                default_par->copy_rect = tgui_copy_rect;
+                tridentfb_fix.accel = FB_ACCEL_TRIDENT_TGUI;
         }
 
-        /* acceleration is on by default for 3D chips */
-        defaultaccel = chip3D && !noaccel;
-
-        fb_info.par = &default_par;
+        default_par->chip_id = chip_id;
 
         /* setup MMIO region */
         tridentfb_fix.mmio_start = pci_resource_start(dev, 1);
-        tridentfb_fix.mmio_len = chip3D ? 0x20000 : 0x10000;
+        tridentfb_fix.mmio_len = pci_resource_len(dev, 1);
 
-        if (!request_mem_region(tridentfb_fix.mmio_start, tridentfb_fix.mmio_len, "tridentfb")) {
+        if (!request_mem_region(tridentfb_fix.mmio_start,
+                                tridentfb_fix.mmio_len, "tridentfb")) {
                 debug("request_region failed!\n");
+                framebuffer_release(info);
                 return -1;
         }
 
-        default_par.io_virt = ioremap_nocache(tridentfb_fix.mmio_start, tridentfb_fix.mmio_len);
+        default_par->io_virt = ioremap_nocache(tridentfb_fix.mmio_start,
+                                               tridentfb_fix.mmio_len);
 
-        if (!default_par.io_virt) {
+        if (!default_par->io_virt) {
                 debug("ioremap failed\n");
                 err = -1;
                 goto out_unmap1;
         }
 
-        enable_mmio();
+        enable_mmio(default_par);
 
         /* setup framebuffer memory */
         tridentfb_fix.smem_start = pci_resource_start(dev, 0);
-        tridentfb_fix.smem_len = get_memsize();
+        tridentfb_fix.smem_len = get_memsize(default_par);
 
-        if (!request_mem_region(tridentfb_fix.smem_start, tridentfb_fix.smem_len, "tridentfb")) {
+        if (!request_mem_region(tridentfb_fix.smem_start,
+                                tridentfb_fix.smem_len, "tridentfb")) {
                 debug("request_mem_region failed!\n");
-                disable_mmio();
+                disable_mmio(info->par);
                 err = -1;
                 goto out_unmap1;
         }
 
-        fb_info.screen_base = ioremap_nocache(tridentfb_fix.smem_start,
-                                              tridentfb_fix.smem_len);
+        info->screen_base = ioremap_nocache(tridentfb_fix.smem_start,
+                                            tridentfb_fix.smem_len);
 
-        if (!fb_info.screen_base) {
+        if (!info->screen_base) {
                 debug("ioremap failed\n");
                 err = -1;
                 goto out_unmap2;
         }
 
-        output("%s board found\n", pci_name(dev));
-        displaytype = get_displaytype();
+        default_par->flatpanel = is_flatpanel(default_par);
 
-        if (flatpanel)
-                nativex = get_nativex();
+        if (default_par->flatpanel)
+                nativex = get_nativex(default_par);
 
-        fb_info.fix = tridentfb_fix;
-        fb_info.fbops = &tridentfb_ops;
+        info->fix = tridentfb_fix;
+        info->fbops = &tridentfb_ops;
+        info->pseudo_palette = default_par->pseudo_pal;
 
+        info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
+        if (!noaccel && default_par->init_accel) {
+                info->flags &= ~FBINFO_HWACCEL_DISABLED;
+                info->flags |= FBINFO_HWACCEL_COPYAREA;
+                info->flags |= FBINFO_HWACCEL_FILLRECT;
+        } else
+                info->flags |= FBINFO_HWACCEL_DISABLED;
 
-        fb_info.flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
-#ifdef CONFIG_FB_TRIDENT_ACCEL
-        fb_info.flags |= FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT;
-#endif
-        fb_info.pseudo_palette = pseudo_pal;
+        info->pixmap.addr = kmalloc(4096, GFP_KERNEL);
+        if (!info->pixmap.addr) {
+                err = -ENOMEM;
+                goto out_unmap2;
+        }
+
+        info->pixmap.size = 4096;
+        info->pixmap.buf_align = 4;
+        info->pixmap.scan_align = 1;
+        info->pixmap.access_align = 32;
+        info->pixmap.flags = FB_PIXMAP_SYSTEM;
 
-        if (!fb_find_mode(&default_var, &fb_info,
+        if (default_par->image_blit) {
+                info->flags |= FBINFO_HWACCEL_IMAGEBLIT;
+                info->pixmap.scan_align = 4;
+        }
+
+        if (noaccel) {
+                printk(KERN_DEBUG "disabling acceleration\n");
+                info->flags |= FBINFO_HWACCEL_DISABLED;
+                info->pixmap.scan_align = 1;
+        }
+
+        if (!fb_find_mode(&info->var, info,
                           mode_option, NULL, 0, NULL, bpp)) {
                 err = -EINVAL;
                 goto out_unmap2;
         }
-        err = fb_alloc_cmap(&fb_info.cmap, 256, 0);
+        err = fb_alloc_cmap(&info->cmap, 256, 0);
         if (err < 0)
                 goto out_unmap2;
 
-        if (defaultaccel && acc)
-                default_var.accel_flags |= FB_ACCELF_TEXT;
-        else
-                default_var.accel_flags &= ~FB_ACCELF_TEXT;
-        default_var.activate |= FB_ACTIVATE_NOW;
-        fb_info.var = default_var;
-        fb_info.device = &dev->dev;
-        if (register_framebuffer(&fb_info) < 0) {
-                printk(KERN_ERR "tridentfb: could not register Trident framebuffer\n");
-                fb_dealloc_cmap(&fb_info.cmap);
+        info->var.activate |= FB_ACTIVATE_NOW;
+        info->device = &dev->dev;
+        if (register_framebuffer(info) < 0) {
+                printk(KERN_ERR "tridentfb: could not register framebuffer\n");
+                fb_dealloc_cmap(&info->cmap);
                 err = -EINVAL;
                 goto out_unmap2;
         }
         output("fb%d: %s frame buffer device %dx%d-%dbpp\n",
-           fb_info.node, fb_info.fix.id, default_var.xres,
-           default_var.yres, default_var.bits_per_pixel);
+           info->node, info->fix.id, info->var.xres,
+           info->var.yres, info->var.bits_per_pixel);
+
+        pci_set_drvdata(dev, info);
         return 0;
 
 out_unmap2:
-        if (fb_info.screen_base)
-                iounmap(fb_info.screen_base);
+        kfree(info->pixmap.addr);
+        if (info->screen_base)
+                iounmap(info->screen_base);
         release_mem_region(tridentfb_fix.smem_start, tridentfb_fix.smem_len);
-        disable_mmio();
+        disable_mmio(info->par);
 out_unmap1:
-        if (default_par.io_virt)
-                iounmap(default_par.io_virt);
+        if (default_par->io_virt)
+                iounmap(default_par->io_virt);
         release_mem_region(tridentfb_fix.mmio_start, tridentfb_fix.mmio_len);
+        framebuffer_release(info);
         return err;
 }
 
 static void __devexit trident_pci_remove(struct pci_dev *dev)
 {
-        struct tridentfb_par *par = (struct tridentfb_par*)fb_info.par;
-        unregister_framebuffer(&fb_info);
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct tridentfb_par *par = info->par;
+
+        unregister_framebuffer(info);
         iounmap(par->io_virt);
-        iounmap(fb_info.screen_base);
+        iounmap(info->screen_base);
         release_mem_region(tridentfb_fix.smem_start, tridentfb_fix.smem_len);
         release_mem_region(tridentfb_fix.mmio_start, tridentfb_fix.mmio_len);
+        pci_set_drvdata(dev, NULL);
+        kfree(info->pixmap.addr);
+        framebuffer_release(info);
 }
 
 /* List of boards that we are trying to support */
@@ -1358,6 +1576,7 @@ static struct pci_device_id trident_devices[] = {
         {PCI_VENDOR_ID_TRIDENT, CYBERBLADEAi1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_TRIDENT, CYBERBLADEAi1D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_TRIDENT, CYBERBLADEE4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_TRIDENT, TGUI9440, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_TRIDENT, TGUI9660, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_TRIDENT, IMAGE975, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_TRIDENT, IMAGE985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
@@ -1399,9 +1618,9 @@ static int __init tridentfb_setup(char *options)
                 if (!strncmp(opt, "noaccel", 7))
                         noaccel = 1;
                 else if (!strncmp(opt, "fp", 2))
-                        displaytype = DISPLAY_FP;
+                        fp = 1;
                 else if (!strncmp(opt, "crt", 3))
-                        displaytype = DISPLAY_CRT;
+                        fp = 0;
                 else if (!strncmp(opt, "bpp=", 4))
                         bpp = simple_strtoul(opt + 4, NULL, 0);
                 else if (!strncmp(opt, "center", 6))
@@ -1430,7 +1649,6 @@ static int __init tridentfb_init(void)
                 return -ENODEV;
         tridentfb_setup(option);
 #endif
-        output("Trident framebuffer %s initializing\n", VERSION);
         return pci_register_driver(&tridentfb_pci_driver);
 }
 
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c
index cdbb56edb6cb..50744229c7a9 100644
--- a/drivers/video/uvesafb.c
+++ b/drivers/video/uvesafb.c
@@ -2054,8 +2054,8 @@ MODULE_PARM_DESC(maxhf,
 module_param(maxvf, ushort, 0);
 MODULE_PARM_DESC(maxvf,
         "Maximum vertical frequency [Hz], overrides EDID data");
-module_param_named(mode, mode_option, charp, 0);
-MODULE_PARM_DESC(mode,
+module_param(mode_option, charp, 0);
+MODULE_PARM_DESC(mode_option,
         "Specify initial video mode as \"<xres>x<yres>[-<bpp>][@<refresh>]\"");
 module_param(vbemode, ushort, 0);
 MODULE_PARM_DESC(vbemode,
diff --git a/drivers/video/vermilion/vermilion.h b/drivers/video/vermilion/vermilion.h
index c4aba59d4809..7491abfcf1fc 100644
--- a/drivers/video/vermilion/vermilion.h
+++ b/drivers/video/vermilion/vermilion.h
@@ -30,7 +30,6 @@
 #define _VERMILION_H_
 
 #include <linux/kernel.h>
-#include <linux/version.h>
 #include <linux/pci.h>
 #include <asm/atomic.h>
 #include <linux/mutex.h>
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index 072638a9528a..93fe08d6c78f 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -443,19 +443,29 @@ static int vfb_mmap(struct fb_info *info,
 }
 
 #ifndef MODULE
+/*
+ * The virtual framebuffer driver is only enabled if explicitly
+ * requested by passing 'video=vfb:' (or any actual options).
+ */
 static int __init vfb_setup(char *options)
 {
         char *this_opt;
 
+        vfb_enable = 0;
+
+        if (!options)
+                return 1;
+
         vfb_enable = 1;
 
-        if (!options || !*options)
+        if (!*options)
                 return 1;
 
         while ((this_opt = strsep(&options, ",")) != NULL) {
                 if (!*this_opt)
                         continue;
-                if (!strncmp(this_opt, "disable", 7))
+                /* Test disable for backwards compatibility */
+                if (!strcmp(this_opt, "disable"))
                         vfb_enable = 0;
         }
         return 1;
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index 9b3c5923365e..e31bca8a0cb2 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -26,18 +26,6 @@
 #include <asm/io.h>
 #include <video/vga.h>
 
-#define GRAPHICS_ADDR_REG VGA_GFX_I     /* Graphics address register. */
-#define GRAPHICS_DATA_REG VGA_GFX_D     /* Graphics data register. */
-
-#define SET_RESET_INDEX         VGA_GFX_SR_VALUE        /* Set/Reset Register index. */
-#define ENABLE_SET_RESET_INDEX  VGA_GFX_SR_ENABLE       /* Enable Set/Reset Register index. */
-#define DATA_ROTATE_INDEX       VGA_GFX_DATA_ROTATE     /* Data Rotate Register index. */
-#define GRAPHICS_MODE_INDEX     VGA_GFX_MODE            /* Graphics Mode Register index. */
-#define BIT_MASK_INDEX          VGA_GFX_BIT_MASK        /* Bit Mask Register index. */
-
-#define dac_reg (VGA_PEL_IW)
-#define dac_val (VGA_PEL_D)
-
 #define VGA_FB_PHYS 0xA0000
 #define VGA_FB_PHYS_LEN 65536
 
@@ -108,7 +96,7 @@ static struct fb_fix_screeninfo vga16fb_fix __initdata = {
         .visual         = FB_VISUAL_PSEUDOCOLOR,
         .xpanstep       = 8,
         .ypanstep       = 1,
-        .line_length    = 640/8,
+        .line_length    = 640 / 8,
         .accel          = FB_ACCEL_NONE
 };
 
@@ -135,23 +123,22 @@ static inline int setmode(int mode)
 {
         int oldmode;
         
-        vga_io_w(GRAPHICS_ADDR_REG, GRAPHICS_MODE_INDEX);
-        oldmode = vga_io_r(GRAPHICS_DATA_REG);
-        vga_io_w(GRAPHICS_DATA_REG, mode);
+        oldmode = vga_io_rgfx(VGA_GFX_MODE);
+        vga_io_w(VGA_GFX_D, mode);
         return oldmode;
 }
 
 /* Select the Bit Mask Register and return its value. */
 static inline int selectmask(void)
 {
-        return vga_io_rgfx(BIT_MASK_INDEX);
+        return vga_io_rgfx(VGA_GFX_BIT_MASK);
 }
 
 /* Set the value of the Bit Mask Register.  It must already have been
    selected with selectmask(). */
 static inline void setmask(int mask)
 {
-        vga_io_w(GRAPHICS_DATA_REG, mask);
+        vga_io_w(VGA_GFX_D, mask);
 }
 
 /* Set the Data Rotate Register and return its old value. 
@@ -161,9 +148,8 @@ static inline int setop(int op)
 {
         int oldop;
         
-        vga_io_w(GRAPHICS_ADDR_REG, DATA_ROTATE_INDEX);
-        oldop = vga_io_r(GRAPHICS_DATA_REG);
-        vga_io_w(GRAPHICS_DATA_REG, op);
+        oldop = vga_io_rgfx(VGA_GFX_DATA_ROTATE);
+        vga_io_w(VGA_GFX_D, op);
         return oldop;
 }
 
@@ -173,9 +159,8 @@ static inline int setsr(int sr)
 {
         int oldsr;
 
-        vga_io_w(GRAPHICS_ADDR_REG, ENABLE_SET_RESET_INDEX);
-        oldsr = vga_io_r(GRAPHICS_DATA_REG);
-        vga_io_w(GRAPHICS_DATA_REG, sr);
+        oldsr = vga_io_rgfx(VGA_GFX_SR_ENABLE);
+        vga_io_w(VGA_GFX_D, sr);
         return oldsr;
 }
 
@@ -184,22 +169,21 @@ static inline int setcolor(int color)
 {
         int oldcolor;
 
-        vga_io_w(GRAPHICS_ADDR_REG, SET_RESET_INDEX);
-        oldcolor = vga_io_r(GRAPHICS_DATA_REG);
-        vga_io_w(GRAPHICS_DATA_REG, color);
+        oldcolor = vga_io_rgfx(VGA_GFX_SR_VALUE);
+        vga_io_w(VGA_GFX_D, color);
         return oldcolor;
 }
 
 /* Return the value in the Graphics Address Register. */
 static inline int getindex(void)
 {
-        return vga_io_r(GRAPHICS_ADDR_REG);
+        return vga_io_r(VGA_GFX_I);
 }
 
 /* Set the value in the Graphics Address Register. */
 static inline void setindex(int index)
 {
-        vga_io_w(GRAPHICS_ADDR_REG, index);
+        vga_io_w(VGA_GFX_I, index);
 }
 
 static void vga16fb_pan_var(struct fb_info *info, 
@@ -672,10 +656,10 @@ static void ega16_setpalette(int regno, unsigned red, unsigned green, unsigned b
 
 static void vga16_setpalette(int regno, unsigned red, unsigned green, unsigned blue)
 {
-        outb(regno,       dac_reg);
-        outb(red   >> 10, dac_val);
-        outb(green >> 10, dac_val);
-        outb(blue  >> 10, dac_val);
+        outb(regno,       VGA_PEL_IW);
+        outb(red   >> 10, VGA_PEL_D);
+        outb(green >> 10, VGA_PEL_D);
+        outb(blue  >> 10, VGA_PEL_D);
 }
 
 static int vga16fb_setcolreg(unsigned regno, unsigned red, unsigned green,
@@ -719,28 +703,15 @@ static int vga16fb_pan_display(struct fb_var_screeninfo *var,
    blanking code was originally by Huang shi chao, and modified by
    Christoph Rimek (chrimek@toppoint.de) and todd j. derr
    (tjd@barefoot.org) for Linux. */
-#define attrib_port             VGA_ATC_IW
-#define seq_port_reg            VGA_SEQ_I
-#define seq_port_val            VGA_SEQ_D
-#define gr_port_reg             VGA_GFX_I
-#define gr_port_val             VGA_GFX_D
-#define video_misc_rd           VGA_MIS_R
-#define video_misc_wr           VGA_MIS_W
-#define vga_video_port_reg      VGA_CRT_IC
-#define vga_video_port_val      VGA_CRT_DC
 
 static void vga_vesa_blank(struct vga16fb_par *par, int mode)
 {
-        unsigned char SeqCtrlIndex;
-        unsigned char CrtCtrlIndex;
+        unsigned char SeqCtrlIndex = vga_io_r(VGA_SEQ_I);
+        unsigned char CrtCtrlIndex = vga_io_r(VGA_CRT_IC);
         
-        //cli();
-        SeqCtrlIndex = vga_io_r(seq_port_reg);
-        CrtCtrlIndex = vga_io_r(vga_video_port_reg);
-
         /* save original values of VGA controller registers */
         if(!par->vesa_blanked) {
-                par->vga_state.CrtMiscIO = vga_io_r(video_misc_rd);
+                par->vga_state.CrtMiscIO = vga_io_r(VGA_MIS_R);
                 //sti();
 
                 par->vga_state.HorizontalTotal = vga_io_rcrt(0x00);     /* HorizontalTotal */
@@ -756,12 +727,11 @@ static void vga_vesa_blank(struct vga16fb_par *par, int mode)
 
         /* assure that video is enabled */
         /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
-        //cli();
         vga_io_wseq(0x01, par->vga_state.ClockingMode | 0x20);
 
         /* test for vertical retrace in process.... */
         if ((par->vga_state.CrtMiscIO & 0x80) == 0x80)
-                vga_io_w(video_misc_wr, par->vga_state.CrtMiscIO & 0xef);
+                vga_io_w(VGA_MIS_W, par->vga_state.CrtMiscIO & 0xef);
 
         /*
          * Set <End of vertical retrace> to minimum (0) and
@@ -769,12 +739,10 @@ static void vga_vesa_blank(struct vga16fb_par *par, int mode)
          * Result: turn off vertical sync (VSync) pulse.
          */
         if (mode & FB_BLANK_VSYNC_SUSPEND) {
-                outb_p(0x10,vga_video_port_reg);        /* StartVertRetrace */
-                outb_p(0xff,vga_video_port_val);        /* maximum value */
-                outb_p(0x11,vga_video_port_reg);        /* EndVertRetrace */
-                outb_p(0x40,vga_video_port_val);        /* minimum (bits 0..3)  */
-                outb_p(0x07,vga_video_port_reg);        /* Overflow */
-                outb_p(par->vga_state.Overflow | 0x84,vga_video_port_val); /* bits 9,10 of vert. retrace */
+                vga_io_wcrt(VGA_CRTC_V_SYNC_START, 0xff);
+                vga_io_wcrt(VGA_CRTC_V_SYNC_END, 0x40);
+                /* bits 9,10 of vert. retrace */
+                vga_io_wcrt(VGA_CRTC_OVERFLOW, par->vga_state.Overflow | 0x84);
         }
 
         if (mode & FB_BLANK_HSYNC_SUSPEND) {
@@ -783,29 +751,22 @@ static void vga_vesa_blank(struct vga16fb_par *par, int mode)
                  *  <Start of horizontal Retrace> to maximum
                  * Result: turn off horizontal sync (HSync) pulse.
                  */
-                outb_p(0x04,vga_video_port_reg);        /* StartHorizRetrace */
-                outb_p(0xff,vga_video_port_val);        /* maximum */
-                outb_p(0x05,vga_video_port_reg);        /* EndHorizRetrace */
-                outb_p(0x00,vga_video_port_val);        /* minimum (0) */
+                vga_io_wcrt(VGA_CRTC_H_SYNC_START, 0xff);
+                vga_io_wcrt(VGA_CRTC_H_SYNC_END, 0x00);
         }
 
         /* restore both index registers */
-        outb_p(SeqCtrlIndex,seq_port_reg);
-        outb_p(CrtCtrlIndex,vga_video_port_reg);
-        //sti();
+        outb_p(SeqCtrlIndex, VGA_SEQ_I);
+        outb_p(CrtCtrlIndex, VGA_CRT_IC);
 }
 
 static void vga_vesa_unblank(struct vga16fb_par *par)
 {
-        unsigned char SeqCtrlIndex;
-        unsigned char CrtCtrlIndex;
+        unsigned char SeqCtrlIndex = vga_io_r(VGA_SEQ_I);
+        unsigned char CrtCtrlIndex = vga_io_r(VGA_CRT_IC);
         
-        //cli();
-        SeqCtrlIndex = vga_io_r(seq_port_reg);
-        CrtCtrlIndex = vga_io_r(vga_video_port_reg);
-
         /* restore original values of VGA controller registers */
-        vga_io_w(video_misc_wr, par->vga_state.CrtMiscIO);
+        vga_io_w(VGA_MIS_W, par->vga_state.CrtMiscIO);
 
         /* HorizontalTotal */
         vga_io_wcrt(0x00, par->vga_state.HorizontalTotal);
@@ -827,9 +788,8 @@ static void vga_vesa_unblank(struct vga16fb_par *par)
         vga_io_wseq(0x01, par->vga_state.ClockingMode);
 
         /* restore index/control registers */
-        vga_io_w(seq_port_reg, SeqCtrlIndex);
-        vga_io_w(vga_video_port_reg, CrtCtrlIndex);
-        //sti();
+        vga_io_w(VGA_SEQ_I, SeqCtrlIndex);
+        vga_io_w(VGA_CRT_IC, CrtCtrlIndex);
 }
 
 static void vga_pal_blank(void)
@@ -837,10 +797,10 @@ static void vga_pal_blank(void)
         int i;
 
         for (i=0; i<16; i++) {
-                outb_p (i, dac_reg) ;
-                outb_p (0, dac_val) ;
-                outb_p (0, dac_val) ;
-                outb_p (0, dac_val) ;
+                outb_p(i, VGA_PEL_IW);
+                outb_p(0, VGA_PEL_D);
+                outb_p(0, VGA_PEL_D);
+                outb_p(0, VGA_PEL_D);
         }
 }
 
@@ -1087,12 +1047,15 @@ static void vga16fb_copyarea(struct fb_info *info, const struct fb_copyarea *are
         width = x2 - dx;
         height = y2 - dy;
 
+        if (sx + dx < old_dx || sy + dy < old_dy)
+                return;
+
         /* update sx1,sy1 */
         sx += (dx - old_dx);
         sy += (dy - old_dy);
 
         /* the source must be completely inside the virtual screen */
-        if (sx < 0 || sy < 0 || (sx + width) > vxres || (sy + height) > vyres)
+        if (sx + width > vxres || sy + height > vyres)
                 return;
 
         switch (info->fix.type) {
@@ -1482,6 +1445,7 @@ static void __exit vga16fb_exit(void)
         platform_driver_unregister(&vga16fb_driver);
 }
 
+MODULE_DESCRIPTION("Legacy VGA framebuffer device driver");
 MODULE_LICENSE("GPL");
 module_init(vga16fb_init);
 module_exit(vga16fb_exit);
diff --git a/drivers/video/vt8623fb.c b/drivers/video/vt8623fb.c
index 536ab11623f0..3df17dc8c3d7 100644
--- a/drivers/video/vt8623fb.c
+++ b/drivers/video/vt8623fb.c
@@ -12,7 +12,6 @@
  * (http://davesdomain.org.uk/viafb/)
  */
 
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -677,13 +676,13 @@ static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_devi
 
         rc = pci_enable_device(dev);
         if (rc < 0) {
-                dev_err(info->dev, "cannot enable PCI device\n");
+                dev_err(info->device, "cannot enable PCI device\n");
                 goto err_enable_device;
         }
 
         rc = pci_request_regions(dev, "vt8623fb");
         if (rc < 0) {
-                dev_err(info->dev, "cannot reserve framebuffer region\n");
+                dev_err(info->device, "cannot reserve framebuffer region\n");
                 goto err_request_regions;
         }
 
@@ -696,14 +695,14 @@ static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_devi
         info->screen_base = pci_iomap(dev, 0, 0);
         if (! info->screen_base) {
                 rc = -ENOMEM;
-                dev_err(info->dev, "iomap for framebuffer failed\n");
+                dev_err(info->device, "iomap for framebuffer failed\n");
                 goto err_iomap_1;
         }
 
         par->mmio_base = pci_iomap(dev, 1, 0);
         if (! par->mmio_base) {
                 rc = -ENOMEM;
-                dev_err(info->dev, "iomap for MMIO failed\n");
+                dev_err(info->device, "iomap for MMIO failed\n");
                 goto err_iomap_2;
         }
 
@@ -714,7 +713,7 @@ static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_devi
         if ((16 <= memsize1) && (memsize1 <= 64) && (memsize1 == memsize2))
                 info->screen_size = memsize1 << 20;
         else {
-                dev_err(info->dev, "memory size detection failed (%x %x), suppose 16 MB\n", memsize1, memsize2);
+                dev_err(info->device, "memory size detection failed (%x %x), suppose 16 MB\n", memsize1, memsize2);
                 info->screen_size = 16 << 20;
         }
 
@@ -731,19 +730,19 @@ static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_devi
         rc = fb_find_mode(&(info->var), info, mode_option, NULL, 0, NULL, 8);
         if (! ((rc == 1) || (rc == 2))) {
                 rc = -EINVAL;
-                dev_err(info->dev, "mode %s not found\n", mode_option);
+                dev_err(info->device, "mode %s not found\n", mode_option);
                 goto err_find_mode;
         }
 
         rc = fb_alloc_cmap(&info->cmap, 256, 0);
         if (rc < 0) {
-                dev_err(info->dev, "cannot allocate colormap\n");
+                dev_err(info->device, "cannot allocate colormap\n");
                 goto err_alloc_cmap;
         }
 
         rc = register_framebuffer(info);
         if (rc < 0) {
-                dev_err(info->dev, "cannot register framebugger\n");
+                dev_err(info->device, "cannot register framebugger\n");
                 goto err_reg_fb;
         }
 
@@ -817,7 +816,7 @@ static int vt8623_pci_suspend(struct pci_dev* dev, pm_message_t state)
         struct fb_info *info = pci_get_drvdata(dev);
         struct vt8623fb_info *par = info->par;
 
-        dev_info(info->dev, "suspend\n");
+        dev_info(info->device, "suspend\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
@@ -848,16 +847,13 @@ static int vt8623_pci_resume(struct pci_dev* dev)
         struct fb_info *info = pci_get_drvdata(dev);
         struct vt8623fb_info *par = info->par;
 
-        dev_info(info->dev, "resume\n");
+        dev_info(info->device, "resume\n");
 
         acquire_console_sem();
         mutex_lock(&(par->open_lock));
 
-        if (par->ref_count == 0) {
-                mutex_unlock(&(par->open_lock));
-                release_console_sem();
-                return 0;
-        }
+        if (par->ref_count == 0)
+                goto fail;
 
         pci_set_power_state(dev, PCI_D0);
         pci_restore_state(dev);
@@ -870,8 +866,8 @@ static int vt8623_pci_resume(struct pci_dev* dev)
         vt8623fb_set_par(info);
         fb_set_suspend(info, 0);
 
-        mutex_unlock(&(par->open_lock));
 fail:
+        mutex_unlock(&(par->open_lock));
         release_console_sem();
 
         return 0;
diff --git a/drivers/video/xilinxfb.c b/drivers/video/xilinxfb.c
index 7b3a8423f485..5da3d2423cc0 100644
--- a/drivers/video/xilinxfb.c
+++ b/drivers/video/xilinxfb.c
@@ -24,7 +24,6 @@
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/version.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>