32 files changed, 493 insertions, 89 deletions

diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 3d886c6902f9..11de3bfd4e54 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -117,6 +117,7 @@ static struct backlight_ops atmel_lcdc_bl_ops = {
 
 static void init_backlight(struct atmel_lcdfb_info *sinfo)
 {
+        struct backlight_properties props;
         struct backlight_device *bl;
 
         sinfo->bl_power = FB_BLANK_UNBLANK;
@@ -124,8 +125,10 @@ static void init_backlight(struct atmel_lcdfb_info *sinfo)
         if (sinfo->backlight)
                 return;
 
-        bl = backlight_device_register("backlight", &sinfo->pdev->dev,
-                        sinfo, &atmel_lcdc_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 0xff;
+        bl = backlight_device_register("backlight", &sinfo->pdev->dev, sinfo,
+                                       &atmel_lcdc_bl_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&sinfo->pdev->dev, "error %ld on backlight register\n",
                                 PTR_ERR(bl));
@@ -135,7 +138,6 @@ static void init_backlight(struct atmel_lcdfb_info *sinfo)
 
         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);
 }
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 9ee67d6da710..a489be0c4614 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1802,6 +1802,7 @@ static void aty128_bl_set_power(struct fb_info *info, int power)
 
 static void aty128_bl_init(struct aty128fb_par *par)
 {
+        struct backlight_properties props;
         struct fb_info *info = pci_get_drvdata(par->pdev);
         struct backlight_device *bd;
         char name[12];
@@ -1817,7 +1818,10 @@ static void aty128_bl_init(struct aty128fb_par *par)
 
         snprintf(name, sizeof(name), "aty128bl%d", info->node);
 
-        bd = backlight_device_register(name, info->dev, par, &aty128_bl_data);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
+        bd = backlight_device_register(name, info->dev, par, &aty128_bl_data,
+                                       &props);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
                 printk(KERN_WARNING "aty128: Backlight registration failed\n");
@@ -1829,7 +1833,6 @@ static void aty128_bl_init(struct aty128fb_par *par)
                  63 * FB_BACKLIGHT_MAX / MAX_LEVEL,
                 219 * FB_BACKLIGHT_MAX / MAX_LEVEL);
 
-        bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd->props.brightness = bd->props.max_brightness;
         bd->props.power = FB_BLANK_UNBLANK;
         backlight_update_status(bd);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index e45ab8db2ddc..29d72851f85b 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2232,6 +2232,7 @@ static struct backlight_ops aty_bl_data = {
 
 static void aty_bl_init(struct atyfb_par *par)
 {
+        struct backlight_properties props;
         struct fb_info *info = pci_get_drvdata(par->pdev);
         struct backlight_device *bd;
         char name[12];
@@ -2243,7 +2244,10 @@ static void aty_bl_init(struct atyfb_par *par)
 
         snprintf(name, sizeof(name), "atybl%d", info->node);
 
-        bd = backlight_device_register(name, info->dev, par, &aty_bl_data);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
+        bd = backlight_device_register(name, info->dev, par, &aty_bl_data,
+                                       &props);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
                 printk(KERN_WARNING "aty: Backlight registration failed\n");
@@ -2255,7 +2259,6 @@ static void aty_bl_init(struct atyfb_par *par)
                             0x3F * FB_BACKLIGHT_MAX / MAX_LEVEL,
                             0xFF * FB_BACKLIGHT_MAX / MAX_LEVEL);
 
-        bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd->props.brightness = bd->props.max_brightness;
         bd->props.power = FB_BLANK_UNBLANK;
         backlight_update_status(bd);
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index fa1198c4ccc5..9fc8c66be3ce 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -134,6 +134,7 @@ static struct backlight_ops radeon_bl_data = {
 
 void radeonfb_bl_init(struct radeonfb_info *rinfo)
 {
+        struct backlight_properties props;
         struct backlight_device *bd;
         struct radeon_bl_privdata *pdata;
         char name[12];
@@ -155,7 +156,10 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
 
         snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node);
 
-        bd = backlight_device_register(name, rinfo->info->dev, pdata, &radeon_bl_data);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
+        bd = backlight_device_register(name, rinfo->info->dev, pdata,
+                                       &radeon_bl_data, &props);
         if (IS_ERR(bd)) {
                 rinfo->info->bl_dev = NULL;
                 printk("radeonfb: Backlight registration failed\n");
@@ -185,7 +189,6 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
                  63 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL,
                 217 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL);
 
-        bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd->props.brightness = bd->props.max_brightness;
         bd->props.power = FB_BLANK_UNBLANK;
         backlight_update_status(bd);
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index b8f705cca438..93e25c77aeb2 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -187,6 +187,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         struct pm860x_backlight_data *data;
         struct backlight_device *bl;
         struct resource *res;
+        struct backlight_properties props;
         unsigned char value;
         char name[MFD_NAME_SIZE];
         int ret;
@@ -223,14 +224,15 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = MAX_BRIGHTNESS;
         bl = backlight_device_register(name, &pdev->dev, data,
-                                        &pm860x_backlight_ops);
+                                        &pm860x_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 kfree(data);
                 return PTR_ERR(bl);
         }
-        bl->props.max_brightness = MAX_BRIGHTNESS;
         bl->props.brightness = MAX_BRIGHTNESS;
 
         platform_set_drvdata(pdev, bl);
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 0c77fc610212..c025c84601b0 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -31,6 +31,13 @@ config LCD_CORGI
           Say y here to support the LCD panels usually found on SHARP
           corgi (C7x0) and spitz (Cxx00) models.
 
+config LCD_L4F00242T03
+        tristate "Epson L4F00242T03 LCD"
+        depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
+        help
+          SPI driver for Epson L4F00242T03. This provides basic support
+          for init and powering the LCD up/down through a sysfs interface.
+
 config LCD_LMS283GF05
         tristate "Samsung LMS283GF05 LCD"
         depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 6c704d41462d..09d1f14d6257 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -3,6 +3,7 @@
 obj-$(CONFIG_LCD_CLASS_DEVICE)     += lcd.o
 obj-$(CONFIG_LCD_CORGI)            += corgi_lcd.o
 obj-$(CONFIG_LCD_HP700)            += jornada720_lcd.o
+obj-$(CONFIG_LCD_L4F00242T03)      += l4f00242t03.o
 obj-$(CONFIG_LCD_LMS283GF05)       += lms283gf05.o
 obj-$(CONFIG_LCD_LTV350QV)         += ltv350qv.o
 obj-$(CONFIG_LCD_ILI9320)          += ili9320.o
diff --git a/drivers/video/backlight/adp5520_bl.c b/drivers/video/backlight/adp5520_bl.c
index 86d95c228adb..5183f0e4d314 100644
--- a/drivers/video/backlight/adp5520_bl.c
+++ b/drivers/video/backlight/adp5520_bl.c
@@ -278,6 +278,7 @@ static const struct attribute_group adp5520_bl_attr_group = {
 
 static int __devinit adp5520_bl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct backlight_device *bl;
         struct adp5520_bl *data;
         int ret = 0;
@@ -300,17 +301,17 @@ static int __devinit adp5520_bl_probe(struct platform_device *pdev)
 
         mutex_init(&data->lock);
 
-        bl = backlight_device_register(pdev->name, data->master,
-                        data, &adp5520_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = ADP5020_MAX_BRIGHTNESS;
+        bl = backlight_device_register(pdev->name, data->master, data,
+                                       &adp5520_bl_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 kfree(data);
                 return PTR_ERR(bl);
         }
 
-        bl->props.max_brightness =
-                bl->props.brightness = ADP5020_MAX_BRIGHTNESS;
-
+        bl->props.brightness = ADP5020_MAX_BRIGHTNESS;
         if (data->pdata->en_ambl_sens)
                 ret = sysfs_create_group(&bl->dev.kobj,
                         &adp5520_bl_attr_group);
diff --git a/drivers/video/backlight/adx_bl.c b/drivers/video/backlight/adx_bl.c
index d769b0bab21a..b0624b983889 100644
--- a/drivers/video/backlight/adx_bl.c
+++ b/drivers/video/backlight/adx_bl.c
@@ -56,7 +56,7 @@ static int adx_backlight_get_brightness(struct backlight_device *bldev)
         return brightness & 0xff;
 }
 
-static int adx_backlight_check_fb(struct fb_info *fb)
+static int adx_backlight_check_fb(struct backlight_device *bldev, struct fb_info *fb)
 {
         return 1;
 }
@@ -70,6 +70,7 @@ static const struct backlight_ops adx_backlight_ops = {
 
 static int __devinit adx_backlight_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct backlight_device *bldev;
         struct resource *res;
         struct adxbl *bl;
@@ -101,14 +102,15 @@ static int __devinit adx_backlight_probe(struct platform_device *pdev)
                 goto out;
         }
 
-        bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, bl,
-                        &adx_backlight_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 0xff;
+        bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
+                                          bl, &adx_backlight_ops, &props);
         if (!bldev) {
                 ret = -ENOMEM;
                 goto out;
         }
 
-        bldev->props.max_brightness = 0xff;
         bldev->props.brightness = 0xff;
         bldev->props.power = FB_BLANK_UNBLANK;
 
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index f625ffc69ad3..2d9760551a4b 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -120,6 +120,7 @@ static const struct backlight_ops atmel_pwm_bl_ops = {
 
 static int atmel_pwm_bl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         const struct atmel_pwm_bl_platform_data *pdata;
         struct backlight_device *bldev;
         struct atmel_pwm_bl *pwmbl;
@@ -165,8 +166,10 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
                         goto err_free_gpio;
         }
 
-        bldev = backlight_device_register("atmel-pwm-bl",
-                        &pdev->dev, pwmbl, &atmel_pwm_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
+        bldev = backlight_device_register("atmel-pwm-bl", &pdev->dev, pwmbl,
+                                          &atmel_pwm_bl_ops, &props);
         if (IS_ERR(bldev)) {
                 retval = PTR_ERR(bldev);
                 goto err_free_gpio;
@@ -178,7 +181,6 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
 
         /* Power up the backlight by default at middle intesity. */
         bldev->props.power = FB_BLANK_UNBLANK;
-        bldev->props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
         bldev->props.brightness = bldev->props.max_brightness / 2;
 
         retval = atmel_pwm_bl_init_pwm(pwmbl);
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 18829cf68b1b..68bb838b9f11 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -38,7 +38,7 @@ static int fb_notifier_callback(struct notifier_block *self,
         mutex_lock(&bd->ops_lock);
         if (bd->ops)
                 if (!bd->ops->check_fb ||
-                    bd->ops->check_fb(evdata->info)) {
+                    bd->ops->check_fb(bd, evdata->info)) {
                         bd->props.fb_blank = *(int *)evdata->data;
                         if (bd->props.fb_blank == FB_BLANK_UNBLANK)
                                 bd->props.state &= ~BL_CORE_FBBLANK;
@@ -269,7 +269,8 @@ EXPORT_SYMBOL(backlight_force_update);
  * ERR_PTR() or a pointer to the newly allocated device.
  */
 struct backlight_device *backlight_device_register(const char *name,
-                struct device *parent, void *devdata, const struct backlight_ops *ops)
+        struct device *parent, void *devdata, const struct backlight_ops *ops,
+        const struct backlight_properties *props)
 {
         struct backlight_device *new_bd;
         int rc;
@@ -289,6 +290,11 @@ struct backlight_device *backlight_device_register(const char *name,
         dev_set_name(&new_bd->dev, name);
         dev_set_drvdata(&new_bd->dev, devdata);
 
+        /* Set default properties */
+        if (props)
+                memcpy(&new_bd->props, props,
+                       sizeof(struct backlight_properties));
+
         rc = device_register(&new_bd->dev);
         if (rc) {
                 kfree(new_bd);
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index b4bcf8043797..73bdd8454c94 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -533,6 +533,7 @@ err_free_backlight_on:
 
 static int __devinit corgi_lcd_probe(struct spi_device *spi)
 {
+        struct backlight_properties props;
         struct corgi_lcd_platform_data *pdata = spi->dev.platform_data;
         struct corgi_lcd *lcd;
         int ret = 0;
@@ -559,13 +560,14 @@ static int __devinit corgi_lcd_probe(struct spi_device *spi)
         lcd->power = FB_BLANK_POWERDOWN;
         lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA;
 
-        lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev,
-                                        lcd, &corgi_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = pdata->max_intensity;
+        lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev, lcd,
+                                                &corgi_bl_ops, &props);
         if (IS_ERR(lcd->bl_dev)) {
                 ret = PTR_ERR(lcd->bl_dev);
                 goto err_unregister_lcd;
         }
-        lcd->bl_dev->props.max_brightness = pdata->max_intensity;
         lcd->bl_dev->props.brightness = pdata->default_intensity;
         lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
 
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
index da86db4374a0..1cce6031bff2 100644
--- a/drivers/video/backlight/cr_bllcd.c
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -170,6 +170,7 @@ static struct lcd_ops cr_lcd_ops = {
 
 static int cr_backlight_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct backlight_device *bdp;
         struct lcd_device *ldp;
         struct cr_panel *crp;
@@ -190,8 +191,9 @@ static int cr_backlight_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        bdp = backlight_device_register("cr-backlight",
-                                        &pdev->dev, NULL, &cr_backlight_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        bdp = backlight_device_register("cr-backlight", &pdev->dev, NULL,
+                                        &cr_backlight_ops, &props);
         if (IS_ERR(bdp)) {
                 pci_dev_put(lpc_dev);
                 return PTR_ERR(bdp);
@@ -220,9 +222,7 @@ static int cr_backlight_probe(struct platform_device *pdev)
         crp->cr_lcd_device = ldp;
         crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK;
         crp->cr_backlight_device->props.brightness = 0;
-        crp->cr_backlight_device->props.max_brightness = 0;
         cr_backlight_set_intensity(crp->cr_backlight_device);
-
         cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK);
 
         platform_set_drvdata(pdev, crp);
diff --git a/drivers/video/backlight/da903x_bl.c b/drivers/video/backlight/da903x_bl.c
index 74cdc640173d..686e4a789238 100644
--- a/drivers/video/backlight/da903x_bl.c
+++ b/drivers/video/backlight/da903x_bl.c
@@ -105,6 +105,7 @@ static int da903x_backlight_probe(struct platform_device *pdev)
         struct da9034_backlight_pdata *pdata = pdev->dev.platform_data;
         struct da903x_backlight_data *data;
         struct backlight_device *bl;
+        struct backlight_properties props;
         int max_brightness;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -134,15 +135,15 @@ static int da903x_backlight_probe(struct platform_device *pdev)
                 da903x_write(data->da903x_dev, DA9034_WLED_CONTROL2,
                                 DA9034_WLED_ISET(pdata->output_current));
 
-        bl = backlight_device_register(pdev->name, data->da903x_dev,
-                        data, &da903x_backlight_ops);
+        props.max_brightness = max_brightness;
+        bl = backlight_device_register(pdev->name, data->da903x_dev, data,
+                                       &da903x_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 kfree(data);
                 return PTR_ERR(bl);
         }
 
-        bl->props.max_brightness = max_brightness;
         bl->props.brightness = max_brightness;
 
         platform_set_drvdata(pdev, bl);
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
index e6d348e63596..312ca619735d 100644
--- a/drivers/video/backlight/generic_bl.c
+++ b/drivers/video/backlight/generic_bl.c
@@ -78,6 +78,7 @@ static const struct backlight_ops genericbl_ops = {
 
 static int genericbl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct generic_bl_info *machinfo = pdev->dev.platform_data;
         const char *name = "generic-bl";
         struct backlight_device *bd;
@@ -89,14 +90,15 @@ static int genericbl_probe(struct platform_device *pdev)
         if (machinfo->name)
                 name = machinfo->name;
 
-        bd = backlight_device_register (name,
-                &pdev->dev, NULL, &genericbl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = machinfo->max_intensity;
+        bd = backlight_device_register(name, &pdev->dev, NULL, &genericbl_ops,
+                                       &props);
         if (IS_ERR (bd))
                 return PTR_ERR (bd);
 
         platform_set_drvdata(pdev, bd);
 
-        bd->props.max_brightness = machinfo->max_intensity;
         bd->props.power = FB_BLANK_UNBLANK;
         bd->props.brightness = machinfo->default_intensity;
         backlight_update_status(bd);
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index f7cc528d5be7..267d23f8d645 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -105,16 +105,18 @@ static const struct backlight_ops hp680bl_ops = {
 
 static int __devinit hp680bl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct backlight_device *bd;
 
-        bd = backlight_device_register ("hp680-bl", &pdev->dev, NULL,
-                    &hp680bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = HP680_MAX_INTENSITY;
+        bd = backlight_device_register("hp680-bl", &pdev->dev, NULL,
+                                       &hp680bl_ops, &props);
         if (IS_ERR(bd))
                 return PTR_ERR(bd);
 
         platform_set_drvdata(pdev, bd);
 
-        bd->props.max_brightness = HP680_MAX_INTENSITY;
         bd->props.brightness = HP680_DEFAULT_INTENSITY;
         hp680bl_send_intensity(bd);
 
diff --git a/drivers/video/backlight/jornada720_bl.c b/drivers/video/backlight/jornada720_bl.c
index db9071fc5665..2f177b3a4885 100644
--- a/drivers/video/backlight/jornada720_bl.c
+++ b/drivers/video/backlight/jornada720_bl.c
@@ -101,10 +101,14 @@ static const struct backlight_ops jornada_bl_ops = {
 
 static int jornada_bl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         int ret;
         struct backlight_device *bd;
 
-        bd = backlight_device_register(S1D_DEVICENAME, &pdev->dev, NULL, &jornada_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = BL_MAX_BRIGHT;
+        bd = backlight_device_register(S1D_DEVICENAME, &pdev->dev, NULL,
+                                       &jornada_bl_ops, &props);
 
         if (IS_ERR(bd)) {
                 ret = PTR_ERR(bd);
@@ -117,7 +121,6 @@ static int jornada_bl_probe(struct platform_device *pdev)
         /* note. make sure max brightness is set otherwise
            you will get seemingly non-related errors when
            trying to change brightness */
-        bd->props.max_brightness = BL_MAX_BRIGHT;
         jornada_bl_update_status(bd);
 
         platform_set_drvdata(pdev, bd);
diff --git a/drivers/video/backlight/kb3886_bl.c b/drivers/video/backlight/kb3886_bl.c
index 939e7b830cf3..f439a8632287 100644
--- a/drivers/video/backlight/kb3886_bl.c
+++ b/drivers/video/backlight/kb3886_bl.c
@@ -141,20 +141,24 @@ static const struct backlight_ops kb3886bl_ops = {
 
 static int kb3886bl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct kb3886bl_machinfo *machinfo = pdev->dev.platform_data;
 
         bl_machinfo = machinfo;
         if (!machinfo->limit_mask)
                 machinfo->limit_mask = -1;
 
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = machinfo->max_intensity;
         kb3886_backlight_device = backlight_device_register("kb3886-bl",
-                &pdev->dev, NULL, &kb3886bl_ops);
+                                                            &pdev->dev, NULL,
+                                                            &kb3886bl_ops,
+                                                            &props);
         if (IS_ERR(kb3886_backlight_device))
                 return PTR_ERR(kb3886_backlight_device);
 
         platform_set_drvdata(pdev, kb3886_backlight_device);
 
-        kb3886_backlight_device->props.max_brightness = machinfo->max_intensity;
         kb3886_backlight_device->props.power = FB_BLANK_UNBLANK;
         kb3886_backlight_device->props.brightness = machinfo->default_intensity;
         backlight_update_status(kb3886_backlight_device);
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
new file mode 100644
index 000000000000..74abd6994b09
--- /dev/null
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -0,0 +1,257 @@
+/*
+ * l4f00242t03.c -- support for Epson L4F00242T03 LCD
+ *
+ * Copyright 2007-2009 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * Copyright (c) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
+ *      Inspired by Marek Vasut work in l4f00242t03.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/lcd.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/l4f00242t03.h>
+
+struct l4f00242t03_priv {
+        struct spi_device       *spi;
+        struct lcd_device       *ld;
+        int lcd_on:1;
+        struct regulator *io_reg;
+        struct regulator *core_reg;
+};
+
+
+static void l4f00242t03_reset(unsigned int gpio)
+{
+        pr_debug("l4f00242t03_reset.\n");
+        gpio_set_value(gpio, 1);
+        mdelay(100);
+        gpio_set_value(gpio, 0);
+        mdelay(10);     /* tRES >= 100us */
+        gpio_set_value(gpio, 1);
+        mdelay(20);
+}
+
+#define param(x) ((x) | 0x100)
+
+static void l4f00242t03_lcd_init(struct spi_device *spi)
+{
+        struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
+        struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
+        const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };
+
+        dev_dbg(&spi->dev, "initializing LCD\n");
+
+        if (priv->io_reg) {
+                regulator_set_voltage(priv->io_reg, 1800000, 1800000);
+                regulator_enable(priv->io_reg);
+        }
+
+        if (priv->core_reg) {
+                regulator_set_voltage(priv->core_reg, 2800000, 2800000);
+                regulator_enable(priv->core_reg);
+        }
+
+        gpio_set_value(pdata->data_enable_gpio, 1);
+        msleep(60);
+        spi_write(spi, (const u8 *)cmd, ARRAY_SIZE(cmd) * sizeof(u16));
+}
+
+static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
+{
+        struct l4f00242t03_priv *priv = lcd_get_data(ld);
+        struct spi_device *spi = priv->spi;
+
+        const u16 slpout = 0x11;
+        const u16 dison = 0x29;
+
+        const u16 slpin = 0x10;
+        const u16 disoff = 0x28;
+
+        if (power) {
+                if (priv->lcd_on)
+                        return 0;
+
+                dev_dbg(&spi->dev, "turning on LCD\n");
+
+                spi_write(spi, (const u8 *)&slpout, sizeof(u16));
+                msleep(60);
+                spi_write(spi, (const u8 *)&dison, sizeof(u16));
+
+                priv->lcd_on = 1;
+        } else {
+                if (!priv->lcd_on)
+                        return 0;
+
+                dev_dbg(&spi->dev, "turning off LCD\n");
+
+                spi_write(spi, (const u8 *)&disoff, sizeof(u16));
+                msleep(60);
+                spi_write(spi, (const u8 *)&slpin, sizeof(u16));
+
+                priv->lcd_on = 0;
+        }
+
+        return 0;
+}
+
+static struct lcd_ops l4f_ops = {
+        .set_power      = l4f00242t03_lcd_power_set,
+        .get_power      = NULL,
+};
+
+static int __devinit l4f00242t03_probe(struct spi_device *spi)
+{
+        struct l4f00242t03_priv *priv;
+        struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
+        int ret;
+
+        if (pdata == NULL) {
+                dev_err(&spi->dev, "Uninitialized platform data.\n");
+                return -EINVAL;
+        }
+
+        priv = kzalloc(sizeof(struct l4f00242t03_priv), GFP_KERNEL);
+
+        if (priv == NULL) {
+                dev_err(&spi->dev, "No memory for this device.\n");
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        dev_set_drvdata(&spi->dev, priv);
+        spi->bits_per_word = 9;
+        spi_setup(spi);
+
+        priv->spi = spi;
+
+        ret = gpio_request(pdata->reset_gpio, "lcd l4f00242t03 reset");
+        if (ret) {
+                dev_err(&spi->dev,
+                        "Unable to get the lcd l4f00242t03 reset gpio.\n");
+                return ret;
+        }
+
+        ret = gpio_direction_output(pdata->reset_gpio, 1);
+        if (ret)
+                goto err2;
+
+        ret = gpio_request(pdata->data_enable_gpio,
+                                "lcd l4f00242t03 data enable");
+        if (ret) {
+                dev_err(&spi->dev,
+                        "Unable to get the lcd l4f00242t03 data en gpio.\n");
+                return ret;
+        }
+
+        ret = gpio_direction_output(pdata->data_enable_gpio, 0);
+        if (ret)
+                goto err3;
+
+        if (pdata->io_supply) {
+                priv->io_reg = regulator_get(NULL, pdata->io_supply);
+
+                if (IS_ERR(priv->io_reg)) {
+                        pr_err("%s: Unable to get the IO regulator\n",
+                                                                __func__);
+                        goto err3;
+                }
+        }
+
+        if (pdata->core_supply) {
+                priv->core_reg = regulator_get(NULL, pdata->core_supply);
+
+                if (IS_ERR(priv->core_reg)) {
+                        pr_err("%s: Unable to get the core regulator\n",
+                                                                __func__);
+                        goto err4;
+                }
+        }
+
+        priv->ld = lcd_device_register("l4f00242t03",
+                                        &spi->dev, priv, &l4f_ops);
+        if (IS_ERR(priv->ld)) {
+                ret = PTR_ERR(priv->ld);
+                goto err5;
+        }
+
+        /* Init the LCD */
+        l4f00242t03_reset(pdata->reset_gpio);
+        l4f00242t03_lcd_init(spi);
+        l4f00242t03_lcd_power_set(priv->ld, 1);
+
+        dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");
+
+        return 0;
+
+err5:
+        if (priv->core_reg)
+                regulator_put(priv->core_reg);
+err4:
+        if (priv->io_reg)
+                regulator_put(priv->io_reg);
+err3:
+        gpio_free(pdata->data_enable_gpio);
+err2:
+        gpio_free(pdata->reset_gpio);
+err:
+        kfree(priv);
+
+        return ret;
+}
+
+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, 0);
+        lcd_device_unregister(priv->ld);
+
+        gpio_free(pdata->data_enable_gpio);
+        gpio_free(pdata->reset_gpio);
+
+        if (priv->io_reg)
+                regulator_put(priv->core_reg);
+        if (priv->core_reg)
+                regulator_put(priv->io_reg);
+
+        kfree(priv);
+
+        return 0;
+}
+
+static struct spi_driver l4f00242t03_driver = {
+        .driver = {
+                .name   = "l4f00242t03",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = l4f00242t03_probe,
+        .remove         = __devexit_p(l4f00242t03_remove),
+};
+
+static __init int l4f00242t03_init(void)
+{
+        return spi_register_driver(&l4f00242t03_driver);
+}
+
+static __exit void l4f00242t03_exit(void)
+{
+        spi_unregister_driver(&l4f00242t03_driver);
+}
+
+module_init(l4f00242t03_init);
+module_exit(l4f00242t03_exit);
+
+MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
+MODULE_DESCRIPTION("EPSON L4F00242T03 LCD");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/backlight/locomolcd.c b/drivers/video/backlight/locomolcd.c
index 00a9591b0003..7571bc26071e 100644
--- a/drivers/video/backlight/locomolcd.c
+++ b/drivers/video/backlight/locomolcd.c
@@ -167,6 +167,7 @@ static int locomolcd_resume(struct locomo_dev *dev)
 
 static int locomolcd_probe(struct locomo_dev *ldev)
 {
+        struct backlight_properties props;
         unsigned long flags;
 
         local_irq_save(flags);
@@ -182,13 +183,16 @@ static int locomolcd_probe(struct locomo_dev *ldev)
 
         local_irq_restore(flags);
 
-        locomolcd_bl_device = backlight_device_register("locomo-bl", &ldev->dev, NULL, &locomobl_data);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 4;
+        locomolcd_bl_device = backlight_device_register("locomo-bl",
+                                                        &ldev->dev, NULL,
+                                                        &locomobl_data, &props);
 
         if (IS_ERR (locomolcd_bl_device))
                 return PTR_ERR (locomolcd_bl_device);
 
         /* Set up frontlight so that screen is readable */
-        locomolcd_bl_device->props.max_brightness = 4,
         locomolcd_bl_device->props.brightness = 2;
         locomolcd_set_intensity(locomolcd_bl_device);
 
diff --git a/drivers/video/backlight/max8925_bl.c b/drivers/video/backlight/max8925_bl.c
index c267069a52a3..c91adaf492cf 100644
--- a/drivers/video/backlight/max8925_bl.c
+++ b/drivers/video/backlight/max8925_bl.c
@@ -104,6 +104,7 @@ static int __devinit max8925_backlight_probe(struct platform_device *pdev)
         struct max8925_backlight_pdata *pdata = NULL;
         struct max8925_backlight_data *data;
         struct backlight_device *bl;
+        struct backlight_properties props;
         struct resource *res;
         char name[MAX8925_NAME_SIZE];
         unsigned char value;
@@ -133,14 +134,15 @@ static int __devinit max8925_backlight_probe(struct platform_device *pdev)
         data->chip = chip;
         data->current_brightness = 0;
 
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = MAX_BRIGHTNESS;
         bl = backlight_device_register(name, &pdev->dev, data,
-                                        &max8925_backlight_ops);
+                                        &max8925_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 kfree(data);
                 return PTR_ERR(bl);
         }
-        bl->props.max_brightness = MAX_BRIGHTNESS;
         bl->props.brightness = MAX_BRIGHTNESS;
 
         platform_set_drvdata(pdev, bl);
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
index 2e78b0784bdc..1b5d3fe6bbbc 100644
--- a/drivers/video/backlight/mbp_nvidia_bl.c
+++ b/drivers/video/backlight/mbp_nvidia_bl.c
@@ -139,6 +139,51 @@ static int mbp_dmi_match(const struct dmi_system_id *id)
 static const struct dmi_system_id __initdata mbp_device_table[] = {
         {
                 .callback       = mbp_dmi_match,
+                .ident          = "MacBook 1,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBook 2,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook2,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBook 3,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook3,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBook 4,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBook 4,2",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,2"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
                 .ident          = "MacBookPro 3,1",
                 .matches        = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
@@ -250,6 +295,7 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
 
 static int __init mbp_init(void)
 {
+        struct backlight_properties props;
         if (!dmi_check_system(mbp_device_table))
                 return -ENODEV;
 
@@ -257,14 +303,17 @@ static int __init mbp_init(void)
                                                 "Macbook Pro backlight"))
                 return -ENXIO;
 
-        mbp_backlight_device = backlight_device_register("mbp_backlight",
-                                        NULL, NULL, &driver_data->backlight_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 15;
+        mbp_backlight_device = backlight_device_register("mbp_backlight", NULL,
+                                                         NULL,
+                                                         &driver_data->backlight_ops,
+                                                         &props);
         if (IS_ERR(mbp_backlight_device)) {
                 release_region(driver_data->iostart, driver_data->iolen);
                 return PTR_ERR(mbp_backlight_device);
         }
 
-        mbp_backlight_device->props.max_brightness = 15;
         mbp_backlight_device->props.brightness =
                 driver_data->backlight_ops.get_brightness(mbp_backlight_device);
         backlight_update_status(mbp_backlight_device);
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index a3a7f8938175..333d28e6b062 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -132,6 +132,7 @@ static const struct backlight_ops omapbl_ops = {
 
 static int omapbl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct backlight_device *dev;
         struct omap_backlight *bl;
         struct omap_backlight_config *pdata = pdev->dev.platform_data;
@@ -143,7 +144,10 @@ static int omapbl_probe(struct platform_device *pdev)
         if (unlikely(!bl))
                 return -ENOMEM;
 
-        dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = OMAPBL_MAX_INTENSITY;
+        dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops,
+                                        &props);
         if (IS_ERR(dev)) {
                 kfree(bl);
                 return PTR_ERR(dev);
@@ -160,7 +164,6 @@ static int omapbl_probe(struct platform_device *pdev)
         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);
 
diff --git a/drivers/video/backlight/progear_bl.c b/drivers/video/backlight/progear_bl.c
index 075786e05034..809278c90738 100644
--- a/drivers/video/backlight/progear_bl.c
+++ b/drivers/video/backlight/progear_bl.c
@@ -61,8 +61,10 @@ static const struct backlight_ops progearbl_ops = {
 
 static int progearbl_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         u8 temp;
         struct backlight_device *progear_backlight_device;
+        int ret;
 
         pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL);
         if (!pmu_dev) {
@@ -73,28 +75,37 @@ static int progearbl_probe(struct platform_device *pdev)
         sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
         if (!sb_dev) {
                 printk("ALI 1533 SB not found.\n");
-                pci_dev_put(pmu_dev);
-                return -ENODEV;
+                ret = -ENODEV;
+                goto put_pmu;
         }
 
         /*     Set SB_MPS1 to enable brightness control. */
         pci_read_config_byte(sb_dev, SB_MPS1, &temp);
         pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20);
 
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
         progear_backlight_device = backlight_device_register("progear-bl",
                                                              &pdev->dev, NULL,
-                                                             &progearbl_ops);
-        if (IS_ERR(progear_backlight_device))
-                return PTR_ERR(progear_backlight_device);
+                                                             &progearbl_ops,
+                                                             &props);
+        if (IS_ERR(progear_backlight_device)) {
+                ret = PTR_ERR(progear_backlight_device);
+                goto put_sb;
+        }
 
         platform_set_drvdata(pdev, progear_backlight_device);
 
         progear_backlight_device->props.power = FB_BLANK_UNBLANK;
         progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
-        progear_backlight_device->props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
         progearbl_set_intensity(progear_backlight_device);
 
         return 0;
+put_sb:
+        pci_dev_put(sb_dev);
+put_pmu:
+        pci_dev_put(pmu_dev);
+        return ret;
 }
 
 static int progearbl_remove(struct platform_device *pdev)
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 9d2ec2a1cce8..b89eebc3f77d 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -65,6 +65,7 @@ static const struct backlight_ops pwm_backlight_ops = {
 
 static int pwm_backlight_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
         struct backlight_device *bl;
         struct pwm_bl_data *pb;
@@ -100,15 +101,16 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         } else
                 dev_dbg(&pdev->dev, "got pwm for backlight\n");
 
-        bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
-                        pb, &pwm_backlight_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = data->max_brightness;
+        bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
+                                       &pwm_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 ret = PTR_ERR(bl);
                 goto err_bl;
         }
 
-        bl->props.max_brightness = data->max_brightness;
         bl->props.brightness = data->dft_brightness;
         backlight_update_status(bl);
 
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index e14ce4d469f5..f57bbf170049 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -80,6 +80,7 @@ static const struct backlight_ops bl_ops = {
 static int __devinit tosa_bl_probe(struct i2c_client *client,
                 const struct i2c_device_id *id)
 {
+        struct backlight_properties props;
         struct tosa_bl_data *data = kzalloc(sizeof(struct tosa_bl_data), GFP_KERNEL);
         int ret = 0;
         if (!data)
@@ -99,15 +100,16 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
         i2c_set_clientdata(client, data);
         data->i2c = client;
 
-        data->bl = backlight_device_register("tosa-bl", &client->dev,
-                        data, &bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 512 - 1;
+        data->bl = backlight_device_register("tosa-bl", &client->dev, data,
+                                             &bl_ops, &props);
         if (IS_ERR(data->bl)) {
                 ret = PTR_ERR(data->bl);
                 goto err_reg;
         }
 
         data->bl->props.brightness = 69;
-        data->bl->props.max_brightness = 512 - 1;
         data->bl->props.power = FB_BLANK_UNBLANK;
 
         backlight_update_status(data->bl);
diff --git a/drivers/video/backlight/wm831x_bl.c b/drivers/video/backlight/wm831x_bl.c
index e32add37a203..a4312709fb1b 100644
--- a/drivers/video/backlight/wm831x_bl.c
+++ b/drivers/video/backlight/wm831x_bl.c
@@ -125,6 +125,7 @@ static int wm831x_backlight_probe(struct platform_device *pdev)
         struct wm831x_backlight_pdata *pdata;
         struct wm831x_backlight_data *data;
         struct backlight_device *bl;
+        struct backlight_properties props;
         int ret, i, max_isel, isink_reg, dcdc_cfg;
 
         /* We need platform data */
@@ -191,15 +192,15 @@ static int wm831x_backlight_probe(struct platform_device *pdev)
         data->current_brightness = 0;
         data->isink_reg = isink_reg;
 
-        bl = backlight_device_register("wm831x", &pdev->dev,
-                        data, &wm831x_backlight_ops);
+        props.max_brightness = max_isel;
+        bl = backlight_device_register("wm831x", &pdev->dev, data,
+                                       &wm831x_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "failed to register backlight\n");
                 kfree(data);
                 return PTR_ERR(bl);
         }
 
-        bl->props.max_brightness = max_isel;
         bl->props.brightness = max_isel;
 
         platform_set_drvdata(pdev, bl);
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index 814312a7452f..23b2a8c0dbfc 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -433,7 +433,7 @@ static int bl_get_brightness(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops bfin_lq043fb_bl_ops = {
+static const struct backlight_ops bfin_lq043fb_bl_ops = {
         .get_brightness = bl_get_brightness,
 };
 
@@ -501,6 +501,7 @@ static irqreturn_t bfin_bf54x_irq_error(int irq, void *dev_id)
 
 static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct bfin_bf54xfb_info *info;
         struct fb_info *fbinfo;
         int ret;
@@ -645,10 +646,16 @@ static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
                 goto out8;
         }
 #ifndef NO_BL_SUPPORT
-        bl_dev =
-            backlight_device_register("bf54x-bl", NULL, NULL,
-                                      &bfin_lq043fb_bl_ops);
-        bl_dev->props.max_brightness = 255;
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 255;
+        bl_dev = backlight_device_register("bf54x-bl", NULL, NULL,
+                                           &bfin_lq043fb_bl_ops, &props);
+        if (IS_ERR(bl_dev)) {
+                printk(KERN_ERR DRIVER_NAME
+                        ": unable to register backlight.\n");
+                ret = -EINVAL;
+                goto out9;
+        }
 
         lcd_dev = lcd_device_register(DRIVER_NAME, &pdev->dev, NULL, &bfin_lcd_ops);
         lcd_dev->props.max_contrast = 255, printk(KERN_INFO "Done.\n");
@@ -656,6 +663,8 @@ static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
 
         return 0;
 
+out9:
+        unregister_framebuffer(fbinfo);
 out8:
         free_irq(info->irq, info);
 out7:
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index 5653d083a983..31a2dec927bb 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -352,7 +352,7 @@ static int bl_get_brightness(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops bfin_lq043fb_bl_ops = {
+static const struct backlight_ops bfin_lq043fb_bl_ops = {
         .get_brightness = bl_get_brightness,
 };
 
@@ -419,6 +419,7 @@ static irqreturn_t bfin_t350mcqb_irq_error(int irq, void *dev_id)
 
 static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
 {
+        struct backlight_properties props;
         struct bfin_t350mcqbfb_info *info;
         struct fb_info *fbinfo;
         int ret;
@@ -540,10 +541,16 @@ static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
                 goto out8;
         }
 #ifndef NO_BL_SUPPORT
-        bl_dev =
-            backlight_device_register("bf52x-bl", NULL, NULL,
-                                      &bfin_lq043fb_bl_ops);
-        bl_dev->props.max_brightness = 255;
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 255;
+        bl_dev = backlight_device_register("bf52x-bl", NULL, NULL,
+                                           &bfin_lq043fb_bl_ops, &props);
+        if (IS_ERR(bl_dev)) {
+                printk(KERN_ERR DRIVER_NAME
+                        ": unable to register backlight.\n");
+                ret = -EINVAL;
+                goto out9;
+        }
 
         lcd_dev = lcd_device_register(DRIVER_NAME, NULL, &bfin_lcd_ops);
         lcd_dev->props.max_contrast = 255, printk(KERN_INFO "Done.\n");
@@ -551,6 +558,8 @@ static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
 
         return 0;
 
+out9:
+        unregister_framebuffer(fbinfo);
 out8:
         free_irq(info->irq, info);
 out7:
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
index 443e3c85a9a0..2fb552a6f32c 100644
--- a/drivers/video/nvidia/nv_backlight.c
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -94,6 +94,7 @@ static struct backlight_ops nvidia_bl_ops = {
 
 void nvidia_bl_init(struct nvidia_par *par)
 {
+        struct backlight_properties props;
         struct fb_info *info = pci_get_drvdata(par->pci_dev);
         struct backlight_device *bd;
         char name[12];
@@ -109,7 +110,10 @@ void nvidia_bl_init(struct nvidia_par *par)
 
         snprintf(name, sizeof(name), "nvidiabl%d", info->node);
 
-        bd = backlight_device_register(name, info->dev, par, &nvidia_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
+        bd = backlight_device_register(name, info->dev, par, &nvidia_bl_ops,
+                                       &props);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
                 printk(KERN_WARNING "nvidia: Backlight registration failed\n");
@@ -121,7 +125,6 @@ void nvidia_bl_init(struct nvidia_par *par)
                 0x158 * FB_BACKLIGHT_MAX / MAX_LEVEL,
                 0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
 
-        bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd->props.brightness = bd->props.max_brightness;
         bd->props.power = FB_BLANK_UNBLANK;
         backlight_update_status(bd);
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index fcd6a61a91eb..59769e85d41c 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -486,6 +486,7 @@ static struct attribute_group taal_attr_group = {
 
 static int taal_probe(struct omap_dss_device *dssdev)
 {
+        struct backlight_properties props;
         struct taal_data *td;
         struct backlight_device *bldev;
         int r;
@@ -520,11 +521,16 @@ static int taal_probe(struct omap_dss_device *dssdev)
 
         /* if no platform set_backlight() defined, presume DSI backlight
          * control */
+        memset(&props, 0, sizeof(struct backlight_properties));
         if (!dssdev->set_backlight)
                 td->use_dsi_bl = true;
 
+        if (td->use_dsi_bl)
+                props.max_brightness = 255;
+        else
+                props.max_brightness = 127;
         bldev = backlight_device_register("taal", &dssdev->dev, dssdev,
-                        &taal_bl_ops);
+                                          &taal_bl_ops, &props);
         if (IS_ERR(bldev)) {
                 r = PTR_ERR(bldev);
                 goto err2;
@@ -534,13 +540,10 @@ static int taal_probe(struct omap_dss_device *dssdev)
 
         bldev->props.fb_blank = FB_BLANK_UNBLANK;
         bldev->props.power = FB_BLANK_UNBLANK;
-        if (td->use_dsi_bl) {
-                bldev->props.max_brightness = 255;
+        if (td->use_dsi_bl)
                 bldev->props.brightness = 255;
-        } else {
-                bldev->props.max_brightness = 127;
+        else
                 bldev->props.brightness = 127;
-        }
 
         taal_bl_update_status(bldev);
 
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index d94c57ffbdb1..618f36bec10d 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -338,6 +338,7 @@ static struct backlight_ops riva_bl_ops = {
 
 static void riva_bl_init(struct riva_par *par)
 {
+        struct backlight_properties props;
         struct fb_info *info = pci_get_drvdata(par->pdev);
         struct backlight_device *bd;
         char name[12];
@@ -353,7 +354,10 @@ static void riva_bl_init(struct riva_par *par)
 
         snprintf(name, sizeof(name), "rivabl%d", info->node);
 
-        bd = backlight_device_register(name, info->dev, par, &riva_bl_ops);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
+        bd = backlight_device_register(name, info->dev, par, &riva_bl_ops,
+                                       &props);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
                 printk(KERN_WARNING "riva: Backlight registration failed\n");
@@ -365,7 +369,6 @@ static void riva_bl_init(struct riva_par *par)
                 MIN_LEVEL * FB_BACKLIGHT_MAX / MAX_LEVEL,
                 FB_BACKLIGHT_MAX);
 
-        bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd->props.brightness = bd->props.max_brightness;
         bd->props.power = FB_BLANK_UNBLANK;
         backlight_update_status(bd);