58 files changed, 1272 insertions, 524 deletions
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index fb9d8d0b2c04..758435f8a6f8 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -503,7 +503,7 @@ config FB_VALKYRIE
 config FB_CT65550
        bool "Chips 65550 display support"
-        depends on (FB = y) && PPC32
+        depends on (FB = y) && PPC32 && PCI
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
@@ -641,6 +641,17 @@ config FB_VESA
          You will get a boot time penguin logo at no additional cost. Please
          read <file:Documentation/fb/vesafb.txt>. If unsure, say Y.
+config FB_EFI
+        bool "EFI-based Framebuffer Support"
+        depends on (FB = y) && X86
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This is the EFI frame buffer device driver. If the firmware on
+          your platform is UEFI2.0, select Y to add support for
+          Graphics Output Protocol for early console messages to appear.
 config FB_IMAC
        bool "Intel-based Macintosh Framebuffer Support"
        depends on (FB = y) && X86 && EFI
@@ -878,7 +889,7 @@ config FB_S1D13XXX
 config FB_ATMEL
        tristate "AT91/AT32 LCD Controller support"
-        depends on FB && (ARCH_AT91SAM9261 || ARCH_AT91SAM9263 || AVR32)
+        depends on FB && (ARCH_AT91SAM9261 || ARCH_AT91SAM9263 || ARCH_AT91SAM9RL || ARCH_AT91CAP9 || AVR32)
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
@@ -1509,7 +1520,7 @@ config FB_VOODOO1
          WARNING: Do not use any application that uses the 3D engine
          (namely glide) while using this driver.
-          Please read the <file:Documentation/fb/README-sstfb.txt> for supported
+          Please read the <file:Documentation/fb/sstfb.txt> for supported
          options and other important info  support.
 config FB_VT8623
@@ -1807,7 +1818,7 @@ config FB_SM501
          This driver is also available as a module ( = code which can be
          inserted and removed from the running kernel whenever you want). The
          module will be called sm501fb. If you want to compile it as a module,
-          say M here and read <file:Documentation/modules.txt>.
+          say M here and read <file:Documentation/kbuild/modules.txt>.
          If unsure, say N.
@@ -1892,9 +1903,7 @@ config FB_VIRTUAL
          If unsure, say N.
-if ARCH_OMAP
+source "drivers/video/omap/Kconfig"
-        source "drivers/video/omap/Kconfig"
-endif
 source "drivers/video/backlight/Kconfig"
 source "drivers/video/display/Kconfig"
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 59d6c45a910d..83e02b3429b6 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -118,6 +118,7 @@ obj-$(CONFIG_FB_OMAP)             += omap/
 obj-$(CONFIG_FB_UVESA)            += uvesafb.o
 obj-$(CONFIG_FB_VESA)             += vesafb.o
 obj-$(CONFIG_FB_IMAC)             += imacfb.o
+obj-$(CONFIG_FB_EFI)              += efifb.o
 obj-$(CONFIG_FB_VGA16)            += vga16fb.o
 obj-$(CONFIG_FB_OF)               += offb.o
 obj-$(CONFIG_FB_BF54X_LQ043)      += bf54x-lq043fb.o
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 235b618b4117..fc65c02306dd 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -16,6 +16,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/backlight.h>
 #include <asm/arch/board.h>
 #include <asm/arch/cpu.h>
@@ -30,7 +31,7 @@
 #define ATMEL_LCDC_CVAL_DEFAULT         0xc8
 #define ATMEL_LCDC_DMA_BURST_LEN        8
-#if defined(CONFIG_ARCH_AT91SAM9263)
+#if defined(CONFIG_ARCH_AT91SAM9263) || defined(CONFIG_ARCH_AT91CAP9)
 #define ATMEL_LCDC_FIFO_SIZE            2048
 #else
 #define ATMEL_LCDC_FIFO_SIZE            512
@@ -69,6 +70,107 @@ static void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info *sinfo,
 }
 #endif
+static const u32 contrast_ctr = ATMEL_LCDC_PS_DIV8
+                | ATMEL_LCDC_POL_POSITIVE
+                | ATMEL_LCDC_ENA_PWMENABLE;
+#ifdef CONFIG_BACKLIGHT_ATMEL_LCDC
+/* some bl->props field just changed */
+static int atmel_bl_update_status(struct backlight_device *bl)
+{
+        struct atmel_lcdfb_info *sinfo = bl_get_data(bl);
+        int                     power = sinfo->bl_power;
+        int                     brightness = bl->props.brightness;
+        /* REVISIT there may be a meaningful difference between
+         * fb_blank and power ... there seem to be some cases
+         * this doesn't handle correctly.
+         */
+        if (bl->props.fb_blank != sinfo->bl_power)
+                power = bl->props.fb_blank;
+        else if (bl->props.power != sinfo->bl_power)
+                power = bl->props.power;
+        if (brightness < 0 && power == FB_BLANK_UNBLANK)
+                brightness = lcdc_readl(sinfo, ATMEL_LCDC_CONTRAST_VAL);
+        else if (power != FB_BLANK_UNBLANK)
+                brightness = 0;
+        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_VAL, brightness);
+        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR,
+                        brightness ? contrast_ctr : 0);
+        bl->props.fb_blank = bl->props.power = sinfo->bl_power = power;
+        return 0;
+}
+static int atmel_bl_get_brightness(struct backlight_device *bl)
+{
+        struct atmel_lcdfb_info *sinfo = bl_get_data(bl);
+        return lcdc_readl(sinfo, ATMEL_LCDC_CONTRAST_VAL);
+}
+static struct backlight_ops atmel_lcdc_bl_ops = {
+        .update_status = atmel_bl_update_status,
+        .get_brightness = atmel_bl_get_brightness,
+};
+static void init_backlight(struct atmel_lcdfb_info *sinfo)
+{
+        struct backlight_device *bl;
+        sinfo->bl_power = FB_BLANK_UNBLANK;
+        if (sinfo->backlight)
+                return;
+        bl = backlight_device_register("backlight", &sinfo->pdev->dev,
+                        sinfo, &atmel_lcdc_bl_ops);
+        if (IS_ERR(sinfo->backlight)) {
+                dev_err(&sinfo->pdev->dev, "error %ld on backlight register\n",
+                                PTR_ERR(bl));
+                return;
+        }
+        sinfo->backlight = bl;
+        bl->props.power = FB_BLANK_UNBLANK;
+        bl->props.fb_blank = FB_BLANK_UNBLANK;
+        bl->props.max_brightness = 0xff;
+        bl->props.brightness = atmel_bl_get_brightness(bl);
+}
+static void exit_backlight(struct atmel_lcdfb_info *sinfo)
+{
+        if (sinfo->backlight)
+                backlight_device_unregister(sinfo->backlight);
+}
+#else
+static void init_backlight(struct atmel_lcdfb_info *sinfo)
+{
+        dev_warn(&sinfo->pdev->dev, "backlight control is not available\n");
+}
+static void exit_backlight(struct atmel_lcdfb_info *sinfo)
+{
+}
+#endif
+static void init_contrast(struct atmel_lcdfb_info *sinfo)
+{
+        /* have some default contrast/backlight settings */
+        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, contrast_ctr);
+        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_VAL, ATMEL_LCDC_CVAL_DEFAULT);
+        if (sinfo->lcdcon_is_backlight)
+                init_backlight(sinfo);
+}
 static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
        .type           = FB_TYPE_PACKED_PIXELS,
@@ -203,6 +305,26 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
        var->transp.offset = var->transp.length = 0;
        var->xoffset = var->yoffset = 0;
+        /* Saturate vertical and horizontal timings at maximum values */
+        var->vsync_len = min_t(u32, var->vsync_len,
+                        (ATMEL_LCDC_VPW >> ATMEL_LCDC_VPW_OFFSET) + 1);
+        var->upper_margin = min_t(u32, var->upper_margin,
+                        ATMEL_LCDC_VBP >> ATMEL_LCDC_VBP_OFFSET);
+        var->lower_margin = min_t(u32, var->lower_margin,
+                        ATMEL_LCDC_VFP);
+        var->right_margin = min_t(u32, var->right_margin,
+                        (ATMEL_LCDC_HFP >> ATMEL_LCDC_HFP_OFFSET) + 1);
+        var->hsync_len = min_t(u32, var->hsync_len,
+                        (ATMEL_LCDC_HPW >> ATMEL_LCDC_HPW_OFFSET) + 1);
+        var->left_margin = min_t(u32, var->left_margin,
+                        ATMEL_LCDC_HBP + 1);
+        /* Some parameters can't be zero */
+        var->vsync_len = max_t(u32, var->vsync_len, 1);
+        var->right_margin = max_t(u32, var->right_margin, 1);
+        var->hsync_len = max_t(u32, var->hsync_len, 1);
+        var->left_margin = max_t(u32, var->left_margin, 1);
        switch (var->bits_per_pixel) {
        case 1:
        case 2:
@@ -268,6 +390,10 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
        /* 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);
        if (info->var.bits_per_pixel == 1)
@@ -366,10 +492,6 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
        /* Disable all interrupts */
        lcdc_writel(sinfo, ATMEL_LCDC_IDR, ~0UL);
-        /* Set contrast */
-        value = ATMEL_LCDC_PS_DIV8 | ATMEL_LCDC_POL_POSITIVE | ATMEL_LCDC_ENA_PWMENABLE;
-        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, value);
-        lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_VAL, ATMEL_LCDC_CVAL_DEFAULT);
        /* ...wait for DMA engine to become idle... */
        while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
                msleep(10);
@@ -573,6 +695,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->lcdcon_is_backlight = pdata_sinfo->lcdcon_is_backlight;
        } else {
                dev_err(dev, "cannot get default configuration\n");
                goto free_info;
@@ -666,6 +789,9 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                goto release_mem;
        }
+        /* Initialize PWM for contrast or backlight ("off") */
+        init_contrast(sinfo);
        /* interrupt */
        ret = request_irq(sinfo->irq_base, atmel_lcdfb_interrupt, 0, pdev->name, info);
        if (ret) {
@@ -717,6 +843,7 @@ free_cmap:
 unregister_irqs:
        free_irq(sinfo->irq_base, info);
 unmap_mmio:
+        exit_backlight(sinfo);
        iounmap(sinfo->mmio);
 release_mem:
        release_mem_region(info->fix.mmio_start, info->fix.mmio_len);
@@ -751,6 +878,7 @@ static int __exit atmel_lcdfb_remove(struct platform_device *pdev)
        if (!sinfo)
                return 0;
+        exit_backlight(sinfo);
        if (sinfo->atmel_lcdfb_power_control)
                sinfo->atmel_lcdfb_power_control(0);
        unregister_framebuffer(info);
@@ -777,6 +905,9 @@ static int __exit atmel_lcdfb_remove(struct platform_device *pdev)
 static struct platform_driver atmel_lcdfb_driver = {
        .remove         = __exit_p(atmel_lcdfb_remove),
+// FIXME need suspend, resume
        .driver         = {
                .name   = "atmel_lcdfb",
                .owner  = THIS_MODULE,
@@ -797,5 +928,5 @@ module_init(atmel_lcdfb_init);
 module_exit(atmel_lcdfb_exit);
 MODULE_DESCRIPTION("AT91/AT32 LCD Controller framebuffer driver");
-MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@rfo.atmel.com>");
+MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@atmel.com>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 1e32b3d13f2e..62867cb63fef 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -202,6 +202,7 @@ static struct pci_device_id radeonfb_pci_table[] = {
        CHIP_DEF(PCI_CHIP_RV380_3154,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
        CHIP_DEF(PCI_CHIP_RV370_5B60,   RV380,  CHIP_HAS_CRTC2),
        CHIP_DEF(PCI_CHIP_RV370_5B62,   RV380,  CHIP_HAS_CRTC2),
+        CHIP_DEF(PCI_CHIP_RV370_5B63,   RV380,  CHIP_HAS_CRTC2),
        CHIP_DEF(PCI_CHIP_RV370_5B64,   RV380,  CHIP_HAS_CRTC2),
        CHIP_DEF(PCI_CHIP_RV370_5B65,   RV380,  CHIP_HAS_CRTC2),
        CHIP_DEF(PCI_CHIP_RV370_5460,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
diff --git a/drivers/video/aty/radeon_pm.c b/drivers/video/aty/radeon_pm.c
index be1d57bf9dc8..675abdafc2d8 100644
--- a/drivers/video/aty/radeon_pm.c
+++ b/drivers/video/aty/radeon_pm.c
@@ -27,8 +27,6 @@
 #include "ati_ids.h"
-static void radeon_reinitialize_M10(struct radeonfb_info *rinfo);
 /*
 * Workarounds for bugs in PC laptops:
 * - enable D2 sleep in some IBM Thinkpads
@@ -39,6 +37,8 @@ static void radeon_reinitialize_M10(struct radeonfb_info *rinfo);
 */
 #if defined(CONFIG_PM) && defined(CONFIG_X86)
+static void radeon_reinitialize_M10(struct radeonfb_info *rinfo);
 struct radeon_device_id {
        const char *ident;                     /* (arbitrary) Name */
        const unsigned short subsystem_vendor; /* Subsystem Vendor ID */
@@ -2561,7 +2561,7 @@ static void radeon_set_suspend(struct radeonfb_info *rinfo, int suspend)
                        pci_read_config_dword(rinfo->pdev, i * 4,
                                              &rinfo->cfg_save[i]);
-                /* Switch PCI power managment to D2. */
+                /* Switch PCI power management to D2. */
                pci_disable_device(rinfo->pdev);
                for (;;) {
                        pci_read_config_word(
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 9609a6c676be..dcd8073c2369 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -50,6 +50,19 @@ config BACKLIGHT_CLASS_DEVICE
          To have support for your specific LCD panel you will have to
          select the proper drivers which depend on this option.
+config BACKLIGHT_ATMEL_LCDC
+        bool "Atmel LCDC Contrast-as-Backlight control"
+        depends on BACKLIGHT_CLASS_DEVICE && FB_ATMEL
+        default y if MACH_SAM9261EK || MACH_SAM9263EK
+        help
+          This provides a backlight control internal to the Atmel LCDC
+          driver.  If the LCD "contrast control" on your board is wired
+          so it controls the backlight brightness, select this option to
+          export this as a PWM-based backlight control.
+          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_CORGI
        tristate "Generic (aka Sharp Corgi) Backlight Driver"
        depends on BACKLIGHT_CLASS_DEVICE
@@ -67,6 +80,15 @@ config BACKLIGHT_LOCOMO
          If you have a Sharp Zaurus SL-5500 (Collie) or SL-5600 (Poodle) say y to
          enable the LCD/backlight driver.
+config BACKLIGHT_OMAP1
+        tristate "OMAP1 PWL-based LCD Backlight"
+        depends on BACKLIGHT_CLASS_DEVICE && ARCH_OMAP1
+        default y
+        help
+          This driver controls the LCD backlight level and power for
+          the PWL module of OMAP1 processors.  Say Y if your board
+          uses this hardware.
 config BACKLIGHT_HP680
        tristate "HP Jornada 680 Backlight Driver"
        depends on BACKLIGHT_CLASS_DEVICE && SH_HP6XX
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 965a78b18118..33f6c7cecc73 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -7,5 +7,6 @@ obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
 obj-$(CONFIG_BACKLIGHT_CORGI)   += corgi_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
+obj-$(CONFIG_BACKLIGHT_OMAP1)   += omap1_bl.o
 obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
 obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 4840fe217e4d..39394757679c 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -94,8 +94,10 @@ static ssize_t backlight_store_power(struct device *dev,
        mutex_lock(&bd->ops_lock);
        if (bd->ops) {
                pr_debug("backlight: set power to %d\n", power);
-                bd->props.power = power;
+                if (bd->props.power != power) {
-                backlight_update_status(bd);
+                        bd->props.power = power;
+                        backlight_update_status(bd);
+                }
                rc = count;
        }
        mutex_unlock(&bd->ops_lock);
@@ -132,8 +134,10 @@ static ssize_t backlight_store_brightness(struct device *dev,
                else {
                        pr_debug("backlight: set brightness to %d\n",
                                 brightness);
-                        bd->props.brightness = brightness;
+                        if (bd->props.brightness != brightness) {
-                        backlight_update_status(bd);
+                                bd->props.brightness = brightness;
+                                backlight_update_status(bd);
+                        }
                        rc = count;
                }
        }
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
new file mode 100644
index 000000000000..891875d53a49
--- /dev/null
+++ b/drivers/video/backlight/omap1_bl.c
@@ -0,0 +1,210 @@
+/*
+ * Backlight driver for OMAP based boards.
+ *
+ * Copyright (c) 2006 Andrzej Zaborowski  <balrog@zabor.org>
+ *
+ * This package 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 package 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 package; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <asm/arch/hardware.h>
+#include <asm/arch/board.h>
+#include <asm/arch/mux.h>
+#define OMAPBL_MAX_INTENSITY            0xff
+struct omap_backlight {
+        int powermode;
+        int current_intensity;
+        struct device *dev;
+        struct omap_backlight_config *pdata;
+};
+static void inline omapbl_send_intensity(int intensity)
+{
+        omap_writeb(intensity, OMAP_PWL_ENABLE);
+}
+static void inline omapbl_send_enable(int enable)
+{
+        omap_writeb(enable, OMAP_PWL_CLK_ENABLE);
+}
+static void omapbl_blank(struct omap_backlight *bl, int mode)
+{
+        if (bl->pdata->set_power)
+                bl->pdata->set_power(bl->dev, mode);
+        switch (mode) {
+        case FB_BLANK_NORMAL:
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                omapbl_send_intensity(0);
+                omapbl_send_enable(0);
+                break;
+        case FB_BLANK_UNBLANK:
+                omapbl_send_intensity(bl->current_intensity);
+                omapbl_send_enable(1);
+                break;
+        }
+}
+#ifdef CONFIG_PM
+static int omapbl_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct backlight_device *dev = platform_get_drvdata(pdev);
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        omapbl_blank(bl, FB_BLANK_POWERDOWN);
+        return 0;
+}
+static int omapbl_resume(struct platform_device *pdev)
+{
+        struct backlight_device *dev = platform_get_drvdata(pdev);
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        omapbl_blank(bl, bl->powermode);
+        return 0;
+}
+#else
+#define omapbl_suspend  NULL
+#define omapbl_resume   NULL
+#endif
+static int omapbl_set_power(struct backlight_device *dev, int state)
+{
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        omapbl_blank(bl, state);
+        bl->powermode = state;
+        return 0;
+}
+static int omapbl_update_status(struct backlight_device *dev)
+{
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        if (bl->current_intensity != dev->props.brightness) {
+                if (bl->powermode == FB_BLANK_UNBLANK)
+                        omapbl_send_intensity(dev->props.brightness);
+                bl->current_intensity = dev->props.brightness;
+        }
+        if (dev->props.fb_blank != bl->powermode)
+                omapbl_set_power(dev, dev->props.fb_blank);
+        return 0;
+}
+static int omapbl_get_intensity(struct backlight_device *dev)
+{
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        return bl->current_intensity;
+}
+static struct backlight_ops omapbl_ops = {
+        .get_brightness = omapbl_get_intensity,
+        .update_status  = omapbl_update_status,
+};
+static int omapbl_probe(struct platform_device *pdev)
+{
+        struct backlight_device *dev;
+        struct omap_backlight *bl;
+        struct omap_backlight_config *pdata = pdev->dev.platform_data;
+        if (!pdata)
+                return -ENXIO;
+        omapbl_ops.check_fb = pdata->check_fb;
+        bl = kzalloc(sizeof(struct omap_backlight), GFP_KERNEL);
+        if (unlikely(!bl))
+                return -ENOMEM;
+        dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops);
+        if (IS_ERR(dev)) {
+                kfree(bl);
+                return PTR_ERR(dev);
+        }
+        bl->powermode = FB_BLANK_POWERDOWN;
+        bl->current_intensity = 0;
+        bl->pdata = pdata;
+        bl->dev = &pdev->dev;
+        platform_set_drvdata(pdev, dev);
+        omap_cfg_reg(PWL);      /* Conflicts with UART3 */
+        dev->props.fb_blank = FB_BLANK_UNBLANK;
+        dev->props.max_brightness = OMAPBL_MAX_INTENSITY;
+        dev->props.brightness = pdata->default_intensity;
+        omapbl_update_status(dev);
+        printk(KERN_INFO "OMAP LCD backlight initialised\n");
+        return 0;
+}
+static int omapbl_remove(struct platform_device *pdev)
+{
+        struct backlight_device *dev = platform_get_drvdata(pdev);
+        struct omap_backlight *bl = dev_get_drvdata(&dev->dev);
+        backlight_device_unregister(dev);
+        kfree(bl);
+        return 0;
+}
+static struct platform_driver omapbl_driver = {
+        .probe          = omapbl_probe,
+        .remove         = omapbl_remove,
+        .suspend        = omapbl_suspend,
+        .resume         = omapbl_resume,
+        .driver         = {
+                .name   = "omap-bl",
+        },
+};
+static int __init omapbl_init(void)
+{
+        return platform_driver_register(&omapbl_driver);
+}
+static void __exit omapbl_exit(void)
+{
+        platform_driver_unregister(&omapbl_driver);
+}
+module_init(omapbl_init);
+module_exit(omapbl_exit);
+MODULE_AUTHOR("Andrzej Zaborowski <balrog@zabor.org>");
+MODULE_DESCRIPTION("OMAP LCD Backlight driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index 74d11c318987..0ce791e6f79c 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -224,7 +224,8 @@ static int config_dma(struct bfin_bf54xfb_info *fbi)
        set_dma_config(CH_EPPI0,
                       set_bfin_dma_config(DIR_READ, DMA_FLOW_AUTO,
                                           INTR_DISABLE, DIMENSION_2D,
-                                           DATA_SIZE_32));
+                                           DATA_SIZE_32,
+                                           DMA_NOSYNC_KEEP_DMA_BUF));
        set_dma_x_count(CH_EPPI0, (LCD_X_RES * LCD_BPP) / DMA_BUS_SIZE);
        set_dma_x_modify(CH_EPPI0, DMA_BUS_SIZE / 8);
        set_dma_y_count(CH_EPPI0, LCD_Y_RES);
@@ -263,8 +264,7 @@ static int request_ports(struct bfin_bf54xfb_info *fbi)
                }
        }
-        gpio_direction_output(disp);
+        gpio_direction_output(disp, 1);
-        gpio_set_value(disp, 1);
        return 0;
 }
@@ -498,8 +498,7 @@ static struct lcd_device *lcd_dev;
 static irqreturn_t bfin_bf54x_irq_error(int irq, void *dev_id)
 {
+        /*struct bfin_bf54xfb_info *info = dev_id;*/
-        /*struct bfin_bf54xfb_info *info = (struct bfin_bf54xfb_info *)dev_id;*/
        u16 status = bfin_read_EPPI0_STATUS();
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index f99cb77e7b42..f7e2d5add831 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -2509,8 +2509,7 @@ static int cirrusfb_zorro_register(struct zorro_dev *z,
        cinfo = info->par;
        cinfo->btype = btype;
-        assert(z > 0);
+        assert(z);
-        assert(z2 >= 0);
        assert(btype != BT_NONE);
        cinfo->zdev = z;
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index 267422f66255..2b53d1f56281 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -6,7 +6,7 @@ menu "Console display driver support"
 config VGA_CONSOLE
        bool "VGA text console" if EMBEDDED || !X86
-        depends on !ARCH_ACORN && !ARCH_EBSA110 && !4xx && !8xx && !SPARC && !M68K && !PARISC && !FRV && !ARCH_VERSATILE && !SUPERH && !BFIN
+        depends on !ARCH_ACORN && !ARCH_EBSA110 && !4xx && !8xx && !SPARC && !M68K && !PARISC && !FRV && !ARCH_VERSATILE && !SUPERH && !BLACKFIN && !AVR32
        default y
        help
          Saying Y here will allow you to use Linux in text mode through a
diff --git a/drivers/video/console/bitblit.c b/drivers/video/console/bitblit.c
index 308850df16fe..69864b1b3f9e 100644
--- a/drivers/video/console/bitblit.c
+++ b/drivers/video/console/bitblit.c
@@ -63,7 +63,7 @@ static void bit_clear(struct vc_data *vc, struct fb_info *info, int sy,
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
        struct fb_fillrect region;
-        region.color = attr_bgcol_ec(bgshift, vc);
+        region.color = attr_bgcol_ec(bgshift, vc, info);
        region.dx = sx * vc->vc_font.width;
        region.dy = sy * vc->vc_font.height;
        region.width = width * vc->vc_font.width;
@@ -213,7 +213,7 @@ static void bit_clear_margins(struct vc_data *vc, struct fb_info *info,
        unsigned int bs = info->var.yres - bh;
        struct fb_fillrect region;
-        region.color = attr_bgcol_ec(bgshift, vc);
+        region.color = attr_bgcol_ec(bgshift, vc, info);
        region.rop = ROP_COPY;
        if (rw && !bottom_only) {
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 0f32f4a00b2d..022282494d3f 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -84,7 +84,7 @@
 #ifdef CONFIG_MAC
 #include <asm/macints.h>
 #endif
-#if defined(__mc68000__) || defined(CONFIG_APUS)
+#if defined(__mc68000__)
 #include <asm/machdep.h>
 #include <asm/setup.h>
 #endif
@@ -147,7 +147,7 @@ static char fontname[40];
 static int info_idx = -1;
 /* console rotation */
-static int rotate;
+static int initial_rotation;
 static int fbcon_has_sysfs;
 static const struct consw fb_con;
@@ -334,10 +334,7 @@ static inline int get_color(struct vc_data *vc, struct fb_info *info,
        switch (depth) {
        case 1:
        {
-                int col = ~(0xfff << (max(info->var.green.length,
+                int col = mono_col(info);
-                                          max(info->var.red.length,
-                                              info->var.blue.length)))) & 0xff;
                /* 0 or 1 */
                int fg = (info->fix.visual != FB_VISUAL_MONO01) ? col : 0;
                int bg = (info->fix.visual != FB_VISUAL_MONO01) ? 0 : col;
@@ -537,9 +534,9 @@ static int __init fb_console_setup(char *this_opt)
                if (!strncmp(options, "rotate:", 7)) {
                        options += 7;
                        if (*options)
-                                rotate = simple_strtoul(options, &options, 0);
+                                initial_rotation = simple_strtoul(options, &options, 0);
-                        if (rotate > 3)
+                        if (initial_rotation > 3)
-                                rotate = 0;
+                                initial_rotation = 0;
                }
        }
        return 1;
@@ -989,7 +986,7 @@ static const char *fbcon_startup(void)
        ops->graphics = 1;
        ops->cur_rotate = -1;
        info->fbcon_par = ops;
-        p->con_rotate = rotate;
+        p->con_rotate = initial_rotation;
        set_blitting_type(vc, info);
        if (info->fix.type != FB_TYPE_TEXT) {
@@ -1176,7 +1173,7 @@ static void fbcon_init(struct vc_data *vc, int init)
                con_copy_unimap(vc, svc);
        ops = info->fbcon_par;
-        p->con_rotate = rotate;
+        p->con_rotate = initial_rotation;
        set_blitting_type(vc, info);
        cols = vc->vc_cols;
@@ -2795,7 +2792,7 @@ static int fbcon_scrolldelta(struct vc_data *vc, int lines)
 {
        struct fb_info *info = registered_fb[con2fb_map[fg_console]];
        struct fbcon_ops *ops = info->fbcon_par;
-        struct display *p = &fb_display[fg_console];
+        struct display *disp = &fb_display[fg_console];
        int offset, limit, scrollback_old;
        if (softback_top) {
@@ -2833,7 +2830,7 @@ static int fbcon_scrolldelta(struct vc_data *vc, int lines)
                        logo_shown = FBCON_LOGO_CANSHOW;
                }
                fbcon_cursor(vc, CM_ERASE | CM_SOFTBACK);
-                fbcon_redraw_softback(vc, p, lines);
+                fbcon_redraw_softback(vc, disp, lines);
                fbcon_cursor(vc, CM_DRAW | CM_SOFTBACK);
                return 0;
        }
@@ -2855,9 +2852,9 @@ static int fbcon_scrolldelta(struct vc_data *vc, int lines)
        fbcon_cursor(vc, CM_ERASE);
-        offset = p->yscroll - scrollback_current;
+        offset = disp->yscroll - scrollback_current;
-        limit = p->vrows;
+        limit = disp->vrows;
-        switch (p->scrollmode) {
+        switch (disp->scrollmode) {
        case SCROLL_WRAP_MOVE:
                info->var.vmode |= FB_VMODE_YWRAP;
                break;
diff --git a/drivers/video/console/fbcon.h b/drivers/video/console/fbcon.h
index 8e6ef4bc7a5c..3706307e70ed 100644
--- a/drivers/video/console/fbcon.h
+++ b/drivers/video/console/fbcon.h
@@ -93,10 +93,6 @@ struct fbcon_ops {
        (((s) >> (fgshift)) & 0x0f)
 #define attr_bgcol(bgshift,s)    \
        (((s) >> (bgshift)) & 0x0f)
-#define attr_bgcol_ec(bgshift,vc) \
-        ((vc) ? (((vc)->vc_video_erase_char >> (bgshift)) & 0x0f) : 0)
-#define attr_fgcol_ec(fgshift,vc) \
-        ((vc) ? (((vc)->vc_video_erase_char >> (fgshift)) & 0x0f) : 0)
 /* Monochrome */
 #define attr_bold(s) \
@@ -108,6 +104,49 @@ struct fbcon_ops {
 #define attr_blink(s) \
        ((s) & 0x8000)
        
+#define mono_col(info)                                                  \
+        (~(0xfff << (max((info)->var.green.length,                      \
+                         max((info)->var.red.length,                    \
+                             (info)->var.blue.length)))) & 0xff)
+static inline int attr_col_ec(int shift, struct vc_data *vc,
+                              struct fb_info *info, int is_fg)
+{
+        int is_mono01;
+        int col;
+        int fg;
+        int bg;
+        if (!vc)
+                return 0;
+        if (vc->vc_can_do_color)
+                return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
+                        : attr_bgcol(shift,vc->vc_video_erase_char);
+        if (!info)
+                return 0;
+        col = mono_col(info);
+        is_mono01 = info->fix.visual == FB_VISUAL_MONO01;
+        if (attr_reverse(vc->vc_video_erase_char)) {
+                fg = is_mono01 ? col : 0;
+                bg = is_mono01 ? 0 : col;
+        }
+        else {
+                fg = is_mono01 ? 0 : col;
+                bg = is_mono01 ? col : 0;
+        }
+        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);
 /* Font */
 #define REFCOUNT(fd)    (((int *)(fd))[-1])
 #define FNTSIZE(fd)     (((int *)(fd))[-2])
diff --git a/drivers/video/console/fbcon_ccw.c b/drivers/video/console/fbcon_ccw.c
index 825e6d6972a7..bdf913ecf001 100644
--- a/drivers/video/console/fbcon_ccw.c
+++ b/drivers/video/console/fbcon_ccw.c
@@ -84,7 +84,7 @@ static void ccw_clear(struct vc_data *vc, struct fb_info *info, int sy,
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
        u32 vyres = GETVYRES(ops->p->scrollmode, info);
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.dx = sy * vc->vc_font.height;
        region.dy = vyres - ((sx + width) * vc->vc_font.width);
        region.height = width * vc->vc_font.width;
@@ -198,7 +198,7 @@ static void ccw_clear_margins(struct vc_data *vc, struct fb_info *info,
        struct fb_fillrect region;
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.rop = ROP_COPY;
        if (rw && !bottom_only) {
diff --git a/drivers/video/console/fbcon_cw.c b/drivers/video/console/fbcon_cw.c
index c637e6318803..a6819b9d1770 100644
--- a/drivers/video/console/fbcon_cw.c
+++ b/drivers/video/console/fbcon_cw.c
@@ -70,7 +70,7 @@ static void cw_clear(struct vc_data *vc, struct fb_info *info, int sy,
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
        u32 vxres = GETVXRES(ops->p->scrollmode, info);
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.dx = vxres - ((sy + height) * vc->vc_font.height);
        region.dy = sx *  vc->vc_font.width;
        region.height = width * vc->vc_font.width;
@@ -182,7 +182,7 @@ static void cw_clear_margins(struct vc_data *vc, struct fb_info *info,
        struct fb_fillrect region;
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.rop = ROP_COPY;
        if (rw && !bottom_only) {
diff --git a/drivers/video/console/fbcon_ud.c b/drivers/video/console/fbcon_ud.c
index 1473506df5d0..d9b5d6eb68a7 100644
--- a/drivers/video/console/fbcon_ud.c
+++ b/drivers/video/console/fbcon_ud.c
@@ -71,7 +71,7 @@ static void ud_clear(struct vc_data *vc, struct fb_info *info, int sy,
        u32 vyres = GETVYRES(ops->p->scrollmode, info);
        u32 vxres = GETVXRES(ops->p->scrollmode, info);
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.dy = vyres - ((sy + height) * vc->vc_font.height);
        region.dx = vxres - ((sx + width) *  vc->vc_font.width);
        region.width = width * vc->vc_font.width;
@@ -228,7 +228,7 @@ static void ud_clear_margins(struct vc_data *vc, struct fb_info *info,
        struct fb_fillrect region;
        int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
-        region.color = attr_bgcol_ec(bgshift,vc);
+        region.color = attr_bgcol_ec(bgshift,vc,info);
        region.rop = ROP_COPY;
        if (rw && !bottom_only) {
diff --git a/drivers/video/console/fonts.c b/drivers/video/console/fonts.c
index 96979c377518..d0c03fd70871 100644
--- a/drivers/video/console/fonts.c
+++ b/drivers/video/console/fonts.c
@@ -15,7 +15,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
-#if defined(__mc68000__) || defined(CONFIG_APUS)
+#if defined(__mc68000__)
 #include <asm/setup.h>
 #endif
 #include <linux/font.h>
@@ -120,7 +120,7 @@ const struct font_desc *get_default_font(int xres, int yres, u32 font_w,
    for(i=0; i<num_fonts; i++) {
        f = fonts[i];
        c = f->pref;
-#if defined(__mc68000__) || defined(CONFIG_APUS)
+#if defined(__mc68000__)
 #ifdef CONFIG_FONT_PEARL_8x8
        if (MACH_IS_AMIGA && f->idx == PEARL8x8_IDX)
            c = 100;
diff --git a/drivers/video/console/tileblit.c b/drivers/video/console/tileblit.c
index d981fe4d86c6..0056a41e5c35 100644
--- a/drivers/video/console/tileblit.c
+++ b/drivers/video/console/tileblit.c
@@ -40,8 +40,8 @@ static void tile_clear(struct vc_data *vc, struct fb_info *info, int sy,
        rect.index = vc->vc_video_erase_char &
                ((vc->vc_hi_font_mask) ? 0x1ff : 0xff);
-        rect.fg = attr_fgcol_ec(fgshift, vc);
+        rect.fg = attr_fgcol_ec(fgshift, vc, info);
-        rect.bg = attr_bgcol_ec(bgshift, vc);
+        rect.bg = attr_bgcol_ec(bgshift, vc, info);
        rect.sx = sx;
        rect.sy = sy;
        rect.width = width;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index f65bcd314d54..6df29a62d720 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -1153,8 +1153,6 @@ static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
        /* if 512 char mode is already enabled don't re-enable it. */
        if ((set) && (ch512 != vga_512_chars)) {
-                int i;  
-                
                /* attribute controller */
                for (i = 0; i < MAX_NR_CONSOLES; i++) {
                        struct vc_data *c = vc_cons[i].d;
diff --git a/drivers/video/cyber2000fb.c b/drivers/video/cyber2000fb.c
index 5fb8675e0d6b..d0e4cb618269 100644
--- a/drivers/video/cyber2000fb.c
+++ b/drivers/video/cyber2000fb.c
@@ -874,6 +874,8 @@ static int cyber2000fb_set_par(struct fb_info *info)
                default:
                        BUG();
                }
+                break;
        case 24:/* TRUECOLOUR, 16m */
                hw.co_pixfmt            = CO_PIXFMT_24BPP;
                hw.width                *= 3;
diff --git a/drivers/video/cyblafb.c b/drivers/video/cyblafb.c
index e23324d10be2..9704b73135f5 100644
--- a/drivers/video/cyblafb.c
+++ b/drivers/video/cyblafb.c
@@ -1156,7 +1156,7 @@ static struct fb_ops cyblafb_ops __devinitdata = {
 // need altered timings to display correctly. So I decided that it is much
 // better to provide a limited optimized set of modes plus the option of
 // using the mode in effect at startup time (might be selected using the
-// vga=??? paramter). After that the user might use fbset to select any
+// vga=??? parameter). After that the user might use fbset to select any
 // mode he likes, check_var will not try to alter geometry parameters as
 // it would be necessary otherwise.
 //
diff --git a/drivers/video/efifb.c b/drivers/video/efifb.c
new file mode 100644
index 000000000000..bd779ae44b1e
--- /dev/null
+++ b/drivers/video/efifb.c
@@ -0,0 +1,232 @@
+/*
+ * Framebuffer driver for EFI/UEFI based system
+ *
+ * (c) 2006 Edgar Hucek <gimli@dark-green.com>
+ * Original efi driver written by Gerd Knorr <kraxel@goldbach.in-berlin.de>
+ *
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/fb.h>
+#include <linux/platform_device.h>
+#include <linux/screen_info.h>
+#include <video/vga.h>
+static struct fb_var_screeninfo efifb_defined __initdata = {
+        .activate               = FB_ACTIVATE_NOW,
+        .height                 = -1,
+        .width                  = -1,
+        .right_margin           = 32,
+        .upper_margin           = 16,
+        .lower_margin           = 4,
+        .vsync_len              = 4,
+        .vmode                  = FB_VMODE_NONINTERLACED,
+};
+static struct fb_fix_screeninfo efifb_fix __initdata = {
+        .id                     = "EFI VGA",
+        .type                   = FB_TYPE_PACKED_PIXELS,
+        .accel                  = FB_ACCEL_NONE,
+        .visual                 = FB_VISUAL_TRUECOLOR,
+};
+static int efifb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                           unsigned blue, unsigned transp,
+                           struct fb_info *info)
+{
+        /*
+         *  Set a single color register. The values supplied are
+         *  already rounded down to the hardware's capabilities
+         *  (according to the entries in the `var' structure). Return
+         *  != 0 for invalid regno.
+         */
+        if (regno >= info->cmap.len)
+                return 1;
+        if (regno < 16) {
+                red   >>= 8;
+                green >>= 8;
+                blue  >>= 8;
+                ((u32 *)(info->pseudo_palette))[regno] =
+                        (red   << info->var.red.offset)   |
+                        (green << info->var.green.offset) |
+                        (blue  << info->var.blue.offset);
+        }
+        return 0;
+}
+static struct fb_ops efifb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_setcolreg   = efifb_setcolreg,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+};
+static int __init efifb_probe(struct platform_device *dev)
+{
+        struct fb_info *info;
+        int err;
+        unsigned int size_vmode;
+        unsigned int size_remap;
+        unsigned int size_total;
+        efifb_fix.smem_start = screen_info.lfb_base;
+        efifb_defined.bits_per_pixel = screen_info.lfb_depth;
+        efifb_defined.xres = screen_info.lfb_width;
+        efifb_defined.yres = screen_info.lfb_height;
+        efifb_fix.line_length = screen_info.lfb_linelength;
+        /*   size_vmode -- that is the amount of memory needed for the
+         *                 used video mode, i.e. the minimum amount of
+         *                 memory we need. */
+        size_vmode = efifb_defined.yres * efifb_fix.line_length;
+        /*   size_total -- all video memory we have. Used for
+         *                 entries, ressource allocation and bounds
+         *                 checking. */
+        size_total = screen_info.lfb_size;
+        if (size_total < size_vmode)
+                size_total = size_vmode;
+        /*   size_remap -- the amount of video memory we are going to
+         *                 use for efifb.  With modern cards it is no
+         *                 option to simply use size_total as that
+         *                 wastes plenty of kernel address space. */
+        size_remap  = size_vmode * 2;
+        if (size_remap < size_vmode)
+                size_remap = size_vmode;
+        if (size_remap > size_total)
+                size_remap = size_total;
+        efifb_fix.smem_len = size_remap;
+        if (!request_mem_region(efifb_fix.smem_start, size_total, "efifb"))
+                /* We cannot make this fatal. Sometimes this comes from magic
+                   spaces our resource handlers simply don't know about */
+                printk(KERN_WARNING
+                       "efifb: cannot reserve video memory at 0x%lx\n",
+                        efifb_fix.smem_start);
+        info = framebuffer_alloc(sizeof(u32) * 16, &dev->dev);
+        if (!info) {
+                err = -ENOMEM;
+                goto err_release_mem;
+        }
+        info->pseudo_palette = info->par;
+        info->par = NULL;
+        info->screen_base = ioremap(efifb_fix.smem_start, efifb_fix.smem_len);
+        if (!info->screen_base) {
+                printk(KERN_ERR "efifb: abort, cannot ioremap video memory "
+                                "0x%x @ 0x%lx\n",
+                        efifb_fix.smem_len, efifb_fix.smem_start);
+                err = -EIO;
+                goto err_unmap;
+        }
+        printk(KERN_INFO "efifb: framebuffer at 0x%lx, mapped to 0x%p, "
+               "using %dk, total %dk\n",
+               efifb_fix.smem_start, info->screen_base,
+               size_remap/1024, size_total/1024);
+        printk(KERN_INFO "efifb: mode is %dx%dx%d, linelength=%d, pages=%d\n",
+               efifb_defined.xres, efifb_defined.yres,
+               efifb_defined.bits_per_pixel, efifb_fix.line_length,
+               screen_info.pages);
+        efifb_defined.xres_virtual = efifb_defined.xres;
+        efifb_defined.yres_virtual = efifb_fix.smem_len /
+                                        efifb_fix.line_length;
+        printk(KERN_INFO "efifb: scrolling: redraw\n");
+        efifb_defined.yres_virtual = efifb_defined.yres;
+        /* some dummy values for timing to make fbset happy */
+        efifb_defined.pixclock     = 10000000 / efifb_defined.xres *
+                                        1000 / efifb_defined.yres;
+        efifb_defined.left_margin  = (efifb_defined.xres / 8) & 0xf8;
+        efifb_defined.hsync_len    = (efifb_defined.xres / 8) & 0xf8;
+        efifb_defined.red.offset    = screen_info.red_pos;
+        efifb_defined.red.length    = screen_info.red_size;
+        efifb_defined.green.offset  = screen_info.green_pos;
+        efifb_defined.green.length  = screen_info.green_size;
+        efifb_defined.blue.offset   = screen_info.blue_pos;
+        efifb_defined.blue.length   = screen_info.blue_size;
+        efifb_defined.transp.offset = screen_info.rsvd_pos;
+        efifb_defined.transp.length = screen_info.rsvd_size;
+        printk(KERN_INFO "efifb: %s: "
+               "size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n",
+               "Truecolor",
+               screen_info.rsvd_size,
+               screen_info.red_size,
+               screen_info.green_size,
+               screen_info.blue_size,
+               screen_info.rsvd_pos,
+               screen_info.red_pos,
+               screen_info.green_pos,
+               screen_info.blue_pos);
+        efifb_fix.ypanstep  = 0;
+        efifb_fix.ywrapstep = 0;
+        info->fbops = &efifb_ops;
+        info->var = efifb_defined;
+        info->fix = efifb_fix;
+        info->flags = FBINFO_FLAG_DEFAULT;
+        if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
+                err = -ENOMEM;
+                goto err_unmap;
+        }
+        if (register_framebuffer(info) < 0) {
+                err = -EINVAL;
+                goto err_fb_dealoc;
+        }
+        printk(KERN_INFO "fb%d: %s frame buffer device\n",
+               info->node, info->fix.id);
+        return 0;
+err_fb_dealoc:
+        fb_dealloc_cmap(&info->cmap);
+err_unmap:
+        iounmap(info->screen_base);
+        framebuffer_release(info);
+err_release_mem:
+        release_mem_region(efifb_fix.smem_start, size_total);
+        return err;
+}
+static struct platform_driver efifb_driver = {
+        .probe  = efifb_probe,
+        .driver = {
+                .name   = "efifb",
+        },
+};
+static struct platform_device efifb_device = {
+        .name   = "efifb",
+};
+static int __init efifb_init(void)
+{
+        int ret;
+        if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI)
+                return -ENODEV;
+        ret = platform_driver_register(&efifb_driver);
+        if (!ret) {
+                ret = platform_device_register(&efifb_device);
+                if (ret)
+                        platform_driver_unregister(&efifb_driver);
+        }
+        return ret;
+}
+module_init(efifb_init);
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/fb_ddc.c b/drivers/video/fb_ddc.c
index f836137a0eda..a0df63289b5f 100644
--- a/drivers/video/fb_ddc.c
+++ b/drivers/video/fb_ddc.c
@@ -56,13 +56,12 @@ unsigned char *fb_ddc_read(struct i2c_adapter *adapter)
        int i, j;
        algo_data->setscl(algo_data->data, 1);
-        algo_data->setscl(algo_data->data, 0);
        for (i = 0; i < 3; i++) {
                /* For some old monitors we need the
                 * following process to initialize/stop DDC
                 */
-                algo_data->setsda(algo_data->data, 0);
+                algo_data->setsda(algo_data->data, 1);
                msleep(13);
                algo_data->setscl(algo_data->data, 1);
@@ -97,14 +96,15 @@ unsigned char *fb_ddc_read(struct i2c_adapter *adapter)
                algo_data->setsda(algo_data->data, 1);
                msleep(15);
                algo_data->setscl(algo_data->data, 0);
+                algo_data->setsda(algo_data->data, 0);
                if (edid)
                        break;
        }
        /* Release the DDC lines when done or the Apple Cinema HD display
         * will switch off
         */
-        algo_data->setsda(algo_data->data, 0);
+        algo_data->setsda(algo_data->data, 1);
-        algo_data->setscl(algo_data->data, 0);
+        algo_data->setscl(algo_data->data, 1);
        return edid;
 }
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index a0c5d9d90d74..0f8cfb988c90 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -25,8 +25,8 @@
 #include <linux/pagemap.h>
 /* this is to find and return the vmalloc-ed fb pages */
-static struct page* fb_deferred_io_nopage(struct vm_area_struct *vma,
+static int fb_deferred_io_fault(struct vm_area_struct *vma,
-                                        unsigned long vaddr, int *type)
+                                struct vm_fault *vmf)
 {
        unsigned long offset;
        struct page *page;
@@ -34,18 +34,17 @@ static struct page* fb_deferred_io_nopage(struct vm_area_struct *vma,
        /* info->screen_base is in System RAM */
        void *screen_base = (void __force *) info->screen_base;
-        offset = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
+        offset = vmf->pgoff << PAGE_SHIFT;
        if (offset >= info->fix.smem_len)
-                return NOPAGE_SIGBUS;
+                return VM_FAULT_SIGBUS;
        page = vmalloc_to_page(screen_base + offset);
        if (!page)
-                return NOPAGE_OOM;
+                return VM_FAULT_SIGBUS;
        get_page(page);
-        if (type)
+        vmf->page = page;
-                *type = VM_FAULT_MINOR;
+        return 0;
-        return page;
 }
 int fb_deferred_io_fsync(struct file *file, struct dentry *dentry, int datasync)
@@ -84,7 +83,7 @@ static int fb_deferred_io_mkwrite(struct vm_area_struct *vma,
 }
 static struct vm_operations_struct fb_deferred_io_vm_ops = {
-        .nopage         = fb_deferred_io_nopage,
+        .fault          = fb_deferred_io_fault,
        .page_mkwrite   = fb_deferred_io_mkwrite,
 };
diff --git a/drivers/video/fb_draw.h b/drivers/video/fb_draw.h
index cdafbe14ef1f..a2a0618d86a5 100644
--- a/drivers/video/fb_draw.h
+++ b/drivers/video/fb_draw.h
@@ -91,6 +91,7 @@ static inline unsigned long fb_rev_pixels_in_long(unsigned long val,
                val = comp(val >> 2, val << 2, REV_PIXELS_MASK2);
        if (bswapmask & 3)
                val = comp(val >> 4, val << 4, REV_PIXELS_MASK4);
+        return val;
 }
 static inline u32 fb_shifted_pixels_mask_u32(u32 index, u32 bswapmask)
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 4ba9c0894416..052e18058498 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -4,7 +4,7 @@
 * Copyright (C) 2002 James Simmons <jsimmons@users.sf.net>
 *
 * Credits:
- * 
+ *
 * The EDID Parser is a conglomeration from the following sources:
 *
 *   1. SciTech SNAP Graphics Architecture
@@ -12,13 +12,13 @@
 *
 *   2. XFree86 4.3.0, interpret_edid.c
 *      Copyright 1998 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE>
- * 
+ *
- *   3. John Fremlin <vii@users.sourceforge.net> and 
+ *   3. John Fremlin <vii@users.sourceforge.net> and
 *      Ani Joshi <ajoshi@unixbox.com>
- *  
+ *
 * Generalized Timing Formula is derived from:
 *
- *      GTF Spreadsheet by Andy Morrish (1/5/97) 
+ *      GTF Spreadsheet by Andy Morrish (1/5/97)
 *      available at http://www.vesa.org
 *
 * This file is subject to the terms and conditions of the GNU General Public
@@ -36,7 +36,7 @@
 #endif
 #include "edid.h"
-/* 
+/*
 * EDID parser
 */
@@ -160,8 +160,8 @@ static int check_edid(unsigned char *edid)
        for (i = 0; i < ARRAY_SIZE(brokendb); i++) {
                if (!strncmp(manufacturer, brokendb[i].manufacturer, 4) &&
                        brokendb[i].model == model) {
-                        fix = brokendb[i].fix;
+                        fix = brokendb[i].fix;
-                        break;
+                        break;
                }
        }
@@ -323,7 +323,7 @@ static void get_dpms_capabilities(unsigned char flags,
               (flags & DPMS_SUSPEND)    ? "yes" : "no",
               (flags & DPMS_STANDBY)    ? "yes" : "no");
 }
-        
 static void get_chroma(unsigned char *block, struct fb_monspecs *specs)
 {
        int tmp;
@@ -365,7 +365,7 @@ static void get_chroma(unsigned char *block, struct fb_monspecs *specs)
        tmp += 512;
        specs->chroma.bluey = tmp/1024;
        DPRINTK("BlueY:    0.%03d\n", specs->chroma.bluey);
-        
        tmp = ((block[6] & (3 << 2)) >> 2) | (block[0xd] << 2);
        tmp *= 1000;
        tmp += 512;
@@ -383,7 +383,7 @@ static void calc_mode_timings(int xres, int yres, int refresh,
                              struct fb_videomode *mode)
 {
        struct fb_var_screeninfo *var;
-        
        var = kzalloc(sizeof(struct fb_var_screeninfo), GFP_KERNEL);
        if (var) {
@@ -451,11 +451,11 @@ static int get_est_timing(unsigned char *block, struct fb_videomode *mode)
        c = block[1];
        if (c&0x80) {
-                mode[num++] = vesa_modes[9];
+                mode[num++] = vesa_modes[9];
                DPRINTK("      800x600@72Hz\n");
        }
        if (c&0x40) {
-                mode[num++] = vesa_modes[10];
+                mode[num++] = vesa_modes[10];
                DPRINTK("      800x600@75Hz\n");
        }
        if (c&0x20) {
@@ -495,7 +495,7 @@ static int get_est_timing(unsigned char *block, struct fb_videomode *mode)
 static int get_std_timing(unsigned char *block, struct fb_videomode *mode)
 {
        int xres, yres = 0, refresh, ratio, i;
-        
        xres = (block[0] + 31) * 8;
        if (xres <= 256)
                return 0;
@@ -519,7 +519,7 @@ static int get_std_timing(unsigned char *block, struct fb_videomode *mode)
        DPRINTK("      %dx%d@%dHz\n", xres, yres, refresh);
        for (i = 0; i < VESA_MODEDB_SIZE; i++) {
-                if (vesa_modes[i].xres == xres && 
+                if (vesa_modes[i].xres == xres &&
                    vesa_modes[i].yres == yres &&
                    vesa_modes[i].refresh == refresh) {
                        *mode = vesa_modes[i];
@@ -536,13 +536,13 @@ static int get_dst_timing(unsigned char *block,
 {
        int j, num = 0;
-        for (j = 0; j < 6; j++, block+= STD_TIMING_DESCRIPTION_SIZE) 
+        for (j = 0; j < 6; j++, block += STD_TIMING_DESCRIPTION_SIZE)
                num += get_std_timing(block, &mode[num]);
        return num;
 }
-static void get_detailed_timing(unsigned char *block, 
+static void get_detailed_timing(unsigned char *block,
                                struct fb_videomode *mode)
 {
        mode->xres = H_ACTIVE;
@@ -553,7 +553,7 @@ static void get_detailed_timing(unsigned char *block,
        mode->right_margin = H_SYNC_OFFSET;
        mode->left_margin = (H_ACTIVE + H_BLANKING) -
                (H_ACTIVE + H_SYNC_OFFSET + H_SYNC_WIDTH);
-        mode->upper_margin = V_BLANKING - V_SYNC_OFFSET - 
+        mode->upper_margin = V_BLANKING - V_SYNC_OFFSET -
                V_SYNC_WIDTH;
        mode->lower_margin = V_SYNC_OFFSET;
        mode->hsync_len = H_SYNC_WIDTH;
@@ -597,7 +597,7 @@ static struct fb_videomode *fb_create_modedb(unsigned char *edid, int *dbsize)
        if (mode == NULL)
                return NULL;
-        if (edid == NULL || !edid_checksum(edid) || 
+        if (edid == NULL || !edid_checksum(edid) ||
            !edid_check_header(edid)) {
                kfree(mode);
                return NULL;
@@ -632,7 +632,7 @@ static struct fb_videomode *fb_create_modedb(unsigned char *edid, int *dbsize)
                if (block[0] == 0x00 && block[1] == 0x00 && block[3] == 0xfa)
                        num += get_dst_timing(block + 5, &mode[num]);
        }
-        
        /* Yikes, EDID data is totally useless */
        if (!num) {
                kfree(mode);
@@ -686,7 +686,7 @@ static int fb_get_monitor_limits(unsigned char *edid, struct fb_monspecs *specs)
        /* estimate monitor limits based on modes supported */
        if (retval) {
                struct fb_videomode *modes, *mode;
-                int num_modes, i, hz, hscan, pixclock;
+                int num_modes, hz, hscan, pixclock;
                int vtotal, htotal;
                modes = fb_create_modedb(edid, &num_modes);
@@ -713,7 +713,7 @@ static int fb_get_monitor_limits(unsigned char *edid, struct fb_monspecs *specs)
                        hscan = (pixclock + htotal / 2) / htotal;
                        hscan = (hscan + 500) / 1000 * 1000;
                        hz = (hscan + vtotal / 2) / vtotal;
-                        
                        if (specs->dclkmax == 0 || specs->dclkmax < pixclock)
                                specs->dclkmax = pixclock;
@@ -966,8 +966,8 @@ void fb_edid_to_monspecs(unsigned char *edid, struct fb_monspecs *specs)
        DPRINTK("========================================\n");
 }
-/* 
+/*
- * VESA Generalized Timing Formula (GTF) 
+ * VESA Generalized Timing Formula (GTF)
 */
 #define FLYBACK                     550
@@ -996,7 +996,7 @@ struct __fb_timings {
 * @hfreq: horizontal freq
 *
 * DESCRIPTION:
- * vblank = right_margin + vsync_len + left_margin 
+ * vblank = right_margin + vsync_len + left_margin
 *
 *    given: right_margin = 1 (V_FRONTPORCH)
 *           vsync_len    = 3
@@ -1010,12 +1010,12 @@ static u32 fb_get_vblank(u32 hfreq)
 {
        u32 vblank;
-        vblank = (hfreq * FLYBACK)/1000; 
+        vblank = (hfreq * FLYBACK)/1000;
        vblank = (vblank + 500)/1000;
        return (vblank + V_FRONTPORCH);
 }
-/** 
+/**
 * fb_get_hblank_by_freq - get horizontal blank time given hfreq
 * @hfreq: horizontal freq
 * @xres: horizontal resolution in pixels
@@ -1031,7 +1031,7 @@ static u32 fb_get_vblank(u32 hfreq)
 *
 * where: C = ((offset - scale factor) * blank_scale)
 *            -------------------------------------- + scale factor
- *                        256 
+ *                        256
 *        M = blank_scale * gradient
 *
 */
@@ -1039,7 +1039,7 @@ static u32 fb_get_hblank_by_hfreq(u32 hfreq, u32 xres)
 {
        u32 c_val, m_val, duty_cycle, hblank;
-        c_val = (((H_OFFSET - H_SCALEFACTOR) * H_BLANKSCALE)/256 + 
+        c_val = (((H_OFFSET - H_SCALEFACTOR) * H_BLANKSCALE)/256 +
                 H_SCALEFACTOR) * 1000;
        m_val = (H_BLANKSCALE * H_GRADIENT)/256;
        m_val = (m_val * 1000000)/hfreq;
@@ -1048,7 +1048,7 @@ static u32 fb_get_hblank_by_hfreq(u32 hfreq, u32 xres)
        return (hblank);
 }
-/** 
+/**
 * fb_get_hblank_by_dclk - get horizontal blank time given pixelclock
 * @dclk: pixelclock in Hz
 * @xres: horizontal resolution in pixels
@@ -1061,7 +1061,7 @@ static u32 fb_get_hblank_by_hfreq(u32 hfreq, u32 xres)
 *
 * duty cycle = percent of htotal assigned to inactive display
 * duty cycle = C - (M * h_period)
- * 
+ *
 * where: h_period = SQRT(100 - C + (0.4 * xres * M)/dclk) + C - 100
 *                   -----------------------------------------------
 *                                    2 * M
@@ -1077,11 +1077,11 @@ static u32 fb_get_hblank_by_dclk(u32 dclk, u32 xres)
        h_period = 100 - C_VAL;
        h_period *= h_period;
        h_period += (M_VAL * xres * 2 * 1000)/(5 * dclk);
-        h_period *=10000; 
+        h_period *= 10000;
        h_period = int_sqrt(h_period);
        h_period -= (100 - C_VAL) * 100;
-        h_period *= 1000; 
+        h_period *= 1000;
        h_period /= 2 * M_VAL;
        duty_cycle = C_VAL * 1000 - (M_VAL * h_period)/100;
@@ -1089,7 +1089,7 @@ static u32 fb_get_hblank_by_dclk(u32 dclk, u32 xres)
        hblank &= ~15;
        return (hblank);
 }
-        
 /**
 * fb_get_hfreq - estimate hsync
 * @vfreq: vertical refresh rate
@@ -1100,13 +1100,13 @@ static u32 fb_get_hblank_by_dclk(u32 dclk, u32 xres)
 *          (yres + front_port) * vfreq * 1000000
 * hfreq = -------------------------------------
 *          (1000000 - (vfreq * FLYBACK)
- * 
+ *
 */
 static u32 fb_get_hfreq(u32 vfreq, u32 yres)
 {
        u32 divisor, hfreq;
-        
        divisor = (1000000 - (vfreq * FLYBACK))/1000;
        hfreq = (yres + V_FRONTPORCH) * vfreq  * 1000;
        return (hfreq/divisor);
@@ -1117,7 +1117,7 @@ static void fb_timings_vfreq(struct __fb_timings *timings)
        timings->hfreq = fb_get_hfreq(timings->vfreq, timings->vactive);
        timings->vblank = fb_get_vblank(timings->hfreq);
        timings->vtotal = timings->vactive + timings->vblank;
-        timings->hblank = fb_get_hblank_by_hfreq(timings->hfreq, 
+        timings->hblank = fb_get_hblank_by_hfreq(timings->hfreq,
                                                 timings->hactive);
        timings->htotal = timings->hactive + timings->hblank;
        timings->dclk = timings->htotal * timings->hfreq;
@@ -1128,7 +1128,7 @@ static void fb_timings_hfreq(struct __fb_timings *timings)
        timings->vblank = fb_get_vblank(timings->hfreq);
        timings->vtotal = timings->vactive + timings->vblank;
        timings->vfreq = timings->hfreq/timings->vtotal;
-        timings->hblank = fb_get_hblank_by_hfreq(timings->hfreq, 
+        timings->hblank = fb_get_hblank_by_hfreq(timings->hfreq,
                                                 timings->hactive);
        timings->htotal = timings->hactive + timings->hblank;
        timings->dclk = timings->htotal * timings->hfreq;
@@ -1136,7 +1136,7 @@ static void fb_timings_hfreq(struct __fb_timings *timings)
 static void fb_timings_dclk(struct __fb_timings *timings)
 {
-        timings->hblank = fb_get_hblank_by_dclk(timings->dclk, 
+        timings->hblank = fb_get_hblank_by_dclk(timings->dclk,
                                                timings->hactive);
        timings->htotal = timings->hactive + timings->hblank;
        timings->hfreq = timings->dclk/timings->htotal;
@@ -1156,29 +1156,29 @@ static void fb_timings_dclk(struct __fb_timings *timings)
 * @info: pointer to fb_info
 *
 * DESCRIPTION:
- * Calculates video mode based on monitor specs using VESA GTF. 
+ * Calculates video mode based on monitor specs using VESA GTF.
- * The GTF is best for VESA GTF compliant monitors but is 
+ * The GTF is best for VESA GTF compliant monitors but is
 * specifically formulated to work for older monitors as well.
 *
- * If @flag==0, the function will attempt to maximize the 
+ * If @flag==0, the function will attempt to maximize the
 * refresh rate.  Otherwise, it will calculate timings based on
- * the flag and accompanying value.  
+ * the flag and accompanying value.
 *
- * If FB_IGNOREMON bit is set in @flags, monitor specs will be 
+ * If FB_IGNOREMON bit is set in @flags, monitor specs will be
 * ignored and @var will be filled with the calculated timings.
 *
 * All calculations are based on the VESA GTF Spreadsheet
 * available at VESA's public ftp (http://www.vesa.org).
- * 
+ *
 * NOTES:
 * The timings generated by the GTF will be different from VESA
 * DMT.  It might be a good idea to keep a table of standard
 * VESA modes as well.  The GTF may also not work for some displays,
 * such as, and especially, analog TV.
- *   
+ *
 * REQUIRES:
 * A valid info->monspecs, otherwise 'safe numbers' will be used.
- */ 
+ */
 int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_info *info)
 {
        struct __fb_timings *timings;
@@ -1191,7 +1191,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
        if (!timings)
                return -ENOMEM;
-        /* 
+        /*
         * If monspecs are invalid, use values that are enough
         * for 640x480@60
         */
@@ -1214,7 +1214,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
        timings->hactive = var->xres;
        timings->vactive = var->yres;
-        if (var->vmode & FB_VMODE_INTERLACED) { 
+        if (var->vmode & FB_VMODE_INTERLACED) {
                timings->vactive /= 2;
                interlace = 2;
        }
@@ -1250,9 +1250,9 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
                break;
        default:
                err = -EINVAL;
-                
-        } 
+        }
-        
        if (err || (!(flags & FB_IGNOREMON) &&
            (timings->vfreq < vfmin || timings->vfreq > vfmax ||
             timings->hfreq < hfmin || timings->hfreq > hfmax ||
@@ -1269,7 +1269,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
                var->upper_margin = (timings->vblank * interlace)/dscan -
                        (var->vsync_len + var->lower_margin);
        }
-        
        kfree(timings);
        return err;
 }
@@ -1291,7 +1291,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var,
        return -EINVAL;
 }
 #endif /* CONFIG_FB_MODE_HELPERS */
-        
 /*
 * fb_validate_mode - validates var against monitor capabilities
 * @var: pointer to fb_var_screeninfo
@@ -1309,7 +1309,7 @@ int fb_validate_mode(const struct fb_var_screeninfo *var, struct fb_info *info)
        u32 hfreq, vfreq, htotal, vtotal, pixclock;
        u32 hfmin, hfmax, vfmin, vfmax, dclkmin, dclkmax;
-        /* 
+        /*
         * If monspecs are invalid, use values that are enough
         * for 640x480@60
         */
@@ -1333,10 +1333,10 @@ int fb_validate_mode(const struct fb_var_screeninfo *var, struct fb_info *info)
        if (!var->pixclock)
                return -EINVAL;
        pixclock = PICOS2KHZ(var->pixclock) * 1000;
-           
-        htotal = var->xres + var->right_margin + var->hsync_len + 
+        htotal = var->xres + var->right_margin + var->hsync_len +
                var->left_margin;
-        vtotal = var->yres + var->lower_margin + var->vsync_len + 
+        vtotal = var->yres + var->lower_margin + var->vsync_len +
                var->upper_margin;
        if (var->vmode & FB_VMODE_INTERLACED)
@@ -1349,7 +1349,7 @@ int fb_validate_mode(const struct fb_var_screeninfo *var, struct fb_info *info)
        vfreq = hfreq/vtotal;
-        return (vfreq < vfmin || vfreq > vfmax || 
+        return (vfreq < vfmin || vfreq > vfmax ||
                hfreq < hfmin || hfreq > hfmax ||
                pixclock < dclkmin || pixclock > dclkmax) ?
                -EINVAL : 0;
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index b9b572b293d4..2e552d5bbb5d 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -183,8 +183,8 @@ static struct fb_videomode default_mode_LCD __initdata = {
        .vmode          = FB_VMODE_NONINTERLACED,
 };
-struct fb_videomode *default_mode = &default_mode_CRT;
+struct fb_videomode *default_mode __initdata = &default_mode_CRT;
-struct fb_var_screeninfo *default_var = &default_var_CRT;
+struct fb_var_screeninfo *default_var __initdata = &default_var_CRT;
 static int flat_panel_enabled = 0;
diff --git a/drivers/video/geode/lxfb.h b/drivers/video/geode/lxfb.h
index 6c227f9592a5..ca13c48d19b0 100644
--- a/drivers/video/geode/lxfb.h
+++ b/drivers/video/geode/lxfb.h
@@ -33,7 +33,7 @@ void lx_set_palette_reg(struct fb_info *, unsigned int, unsigned int,
 #define MSR_LX_GLD_CONFIG    0x48002001
 #define MSR_LX_GLCP_DOTPLL   0x4c000015
-#define MSR_LX_DF_PADSEL     0x48000011
+#define MSR_LX_DF_PADSEL     0x48002011
 #define MSR_LX_DC_SPARE      0x80000011
 #define MSR_LX_DF_GLCONFIG   0x48002001
diff --git a/drivers/video/geode/lxfb_core.c b/drivers/video/geode/lxfb_core.c
index 583185fd7c94..eb6b88171538 100644
--- a/drivers/video/geode/lxfb_core.c
+++ b/drivers/video/geode/lxfb_core.c
@@ -34,7 +34,7 @@ static int fbsize;
 * we try to make it something sane - 640x480-60 is sane
 */
-const struct fb_videomode geode_modedb[] __initdata = {
+static const struct fb_videomode geode_modedb[] __initdata = {
        /* 640x480-60 */
        { NULL, 60, 640, 480, 39682, 48, 8, 25, 2, 88, 2,
          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
diff --git a/drivers/video/hpfb.c b/drivers/video/hpfb.c
index b18486ad8e17..2eb4fb159084 100644
--- a/drivers/video/hpfb.c
+++ b/drivers/video/hpfb.c
@@ -207,7 +207,8 @@ static struct fb_ops hpfb_ops = {
 #define HPFB_FBOMSB     0x5d    /* Frame buffer offset          */
 #define HPFB_FBOLSB     0x5f
-static int __init hpfb_init_one(unsigned long phys_base, unsigned long virt_base)
+static int __devinit hpfb_init_one(unsigned long phys_base,
+                                   unsigned long virt_base)
 {
        unsigned long fboff, fb_width, fb_height, fb_start;
diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c
index 1a7d7789d877..1d13dd099af8 100644
--- a/drivers/video/i810/i810_main.c
+++ b/drivers/video/i810/i810_main.c
@@ -1476,7 +1476,7 @@ static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
        struct i810fb_par *par = info->par;
        u8 __iomem *mmio = par->mmio_start_virtual;
-        if (!par->dev_flags & LOCKUP)
+        if (!(par->dev_flags & LOCKUP))
                return -ENXIO;
        if (cursor->image.width > 64 || cursor->image.height > 64)
diff --git a/drivers/video/igafb.c b/drivers/video/igafb.c
index b87ea21d3d78..3a81060137a2 100644
--- a/drivers/video/igafb.c
+++ b/drivers/video/igafb.c
@@ -400,6 +400,7 @@ int __init igafb_init(void)
        info = kzalloc(size, GFP_ATOMIC);
        if (!info) {
                printk("igafb_init: can't alloc fb_info\n");
+                 pci_dev_put(pdev);
                return -ENOMEM;
        }
@@ -409,12 +410,14 @@ int __init igafb_init(void)
        if ((addr = pdev->resource[0].start) == 0) {
                printk("igafb_init: no memory start\n");
                kfree(info);
+                pci_dev_put(pdev);
                return -ENXIO;
        }
        if ((info->screen_base = ioremap(addr, 1024*1024*2)) == 0) {
                printk("igafb_init: can't remap %lx[2M]\n", addr);
                kfree(info);
+                pci_dev_put(pdev);
                return -ENXIO;
        }
@@ -449,6 +452,7 @@ int __init igafb_init(void)
                printk("igafb_init: can't remap %lx[4K]\n", igafb_fix.mmio_start);
                iounmap((void *)info->screen_base);
                kfree(info);
+                pci_dev_put(pdev);
                return -ENXIO;
        }
@@ -466,6 +470,7 @@ int __init igafb_init(void)
                iounmap((void *)par->io_base);
                iounmap(info->screen_base);
                kfree(info);
+                pci_dev_put(pdev);
                return -ENOMEM;
        }
diff --git a/drivers/video/imacfb.c b/drivers/video/imacfb.c
index 6455fd2a39f2..9366ef2bb5f7 100644
--- a/drivers/video/imacfb.c
+++ b/drivers/video/imacfb.c
@@ -234,10 +234,6 @@ static int __init imacfb_probe(struct platform_device *dev)
                size_remap = size_total;
        imacfb_fix.smem_len = size_remap;
-#ifndef __i386__
-        screen_info.imacpm_seg = 0;
-#endif
        if (!request_mem_region(imacfb_fix.smem_start, size_total, "imacfb")) {
                printk(KERN_WARNING
                       "imacfb: cannot reserve video memory at 0x%lx\n",
diff --git a/drivers/video/intelfb/intelfb.h b/drivers/video/intelfb/intelfb.h
index 2fe3f7def530..836796177942 100644
--- a/drivers/video/intelfb/intelfb.h
+++ b/drivers/video/intelfb/intelfb.h
@@ -111,7 +111,7 @@
 #define FIXED_MODE(d) ((d)->fixed_mode)
-/*** Driver paramters ***/
+/*** Driver parameters ***/
 #define RINGBUFFER_SIZE         KB(64)
 #define HW_CURSOR_SIZE          KB(4)
diff --git a/drivers/video/intelfb/intelfbhw.c b/drivers/video/intelfb/intelfbhw.c
index 5f6fb7d2c408..fa1fff553565 100644
--- a/drivers/video/intelfb/intelfbhw.c
+++ b/drivers/video/intelfb/intelfbhw.c
@@ -1971,7 +1971,7 @@ void intelfbhw_cursor_reset(struct intelfb_info *dinfo)
 static irqreturn_t intelfbhw_irq(int irq, void *dev_id)
 {
        u16 tmp;
-        struct intelfb_info *dinfo = (struct intelfb_info *)dev_id;
+        struct intelfb_info *dinfo = dev_id;
        spin_lock(&dinfo->int_lock);
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index 49cd53e46c0a..0cd58f84fb46 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -1232,7 +1232,7 @@ static int maven_shutdown_client(struct i2c_client* clnt) {
        return 0;
 }
-static unsigned short normal_i2c[] = { MAVEN_I2CID, I2C_CLIENT_END };
+static const unsigned short normal_i2c[] = { MAVEN_I2CID, I2C_CLIENT_END };
 I2C_CLIENT_INSMOD;
 static struct i2c_driver maven_driver;
diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c
index 8d81ef019c6c..08d072552233 100644
--- a/drivers/video/modedb.c
+++ b/drivers/video/modedb.c
@@ -259,6 +259,10 @@ static const struct fb_videomode modedb[] = {
        /* 1366x768, 60 Hz, 47.403 kHz hsync, WXGA 16:9 aspect ratio */
        NULL, 60, 1366, 768, 13806, 120, 10, 14, 3, 32, 5,
        0, FB_VMODE_NONINTERLACED
+   }, {
+        /* 1280x800, 60 Hz, 47.403 kHz hsync, WXGA 16:10 aspect ratio */
+        NULL, 60, 1280, 800, 12048, 200, 64, 24, 1, 136, 3,
+        0, FB_VMODE_NONINTERLACED
    },
 };
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index 4b6a99b5be0d..5246b0402d76 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -2066,40 +2066,49 @@ static struct fb_info *__devinit neo_alloc_fb_info(struct pci_dev *dev, const st
        switch (info->fix.accel) {
        case FB_ACCEL_NEOMAGIC_NM2070:
-                sprintf(info->fix.id, "MagicGraph 128");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 128");
                break;
        case FB_ACCEL_NEOMAGIC_NM2090:
-                sprintf(info->fix.id, "MagicGraph 128V");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 128V");
                break;
        case FB_ACCEL_NEOMAGIC_NM2093:
-                sprintf(info->fix.id, "MagicGraph 128ZV");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 128ZV");
                break;
        case FB_ACCEL_NEOMAGIC_NM2097:
-                sprintf(info->fix.id, "MagicGraph 128ZV+");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 128ZV+");
                break;
        case FB_ACCEL_NEOMAGIC_NM2160:
-                sprintf(info->fix.id, "MagicGraph 128XD");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 128XD");
                break;
        case FB_ACCEL_NEOMAGIC_NM2200:
-                sprintf(info->fix.id, "MagicGraph 256AV");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 256AV");
                info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
                               FBINFO_HWACCEL_COPYAREA |
                               FBINFO_HWACCEL_FILLRECT;
                break;
        case FB_ACCEL_NEOMAGIC_NM2230:
-                sprintf(info->fix.id, "MagicGraph 256AV+");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 256AV+");
                info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
                               FBINFO_HWACCEL_COPYAREA |
                               FBINFO_HWACCEL_FILLRECT;
                break;
        case FB_ACCEL_NEOMAGIC_NM2360:
-                sprintf(info->fix.id, "MagicGraph 256ZX");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 256ZX");
                info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
                               FBINFO_HWACCEL_COPYAREA |
                               FBINFO_HWACCEL_FILLRECT;
                break;
        case FB_ACCEL_NEOMAGIC_NM2380:
-                sprintf(info->fix.id, "MagicGraph 256XL+");
+                snprintf(info->fix.id, sizeof(info->fix.id),
+                                "MagicGraph 256XL+");
                info->flags |= FBINFO_HWACCEL_IMAGEBLIT |
                               FBINFO_HWACCEL_COPYAREA |
                               FBINFO_HWACCEL_FILLRECT;
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index 30e14eb1f51e..74517b1b26a6 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -849,9 +849,27 @@ static int nvidiafb_check_var(struct fb_var_screeninfo *var,
        if (!mode_valid && info->monspecs.modedb_len)
                return -EINVAL;
+        /*
+         * If we're on a flat panel, check if the mode is outside of the
+         * panel dimensions. If so, cap it and try for the next best mode
+         * before bailing out.
+         */
        if (par->fpWidth && par->fpHeight && (par->fpWidth < var->xres ||
-                                              par->fpHeight < var->yres))
+                                              par->fpHeight < var->yres)) {
-                return -EINVAL;
+                const struct fb_videomode *mode;
+                var->xres = par->fpWidth;
+                var->yres = par->fpHeight;
+                mode = fb_find_best_mode(var, &info->modelist);
+                if (!mode) {
+                        printk(KERN_ERR PFX "mode out of range of flat "
+                               "panel dimensions\n");
+                        return -EINVAL;
+                }
+                fb_videomode_to_var(var, mode);
+        }
        if (var->yres_virtual < var->yres)
                var->yres_virtual = var->yres;
diff --git a/drivers/video/omap/Kconfig b/drivers/video/omap/Kconfig
index f4fcf11b290d..44408850e2eb 100644
--- a/drivers/video/omap/Kconfig
+++ b/drivers/video/omap/Kconfig
@@ -1,6 +1,6 @@
 config FB_OMAP
        tristate "OMAP frame buffer support (EXPERIMENTAL)"
-        depends on FB
+        depends on FB && ARCH_OMAP
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
diff --git a/drivers/video/omap/lcd_h3.c b/drivers/video/omap/lcd_h3.c
index c604d935c188..31e978349a80 100644
--- a/drivers/video/omap/lcd_h3.c
+++ b/drivers/video/omap/lcd_h3.c
@@ -21,9 +21,9 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/i2c/tps65010.h>
 #include <asm/arch/gpio.h>
-#include <asm/arch/tps65010.h>
 #include <asm/arch/omapfb.h>
 #define MODULE_NAME     "omapfb-lcd_h3"
diff --git a/drivers/video/omap/lcdc.c b/drivers/video/omap/lcdc.c
index 9085188d815e..fb19ed4992db 100644
--- a/drivers/video/omap/lcdc.c
+++ b/drivers/video/omap/lcdc.c
@@ -312,7 +312,7 @@ static irqreturn_t lcdc_irq_handler(int irq, void *dev_id)
 /*
 * Change to a new video mode. We defer this to a later time to avoid any
 * flicker and not to mess up the current LCD DMA context. For this we disable
- * the LCD controler, which will generate a DONE irq after the last frame has
+ * the LCD controller, which will generate a DONE irq after the last frame has
 * been transferred. Then it'll be safe to reconfigure both the LCD controller
 * as well as the LCD DMA.
 */
diff --git a/drivers/video/pm2fb.c b/drivers/video/pm2fb.c
index 5591dfb22b18..30181b593829 100644
--- a/drivers/video/pm2fb.c
+++ b/drivers/video/pm2fb.c
@@ -1159,6 +1159,11 @@ static void pm2fb_imageblit(struct fb_info *info, const struct fb_image *image)
        u32 fgx, bgx;
        const u32 *src = (const u32 *)image->data;
        u32 xres = (info->var.xres + 31) & ~31;
+        int raster_mode = 1; /* invert bits */
+#ifdef __LITTLE_ENDIAN
+        raster_mode |= 3 << 7; /* reverse byte order */
+#endif
        if (info->state != FBINFO_STATE_RUNNING)
                return;
@@ -1208,9 +1213,8 @@ static void pm2fb_imageblit(struct fb_info *info, const struct fb_image *image)
                pm2_WR(par, PM2R_RENDER,
                        PM2F_RENDER_RECTANGLE |
                        PM2F_INCREASE_X | PM2F_INCREASE_Y);
-                /* BitMapPackEachScanline & invert bits and byte order*/
+                /* BitMapPackEachScanline */
-                /* force background */
+                pm2_WR(par, PM2R_RASTERIZER_MODE, raster_mode | (1 << 9));
-                pm2_WR(par, PM2R_RASTERIZER_MODE,  (1 << 9) | 1 | (3 << 7));
                pm2_WR(par, PM2R_CONSTANT_COLOR, fgx);
                pm2_WR(par, PM2R_RENDER,
                        PM2F_RENDER_RECTANGLE |
@@ -1224,8 +1228,7 @@ static void pm2fb_imageblit(struct fb_info *info, const struct fb_image *image)
                        PM2F_RENDER_RECTANGLE |
                        PM2F_RENDER_FASTFILL |
                        PM2F_INCREASE_X | PM2F_INCREASE_Y);
-                /* invert bits and byte order*/
+                pm2_WR(par, PM2R_RASTERIZER_MODE, raster_mode);
-                pm2_WR(par, PM2R_RASTERIZER_MODE,  1 | (3 << 7));
                pm2_WR(par, PM2R_FB_BLOCK_COLOR, fgx);
                pm2_WR(par, PM2R_RENDER,
                        PM2F_RENDER_RECTANGLE |
diff --git a/drivers/video/pm3fb.c b/drivers/video/pm3fb.c
index 070659992c18..5dba8cdd0517 100644
--- a/drivers/video/pm3fb.c
+++ b/drivers/video/pm3fb.c
@@ -1227,7 +1227,7 @@ static struct fb_ops pm3fb_ops = {
 /* mmio register are already mapped when this function is called */
 /* the pm3fb_fix.smem_start is also set */
-static unsigned long pm3fb_size_memory(struct pm3_par *par)
+static unsigned long __devinit pm3fb_size_memory(struct pm3_par *par)
 {
        unsigned long   memsize = 0;
        unsigned long   tempBypass, i, temp1, temp2;
diff --git a/drivers/video/pmag-aa-fb.c b/drivers/video/pmag-aa-fb.c
index a864438b6008..6515ec11c16b 100644
--- a/drivers/video/pmag-aa-fb.c
+++ b/drivers/video/pmag-aa-fb.c
@@ -150,7 +150,7 @@ static int aafbcon_set_font(struct display *disp, int width, int height)
 {
        struct aafb_info *info = (struct aafb_info *)disp->fb_info;
        struct aafb_cursor *c = &info->cursor;
-        u8 fgc = ~attr_bgcol_ec(disp, disp->conp);
+        u8 fgc = ~attr_bgcol_ec(disp, disp->conp, &info->info);
        if (width > 64 || height > 64 || width < 0 || height < 0)
                return -EINVAL;
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index b3463ddcfd60..dc3af1c78c56 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -51,14 +51,12 @@
 #define L1GPU_DISPLAY_SYNC_HSYNC                1
 #define L1GPU_DISPLAY_SYNC_VSYNC                2
-#define DDR_SIZE                                (0)     /* used no ddr */
+#define GPU_CMD_BUF_SIZE                        (2 * 1024 * 1024)
-#define GPU_CMD_BUF_SIZE                        (64 * 1024)
+#define GPU_FB_START                            (64 * 1024)
 #define GPU_IOIF                                (0x0d000000UL)
 #define GPU_ALIGN_UP(x)                         _ALIGN_UP((x), 64)
 #define GPU_MAX_LINE_LENGTH                     (65536 - 64)
-#define PS3FB_FULL_MODE_BIT                     0x80
 #define GPU_INTR_STATUS_VSYNC_0                 0       /* vsync on head A */
 #define GPU_INTR_STATUS_VSYNC_1                 1       /* vsync on head B */
 #define GPU_INTR_STATUS_FLIP_0                  3       /* flip head A */
@@ -118,8 +116,6 @@ struct ps3fb_priv {
        unsigned int irq_no;
        u64 context_handle, memory_handle;
-        void *xdr_ea;
-        size_t xdr_size;
        struct gpu_driver_info *dinfo;
        u64 vblank_count;       /* frame count */
@@ -136,42 +132,19 @@ static struct ps3fb_priv ps3fb;
 struct ps3fb_par {
        u32 pseudo_palette[16];
        int mode_id, new_mode_id;
-        int res_index;
        unsigned int num_frames;        /* num of frame buffers */
        unsigned int width;
        unsigned int height;
-        unsigned long full_offset;      /* start of fullscreen DDR fb */
+        unsigned int ddr_line_length;
-        unsigned long fb_offset;        /* start of actual DDR fb */
+        unsigned int ddr_frame_size;
-        unsigned long pan_offset;
+        unsigned int xdr_frame_size;
+        unsigned int full_offset;       /* start of fullscreen DDR fb */
+        unsigned int fb_offset;         /* start of actual DDR fb */
+        unsigned int pan_offset;
 };
-struct ps3fb_res_table {
-        u32 xres;
+#define FIRST_NATIVE_MODE_INDEX 10
-        u32 yres;
-        u32 xoff;
-        u32 yoff;
-        u32 type;
-};
-#define PS3FB_RES_FULL 1
-static const struct ps3fb_res_table ps3fb_res[] = {
-        /* res_x,y   margin_x,y  full */
-        {  720,  480,  72,  48 , 0},
-        {  720,  576,  72,  58 , 0},
-        { 1280,  720,  78,  38 , 0},
-        { 1920, 1080, 116,  58 , 0},
-        /* full mode */
-        {  720,  480,   0,   0 , PS3FB_RES_FULL},
-        {  720,  576,   0,   0 , PS3FB_RES_FULL},
-        { 1280,  720,   0,   0 , PS3FB_RES_FULL},
-        { 1920, 1080,   0,   0 , PS3FB_RES_FULL},
-        /* vesa: normally full mode */
-        { 1280,  768,   0,   0 , 0},
-        { 1280, 1024,   0,   0 , 0},
-        { 1920, 1200,   0,   0 , 0},
-        {    0,    0,   0,   0 , 0} };
-/* default resolution */
-#define GPU_RES_INDEX   0               /* 720 x 480 */
 static const struct fb_videomode ps3fb_modedb[] = {
    /* 60 Hz broadcast modes (modes "1" to "5") */
@@ -211,7 +184,7 @@ static const struct fb_videomode ps3fb_modedb[] = {
        "720p", 50, 1124, 644, 13468, 298, 478, 57, 44, 80, 5,
        FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED
    },    {
-        /* 1080 */
+        /* 1080i */
        "1080i", 50, 1688, 964, 13468, 264, 600, 94, 62, 88, 5,
        FB_SYNC_BROADCAST, FB_VMODE_INTERLACED
    },    {
@@ -220,24 +193,7 @@ static const struct fb_videomode ps3fb_modedb[] = {
        FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED
    },
-    /* VESA modes (modes "11" to "13") */
+    [FIRST_NATIVE_MODE_INDEX] =
-    {
-        /* WXGA */
-        "wxga", 60, 1280, 768, 12924, 160, 24, 29, 3, 136, 6,
-        0, FB_VMODE_NONINTERLACED,
-        FB_MODE_IS_VESA
-    }, {
-        /* SXGA */
-        "sxga", 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
-        FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED,
-        FB_MODE_IS_VESA
-    }, {
-        /* WUXGA */
-        "wuxga", 60, 1920, 1200, 6494, 80, 48, 26, 3, 32, 6,
-        FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED,
-        FB_MODE_IS_VESA
-    },
    /* 60 Hz broadcast modes (full resolution versions of modes "1" to "5") */
    {
        /* 480if */
@@ -276,12 +232,30 @@ static const struct fb_videomode ps3fb_modedb[] = {
        FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED
    }, {
        /* 1080if */
-        "1080f", 50, 1920, 1080, 13468, 148, 484, 36, 4, 88, 5,
+        "1080if", 50, 1920, 1080, 13468, 148, 484, 36, 4, 88, 5,
        FB_SYNC_BROADCAST, FB_VMODE_INTERLACED
    }, {
        /* 1080pf */
        "1080pf", 50, 1920, 1080, 6734, 148, 484, 36, 4, 88, 5,
        FB_SYNC_BROADCAST, FB_VMODE_NONINTERLACED
+    },
+    /* VESA modes (modes "11" to "13") */
+    {
+        /* WXGA */
+        "wxga", 60, 1280, 768, 12924, 160, 24, 29, 3, 136, 6,
+        0, FB_VMODE_NONINTERLACED,
+        FB_MODE_IS_VESA
+    }, {
+        /* SXGA */
+        "sxga", 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
+        FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED,
+        FB_MODE_IS_VESA
+    }, {
+        /* WUXGA */
+        "wuxga", 60, 1920, 1200, 6494, 80, 48, 26, 3, 32, 6,
+        FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED,
+        FB_MODE_IS_VESA
    }
 };
@@ -289,110 +263,188 @@ static const struct fb_videomode ps3fb_modedb[] = {
 #define HEAD_A
 #define HEAD_B
-#define X_OFF(i)        (ps3fb_res[i].xoff)     /* left/right margin (pixel) */
-#define Y_OFF(i)        (ps3fb_res[i].yoff)     /* top/bottom margin (pixel) */
-#define WIDTH(i)        (ps3fb_res[i].xres)     /* width of FB */
-#define HEIGHT(i)       (ps3fb_res[i].yres)     /* height of FB */
 #define BPP             4                       /* number of bytes per pixel */
-/* Start of the virtual frame buffer (relative to fullscreen ) */
-#define VP_OFF(i)       ((WIDTH(i) * Y_OFF(i) + X_OFF(i)) * BPP)
 static int ps3fb_mode;
 module_param(ps3fb_mode, int, 0);
 static char *mode_option __devinitdata;
-static int ps3fb_get_res_table(u32 xres, u32 yres, int mode)
+static int ps3fb_cmp_mode(const struct fb_videomode *vmode,
+                          const struct fb_var_screeninfo *var)
 {
-        int full_mode;
+        long xres, yres, left_margin, right_margin, upper_margin, lower_margin;
-        unsigned int i;
+        long dx, dy;
-        u32 x, y, f;
+        /* maximum values */
-        full_mode = (mode & PS3FB_FULL_MODE_BIT) ? PS3FB_RES_FULL : 0;
+        if (var->xres > vmode->xres || var->yres > vmode->yres ||
-        for (i = 0;; i++) {
+            var->pixclock > vmode->pixclock ||
-                x = ps3fb_res[i].xres;
+            var->hsync_len > vmode->hsync_len ||
-                y = ps3fb_res[i].yres;
+            var->vsync_len > vmode->vsync_len)
-                f = ps3fb_res[i].type;
+                return -1;
-                if (!x) {
-                        pr_debug("ERROR: ps3fb_get_res_table()\n");
-                        return -1;
-                }
-                if (full_mode == PS3FB_RES_FULL && f != PS3FB_RES_FULL)
+        /* progressive/interlaced must match */
-                        continue;
+        if ((var->vmode & FB_VMODE_MASK) != vmode->vmode)
+                return -1;
-                if (x == xres && (yres == 0 || y == yres))
+        /* minimum resolution */
-                        break;
+        xres = max(var->xres, 1U);
+        yres = max(var->yres, 1U);
+        /* minimum margins */
+        left_margin = max(var->left_margin, vmode->left_margin);
+        right_margin = max(var->right_margin, vmode->right_margin);
+        upper_margin = max(var->upper_margin, vmode->upper_margin);
+        lower_margin = max(var->lower_margin, vmode->lower_margin);
+        /* resolution + margins may not exceed native parameters */
+        dx = ((long)vmode->left_margin + (long)vmode->xres +
+              (long)vmode->right_margin) -
+             (left_margin + xres + right_margin);
+        if (dx < 0)
+                return -1;
-                x = x - 2 * ps3fb_res[i].xoff;
+        dy = ((long)vmode->upper_margin + (long)vmode->yres +
-                y = y - 2 * ps3fb_res[i].yoff;
+              (long)vmode->lower_margin) -
-                if (x == xres && (yres == 0 || y == yres))
+             (upper_margin + yres + lower_margin);
-                        break;
+        if (dy < 0)
+                return -1;
+        /* exact match */
+        if (!dx && !dy)
+                return 0;
+        /* resolution difference */
+        return (vmode->xres - xres) * (vmode->yres - yres);
+}
+static const struct fb_videomode *ps3fb_native_vmode(enum ps3av_mode_num id)
+{
+        return &ps3fb_modedb[FIRST_NATIVE_MODE_INDEX + id - 1];
+}
+static const struct fb_videomode *ps3fb_vmode(int id)
+{
+        u32 mode = id & PS3AV_MODE_MASK;
+        if (mode < PS3AV_MODE_480I || mode > PS3AV_MODE_WUXGA)
+                return NULL;
+        if (mode <= PS3AV_MODE_1080P50 && !(id & PS3AV_MODE_FULL)) {
+                /* Non-fullscreen broadcast mode */
+                return &ps3fb_modedb[mode - 1];
        }
-        return i;
+        return ps3fb_native_vmode(mode);
 }
-static unsigned int ps3fb_find_mode(const struct fb_var_screeninfo *var,
+static unsigned int ps3fb_find_mode(struct fb_var_screeninfo *var,
                                    u32 *ddr_line_length, u32 *xdr_line_length)
 {
-        unsigned int i, mode;
+        unsigned int id, best_id;
+        int diff, best_diff;
-        for (i = 0; i < ARRAY_SIZE(ps3fb_modedb); i++)
+        const struct fb_videomode *vmode;
-                if (var->xres == ps3fb_modedb[i].xres &&
+        long gap;
-                    var->yres == ps3fb_modedb[i].yres &&
-                    var->pixclock == ps3fb_modedb[i].pixclock &&
+        best_id = 0;
-                    var->hsync_len == ps3fb_modedb[i].hsync_len &&
+        best_diff = INT_MAX;
-                    var->vsync_len == ps3fb_modedb[i].vsync_len &&
+        pr_debug("%s: wanted %u [%u] %u x %u [%u] %u\n", __func__,
-                    var->left_margin == ps3fb_modedb[i].left_margin &&
+                 var->left_margin, var->xres, var->right_margin,
-                    var->right_margin == ps3fb_modedb[i].right_margin &&
+                 var->upper_margin, var->yres, var->lower_margin);
-                    var->upper_margin == ps3fb_modedb[i].upper_margin &&
+        for (id = PS3AV_MODE_480I; id <= PS3AV_MODE_WUXGA; id++) {
-                    var->lower_margin == ps3fb_modedb[i].lower_margin &&
+                vmode = ps3fb_native_vmode(id);
-                    var->sync == ps3fb_modedb[i].sync &&
+                diff = ps3fb_cmp_mode(vmode, var);
-                    (var->vmode & FB_VMODE_MASK) == ps3fb_modedb[i].vmode)
+                pr_debug("%s: mode %u: %u [%u] %u x %u [%u] %u: diff = %d\n",
-                        goto found;
+                         __func__, id, vmode->left_margin, vmode->xres,
+                         vmode->right_margin, vmode->upper_margin,
-        pr_debug("ps3fb_find_mode: mode not found\n");
+                         vmode->yres, vmode->lower_margin, diff);
-        return 0;
+                if (diff < 0)
+                        continue;
+                if (diff < best_diff) {
+                        best_id = id;
+                        if (!diff)
+                                break;
+                        best_diff = diff;
+                }
+        }
-found:
+        if (!best_id) {
-        /* Cropped broadcast modes use the full line length */
+                pr_debug("%s: no suitable mode found\n", __func__);
-        *ddr_line_length = ps3fb_modedb[i < 10 ? i + 13 : i].xres * BPP;
+                return 0;
+        }
-        if (ps3_compare_firmware_version(1, 9, 0) >= 0) {
+        id = best_id;
-                *xdr_line_length = GPU_ALIGN_UP(max(var->xres,
+        vmode = ps3fb_native_vmode(id);
-                                                    var->xres_virtual) * BPP);
-                if (*xdr_line_length > GPU_MAX_LINE_LENGTH)
-                        *xdr_line_length = GPU_MAX_LINE_LENGTH;
-        } else
-                *xdr_line_length = *ddr_line_length;
-        /* Full broadcast modes have the full mode bit set */
+        *ddr_line_length = vmode->xres * BPP;
-        mode = i > 12 ? (i - 12) | PS3FB_FULL_MODE_BIT : i + 1;
-        pr_debug("ps3fb_find_mode: mode %u\n", mode);
+        /* minimum resolution */
+        if (!var->xres)
+                var->xres = 1;
+        if (!var->yres)
+                var->yres = 1;
-        return mode;
+        /* minimum virtual resolution */
-}
+        if (var->xres_virtual < var->xres)
+                var->xres_virtual = var->xres;
+        if (var->yres_virtual < var->yres)
+                var->yres_virtual = var->yres;
-static const struct fb_videomode *ps3fb_default_mode(int id)
+        /* minimum margins */
-{
+        if (var->left_margin < vmode->left_margin)
-        u32 mode = id & PS3AV_MODE_MASK;
+                var->left_margin = vmode->left_margin;
-        u32 flags;
+        if (var->right_margin < vmode->right_margin)
+                var->right_margin = vmode->right_margin;
+        if (var->upper_margin < vmode->upper_margin)
+                var->upper_margin = vmode->upper_margin;
+        if (var->lower_margin < vmode->lower_margin)
+                var->lower_margin = vmode->lower_margin;
+        /* extra margins */
+        gap = ((long)vmode->left_margin + (long)vmode->xres +
+               (long)vmode->right_margin) -
+              ((long)var->left_margin + (long)var->xres +
+               (long)var->right_margin);
+        if (gap > 0) {
+                var->left_margin += gap/2;
+                var->right_margin += (gap+1)/2;
+                pr_debug("%s: rounded up H to %u [%u] %u\n", __func__,
+                         var->left_margin, var->xres, var->right_margin);
+        }
-        if (mode < 1 || mode > 13)
+        gap = ((long)vmode->upper_margin + (long)vmode->yres +
-                return NULL;
+               (long)vmode->lower_margin) -
+              ((long)var->upper_margin + (long)var->yres +
+               (long)var->lower_margin);
+        if (gap > 0) {
+                var->upper_margin += gap/2;
+                var->lower_margin += (gap+1)/2;
+                pr_debug("%s: rounded up V to %u [%u] %u\n", __func__,
+                         var->upper_margin, var->yres, var->lower_margin);
+        }
-        flags = id & ~PS3AV_MODE_MASK;
+        /* fixed fields */
+        var->pixclock = vmode->pixclock;
+        var->hsync_len = vmode->hsync_len;
+        var->vsync_len = vmode->vsync_len;
+        var->sync = vmode->sync;
+        if (ps3_compare_firmware_version(1, 9, 0) >= 0) {
+                *xdr_line_length = GPU_ALIGN_UP(var->xres_virtual * BPP);
+                if (*xdr_line_length > GPU_MAX_LINE_LENGTH)
+                        *xdr_line_length = GPU_MAX_LINE_LENGTH;
+        } else
+                *xdr_line_length = *ddr_line_length;
-        if (mode <= 10 && flags & PS3FB_FULL_MODE_BIT) {
+        if (vmode->sync & FB_SYNC_BROADCAST) {
-                /* Full broadcast mode */
+                /* Full broadcast modes have the full mode bit set */
-                return &ps3fb_modedb[mode + 12];
+                if (vmode->xres == var->xres && vmode->yres == var->yres)
+                        id |= PS3AV_MODE_FULL;
        }
-        return &ps3fb_modedb[mode - 1];
+        pr_debug("%s: mode %u\n", __func__, id);
+        return id;
 }
 static void ps3fb_sync_image(struct device *dev, u64 frame_offset,
@@ -407,6 +459,7 @@ static void ps3fb_sync_image(struct device *dev, u64 frame_offset,
        if (src_line_length != dst_line_length)
                line_length |= (u64)src_line_length << 32;
+        src_offset += GPU_FB_START;
        status = lv1_gpu_context_attribute(ps3fb.context_handle,
                                           L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT,
                                           dst_offset, GPU_IOIF + src_offset,
@@ -438,12 +491,9 @@ static void ps3fb_sync_image(struct device *dev, u64 frame_offset,
 static int ps3fb_sync(struct fb_info *info, u32 frame)
 {
        struct ps3fb_par *par = info->par;
-        int i, error = 0;
+        int error = 0;
-        u32 ddr_line_length, xdr_line_length;
        u64 ddr_base, xdr_base;
-        acquire_console_sem();
        if (frame > par->num_frames - 1) {
                dev_dbg(info->device, "%s: invalid frame number (%u)\n",
                        __func__, frame);
@@ -451,19 +501,15 @@ static int ps3fb_sync(struct fb_info *info, u32 frame)
                goto out;
        }
-        i = par->res_index;
+        xdr_base = frame * par->xdr_frame_size;
-        xdr_line_length = info->fix.line_length;
+        ddr_base = frame * par->ddr_frame_size;
-        ddr_line_length = ps3fb_res[i].xres * BPP;
-        xdr_base = frame * info->var.yres_virtual * xdr_line_length;
-        ddr_base = frame * ps3fb_res[i].yres * ddr_line_length;
        ps3fb_sync_image(info->device, ddr_base + par->full_offset,
                         ddr_base + par->fb_offset, xdr_base + par->pan_offset,
-                         par->width, par->height, ddr_line_length,
+                         par->width, par->height, par->ddr_line_length,
-                         xdr_line_length);
+                         info->fix.line_length);
 out:
-        release_console_sem();
        return error;
 }
@@ -478,7 +524,10 @@ static int ps3fb_release(struct fb_info *info, int user)
        if (atomic_dec_and_test(&ps3fb.f_count)) {
                if (atomic_read(&ps3fb.ext_flip)) {
                        atomic_set(&ps3fb.ext_flip, 0);
-                        ps3fb_sync(info, 0);    /* single buffer */
+                        if (!try_acquire_console_sem()) {
+                                ps3fb_sync(info, 0);    /* single buffer */
+                                release_console_sem();
+                        }
                }
        }
        return 0;
@@ -497,22 +546,11 @@ static int ps3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
        u32 xdr_line_length, ddr_line_length;
        int mode;
-        dev_dbg(info->device, "var->xres:%u info->var.xres:%u\n", var->xres,
-                info->var.xres);
-        dev_dbg(info->device, "var->yres:%u info->var.yres:%u\n", var->yres,
-                info->var.yres);
-        /* FIXME For now we do exact matches only */
        mode = ps3fb_find_mode(var, &ddr_line_length, &xdr_line_length);
        if (!mode)
                return -EINVAL;
        /* Virtual screen */
-        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 > xdr_line_length / BPP) {
                dev_dbg(info->device,
                        "Horizontal virtual screen size too large\n");
@@ -558,7 +596,7 @@ static int ps3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
        }
        /* Memory limit */
-        if (var->yres_virtual * xdr_line_length > ps3fb.xdr_size) {
+        if (var->yres_virtual * xdr_line_length > info->fix.smem_len) {
                dev_dbg(info->device, "Not enough memory\n");
                return -ENOMEM;
        }
@@ -577,39 +615,38 @@ static int ps3fb_set_par(struct fb_info *info)
 {
        struct ps3fb_par *par = info->par;
        unsigned int mode, ddr_line_length, xdr_line_length, lines, maxlines;
-        int i;
+        unsigned int ddr_xoff, ddr_yoff, offset;
-        unsigned long offset;
+        const struct fb_videomode *vmode;
        u64 dst;
-        dev_dbg(info->device, "xres:%d xv:%d yres:%d yv:%d clock:%d\n",
-                info->var.xres, info->var.xres_virtual,
-                info->var.yres, info->var.yres_virtual, info->var.pixclock);
        mode = ps3fb_find_mode(&info->var, &ddr_line_length, &xdr_line_length);
        if (!mode)
                return -EINVAL;
-        i = ps3fb_get_res_table(info->var.xres, info->var.yres, mode);
+        vmode = ps3fb_native_vmode(mode & PS3AV_MODE_MASK);
-        par->res_index = i;
-        info->fix.smem_start = virt_to_abs(ps3fb.xdr_ea);
-        info->fix.smem_len = ps3fb.xdr_size;
        info->fix.xpanstep = info->var.xres_virtual > info->var.xres ? 1 : 0;
        info->fix.ypanstep = info->var.yres_virtual > info->var.yres ? 1 : 0;
        info->fix.line_length = xdr_line_length;
-        info->screen_base = (char __iomem *)ps3fb.xdr_ea;
+        par->ddr_line_length = ddr_line_length;
+        par->ddr_frame_size = vmode->yres * ddr_line_length;
+        par->xdr_frame_size = info->var.yres_virtual * xdr_line_length;
-        par->num_frames = ps3fb.xdr_size /
+        par->num_frames = info->fix.smem_len /
-                          max(ps3fb_res[i].yres * ddr_line_length,
+                          max(par->ddr_frame_size, par->xdr_frame_size);
-                              info->var.yres_virtual * xdr_line_length);
        /* Keep the special bits we cannot set using fb_var_screeninfo */
        par->new_mode_id = (par->new_mode_id & ~PS3AV_MODE_MASK) | mode;
        par->width = info->var.xres;
        par->height = info->var.yres;
-        offset = VP_OFF(i);
+        /* Start of the virtual frame buffer (relative to fullscreen) */
+        ddr_xoff = info->var.left_margin - vmode->left_margin;
+        ddr_yoff = info->var.upper_margin - vmode->upper_margin;
+        offset = ddr_yoff * ddr_line_length + ddr_xoff * BPP;
        par->fb_offset = GPU_ALIGN_UP(offset);
        par->full_offset = par->fb_offset - offset;
        par->pan_offset = info->var.yoffset * xdr_line_length +
@@ -624,16 +661,16 @@ static int ps3fb_set_par(struct fb_info *info)
        }
        /* Clear XDR frame buffer memory */
-        memset(ps3fb.xdr_ea, 0, ps3fb.xdr_size);
+        memset((void __force *)info->screen_base, 0, info->fix.smem_len);
        /* Clear DDR frame buffer memory */
-        lines = ps3fb_res[i].yres * par->num_frames;
+        lines = vmode->yres * par->num_frames;
        if (par->full_offset)
                lines++;
-        maxlines = ps3fb.xdr_size / ddr_line_length;
+        maxlines = info->fix.smem_len / ddr_line_length;
        for (dst = 0; lines; dst += maxlines * ddr_line_length) {
                unsigned int l = min(lines, maxlines);
-                ps3fb_sync_image(info->device, 0, dst, 0, ps3fb_res[i].xres, l,
+                ps3fb_sync_image(info->device, 0, dst, 0, vmode->xres, l,
                                 ddr_line_length, ddr_line_length);
                lines -= l;
        }
@@ -727,7 +764,7 @@ static int ps3fb_blank(int blank, struct fb_info *info)
 static int ps3fb_get_vblank(struct fb_vblank *vblank)
 {
-        memset(vblank, 0, sizeof(&vblank));
+        memset(vblank, 0, sizeof(*vblank));
        vblank->flags = FB_VBLANK_HAVE_VSYNC;
        return 0;
 }
@@ -796,7 +833,7 @@ static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd,
        case PS3FB_IOCTL_SETMODE:
                {
                        struct ps3fb_par *par = info->par;
-                        const struct fb_videomode *mode;
+                        const struct fb_videomode *vmode;
                        struct fb_var_screeninfo var;
                        if (copy_from_user(&val, argp, sizeof(val)))
@@ -809,10 +846,10 @@ static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd,
                        }
                        dev_dbg(info->device, "PS3FB_IOCTL_SETMODE:%x\n", val);
                        retval = -EINVAL;
-                        mode = ps3fb_default_mode(val);
+                        vmode = ps3fb_vmode(val);
-                        if (mode) {
+                        if (vmode) {
                                var = info->var;
-                                fb_videomode_to_var(&var, mode);
+                                fb_videomode_to_var(&var, vmode);
                                acquire_console_sem();
                                info->flags |= FBINFO_MISC_USEREVENT;
                                /* Force, in case only special bits changed */
@@ -864,7 +901,9 @@ static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd,
                        break;
                dev_dbg(info->device, "PS3FB_IOCTL_FSEL:%d\n", val);
+                acquire_console_sem();
                retval = ps3fb_sync(info, val);
+                release_console_sem();
                break;
        default:
@@ -884,7 +923,9 @@ static int ps3fbd(void *arg)
                set_current_state(TASK_INTERRUPTIBLE);
                if (ps3fb.is_kicked) {
                        ps3fb.is_kicked = 0;
+                        acquire_console_sem();
                        ps3fb_sync(info, 0);    /* single buffer */
+                        release_console_sem();
                }
                schedule();
        }
@@ -970,16 +1011,14 @@ static int ps3fb_xdr_settings(u64 xdr_lpar, struct device *dev)
                        __func__, status);
                return -ENXIO;
        }
-        dev_dbg(dev,
+        dev_dbg(dev, "video:%p ioif:%lx lpar:%lx size:%lx\n",
-                "video:%p xdr_ea:%p ioif:%lx lpar:%lx phys:%lx size:%lx\n",
+                ps3fb_videomemory.address, GPU_IOIF, xdr_lpar,
-                ps3fb_videomemory.address, ps3fb.xdr_ea, GPU_IOIF, xdr_lpar,
+                ps3fb_videomemory.size);
-                virt_to_abs(ps3fb.xdr_ea), ps3fb_videomemory.size);
        status = lv1_gpu_context_attribute(ps3fb.context_handle,
                                           L1GPU_CONTEXT_ATTRIBUTE_FB_SETUP,
-                                           xdr_lpar + ps3fb.xdr_size,
+                                           xdr_lpar, GPU_CMD_BUF_SIZE,
-                                           GPU_CMD_BUF_SIZE,
+                                           GPU_IOIF, 0);
-                                           GPU_IOIF + ps3fb.xdr_size, 0);
        if (status) {
                dev_err(dev,
                        "%s: lv1_gpu_context_attribute FB_SETUP failed: %d\n",
@@ -1051,15 +1090,21 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        struct fb_info *info;
        struct ps3fb_par *par;
        int retval = -ENOMEM;
-        u32 xres, yres;
        u64 ddr_lpar = 0;
        u64 lpar_dma_control = 0;
        u64 lpar_driver_info = 0;
        u64 lpar_reports = 0;
        u64 lpar_reports_size = 0;
        u64 xdr_lpar;
-        int status, res_index;
+        void *fb_start;
+        int status;
        struct task_struct *task;
+        unsigned long max_ps3fb_size;
+        if (ps3fb_videomemory.size < GPU_CMD_BUF_SIZE) {
+                dev_err(&dev->core, "%s: Not enough video memory\n", __func__);
+                return -ENOMEM;
+        }
        status = ps3_open_hv_device(dev);
        if (status) {
@@ -1070,14 +1115,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        if (!ps3fb_mode)
                ps3fb_mode = ps3av_get_mode();
-        dev_dbg(&dev->core, "ps3av_mode:%d\n", ps3fb_mode);
+        dev_dbg(&dev->core, "ps3fb_mode: %d\n", ps3fb_mode);
-        if (ps3fb_mode > 0 &&
-            !ps3av_video_mode2res(ps3fb_mode, &xres, &yres)) {
-                res_index = ps3fb_get_res_table(xres, yres, ps3fb_mode);
-                dev_dbg(&dev->core, "res_index:%d\n", res_index);
-        } else
-                res_index = GPU_RES_INDEX;
        atomic_set(&ps3fb.f_count, -1); /* fbcon opens ps3fb */
        atomic_set(&ps3fb.ext_flip, 0); /* for flip with vsync */
@@ -1085,8 +1123,15 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        ps3fb_set_sync(&dev->core);
+        max_ps3fb_size = _ALIGN_UP(GPU_IOIF, 256*1024*1024) - GPU_IOIF;
+        if (ps3fb_videomemory.size > max_ps3fb_size) {
+                dev_info(&dev->core, "Limiting ps3fb mem size to %lu bytes\n",
+                         max_ps3fb_size);
+                ps3fb_videomemory.size = max_ps3fb_size;
+        }
        /* get gpu context handle */
-        status = lv1_gpu_memory_allocate(DDR_SIZE, 0, 0, 0, 0,
+        status = lv1_gpu_memory_allocate(ps3fb_videomemory.size, 0, 0, 0, 0,
                                         &ps3fb.memory_handle, &ddr_lpar);
        if (status) {
                dev_err(&dev->core, "%s: lv1_gpu_memory_allocate failed: %d\n",
@@ -1107,7 +1152,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        }
        /* vsync interrupt */
-        ps3fb.dinfo = ioremap(lpar_driver_info, 128 * 1024);
+        ps3fb.dinfo = (void __force *)ioremap(lpar_driver_info, 128 * 1024);
        if (!ps3fb.dinfo) {
                dev_err(&dev->core, "%s: ioremap failed\n", __func__);
                goto err_gpu_context_free;
@@ -1117,16 +1162,10 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        if (retval)
                goto err_iounmap_dinfo;
-        /* XDR frame buffer */
-        ps3fb.xdr_ea = ps3fb_videomemory.address;
-        xdr_lpar = ps3_mm_phys_to_lpar(__pa(ps3fb.xdr_ea));
        /* Clear memory to prevent kernel info leakage into userspace */
-        memset(ps3fb.xdr_ea, 0, ps3fb_videomemory.size);
+        memset(ps3fb_videomemory.address, 0, ps3fb_videomemory.size);
-        /* The GPU command buffer is at the end of video memory */
-        ps3fb.xdr_size = ps3fb_videomemory.size - GPU_CMD_BUF_SIZE;
+        xdr_lpar = ps3_mm_phys_to_lpar(__pa(ps3fb_videomemory.address));
        retval = ps3fb_xdr_settings(xdr_lpar, &dev->core);
        if (retval)
                goto err_free_irq;
@@ -1138,15 +1177,22 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        par = info->par;
        par->mode_id = ~ps3fb_mode;     /* != ps3fb_mode, to trigger change */
        par->new_mode_id = ps3fb_mode;
-        par->res_index = res_index;
        par->num_frames = 1;
-        info->screen_base = (char __iomem *)ps3fb.xdr_ea;
        info->fbops = &ps3fb_ops;
        info->fix = ps3fb_fix;
-        info->fix.smem_start = virt_to_abs(ps3fb.xdr_ea);
-        info->fix.smem_len = ps3fb.xdr_size;
+        /*
+         * The GPU command buffer is at the start of video memory
+         * As we don't use the full command buffer, we can put the actual
+         * frame buffer at offset GPU_FB_START and save some precious XDR
+         * memory
+         */
+        fb_start = ps3fb_videomemory.address + GPU_FB_START;
+        info->screen_base = (char __force __iomem *)fb_start;
+        info->fix.smem_start = virt_to_abs(fb_start);
+        info->fix.smem_len = ps3fb_videomemory.size - GPU_FB_START;
        info->pseudo_palette = par->pseudo_palette;
        info->flags = FBINFO_DEFAULT | FBINFO_READS_FAST |
                      FBINFO_HWACCEL_XPAN | FBINFO_HWACCEL_YPAN;
@@ -1157,7 +1203,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        if (!fb_find_mode(&info->var, info, mode_option, ps3fb_modedb,
                          ARRAY_SIZE(ps3fb_modedb),
-                          ps3fb_default_mode(par->new_mode_id), 32)) {
+                          ps3fb_vmode(par->new_mode_id), 32)) {
                retval = -EINVAL;
                goto err_fb_dealloc;
        }
@@ -1171,9 +1217,9 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        dev->core.driver_data = info;
-        dev_info(info->device, "%s %s, using %lu KiB of video memory\n",
+        dev_info(info->device, "%s %s, using %u KiB of video memory\n",
                 dev_driver_string(info->dev), info->dev->bus_id,
-                 ps3fb.xdr_size >> 10);
+                 info->fix.smem_len >> 10);
        task = kthread_run(ps3fbd, info, DEVICE_NAME);
        if (IS_ERR(task)) {
@@ -1193,10 +1239,10 @@ err_fb_dealloc:
 err_framebuffer_release:
        framebuffer_release(info);
 err_free_irq:
-        free_irq(ps3fb.irq_no, dev);
+        free_irq(ps3fb.irq_no, &dev->core);
        ps3_irq_plug_destroy(ps3fb.irq_no);
 err_iounmap_dinfo:
-        iounmap((u8 __iomem *)ps3fb.dinfo);
+        iounmap((u8 __force __iomem *)ps3fb.dinfo);
 err_gpu_context_free:
        lv1_gpu_context_free(ps3fb.context_handle);
 err_gpu_memory_free:
@@ -1215,12 +1261,6 @@ static int ps3fb_shutdown(struct ps3_system_bus_device *dev)
        ps3fb_flip_ctl(0, &ps3fb);      /* flip off */
        ps3fb.dinfo->irq.mask = 0;
-        if (info) {
-                unregister_framebuffer(info);
-                fb_dealloc_cmap(&info->cmap);
-                framebuffer_release(info);
-        }
        ps3av_register_flip_ctl(NULL, NULL);
        if (ps3fb.task) {
                struct task_struct *task = ps3fb.task;
@@ -1228,10 +1268,16 @@ static int ps3fb_shutdown(struct ps3_system_bus_device *dev)
                kthread_stop(task);
        }
        if (ps3fb.irq_no) {
-                free_irq(ps3fb.irq_no, dev);
+                free_irq(ps3fb.irq_no, &dev->core);
                ps3_irq_plug_destroy(ps3fb.irq_no);
        }
-        iounmap((u8 __iomem *)ps3fb.dinfo);
+        if (info) {
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info->cmap);
+                framebuffer_release(info);
+                info = dev->core.driver_data = NULL;
+        }
+        iounmap((u8 __force __iomem *)ps3fb.dinfo);
        status = lv1_gpu_context_free(ps3fb.context_handle);
        if (status)
diff --git a/drivers/video/s1d13xxxfb.c b/drivers/video/s1d13xxxfb.c
index a5333c190789..b829dc7c5edf 100644
--- a/drivers/video/s1d13xxxfb.c
+++ b/drivers/video/s1d13xxxfb.c
@@ -540,7 +540,7 @@ s1d13xxxfb_probe(struct platform_device *pdev)
        int ret = 0;
        u8 revision;
-        dbg("probe called: device is %p\n", dev);
+        dbg("probe called: device is %p\n", pdev);
        printk(KERN_INFO "Epson S1D13XXX FB Driver\n");
@@ -753,8 +753,11 @@ static struct platform_driver s1d13xxxfb_driver = {
 static int __init
 s1d13xxxfb_init(void)
 {
+#ifndef MODULE
        if (fb_get_options("s1d13xxxfb", NULL))
                return -ENODEV;
+#endif
        return platform_driver_register(&s1d13xxxfb_driver);
 }
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index 5857ccf5f6b1..71fa6edb5c47 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -110,6 +110,11 @@ static int debug	= 0;
 /* useful functions */
+static int is_s3c2412(struct s3c2410fb_info *fbi)
+{
+        return (fbi->drv_type == DRV_S3C2412);
+}
 /* s3c2410fb_set_lcdaddr
 *
 * initialise lcd controller address pointers
@@ -488,7 +493,7 @@ static int s3c2410fb_set_par(struct fb_info *info)
                break;
        }
-        info->fix.line_length = (var->width * var->bits_per_pixel) / 8;
+        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8;
        /* activate this new configuration */
@@ -501,7 +506,7 @@ static void schedule_palette_update(struct s3c2410fb_info *fbi,
 {
        unsigned long flags;
        unsigned long irqen;
-        void __iomem *regs = fbi->io;
+        void __iomem *irq_base = fbi->irq_base;
        local_irq_save(flags);
@@ -511,9 +516,9 @@ static void schedule_palette_update(struct s3c2410fb_info *fbi,
                fbi->palette_ready = 1;
                /* enable IRQ */
-                irqen = readl(regs + S3C2410_LCDINTMSK);
+                irqen = readl(irq_base + S3C24XX_LCDINTMSK);
                irqen &= ~S3C2410_LCDINT_FRSYNC;
-                writel(irqen, regs + S3C2410_LCDINTMSK);
+                writel(irqen, irq_base + S3C24XX_LCDINTMSK);
        }
        local_irq_restore(flags);
@@ -594,15 +599,17 @@ static int s3c2410fb_setcolreg(unsigned regno,
 static int s3c2410fb_blank(int blank_mode, struct fb_info *info)
 {
        struct s3c2410fb_info *fbi = info->par;
-        void __iomem *regs = fbi->io;
+        void __iomem *tpal_reg = fbi->io;
        dprintk("blank(mode=%d, info=%p)\n", blank_mode, info);
+        tpal_reg += is_s3c2412(fbi) ? S3C2412_TPAL : S3C2410_TPAL;
        if (blank_mode == FB_BLANK_UNBLANK)
-                writel(0x0, regs + S3C2410_TPAL);
+                writel(0x0, tpal_reg);
        else {
                dprintk("setting TPAL to output 0x000000\n");
-                writel(S3C2410_TPAL_EN, regs + S3C2410_TPAL);
+                writel(S3C2410_TPAL_EN, tpal_reg);
        }
        return 0;
@@ -663,7 +670,7 @@ static int __init s3c2410fb_map_video_memory(struct fb_info *info)
        dma_addr_t map_dma;
        unsigned map_size = PAGE_ALIGN(info->fix.smem_len);
-        dprintk("map_video_memory(fbi=%p)\n", fbi);
+        dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size);
        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
                                                   &map_dma, GFP_KERNEL);
@@ -672,7 +679,7 @@ static int __init s3c2410fb_map_video_memory(struct fb_info *info)
                /* prevent initial garbage on screen */
                dprintk("map_video_memory: clear %p:%08x\n",
                        info->screen_base, map_size);
-                memset(info->screen_base, 0xf0, map_size);
+                memset(info->screen_base, 0x00, map_size);
                info->fix.smem_start = map_dma;
@@ -709,6 +716,16 @@ static int s3c2410fb_init_registers(struct fb_info *info)
        struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;
        unsigned long flags;
        void __iomem *regs = fbi->io;
+        void __iomem *tpal;
+        void __iomem *lpcsel;
+        if (is_s3c2412(fbi)) {
+                tpal = regs + S3C2412_TPAL;
+                lpcsel = regs + S3C2412_TCONSEL;
+        } else {
+                tpal = regs + S3C2410_TPAL;
+                lpcsel = regs + S3C2410_LPCSEL;
+        }
        /* Initialise LCD with values from haret */
@@ -724,12 +741,12 @@ static int s3c2410fb_init_registers(struct fb_info *info)
        local_irq_restore(flags);
        dprintk("LPCSEL    = 0x%08lx\n", mach_info->lpcsel);
-        writel(mach_info->lpcsel, regs + S3C2410_LPCSEL);
+        writel(mach_info->lpcsel, lpcsel);
-        dprintk("replacing TPAL %08x\n", readl(regs + S3C2410_TPAL));
+        dprintk("replacing TPAL %08x\n", readl(tpal));
        /* ensure temporary palette disabled */
-        writel(0x00, regs + S3C2410_TPAL);
+        writel(0x00, tpal);
        return 0;
 }
@@ -763,15 +780,15 @@ static void s3c2410fb_write_palette(struct s3c2410fb_info *fbi)
 static irqreturn_t s3c2410fb_irq(int irq, void *dev_id)
 {
        struct s3c2410fb_info *fbi = dev_id;
-        void __iomem *regs = fbi->io;
+        void __iomem *irq_base = fbi->irq_base;
-        unsigned long lcdirq = readl(regs + S3C2410_LCDINTPND);
+        unsigned long lcdirq = readl(irq_base + S3C24XX_LCDINTPND);
        if (lcdirq & S3C2410_LCDINT_FRSYNC) {
                if (fbi->palette_ready)
                        s3c2410fb_write_palette(fbi);
-                writel(S3C2410_LCDINT_FRSYNC, regs + S3C2410_LCDINTPND);
+                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDINTPND);
-                writel(S3C2410_LCDINT_FRSYNC, regs + S3C2410_LCDSRCPND);
+                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDSRCPND);
        }
        return IRQ_HANDLED;
@@ -779,7 +796,8 @@ static irqreturn_t s3c2410fb_irq(int irq, void *dev_id)
 static char driver_name[] = "s3c2410fb";
-static int __init s3c2410fb_probe(struct platform_device *pdev)
+static int __init s3c24xxfb_probe(struct platform_device *pdev,
+                                  enum s3c_drv_type drv_type)
 {
        struct s3c2410fb_info *info;
        struct s3c2410fb_display *display;
@@ -799,6 +817,12 @@ static int __init s3c2410fb_probe(struct platform_device *pdev)
                return -EINVAL;
        }
+        if (mach_info->default_display >= mach_info->num_displays) {
+                dev_err(&pdev->dev, "default is %d but only %d displays\n",
+                        mach_info->default_display, mach_info->num_displays);
+                return -EINVAL;
+        }
        display = mach_info->displays + mach_info->default_display;
        irq = platform_get_irq(pdev, 0);
@@ -815,6 +839,7 @@ static int __init s3c2410fb_probe(struct platform_device *pdev)
        info = fbinfo->par;
        info->dev = &pdev->dev;
+        info->drv_type = drv_type;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (res == NULL) {
@@ -838,6 +863,8 @@ static int __init s3c2410fb_probe(struct platform_device *pdev)
                goto release_mem;
        }
+        info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);
        dprintk("devinit\n");
        strcpy(fbinfo->fix.id, driver_name);
@@ -946,6 +973,16 @@ dealloc_fb:
        return ret;
 }
+static int __init s3c2410fb_probe(struct platform_device *pdev)
+{
+        return s3c24xxfb_probe(pdev, DRV_S3C2410);
+}
+static int __init s3c2412fb_probe(struct platform_device *pdev)
+{
+        return s3c24xxfb_probe(pdev, DRV_S3C2412);
+}
 /* s3c2410fb_stop_lcd
 *
 * shutdown the lcd controller
@@ -1026,7 +1063,7 @@ static int s3c2410fb_resume(struct platform_device *dev)
        clk_enable(info->clk);
        msleep(1);
-        s3c2410fb_init_registers(info);
+        s3c2410fb_init_registers(fbinfo);
        return 0;
 }
@@ -1047,14 +1084,31 @@ static struct platform_driver s3c2410fb_driver = {
        },
 };
+static struct platform_driver s3c2412fb_driver = {
+        .probe          = s3c2412fb_probe,
+        .remove         = s3c2410fb_remove,
+        .suspend        = s3c2410fb_suspend,
+        .resume         = s3c2410fb_resume,
+        .driver         = {
+                .name   = "s3c2412-lcd",
+                .owner  = THIS_MODULE,
+        },
+};
 int __init s3c2410fb_init(void)
 {
-        return platform_driver_register(&s3c2410fb_driver);
+        int ret = platform_driver_register(&s3c2410fb_driver);
+        if (ret == 0)
+                ret = platform_driver_register(&s3c2412fb_driver);;
+        return ret;
 }
 static void __exit s3c2410fb_cleanup(void)
 {
        platform_driver_unregister(&s3c2410fb_driver);
+        platform_driver_unregister(&s3c2412fb_driver);
 }
 module_init(s3c2410fb_init);
diff --git a/drivers/video/s3c2410fb.h b/drivers/video/s3c2410fb.h
index 6ce5dc26c5f7..dbb73b95e2ef 100644
--- a/drivers/video/s3c2410fb.h
+++ b/drivers/video/s3c2410fb.h
@@ -25,13 +25,20 @@
 #ifndef __S3C2410FB_H
 #define __S3C2410FB_H
+enum s3c_drv_type {
+        DRV_S3C2410,
+        DRV_S3C2412,
+};
 struct s3c2410fb_info {
        struct device           *dev;
        struct clk              *clk;
        struct resource         *mem;
        void __iomem            *io;
+        void __iomem            *irq_base;
+        enum s3c_drv_type       drv_type;
        struct s3c2410fb_hw     regs;
        unsigned int            palette_ready;
diff --git a/drivers/video/sis/sis.h b/drivers/video/sis/sis.h
index d53bf6945f0c..9b05da6268f7 100644
--- a/drivers/video/sis/sis.h
+++ b/drivers/video/sis/sis.h
@@ -39,12 +39,7 @@
 #include <linux/spinlock.h>
 #ifdef CONFIG_COMPAT
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,10)
-#include <linux/ioctl32.h>
-#define SIS_OLD_CONFIG_COMPAT
-#else
 #define SIS_NEW_CONFIG_COMPAT
-#endif
 #endif  /* CONFIG_COMPAT */
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
@@ -607,9 +602,6 @@ struct sis_video_info {
        int             haveXGIROM;
        int             registered;
        int             warncount;
-#ifdef SIS_OLD_CONFIG_COMPAT
-        int             ioctl32registered;
-#endif
        int             sisvga_engine;
        int             hwcursor_size;
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index bc7d23683735..73803624c131 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -427,7 +427,7 @@ sisfb_interpret_edid(struct sisfb_monitor *monitor, u8 *buffer)
        monitor->feature = buffer[0x18];
-        if(!buffer[0x14] & 0x80) {
+        if(!(buffer[0x14] & 0x80)) {
                if(!(buffer[0x14] & 0x08)) {
                        printk(KERN_INFO
                                "sisfb: WARNING: Monitor does not support separate syncs\n");
@@ -1248,7 +1248,6 @@ sisfb_do_set_var(struct fb_var_screeninfo *var, int isactive, struct fb_info *in
        if(found_mode) {
                ivideo->sisfb_mode_idx = sisfb_validate_mode(ivideo,
                                ivideo->sisfb_mode_idx, ivideo->currentvbflags);
-                ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
        } else {
                ivideo->sisfb_mode_idx = -1;
        }
@@ -1260,6 +1259,8 @@ sisfb_do_set_var(struct fb_var_screeninfo *var, int isactive, struct fb_info *in
                return -EINVAL;
        }
+        ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
        if(sisfb_search_refresh_rate(ivideo, ivideo->refresh_rate, ivideo->sisfb_mode_idx) == 0) {
                ivideo->rate_idx = sisbios_mode[ivideo->sisfb_mode_idx].rate_idx;
                ivideo->refresh_rate = 60;
@@ -4620,9 +4621,9 @@ sisfb_find_host_bridge(struct sis_video_info *ivideo, struct pci_dev *mypdev,
        while((pdev = pci_get_class(PCI_CLASS_BRIDGE_HOST, pdev))) {
                temp = pdev->vendor;
-                pci_dev_put(pdev);
                if(temp == pcivendor) {
                        ret = 1;
+                        pci_dev_put(pdev);
                        break;
                }
        }
@@ -5804,9 +5805,6 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        ivideo->pcifunc = PCI_FUNC(pdev->devfn);
        ivideo->subsysvendor = pdev->subsystem_vendor;
        ivideo->subsysdevice = pdev->subsystem_device;
-#ifdef SIS_OLD_CONFIG_COMPAT
-        ivideo->ioctl32registered = 0;
-#endif
 #ifndef MODULE
        if(sisfb_mode_idx == -1) {
@@ -6419,30 +6417,6 @@ error_3:	vfree(ivideo->bios_abase);
                ivideo->next = card_list;
                card_list = ivideo;
-#ifdef SIS_OLD_CONFIG_COMPAT
-                {
-                int ret;
-                /* Our ioctls are all "32/64bit compatible" */
-                ret =  register_ioctl32_conversion(FBIO_ALLOC,             NULL);
-                ret |= register_ioctl32_conversion(FBIO_FREE,              NULL);
-                ret |= register_ioctl32_conversion(FBIOGET_VBLANK,         NULL);
-                ret |= register_ioctl32_conversion(SISFB_GET_INFO_SIZE,    NULL);
-                ret |= register_ioctl32_conversion(SISFB_GET_INFO,         NULL);
-                ret |= register_ioctl32_conversion(SISFB_GET_TVPOSOFFSET,  NULL);
-                ret |= register_ioctl32_conversion(SISFB_SET_TVPOSOFFSET,  NULL);
-                ret |= register_ioctl32_conversion(SISFB_SET_LOCK,         NULL);
-                ret |= register_ioctl32_conversion(SISFB_GET_VBRSTATUS,    NULL);
-                ret |= register_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE, NULL);
-                ret |= register_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE, NULL);
-                ret |= register_ioctl32_conversion(SISFB_COMMAND,          NULL);
-                if(ret)
-                        printk(KERN_ERR
-                                "sisfb: Error registering ioctl32 translations\n");
-                else
-                        ivideo->ioctl32registered = 1;
-                }
-#endif
                printk(KERN_INFO "sisfb: 2D acceleration is %s, y-panning %s\n",
                        ivideo->sisfb_accel ? "enabled" : "disabled",
                        ivideo->sisfb_ypan  ?
@@ -6472,27 +6446,6 @@ static void __devexit sisfb_remove(struct pci_dev *pdev)
        int                     registered = ivideo->registered;
        int                     modechanged = ivideo->modechanged;
-#ifdef SIS_OLD_CONFIG_COMPAT
-        if(ivideo->ioctl32registered) {
-                int ret;
-                ret =  unregister_ioctl32_conversion(FBIO_ALLOC);
-                ret |= unregister_ioctl32_conversion(FBIO_FREE);
-                ret |= unregister_ioctl32_conversion(FBIOGET_VBLANK);
-                ret |= unregister_ioctl32_conversion(SISFB_GET_INFO_SIZE);
-                ret |= unregister_ioctl32_conversion(SISFB_GET_INFO);
-                ret |= unregister_ioctl32_conversion(SISFB_GET_TVPOSOFFSET);
-                ret |= unregister_ioctl32_conversion(SISFB_SET_TVPOSOFFSET);
-                ret |= unregister_ioctl32_conversion(SISFB_SET_LOCK);
-                ret |= unregister_ioctl32_conversion(SISFB_GET_VBRSTATUS);
-                ret |= unregister_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE);
-                ret |= unregister_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE);
-                ret |= unregister_ioctl32_conversion(SISFB_COMMAND);
-                if(ret)
-                        printk(KERN_ERR
-                             "sisfb: Error unregistering ioctl32 translations\n");
-        }
-#endif
        /* Unmap */
        iounmap(ivideo->mmio_vbase);
        iounmap(ivideo->video_vbase);
diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c
index 1be95a68d696..e83dfba7e636 100644
--- a/drivers/video/sm501fb.c
+++ b/drivers/video/sm501fb.c
@@ -48,7 +48,7 @@ enum sm501_controller {
        HEAD_PANEL      = 1,
 };
-/* SM501 memory adress */
+/* SM501 memory address */
 struct sm501_mem {
        unsigned long    size;
        unsigned long    sm_addr;
@@ -641,6 +641,7 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
 {
        unsigned long control;
        void __iomem *ctrl_reg = fbi->regs + SM501_DC_PANEL_CONTROL;
+        struct sm501_platdata_fbsub *pd = fbi->pdata->fb_pnl;
        control = readl(ctrl_reg);
@@ -657,26 +658,34 @@ static void sm501fb_panel_power(struct sm501fb_info *fbi, int to)
                sm501fb_sync_regs(fbi);
                mdelay(10);
-                control |= SM501_DC_PANEL_CONTROL_BIAS; /* VBIASEN */
+                if (pd->flags & SM501FB_FLAG_PANEL_USE_VBIASEN) {
-                writel(control, ctrl_reg);
+                        control |= SM501_DC_PANEL_CONTROL_BIAS; /* VBIASEN */
-                sm501fb_sync_regs(fbi);
+                        writel(control, ctrl_reg);
-                mdelay(10);
+                        sm501fb_sync_regs(fbi);
+                        mdelay(10);
-                control |= SM501_DC_PANEL_CONTROL_FPEN;
+                }
-                writel(control, ctrl_reg);
+                if (pd->flags & SM501FB_FLAG_PANEL_USE_FPEN) {
+                        control |= SM501_DC_PANEL_CONTROL_FPEN;
+                        writel(control, ctrl_reg);
+                        sm501fb_sync_regs(fbi);
+                        mdelay(10);
+                }
        } else if (!to && (control & SM501_DC_PANEL_CONTROL_VDD) != 0) {
                /* disable panel power */
+                if (pd->flags & SM501FB_FLAG_PANEL_USE_FPEN) {
+                        control &= ~SM501_DC_PANEL_CONTROL_FPEN;
+                        writel(control, ctrl_reg);
+                        sm501fb_sync_regs(fbi);
+                        mdelay(10);
+                }
-                control &= ~SM501_DC_PANEL_CONTROL_FPEN;
+                if (pd->flags & SM501FB_FLAG_PANEL_USE_VBIASEN) {
-                writel(control, ctrl_reg);
+                        control &= ~SM501_DC_PANEL_CONTROL_BIAS;
-                sm501fb_sync_regs(fbi);
+                        writel(control, ctrl_reg);
-                mdelay(10);
+                        sm501fb_sync_regs(fbi);
+                        mdelay(10);
-                control &= ~SM501_DC_PANEL_CONTROL_BIAS;
+                }
-                writel(control, ctrl_reg);
-                sm501fb_sync_regs(fbi);
-                mdelay(10);
                control &= ~SM501_DC_PANEL_CONTROL_DATA;
                writel(control, ctrl_reg);
@@ -1267,6 +1276,7 @@ static int sm501fb_start(struct sm501fb_info *info,
 {
        struct resource *res;
        struct device *dev;
+        int k;
        int ret;
        info->dev = dev = &pdev->dev;
@@ -1328,6 +1338,13 @@ static int sm501fb_start(struct sm501fb_info *info,
        info->fbmem_len = (res->end - res->start)+1;
+        /* clear framebuffer memory - avoids garbage data on unused fb */
+        memset(info->fbmem, 0, info->fbmem_len);
+        /* clear palette ram - undefined at power on */
+        for (k = 0; k < (256 * 3); k++)
+                writel(0, info->regs + SM501_DC_PANEL_PALETTE + (k * 4));
        /* enable display controller */
        sm501_unit_power(dev->parent, SM501_GATE_DISPLAY, 1);
@@ -1681,6 +1698,15 @@ static int sm501fb_suspend_fb(struct sm501fb_info *info,
        if (par->screen.size == 0)
                return 0;
+        /* blank the relevant interface to ensure unit power minimised */
+        (par->ops.fb_blank)(FB_BLANK_POWERDOWN, fbi);
+        /* tell console/fb driver we are suspending */
+        acquire_console_sem();
+        fb_set_suspend(fbi, 1);
+        release_console_sem();
        /* backup copies in case chip is powered down over suspend */
        par->store_fb = vmalloc(par->screen.size);
@@ -1700,12 +1726,6 @@ static int sm501fb_suspend_fb(struct sm501fb_info *info,
        memcpy_fromio(par->store_fb, par->screen.k_addr, par->screen.size);
        memcpy_fromio(par->store_cursor, par->cursor.k_addr, par->cursor.size);
-        /* blank the relevant interface to ensure unit power minimised */
-        (par->ops.fb_blank)(FB_BLANK_POWERDOWN, fbi);
-        acquire_console_sem();
-        fb_set_suspend(fbi, 1);
-        release_console_sem();
        return 0;
diff --git a/drivers/video/tdfxfb.c b/drivers/video/tdfxfb.c
index 057bdd593800..71e179ea5f95 100644
--- a/drivers/video/tdfxfb.c
+++ b/drivers/video/tdfxfb.c
@@ -1342,7 +1342,7 @@ out_err:
 }
 #ifndef MODULE
-static void tdfxfb_setup(char *options)
+static void __init tdfxfb_setup(char *options)
 {
        char *this_opt;
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c
index b983d262ab78..be27b9c1ed72 100644
--- a/drivers/video/uvesafb.c
+++ b/drivers/video/uvesafb.c
@@ -43,7 +43,7 @@ static struct fb_fix_screeninfo uvesafb_fix __devinitdata = {
 };
 static int mtrr         __devinitdata = 3; /* enable mtrr by default */
-static int blank        __devinitdata = 1; /* enable blanking by default */
+static int blank        = 1;               /* enable blanking by default */
 static int ypan         __devinitdata = 1; /* 0: scroll, 1: ypan, 2: ywrap */
 static int pmi_setpal   __devinitdata = 1; /* use PMI for palette changes */
 static int nocrtc       __devinitdata; /* ignore CRTC settings */
@@ -926,8 +926,10 @@ static int uvesafb_setpalette(struct uvesafb_pal_entry *entries, int count,
                int start, struct fb_info *info)
 {
        struct uvesafb_ktask *task;
+#ifdef CONFIG_X86
        struct uvesafb_par *par = info->par;
        int i = par->mode_idx;
+#endif
        int err = 0;
        /*
@@ -1103,11 +1105,11 @@ static int uvesafb_pan_display(struct fb_var_screeninfo *var,
 static int uvesafb_blank(int blank, struct fb_info *info)
 {
-        struct uvesafb_par *par = info->par;
        struct uvesafb_ktask *task;
        int err = 1;
 #ifdef CONFIG_X86
+        struct uvesafb_par *par = info->par;
        if (par->vbe_ib.capabilities & VBE_CAP_VGACOMPAT) {
                int loop = 10000;
                u8 seq = 0, crtc17 = 0;
@@ -1547,7 +1549,7 @@ static void __devinit uvesafb_init_info(struct fb_info *info,
                info->fbops->fb_pan_display = NULL;
 }
-static void uvesafb_init_mtrr(struct fb_info *info)
+static void __devinit uvesafb_init_mtrr(struct fb_info *info)
 {
 #ifdef CONFIG_MTRR
        if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) {
@@ -2001,12 +2003,12 @@ static void __devexit uvesafb_exit(void)
 module_exit(uvesafb_exit);
-static inline int param_get_scroll(char *buffer, struct kernel_param *kp)
+static int param_get_scroll(char *buffer, struct kernel_param *kp)
 {
        return 0;
 }
-static inline int param_set_scroll(const char *val, struct kernel_param *kp)
+static int param_set_scroll(const char *val, struct kernel_param *kp)
 {
        ypan = 0;
@@ -2020,11 +2022,11 @@ static inline int param_set_scroll(const char *val, struct kernel_param *kp)
        return 0;
 }
-#define param_check_scroll(name, p) __param_check(name, p, void);
+#define param_check_scroll(name, p) __param_check(name, p, void)
 module_param_named(scroll, ypan, scroll, 0);
 MODULE_PARM_DESC(scroll,
-        "Scrolling mode, set to 'redraw', ''ypan' or 'ywrap'");
+        "Scrolling mode, set to 'redraw', 'ypan', or 'ywrap'");
 module_param_named(vgapal, pmi_setpal, invbool, 0);
 MODULE_PARM_DESC(vgapal, "Set palette using VGA registers");
 module_param_named(pmipal, pmi_setpal, bool, 0);
diff --git a/drivers/video/vermilion/vermilion.c b/drivers/video/vermilion/vermilion.c
index c31f549ebea0..2aa71eb67c2b 100644
--- a/drivers/video/vermilion/vermilion.c
+++ b/drivers/video/vermilion/vermilion.c
@@ -88,9 +88,7 @@ static int vmlfb_alloc_vram_area(struct vram_area *va, unsigned max_order,
 {
        gfp_t flags;
        unsigned long i;
-        pgprot_t wc_pageprot;
-        wc_pageprot = PAGE_KERNEL_NOCACHE;
        max_order++;
        do {
                /*
@@ -126,14 +124,8 @@ static int vmlfb_alloc_vram_area(struct vram_area *va, unsigned max_order,
        /*
         * Change caching policy of the linear kernel map to avoid
         * mapping type conflicts with user-space mappings.
-         * The first global_flush_tlb() is really only there to do a global
-         * wbinvd().
         */
+        set_pages_uc(virt_to_page(va->logical), va->size >> PAGE_SHIFT);
-        global_flush_tlb();
-        change_page_attr(virt_to_page(va->logical), va->size >> PAGE_SHIFT,
-                         wc_pageprot);
-        global_flush_tlb();
        printk(KERN_DEBUG MODULE_NAME
               ": Allocated %ld bytes vram area at 0x%08lx\n",
@@ -157,9 +149,8 @@ static void vmlfb_free_vram_area(struct vram_area *va)
                 * Reset the linear kernel map caching policy.
                 */
-                change_page_attr(virt_to_page(va->logical),
+                set_pages_wb(virt_to_page(va->logical),
-                                 va->size >> PAGE_SHIFT, PAGE_KERNEL);
+                                 va->size >> PAGE_SHIFT);
-                global_flush_tlb();
                /*
                 * Decrease the usage count on the pages we've used
@@ -660,7 +651,7 @@ static int vmlfb_check_var_locked(struct fb_var_screeninfo *var,
                return -EINVAL;
        }
-        pitch = __ALIGN_MASK((var->xres * var->bits_per_pixel) >> 3, 0x3F);
+        pitch = ALIGN((var->xres * var->bits_per_pixel) >> 3, 0x40);
        mem = pitch * var->yres_virtual;
        if (mem > vinfo->vram_contig_size) {
                return -ENOMEM;
@@ -794,8 +785,7 @@ static int vmlfb_set_par_locked(struct vml_info *vinfo)
        int clock;
        vinfo->bytes_per_pixel = var->bits_per_pixel >> 3;
-        vinfo->stride =
+        vinfo->stride = ALIGN(var->xres_virtual * vinfo->bytes_per_pixel, 0x40);
-            __ALIGN_MASK(var->xres_virtual * vinfo->bytes_per_pixel, 0x3F);
        info->fix.line_length = vinfo->stride;
        if (!subsys)
diff --git a/drivers/video/xilinxfb.c b/drivers/video/xilinxfb.c
index e38d3b7c3ad7..7b3a8423f485 100644
--- a/drivers/video/xilinxfb.c
+++ b/drivers/video/xilinxfb.c
@@ -459,8 +459,8 @@ static int __devexit xilinxfb_of_remove(struct of_device *op)
 }
 /* Match table for of_platform binding */
-static struct of_device_id __devinit xilinxfb_of_match[] = {
+static struct of_device_id xilinxfb_of_match[] __devinitdata = {
-        { .compatible = "xilinx,ml300-fb", },
+        { .compatible = "xlnx,plb-tft-cntlr-ref-1.00.a", },
        {},
 };
 MODULE_DEVICE_TABLE(of, xilinxfb_of_match);