29 files changed, 294 insertions, 157 deletions

diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index c22e8d39a2cb..a1d58e9d3073 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -336,8 +336,8 @@ static void arcfb_lcd_update_horiz(struct arcfb_par *par, unsigned int left,
 }
 
 /*
- * here we start the process of spliting out the fb update into
- * individual blocks of pixels. we end up spliting into 64x64 blocks
+ * here we start the process of splitting out the fb update into
+ * individual blocks of pixels. we end up splitting into 64x64 blocks
  * and finally down to 64x8 pages.
  */
 static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index d99505b16374..15055395cd95 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -939,7 +939,7 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
                  * up a splash image.
                  */
         } else {
-                /* alocate memory buffer */
+                /* allocate memory buffer */
                 ret = atmel_lcdfb_alloc_video_memory(sinfo);
                 if (ret < 0) {
                         dev_err(dev, "cannot allocate framebuffer: %d\n", ret);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 622f12b62a47..3f2e8c13f1ca 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -863,7 +863,7 @@ static int aty_var_to_crtc(const struct fb_info *info,
 
         if ((xres > 1600) || (yres > 1200)) {
                 FAIL("MACH64 chips are designed for max 1600x1200\n"
-                     "select anoter resolution.");
+                     "select another resolution.");
         }
         h_sync_strt = h_disp + var->right_margin;
         h_sync_end = h_sync_strt + var->hsync_len;
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index ce1506b75adf..9e279ee38da8 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -2018,7 +2018,7 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
           if ((rinfo->family == CHIP_FAMILY_RS100) ||
               (rinfo->family == CHIP_FAMILY_RS200)) {
              /* This is to workaround the asic bug for RMX, some versions
-                of BIOS dosen't have this register initialized correctly.
+                of BIOS doesn't have this register initialized correctly.
              */
              OUTREGP(CRTC_MORE_CNTL, CRTC_H_CUTOFF_ACTIVE_EN,
                      ~CRTC_H_CUTOFF_ACTIVE_EN);
diff --git a/drivers/video/aty/radeon_monitor.c b/drivers/video/aty/radeon_monitor.c
index 9261c918fde8..5c23eac0eb9a 100644
--- a/drivers/video/aty/radeon_monitor.c
+++ b/drivers/video/aty/radeon_monitor.c
@@ -730,6 +730,25 @@ static void radeon_videomode_to_var(struct fb_var_screeninfo *var,
         var->vmode = mode->vmode;
 }
 
+#ifdef CONFIG_PPC_PSERIES
+static int is_powerblade(const char *model)
+{
+        struct device_node *root;
+        const char* cp;
+        int len, l, rc = 0;
+
+        root = of_find_node_by_path("/");
+        if (root && model) {
+                l = strlen(model);
+                cp = of_get_property(root, "model", &len);
+                if (cp)
+                        rc = memcmp(model, cp, min(len, l)) == 0;
+                of_node_put(root);
+        }
+        return rc;
+}
+#endif
+
 /*
  * Build the modedb for head 1 (head 2 will come later), check panel infos
  * from either BIOS or EDID, and pick up the default mode
@@ -865,6 +884,22 @@ void __devinit radeon_check_modes(struct radeonfb_info *rinfo, const char *mode_
                         has_default_mode = 1;
         }
 
+#ifdef CONFIG_PPC_PSERIES
+        if (!has_default_mode && (
+                is_powerblade("IBM,8842") || /* JS20 */
+                is_powerblade("IBM,8844") || /* JS21 */
+                is_powerblade("IBM,7998") || /* JS12/JS21/JS22 */
+                is_powerblade("IBM,0792") || /* QS21 */
+                is_powerblade("IBM,0793")    /* QS22 */
+            )) {
+                printk("Falling back to 800x600 on JSxx hardware\n");
+                if (fb_find_mode(&info->var, info, "800x600@60",
+                                 info->monspecs.modedb,
+                                 info->monspecs.modedb_len, NULL, 8) != 0)
+                        has_default_mode = 1;
+        }
+#endif
+
         /*
          * Still no mode, let's pick up a default from the db
          */
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index f49181c73113..f75da8758adc 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -228,6 +228,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         data->port = pdata->flags;
         if (data->port < 0) {
                 dev_err(&pdev->dev, "wrong platform data is assigned");
+                kfree(data);
                 return -EINVAL;
         }
 
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 2979292650d6..cf282763a8dc 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -245,7 +245,7 @@ config BACKLIGHT_CARILLO_RANCH
 
 config BACKLIGHT_PWM
         tristate "Generic PWM based Backlight Driver"
-        depends on HAVE_PWM
+        depends on PWM
         help
           If you have a LCD backlight adjustable by PWM, say Y to enable
           this driver.
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index 0443a4f71858..df1cbb7ef6ca 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -127,7 +127,8 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
         struct atmel_pwm_bl *pwmbl;
         int retval;
 
-        pwmbl = kzalloc(sizeof(struct atmel_pwm_bl), GFP_KERNEL);
+        pwmbl = devm_kzalloc(&pdev->dev, sizeof(struct atmel_pwm_bl),
+                                GFP_KERNEL);
         if (!pwmbl)
                 return -ENOMEM;
 
@@ -154,7 +155,8 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                 goto err_free_mem;
 
         if (pwmbl->gpio_on != -1) {
-                retval = gpio_request(pwmbl->gpio_on, "gpio_atmel_pwm_bl");
+                retval = devm_gpio_request(&pdev->dev, pwmbl->gpio_on,
+                                        "gpio_atmel_pwm_bl");
                 if (retval) {
                         pwmbl->gpio_on = -1;
                         goto err_free_pwm;
@@ -164,7 +166,7 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                 retval = gpio_direction_output(pwmbl->gpio_on,
                                 0 ^ pdata->on_active_low);
                 if (retval)
-                        goto err_free_gpio;
+                        goto err_free_pwm;
         }
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -174,7 +176,7 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                                           &atmel_pwm_bl_ops, &props);
         if (IS_ERR(bldev)) {
                 retval = PTR_ERR(bldev);
-                goto err_free_gpio;
+                goto err_free_pwm;
         }
 
         pwmbl->bldev = bldev;
@@ -196,13 +198,9 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
 err_free_bl_dev:
         platform_set_drvdata(pdev, NULL);
         backlight_device_unregister(bldev);
-err_free_gpio:
-        if (pwmbl->gpio_on != -1)
-                gpio_free(pwmbl->gpio_on);
 err_free_pwm:
         pwm_channel_free(&pwmbl->pwmc);
 err_free_mem:
-        kfree(pwmbl);
         return retval;
 }
 
@@ -210,15 +208,12 @@ static int __exit atmel_pwm_bl_remove(struct platform_device *pdev)
 {
         struct atmel_pwm_bl *pwmbl = platform_get_drvdata(pdev);
 
-        if (pwmbl->gpio_on != -1) {
+        if (pwmbl->gpio_on != -1)
                 gpio_set_value(pwmbl->gpio_on, 0);
-                gpio_free(pwmbl->gpio_on);
-        }
         pwm_channel_disable(&pwmbl->pwmc);
         pwm_channel_free(&pwmbl->pwmc);
         backlight_device_unregister(pwmbl->bldev);
         platform_set_drvdata(pdev, NULL);
-        kfree(pwmbl);
 
         return 0;
 }
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index 23d732677ba1..c781768ba892 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -492,7 +492,8 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
         lcd->gpio_backlight_cont = -1;
 
         if (gpio_is_valid(pdata->gpio_backlight_on)) {
-                err = gpio_request(pdata->gpio_backlight_on, "BL_ON");
+                err = devm_gpio_request(&spi->dev, pdata->gpio_backlight_on,
+                                        "BL_ON");
                 if (err) {
                         dev_err(&spi->dev, "failed to request GPIO%d for "
                                 "backlight_on\n", pdata->gpio_backlight_on);
@@ -504,11 +505,12 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
         }
 
         if (gpio_is_valid(pdata->gpio_backlight_cont)) {
-                err = gpio_request(pdata->gpio_backlight_cont, "BL_CONT");
+                err = devm_gpio_request(&spi->dev, pdata->gpio_backlight_cont,
+                                        "BL_CONT");
                 if (err) {
                         dev_err(&spi->dev, "failed to request GPIO%d for "
                                 "backlight_cont\n", pdata->gpio_backlight_cont);
-                        goto err_free_backlight_on;
+                        return err;
                 }
 
                 lcd->gpio_backlight_cont = pdata->gpio_backlight_cont;
@@ -525,11 +527,6 @@ static int setup_gpio_backlight(struct corgi_lcd *lcd,
                 }
         }
         return 0;
-
-err_free_backlight_on:
-        if (gpio_is_valid(lcd->gpio_backlight_on))
-                gpio_free(lcd->gpio_backlight_on);
-        return err;
 }
 
 static int __devinit corgi_lcd_probe(struct spi_device *spi)
@@ -602,12 +599,6 @@ static int __devexit corgi_lcd_remove(struct spi_device *spi)
         backlight_update_status(lcd->bl_dev);
         backlight_device_unregister(lcd->bl_dev);
 
-        if (gpio_is_valid(lcd->gpio_backlight_on))
-                gpio_free(lcd->gpio_backlight_on);
-
-        if (gpio_is_valid(lcd->gpio_backlight_cont))
-                gpio_free(lcd->gpio_backlight_cont);
-
         corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
         lcd_device_unregister(lcd->lcd_dev);
 
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index 40f606a86093..2d90c0648aa0 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -175,28 +175,27 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
 
         priv->spi = spi;
 
-        ret = gpio_request_one(pdata->reset_gpio, GPIOF_OUT_INIT_HIGH,
-                                                "lcd l4f00242t03 reset");
+        ret = devm_gpio_request_one(&spi->dev, pdata->reset_gpio,
+                        GPIOF_OUT_INIT_HIGH, "lcd l4f00242t03 reset");
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 reset gpio.\n");
                 return ret;
         }
 
-        ret = gpio_request_one(pdata->data_enable_gpio, GPIOF_OUT_INIT_LOW,
-                                                "lcd l4f00242t03 data enable");
+        ret = devm_gpio_request_one(&spi->dev, pdata->data_enable_gpio,
+                        GPIOF_OUT_INIT_LOW, "lcd l4f00242t03 data enable");
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 data en gpio.\n");
-                goto err;
+                return ret;
         }
 
         priv->io_reg = regulator_get(&spi->dev, "vdd");
         if (IS_ERR(priv->io_reg)) {
-                ret = PTR_ERR(priv->io_reg);
                 dev_err(&spi->dev, "%s: Unable to get the IO regulator\n",
                        __func__);
-                goto err2;
+                return PTR_ERR(priv->io_reg);
         }
 
         priv->core_reg = regulator_get(&spi->dev, "vcore");
@@ -204,14 +203,14 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
                 ret = PTR_ERR(priv->core_reg);
                 dev_err(&spi->dev, "%s: Unable to get the core regulator\n",
                        __func__);
-                goto err3;
+                goto err1;
         }
 
         priv->ld = lcd_device_register("l4f00242t03",
                                         &spi->dev, priv, &l4f_ops);
         if (IS_ERR(priv->ld)) {
                 ret = PTR_ERR(priv->ld);
-                goto err4;
+                goto err2;
         }
 
         /* Init the LCD */
@@ -223,14 +222,10 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
 
         return 0;
 
-err4:
+err2:
         regulator_put(priv->core_reg);
-err3:
+err1:
         regulator_put(priv->io_reg);
-err2:
-        gpio_free(pdata->data_enable_gpio);
-err:
-        gpio_free(pdata->reset_gpio);
 
         return ret;
 }
@@ -238,16 +233,12 @@ err:
 static int __devexit l4f00242t03_remove(struct spi_device *spi)
 {
         struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
-        struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
 
         l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
         lcd_device_unregister(priv->ld);
 
         dev_set_drvdata(&spi->dev, NULL);
 
-        gpio_free(pdata->data_enable_gpio);
-        gpio_free(pdata->reset_gpio);
-
         regulator_put(priv->io_reg);
         regulator_put(priv->core_reg);
 
diff --git a/drivers/video/backlight/lm3533_bl.c b/drivers/video/backlight/lm3533_bl.c
index bebeb63607db..18dca0c29c68 100644
--- a/drivers/video/backlight/lm3533_bl.c
+++ b/drivers/video/backlight/lm3533_bl.c
@@ -295,7 +295,7 @@ static int __devinit lm3533_bl_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        bl = kzalloc(sizeof(*bl), GFP_KERNEL);
+        bl = devm_kzalloc(&pdev->dev, sizeof(*bl), GFP_KERNEL);
         if (!bl) {
                 dev_err(&pdev->dev,
                                 "failed to allocate memory for backlight\n");
@@ -317,8 +317,7 @@ static int __devinit lm3533_bl_probe(struct platform_device *pdev)
                                                 &lm3533_bl_ops, &props);
         if (IS_ERR(bd)) {
                 dev_err(&pdev->dev, "failed to register backlight device\n");
-                ret = PTR_ERR(bd);
-                goto err_free;
+                return PTR_ERR(bd);
         }
 
         bl->bd = bd;
@@ -348,8 +347,6 @@ err_sysfs_remove:
         sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
 err_unregister:
         backlight_device_unregister(bd);
-err_free:
-        kfree(bl);
 
         return ret;
 }
@@ -367,7 +364,6 @@ static int __devexit lm3533_bl_remove(struct platform_device *pdev)
         lm3533_ctrlbank_disable(&bl->cb);
         sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
         backlight_device_unregister(bd);
-        kfree(bl);
 
         return 0;
 }
diff --git a/drivers/video/backlight/lms283gf05.c b/drivers/video/backlight/lms283gf05.c
index a9f2c36966f1..ea43f2254196 100644
--- a/drivers/video/backlight/lms283gf05.c
+++ b/drivers/video/backlight/lms283gf05.c
@@ -158,29 +158,27 @@ static int __devinit lms283gf05_probe(struct spi_device *spi)
         int ret = 0;
 
         if (pdata != NULL) {
-                ret = gpio_request(pdata->reset_gpio, "LMS285GF05 RESET");
+                ret = devm_gpio_request(&spi->dev, pdata->reset_gpio,
+                                        "LMS285GF05 RESET");
                 if (ret)
                         return ret;
 
                 ret = gpio_direction_output(pdata->reset_gpio,
                                                 !pdata->reset_inverted);
                 if (ret)
-                        goto err;
+                        return ret;
         }
 
         st = devm_kzalloc(&spi->dev, sizeof(struct lms283gf05_state),
                                 GFP_KERNEL);
         if (st == NULL) {
                 dev_err(&spi->dev, "No memory for device state\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         ld = lcd_device_register("lms283gf05", &spi->dev, st, &lms_ops);
-        if (IS_ERR(ld)) {
-                ret = PTR_ERR(ld);
-                goto err;
-        }
+        if (IS_ERR(ld))
+                return PTR_ERR(ld);
 
         st->spi = spi;
         st->ld = ld;
@@ -193,24 +191,14 @@ static int __devinit lms283gf05_probe(struct spi_device *spi)
         lms283gf05_toggle(spi, disp_initseq, ARRAY_SIZE(disp_initseq));
 
         return 0;
-
-err:
-        if (pdata != NULL)
-                gpio_free(pdata->reset_gpio);
-
-        return ret;
 }
 
 static int __devexit lms283gf05_remove(struct spi_device *spi)
 {
         struct lms283gf05_state *st = dev_get_drvdata(&spi->dev);
-        struct lms283gf05_pdata *pdata = st->spi->dev.platform_data;
 
         lcd_device_unregister(st->ld);
 
-        if (pdata != NULL)
-                gpio_free(pdata->reset_gpio);
-
         return 0;
 }
 
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c
index 72a0e0c917cf..aa6d4f71131f 100644
--- a/drivers/video/backlight/lp855x_bl.c
+++ b/drivers/video/backlight/lp855x_bl.c
@@ -14,11 +14,15 @@
 #include <linux/i2c.h>
 #include <linux/backlight.h>
 #include <linux/err.h>
-#include <linux/lp855x.h>
+#include <linux/platform_data/lp855x.h>
 
 /* Registers */
-#define BRIGHTNESS_CTRL         (0x00)
-#define DEVICE_CTRL             (0x01)
+#define BRIGHTNESS_CTRL         0x00
+#define DEVICE_CTRL             0x01
+#define EEPROM_START            0xA0
+#define EEPROM_END              0xA7
+#define EPROM_START             0xA0
+#define EPROM_END               0xAF
 
 #define BUF_SIZE                20
 #define DEFAULT_BL_NAME         "lcd-backlight"
diff --git a/drivers/video/backlight/ot200_bl.c b/drivers/video/backlight/ot200_bl.c
index f519d55a294c..469cf0f109d2 100644
--- a/drivers/video/backlight/ot200_bl.c
+++ b/drivers/video/backlight/ot200_bl.c
@@ -84,7 +84,8 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         int retval = 0;
 
         /* request gpio */
-        if (gpio_request(GPIO_DIMM, "ot200 backlight dimmer") < 0) {
+        if (devm_gpio_request(&pdev->dev, GPIO_DIMM,
+                                "ot200 backlight dimmer") < 0) {
                 dev_err(&pdev->dev, "failed to request GPIO %d\n", GPIO_DIMM);
                 return -ENODEV;
         }
@@ -93,14 +94,13 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         pwm_timer = cs5535_mfgpt_alloc_timer(7, MFGPT_DOMAIN_ANY);
         if (!pwm_timer) {
                 dev_err(&pdev->dev, "MFGPT 7 not available\n");
-                retval = -ENODEV;
-                goto error_mfgpt_alloc;
+                return -ENODEV;
         }
 
-        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
         if (!data) {
                 retval = -ENOMEM;
-                goto error_kzalloc;
+                goto error_devm_kzalloc;
         }
 
         /* setup gpio */
@@ -122,26 +122,21 @@ static int ot200_backlight_probe(struct platform_device *pdev)
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 retval = PTR_ERR(bl);
-                goto error_backlight_device_register;
+                goto error_devm_kzalloc;
         }
 
         platform_set_drvdata(pdev, bl);
 
         return 0;
 
-error_backlight_device_register:
-        kfree(data);
-error_kzalloc:
+error_devm_kzalloc:
         cs5535_mfgpt_free_timer(pwm_timer);
-error_mfgpt_alloc:
-        gpio_free(GPIO_DIMM);
         return retval;
 }
 
 static int ot200_backlight_remove(struct platform_device *pdev)
 {
         struct backlight_device *bl = platform_get_drvdata(pdev);
-        struct ot200_backlight_data *data = bl_get_data(bl);
 
         backlight_device_unregister(bl);
 
@@ -152,9 +147,7 @@ static int ot200_backlight_remove(struct platform_device *pdev)
                 MAX_COMP2 - dim_table[100]);
 
         cs5535_mfgpt_free_timer(pwm_timer);
-        gpio_free(GPIO_DIMM);
 
-        kfree(data);
         return 0;
 }
 
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 342b7d7cbb63..995f0164c9b0 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -26,11 +26,13 @@ struct pwm_bl_data {
         struct device           *dev;
         unsigned int            period;
         unsigned int            lth_brightness;
+        unsigned int            *levels;
         int                     (*notify)(struct device *,
                                           int brightness);
         void                    (*notify_after)(struct device *,
                                         int brightness);
         int                     (*check_fb)(struct device *, struct fb_info *);
+        void                    (*exit)(struct device *);
 };
 
 static int pwm_backlight_update_status(struct backlight_device *bl)
@@ -52,9 +54,18 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
                 pwm_config(pb->pwm, 0, pb->period);
                 pwm_disable(pb->pwm);
         } else {
-                brightness = pb->lth_brightness +
-                        (brightness * (pb->period - pb->lth_brightness) / max);
-                pwm_config(pb->pwm, brightness, pb->period);
+                int duty_cycle;
+
+                if (pb->levels) {
+                        duty_cycle = pb->levels[brightness];
+                        max = pb->levels[max];
+                } else {
+                        duty_cycle = brightness;
+                }
+
+                duty_cycle = pb->lth_brightness +
+                     (duty_cycle * (pb->period - pb->lth_brightness) / max);
+                pwm_config(pb->pwm, duty_cycle, pb->period);
                 pwm_enable(pb->pwm);
         }
 
@@ -83,17 +94,98 @@ static const struct backlight_ops pwm_backlight_ops = {
         .check_fb       = pwm_backlight_check_fb,
 };
 
+#ifdef CONFIG_OF
+static int pwm_backlight_parse_dt(struct device *dev,
+                                  struct platform_pwm_backlight_data *data)
+{
+        struct device_node *node = dev->of_node;
+        struct property *prop;
+        int length;
+        u32 value;
+        int ret;
+
+        if (!node)
+                return -ENODEV;
+
+        memset(data, 0, sizeof(*data));
+
+        /* determine the number of brightness levels */
+        prop = of_find_property(node, "brightness-levels", &length);
+        if (!prop)
+                return -EINVAL;
+
+        data->max_brightness = length / sizeof(u32);
+
+        /* read brightness levels from DT property */
+        if (data->max_brightness > 0) {
+                size_t size = sizeof(*data->levels) * data->max_brightness;
+
+                data->levels = devm_kzalloc(dev, size, GFP_KERNEL);
+                if (!data->levels)
+                        return -ENOMEM;
+
+                ret = of_property_read_u32_array(node, "brightness-levels",
+                                                 data->levels,
+                                                 data->max_brightness);
+                if (ret < 0)
+                        return ret;
+
+                ret = of_property_read_u32(node, "default-brightness-level",
+                                           &value);
+                if (ret < 0)
+                        return ret;
+
+                if (value >= data->max_brightness) {
+                        dev_warn(dev, "invalid default brightness level: %u, using %u\n",
+                                 value, data->max_brightness - 1);
+                        value = data->max_brightness - 1;
+                }
+
+                data->dft_brightness = value;
+                data->max_brightness--;
+        }
+
+        /*
+         * TODO: Most users of this driver use a number of GPIOs to control
+         *       backlight power. Support for specifying these needs to be
+         *       added.
+         */
+
+        return 0;
+}
+
+static struct of_device_id pwm_backlight_of_match[] = {
+        { .compatible = "pwm-backlight" },
+        { }
+};
+
+MODULE_DEVICE_TABLE(of, pwm_backlight_of_match);
+#else
+static int pwm_backlight_parse_dt(struct device *dev,
+                                  struct platform_pwm_backlight_data *data)
+{
+        return -ENODEV;
+}
+#endif
+
 static int pwm_backlight_probe(struct platform_device *pdev)
 {
-        struct backlight_properties props;
         struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
+        struct platform_pwm_backlight_data defdata;
+        struct backlight_properties props;
         struct backlight_device *bl;
         struct pwm_bl_data *pb;
+        unsigned int max;
         int ret;
 
         if (!data) {
-                dev_err(&pdev->dev, "failed to find platform data\n");
-                return -EINVAL;
+                ret = pwm_backlight_parse_dt(&pdev->dev, &defdata);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "failed to find platform data\n");
+                        return ret;
+                }
+
+                data = &defdata;
         }
 
         if (data->init) {
@@ -109,21 +201,42 @@ static int pwm_backlight_probe(struct platform_device *pdev)
                 goto err_alloc;
         }
 
-        pb->period = data->pwm_period_ns;
+        if (data->levels) {
+                max = data->levels[data->max_brightness];
+                pb->levels = data->levels;
+        } else
+                max = data->max_brightness;
+
         pb->notify = data->notify;
         pb->notify_after = data->notify_after;
         pb->check_fb = data->check_fb;
-        pb->lth_brightness = data->lth_brightness *
-                (data->pwm_period_ns / data->max_brightness);
+        pb->exit = data->exit;
         pb->dev = &pdev->dev;
 
-        pb->pwm = pwm_request(data->pwm_id, "backlight");
+        pb->pwm = pwm_get(&pdev->dev, NULL);
         if (IS_ERR(pb->pwm)) {
-                dev_err(&pdev->dev, "unable to request PWM for backlight\n");
-                ret = PTR_ERR(pb->pwm);
-                goto err_alloc;
-        } else
-                dev_dbg(&pdev->dev, "got pwm for backlight\n");
+                dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
+
+                pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
+                if (IS_ERR(pb->pwm)) {
+                        dev_err(&pdev->dev, "unable to request legacy PWM\n");
+                        ret = PTR_ERR(pb->pwm);
+                        goto err_alloc;
+                }
+        }
+
+        dev_dbg(&pdev->dev, "got pwm for backlight\n");
+
+        /*
+         * The DT case will set the pwm_period_ns field to 0 and store the
+         * period, parsed from the DT, in the PWM device. For the non-DT case,
+         * set the period from platform data.
+         */
+        if (data->pwm_period_ns > 0)
+                pwm_set_period(pb->pwm, data->pwm_period_ns);
+
+        pb->period = pwm_get_period(pb->pwm);
+        pb->lth_brightness = data->lth_brightness * (pb->period / max);
 
         memset(&props, 0, sizeof(struct backlight_properties));
         props.type = BACKLIGHT_RAW;
@@ -143,7 +256,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         return 0;
 
 err_bl:
-        pwm_free(pb->pwm);
+        pwm_put(pb->pwm);
 err_alloc:
         if (data->exit)
                 data->exit(&pdev->dev);
@@ -152,16 +265,15 @@ err_alloc:
 
 static int pwm_backlight_remove(struct platform_device *pdev)
 {
-        struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
         struct backlight_device *bl = platform_get_drvdata(pdev);
         struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
 
         backlight_device_unregister(bl);
         pwm_config(pb->pwm, 0, pb->period);
         pwm_disable(pb->pwm);
-        pwm_free(pb->pwm);
-        if (data->exit)
-                data->exit(&pdev->dev);
+        pwm_put(pb->pwm);
+        if (pb->exit)
+                pb->exit(&pdev->dev);
         return 0;
 }
 
@@ -195,11 +307,12 @@ static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops, pwm_backlight_suspend,
 
 static struct platform_driver pwm_backlight_driver = {
         .driver         = {
-                .name   = "pwm-backlight",
-                .owner  = THIS_MODULE,
+                .name           = "pwm-backlight",
+                .owner          = THIS_MODULE,
 #ifdef CONFIG_PM
-                .pm     = &pwm_backlight_pm_ops,
+                .pm             = &pwm_backlight_pm_ops,
 #endif
+                .of_match_table = of_match_ptr(pwm_backlight_of_match),
         },
         .probe          = pwm_backlight_probe,
         .remove         = pwm_backlight_remove,
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index 0d54e607e82d..49342e1d20be 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -92,14 +92,14 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
 
         data->comadj = sharpsl_param.comadj == -1 ? COMADJ_DEFAULT : sharpsl_param.comadj;
 
-        ret = gpio_request(TOSA_GPIO_BL_C20MA, "backlight");
+        ret = devm_gpio_request(&client->dev, TOSA_GPIO_BL_C20MA, "backlight");
         if (ret) {
                 dev_dbg(&data->bl->dev, "Unable to request gpio!\n");
                 return ret;
         }
         ret = gpio_direction_output(TOSA_GPIO_BL_C20MA, 0);
         if (ret)
-                goto err_gpio_dir;
+                return ret;
 
         i2c_set_clientdata(client, data);
         data->i2c = client;
@@ -123,8 +123,6 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
 
 err_reg:
         data->bl = NULL;
-err_gpio_dir:
-        gpio_free(TOSA_GPIO_BL_C20MA);
         return ret;
 }
 
@@ -135,8 +133,6 @@ static int __devexit tosa_bl_remove(struct i2c_client *client)
         backlight_device_unregister(data->bl);
         data->bl = NULL;
 
-        gpio_free(TOSA_GPIO_BL_C20MA);
-
         return 0;
 }
 
diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c
index 47823b8efff0..33047a66cc24 100644
--- a/drivers/video/backlight/tosa_lcd.c
+++ b/drivers/video/backlight/tosa_lcd.c
@@ -193,7 +193,7 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
         data->spi = spi;
         dev_set_drvdata(&spi->dev, data);
 
-        ret = gpio_request(TOSA_GPIO_TG_ON, "tg #pwr");
+        ret = devm_gpio_request(&spi->dev, TOSA_GPIO_TG_ON, "tg #pwr");
         if (ret < 0)
                 goto err_gpio_tg;
 
@@ -201,7 +201,7 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
 
         ret = gpio_direction_output(TOSA_GPIO_TG_ON, 0);
         if (ret < 0)
-                goto err_gpio_dir;
+                goto err_gpio_tg;
 
         mdelay(60);
         tosa_lcd_tg_init(data);
@@ -221,8 +221,6 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
 
 err_register:
         tosa_lcd_tg_off(data);
-err_gpio_dir:
-        gpio_free(TOSA_GPIO_TG_ON);
 err_gpio_tg:
         dev_set_drvdata(&spi->dev, NULL);
         return ret;
@@ -239,7 +237,6 @@ static int __devexit tosa_lcd_remove(struct spi_device *spi)
 
         tosa_lcd_tg_off(data);
 
-        gpio_free(TOSA_GPIO_TG_ON);
         dev_set_drvdata(&spi->dev, NULL);
 
         return 0;
diff --git a/drivers/video/bfin_adv7393fb.c b/drivers/video/bfin_adv7393fb.c
index 9bdd4b0c18c8..d0f121bd8b25 100644
--- a/drivers/video/bfin_adv7393fb.c
+++ b/drivers/video/bfin_adv7393fb.c
@@ -58,7 +58,7 @@ static const unsigned short ppi_pins[] = {
  */
 
 static struct bfin_adv7393_fb_par {
-        /* structure holding blackfin / adv7393 paramters when
+        /* structure holding blackfin / adv7393 parameters when
            screen is blanked */
         struct {
                 u8 Mode;        /* ntsc/pal/? */
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index 738c8ce7d132..bc67d05cad60 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -1611,7 +1611,7 @@ static void init_vgachip(struct fb_info *info)
         /* ext. display controls: ext.adr. wrap */
         vga_wcrt(cinfo->regbase, CL_CRT1B, 0x02);
 
-        /* Set/Reset registes: - */
+        /* Set/Reset registers: - */
         vga_wgfx(cinfo->regbase, VGA_GFX_SR_VALUE, 0x00);
         /* Set/Reset enable: - */
         vga_wgfx(cinfo->regbase, VGA_GFX_SR_ENABLE, 0x00);
diff --git a/drivers/video/exynos/exynos_dp_reg.c b/drivers/video/exynos/exynos_dp_reg.c
index ce401c83f638..2db5b9aa250a 100644
--- a/drivers/video/exynos/exynos_dp_reg.c
+++ b/drivers/video/exynos/exynos_dp_reg.c
@@ -752,7 +752,7 @@ int exynos_dp_read_bytes_from_i2c(struct exynos_dp_device *dp,
 
                         /*
                          * If Rx sends defer, Tx sends only reads
-                         * request without sending addres
+                         * request without sending address
                          */
                         if (!defer)
                                 retval = exynos_dp_select_i2c_device(dp,
diff --git a/drivers/video/exynos/exynos_mipi_dsi.c b/drivers/video/exynos/exynos_mipi_dsi.c
index 939064064a4f..4bc2b8a5dd8b 100644
--- a/drivers/video/exynos/exynos_mipi_dsi.c
+++ b/drivers/video/exynos/exynos_mipi_dsi.c
@@ -106,7 +106,7 @@ static void exynos_mipi_update_cfg(struct mipi_dsim_device *dsim)
 
         /*
          * data from Display controller(FIMD) is transferred in video mode
-         * but in case of command mode, all settigs is updated to registers.
+         * but in case of command mode, all settings are updated to registers.
          */
         exynos_mipi_dsi_stand_by(dsim, 1);
 }
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 1ddeb11659d4..64cda560c488 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -104,6 +104,8 @@ static int fb_deferred_io_mkwrite(struct vm_area_struct *vma,
         deferred framebuffer IO. then if userspace touches a page
         again, we repeat the same scheme */
 
+        file_update_time(vma->vm_file);
+
         /* protect against the workqueue changing the page list */
         mutex_lock(&fbdefio->lock);
 
diff --git a/drivers/video/i740fb.c b/drivers/video/i740fb.c
index fe574d84ed99..ff3f8808e4e9 100644
--- a/drivers/video/i740fb.c
+++ b/drivers/video/i740fb.c
@@ -497,7 +497,7 @@ static int i740fb_decode_var(const struct fb_var_screeninfo *var,
 
         mem = vxres * vyres * ((bpp + 1) / 8);
         if (mem > info->screen_size) {
-                dev_err(info->device, "not enough video memory (%d KB requested, %ld KB avaliable)\n",
+                dev_err(info->device, "not enough video memory (%d KB requested, %ld KB available)\n",
                         mem >> 10, info->screen_size >> 10);
                 return -ENOMEM;
         }
@@ -728,7 +728,7 @@ static void vga_protect(struct i740fb_par *par)
         i740outreg_mask(par, VGA_SEQ_I, VGA_SEQ_CLOCK_MODE, 0x20, 0x20);
 
         i740inb(par, 0x3DA);
-        i740outb(par, VGA_ATT_W, 0x00); /* enable pallete access */
+        i740outb(par, VGA_ATT_W, 0x00); /* enable palette access */
 }
 
 static void vga_unprotect(struct i740fb_par *par)
@@ -737,7 +737,7 @@ static void vga_unprotect(struct i740fb_par *par)
         i740outreg_mask(par, VGA_SEQ_I, VGA_SEQ_CLOCK_MODE, 0, 0x20);
 
         i740inb(par, 0x3DA);
-        i740outb(par, VGA_ATT_W, 0x20); /* disable pallete access */
+        i740outb(par, VGA_ATT_W, 0x20); /* disable palette access */
 }
 
 static int i740fb_set_par(struct fb_info *info)
diff --git a/drivers/video/mxsfb.c b/drivers/video/mxsfb.c
index abbe691047bd..49619b441500 100644
--- a/drivers/video/mxsfb.c
+++ b/drivers/video/mxsfb.c
@@ -41,12 +41,14 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/pinctrl/consumer.h>
-#include <mach/mxsfb.h>
+#include <linux/mxsfb.h>
 
 #define REG_SET 4
 #define REG_CLR 8
@@ -750,16 +752,43 @@ static void __devexit mxsfb_free_videomem(struct mxsfb_info *host)
         }
 }
 
+static struct platform_device_id mxsfb_devtype[] = {
+        {
+                .name = "imx23-fb",
+                .driver_data = MXSFB_V3,
+        }, {
+                .name = "imx28-fb",
+                .driver_data = MXSFB_V4,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(platform, mxsfb_devtype);
+
+static const struct of_device_id mxsfb_dt_ids[] = {
+        { .compatible = "fsl,imx23-lcdif", .data = &mxsfb_devtype[0], },
+        { .compatible = "fsl,imx28-lcdif", .data = &mxsfb_devtype[1], },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mxsfb_dt_ids);
+
 static int __devinit mxsfb_probe(struct platform_device *pdev)
 {
+        const struct of_device_id *of_id =
+                        of_match_device(mxsfb_dt_ids, &pdev->dev);
         struct mxsfb_platform_data *pdata = pdev->dev.platform_data;
         struct resource *res;
         struct mxsfb_info *host;
         struct fb_info *fb_info;
         struct fb_modelist *modelist;
         struct pinctrl *pinctrl;
+        int panel_enable;
+        enum of_gpio_flags flags;
         int i, ret;
 
+        if (of_id)
+                pdev->id_entry = of_id->data;
+
         if (!pdata) {
                 dev_err(&pdev->dev, "No platformdata. Giving up\n");
                 return -ENODEV;
@@ -807,6 +836,22 @@ static int __devinit mxsfb_probe(struct platform_device *pdev)
                 goto error_getclock;
         }
 
+        panel_enable = of_get_named_gpio_flags(pdev->dev.of_node,
+                                               "panel-enable-gpios", 0, &flags);
+        if (gpio_is_valid(panel_enable)) {
+                unsigned long f = GPIOF_OUT_INIT_HIGH;
+                if (flags == OF_GPIO_ACTIVE_LOW)
+                        f = GPIOF_OUT_INIT_LOW;
+                ret = devm_gpio_request_one(&pdev->dev, panel_enable,
+                                            f, "panel-enable");
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "failed to request gpio %d: %d\n",
+                                panel_enable, ret);
+                        goto error_panel_enable;
+                }
+        }
+
         fb_info->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
         if (!fb_info->pseudo_palette) {
                 ret = -ENOMEM;
@@ -854,6 +899,7 @@ error_register:
 error_init_fb:
         kfree(fb_info->pseudo_palette);
 error_pseudo_pallette:
+error_panel_enable:
         clk_put(host->clk);
 error_getclock:
 error_getpin:
@@ -901,19 +947,6 @@ static void mxsfb_shutdown(struct platform_device *pdev)
         writel(CTRL_RUN, host->base + LCDC_CTRL + REG_CLR);
 }
 
-static struct platform_device_id mxsfb_devtype[] = {
-        {
-                .name = "imx23-fb",
-                .driver_data = MXSFB_V3,
-        }, {
-                .name = "imx28-fb",
-                .driver_data = MXSFB_V4,
-        }, {
-                /* sentinel */
-        }
-};
-MODULE_DEVICE_TABLE(platform, mxsfb_devtype);
-
 static struct platform_driver mxsfb_driver = {
         .probe = mxsfb_probe,
         .remove = __devexit_p(mxsfb_remove),
@@ -921,6 +954,7 @@ static struct platform_driver mxsfb_driver = {
         .id_table = mxsfb_devtype,
         .driver = {
                    .name = DRIVER_NAME,
+                   .of_match_table = mxsfb_dt_ids,
         },
 };
 
diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c
index ea7b661e7229..69bf9d07c237 100644
--- a/drivers/video/s3c-fb.c
+++ b/drivers/video/s3c-fb.c
@@ -189,7 +189,7 @@ struct s3c_fb_vsync {
 
 /**
  * struct s3c_fb - overall hardware state of the hardware
- * @slock: The spinlock protection for this data sturcture.
+ * @slock: The spinlock protection for this data sturucture.
  * @dev: The device that we bound to, for printing, etc.
  * @bus_clk: The clk (hclk) feeding our interface and possibly pixclk.
  * @lcd_clk: The clk (sclk) feeding pixclk.
diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c
index f3d3b9ce4751..0d0f52c18fd8 100644
--- a/drivers/video/savage/savagefb_driver.c
+++ b/drivers/video/savage/savagefb_driver.c
@@ -662,7 +662,7 @@ static void savage_get_default_par(struct savagefb_par *par, struct savage_reg *
         vga_out8(0x3c4, 0x18, par);
         reg->SR18 = vga_in8(0x3c5, par);
 
-        /* Save flat panel expansion regsters. */
+        /* Save flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
@@ -815,7 +815,7 @@ static void savage_set_default_par(struct savagefb_par *par,
         vga_out8(0x3c4, 0x18, par);
         vga_out8(0x3c5, reg->SR18, par);
 
-        /* Save flat panel expansion regsters. */
+        /* Save flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
@@ -1318,7 +1318,7 @@ static void savagefb_set_par_int(struct savagefb_par  *par, struct savage_reg *r
         vga_out8(0x3c4, 0x15, par);
         vga_out8(0x3c5, reg->SR15, par);
 
-        /* Restore flat panel expansion regsters. */
+        /* Restore flat panel expansion registers. */
         if (par->chip == S3_SAVAGE_MX) {
                 int i;
 
diff --git a/drivers/video/sis/init.c b/drivers/video/sis/init.c
index 66de832361cc..f082ae55c0c9 100644
--- a/drivers/video/sis/init.c
+++ b/drivers/video/sis/init.c
@@ -2628,7 +2628,8 @@ SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
       else if(VCLK >= 135) data = 0x02;
 
       if(SiS_Pr->ChipType == SIS_540) {
-         if((VCLK == 203) || (VCLK < 234)) data = 0x02;
+         /* Was == 203 or < 234 which made no sense */
+         if (VCLK < 234) data = 0x02;
       }
 
       if(SiS_Pr->ChipType < SIS_315H) {
diff --git a/drivers/video/smscufx.c b/drivers/video/smscufx.c
index f39e0690f484..5533a32c6ca1 100644
--- a/drivers/video/smscufx.c
+++ b/drivers/video/smscufx.c
@@ -1,7 +1,7 @@
 /*
  * smscufx.c -- Framebuffer driver for SMSC UFX USB controller
  *
- * Copyright (C) 2011 Steve Glendinning <steve.glendinning@smsc.com>
+ * Copyright (C) 2011 Steve Glendinning <steve.glendinning@shawell.net>
  * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
  * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
  * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
@@ -1002,7 +1002,7 @@ static int ufx_ops_ioctl(struct fb_info *info, unsigned int cmd,
         /* TODO: Help propose a standard fb.h ioctl to report mmap damage */
         if (cmd == UFX_IOCTL_REPORT_DAMAGE) {
                 /* If we have a damage-aware client, turn fb_defio "off"
-                 * To avoid perf imact of unecessary page fault handling.
+                 * To avoid perf imact of unnecessary page fault handling.
                  * Done by resetting the delay for this fb_info to a very
                  * long period. Pages will become writable and stay that way.
                  * Reset to normal value when all clients have closed this fb.
@@ -1466,7 +1466,7 @@ static int ufx_read_edid(struct ufx_data *dev, u8 *edid, int edid_len)
         /* all FF's in the first 16 bytes indicates nothing is connected */
         for (i = 0; i < 16; i++) {
                 if (edid[i] != 0xFF) {
-                        pr_debug("edid data read succesfully");
+                        pr_debug("edid data read successfully");
                         return EDID_LENGTH;
                 }
         }
@@ -1972,6 +1972,6 @@ MODULE_PARM_DESC(console, "Allow fbcon to be used on this display");
 module_param(fb_defio, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
 MODULE_PARM_DESC(fb_defio, "Enable fb_defio mmap support");
 
-MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
+MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
 MODULE_DESCRIPTION("SMSC UFX kernel framebuffer driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/sunxvr500.c b/drivers/video/sunxvr500.c
index b9c2b948d34d..eb931b8626fa 100644
--- a/drivers/video/sunxvr500.c
+++ b/drivers/video/sunxvr500.c
@@ -12,7 +12,7 @@
 
 #include <asm/io.h>
 
-/* XXX This device has a 'dev-comm' property which aparently is
+/* XXX This device has a 'dev-comm' property which apparently is
  * XXX a pointer into the openfirmware's address space which is
  * XXX a shared area the kernel driver can use to keep OBP
  * XXX informed about the current resolution setting.  The idea