aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/video/backlight
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/video/backlight')
-rw-r--r--drivers/video/backlight/88pm860x_bl.c307
-rw-r--r--drivers/video/backlight/Kconfig20
-rw-r--r--drivers/video/backlight/Makefile3
-rw-r--r--drivers/video/backlight/adp5520_bl.c137
-rw-r--r--drivers/video/backlight/adx_bl.c13
-rw-r--r--drivers/video/backlight/atmel-pwm-bl.c13
-rw-r--r--drivers/video/backlight/backlight.c11
-rw-r--r--drivers/video/backlight/corgi_lcd.c11
-rw-r--r--drivers/video/backlight/cr_bllcd.c13
-rw-r--r--drivers/video/backlight/da903x_bl.c19
-rw-r--r--drivers/video/backlight/generic_bl.c10
-rw-r--r--drivers/video/backlight/hp680_bl.c10
-rw-r--r--drivers/video/backlight/ili9320.c1
-rw-r--r--drivers/video/backlight/jornada720_bl.c9
-rw-r--r--drivers/video/backlight/kb3886_bl.c10
-rw-r--r--drivers/video/backlight/l4f00242t03.c258
-rw-r--r--drivers/video/backlight/lcd.c5
-rw-r--r--drivers/video/backlight/lms283gf05.c1
-rw-r--r--drivers/video/backlight/locomolcd.c10
-rw-r--r--drivers/video/backlight/ltv350qv.c1
-rw-r--r--drivers/video/backlight/max8925_bl.c203
-rw-r--r--drivers/video/backlight/mbp_nvidia_bl.c75
-rw-r--r--drivers/video/backlight/omap1_bl.c16
-rw-r--r--drivers/video/backlight/platform_lcd.c1
-rw-r--r--drivers/video/backlight/progear_bl.c25
-rw-r--r--drivers/video/backlight/pwm_bl.c20
-rw-r--r--drivers/video/backlight/tdo24m.c2
-rw-r--r--drivers/video/backlight/tosa_bl.c11
-rw-r--r--drivers/video/backlight/tosa_lcd.c3
-rw-r--r--drivers/video/backlight/wm831x_bl.c10
30 files changed, 1089 insertions, 139 deletions
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
new file mode 100644
index 000000000000..68d2518fadaa
--- /dev/null
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -0,0 +1,307 @@
1/*
2 * Backlight driver for Marvell Semiconductor 88PM8606
3 *
4 * Copyright (C) 2009 Marvell International Ltd.
5 * Haojian Zhuang <haojian.zhuang@marvell.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/init.h>
13#include <linux/kernel.h>
14#include <linux/platform_device.h>
15#include <linux/fb.h>
16#include <linux/i2c.h>
17#include <linux/backlight.h>
18#include <linux/mfd/88pm860x.h>
19#include <linux/slab.h>
20
21#define MAX_BRIGHTNESS (0xFF)
22#define MIN_BRIGHTNESS (0)
23
24#define CURRENT_MASK (0x1F << 1)
25
26struct pm860x_backlight_data {
27 struct pm860x_chip *chip;
28 struct i2c_client *i2c;
29 int current_brightness;
30 int port;
31 int pwm;
32 int iset;
33};
34
35static inline int wled_a(int port)
36{
37 int ret;
38
39 ret = ((port - PM8606_BACKLIGHT1) << 1) + 2;
40 return ret;
41}
42
43static inline int wled_b(int port)
44{
45 int ret;
46
47 ret = ((port - PM8606_BACKLIGHT1) << 1) + 3;
48 return ret;
49}
50
51/* WLED2 & WLED3 share the same IDC */
52static inline int wled_idc(int port)
53{
54 int ret;
55
56 switch (port) {
57 case PM8606_BACKLIGHT1:
58 case PM8606_BACKLIGHT2:
59 ret = ((port - PM8606_BACKLIGHT1) << 1) + 3;
60 break;
61 case PM8606_BACKLIGHT3:
62 default:
63 ret = ((port - PM8606_BACKLIGHT2) << 1) + 3;
64 break;
65 }
66 return ret;
67}
68
69static int pm860x_backlight_set(struct backlight_device *bl, int brightness)
70{
71 struct pm860x_backlight_data *data = bl_get_data(bl);
72 struct pm860x_chip *chip = data->chip;
73 unsigned char value;
74 int ret;
75
76 if (brightness > MAX_BRIGHTNESS)
77 value = MAX_BRIGHTNESS;
78 else
79 value = brightness;
80
81 ret = pm860x_reg_write(data->i2c, wled_a(data->port), value);
82 if (ret < 0)
83 goto out;
84
85 if ((data->current_brightness == 0) && brightness) {
86 if (data->iset) {
87 ret = pm860x_set_bits(data->i2c, wled_idc(data->port),
88 CURRENT_MASK, data->iset);
89 if (ret < 0)
90 goto out;
91 }
92 if (data->pwm) {
93 ret = pm860x_set_bits(data->i2c, PM8606_PWM,
94 PM8606_PWM_FREQ_MASK, data->pwm);
95 if (ret < 0)
96 goto out;
97 }
98 if (brightness == MAX_BRIGHTNESS) {
99 /* set WLED_ON bit as 100% */
100 ret = pm860x_set_bits(data->i2c, wled_b(data->port),
101 PM8606_WLED_ON, PM8606_WLED_ON);
102 }
103 } else {
104 if (brightness == MAX_BRIGHTNESS) {
105 /* set WLED_ON bit as 100% */
106 ret = pm860x_set_bits(data->i2c, wled_b(data->port),
107 PM8606_WLED_ON, PM8606_WLED_ON);
108 } else {
109 /* clear WLED_ON bit since it's not 100% */
110 ret = pm860x_set_bits(data->i2c, wled_b(data->port),
111 PM8606_WLED_ON, 0);
112 }
113 }
114 if (ret < 0)
115 goto out;
116
117 dev_dbg(chip->dev, "set brightness %d\n", value);
118 data->current_brightness = value;
119 return 0;
120out:
121 dev_dbg(chip->dev, "set brightness %d failure with return "
122 "value:%d\n", value, ret);
123 return ret;
124}
125
126static int pm860x_backlight_update_status(struct backlight_device *bl)
127{
128 int brightness = bl->props.brightness;
129
130 if (bl->props.power != FB_BLANK_UNBLANK)
131 brightness = 0;
132
133 if (bl->props.fb_blank != FB_BLANK_UNBLANK)
134 brightness = 0;
135
136 if (bl->props.state & BL_CORE_SUSPENDED)
137 brightness = 0;
138
139 return pm860x_backlight_set(bl, brightness);
140}
141
142static int pm860x_backlight_get_brightness(struct backlight_device *bl)
143{
144 struct pm860x_backlight_data *data = bl_get_data(bl);
145 struct pm860x_chip *chip = data->chip;
146 int ret;
147
148 ret = pm860x_reg_read(data->i2c, wled_a(data->port));
149 if (ret < 0)
150 goto out;
151 data->current_brightness = ret;
152 dev_dbg(chip->dev, "get brightness %d\n", data->current_brightness);
153 return data->current_brightness;
154out:
155 return -EINVAL;
156}
157
158static struct backlight_ops pm860x_backlight_ops = {
159 .options = BL_CORE_SUSPENDRESUME,
160 .update_status = pm860x_backlight_update_status,
161 .get_brightness = pm860x_backlight_get_brightness,
162};
163
164static int __check_device(struct pm860x_backlight_pdata *pdata, char *name)
165{
166 struct pm860x_backlight_pdata *p = pdata;
167 int ret = -EINVAL;
168
169 while (p && p->id) {
170 if ((p->id != PM8606_ID_BACKLIGHT) || (p->flags < 0))
171 break;
172
173 if (!strncmp(name, pm860x_backlight_name[p->flags],
174 MFD_NAME_SIZE)) {
175 ret = (int)p->flags;
176 break;
177 }
178 p++;
179 }
180 return ret;
181}
182
183static int pm860x_backlight_probe(struct platform_device *pdev)
184{
185 struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
186 struct pm860x_platform_data *pm860x_pdata;
187 struct pm860x_backlight_pdata *pdata = NULL;
188 struct pm860x_backlight_data *data;
189 struct backlight_device *bl;
190 struct resource *res;
191 struct backlight_properties props;
192 unsigned char value;
193 char name[MFD_NAME_SIZE];
194 int ret;
195
196 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
197 if (res == NULL) {
198 dev_err(&pdev->dev, "No I/O resource!\n");
199 return -EINVAL;
200 }
201
202 if (pdev->dev.parent->platform_data) {
203 pm860x_pdata = pdev->dev.parent->platform_data;
204 pdata = pm860x_pdata->backlight;
205 }
206 if (pdata == NULL) {
207 dev_err(&pdev->dev, "platform data isn't assigned to "
208 "backlight\n");
209 return -EINVAL;
210 }
211
212 data = kzalloc(sizeof(struct pm860x_backlight_data), GFP_KERNEL);
213 if (data == NULL)
214 return -ENOMEM;
215 strncpy(name, res->name, MFD_NAME_SIZE);
216 data->chip = chip;
217 data->i2c = (chip->id == CHIP_PM8606) ? chip->client \
218 : chip->companion;
219 data->current_brightness = MAX_BRIGHTNESS;
220 data->pwm = pdata->pwm;
221 data->iset = pdata->iset;
222 data->port = __check_device(pdata, name);
223 if (data->port < 0) {
224 dev_err(&pdev->dev, "wrong platform data is assigned");
225 return -EINVAL;
226 }
227
228 memset(&props, 0, sizeof(struct backlight_properties));
229 props.max_brightness = MAX_BRIGHTNESS;
230 bl = backlight_device_register(name, &pdev->dev, data,
231 &pm860x_backlight_ops, &props);
232 if (IS_ERR(bl)) {
233 dev_err(&pdev->dev, "failed to register backlight\n");
234 kfree(data);
235 return PTR_ERR(bl);
236 }
237 bl->props.brightness = MAX_BRIGHTNESS;
238
239 platform_set_drvdata(pdev, bl);
240
241 /* Enable reference VSYS */
242 ret = pm860x_reg_read(data->i2c, PM8606_VSYS);
243 if (ret < 0)
244 goto out;
245 if ((ret & PM8606_VSYS_EN) == 0) {
246 value = ret | PM8606_VSYS_EN;
247 ret = pm860x_reg_write(data->i2c, PM8606_VSYS, value);
248 if (ret < 0)
249 goto out;
250 }
251 /* Enable reference OSC */
252 ret = pm860x_reg_read(data->i2c, PM8606_MISC);
253 if (ret < 0)
254 goto out;
255 if ((ret & PM8606_MISC_OSC_EN) == 0) {
256 value = ret | PM8606_MISC_OSC_EN;
257 ret = pm860x_reg_write(data->i2c, PM8606_MISC, value);
258 if (ret < 0)
259 goto out;
260 }
261 /* read current backlight */
262 ret = pm860x_backlight_get_brightness(bl);
263 if (ret < 0)
264 goto out;
265
266 backlight_update_status(bl);
267 return 0;
268out:
269 kfree(data);
270 return ret;
271}
272
273static int pm860x_backlight_remove(struct platform_device *pdev)
274{
275 struct backlight_device *bl = platform_get_drvdata(pdev);
276 struct pm860x_backlight_data *data = bl_get_data(bl);
277
278 backlight_device_unregister(bl);
279 kfree(data);
280 return 0;
281}
282
283static struct platform_driver pm860x_backlight_driver = {
284 .driver = {
285 .name = "88pm860x-backlight",
286 .owner = THIS_MODULE,
287 },
288 .probe = pm860x_backlight_probe,
289 .remove = pm860x_backlight_remove,
290};
291
292static int __init pm860x_backlight_init(void)
293{
294 return platform_driver_register(&pm860x_backlight_driver);
295}
296module_init(pm860x_backlight_init);
297
298static void __exit pm860x_backlight_exit(void)
299{
300 platform_driver_unregister(&pm860x_backlight_driver);
301}
302module_exit(pm860x_backlight_exit);
303
304MODULE_DESCRIPTION("Backlight Driver for Marvell Semiconductor 88PM8606");
305MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
306MODULE_LICENSE("GPL");
307MODULE_ALIAS("platform:88pm860x-backlight");
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 09bfa9662e4d..c025c84601b0 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -31,6 +31,13 @@ config LCD_CORGI
31 Say y here to support the LCD panels usually found on SHARP 31 Say y here to support the LCD panels usually found on SHARP
32 corgi (C7x0) and spitz (Cxx00) models. 32 corgi (C7x0) and spitz (Cxx00) models.
33 33
34config LCD_L4F00242T03
35 tristate "Epson L4F00242T03 LCD"
36 depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
37 help
38 SPI driver for Epson L4F00242T03. This provides basic support
39 for init and powering the LCD up/down through a sysfs interface.
40
34config LCD_LMS283GF05 41config LCD_LMS283GF05
35 tristate "Samsung LMS283GF05 LCD" 42 tristate "Samsung LMS283GF05 LCD"
36 depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO 43 depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
@@ -212,6 +219,13 @@ config BACKLIGHT_DA903X
212 If you have a LCD backlight connected to the WLED output of DA9030 219 If you have a LCD backlight connected to the WLED output of DA9030
213 or DA9034 WLED output, say Y here to enable this driver. 220 or DA9034 WLED output, say Y here to enable this driver.
214 221
222config BACKLIGHT_MAX8925
223 tristate "Backlight driver for MAX8925"
224 depends on BACKLIGHT_CLASS_DEVICE && MFD_MAX8925
225 help
226 If you have a LCD backlight connected to the WLED output of MAX8925
227 WLED output, say Y here to enable this driver.
228
215config BACKLIGHT_MBP_NVIDIA 229config BACKLIGHT_MBP_NVIDIA
216 tristate "MacBook Pro Nvidia Backlight Driver" 230 tristate "MacBook Pro Nvidia Backlight Driver"
217 depends on BACKLIGHT_CLASS_DEVICE && X86 231 depends on BACKLIGHT_CLASS_DEVICE && X86
@@ -262,3 +276,9 @@ config BACKLIGHT_ADP5520
262 To compile this driver as a module, choose M here: the module will 276 To compile this driver as a module, choose M here: the module will
263 be called adp5520_bl. 277 be called adp5520_bl.
264 278
279config BACKLIGHT_88PM860X
280 tristate "Backlight Driver for 88PM8606 using WLED"
281 depends on BACKLIGHT_CLASS_DEVICE && MFD_88PM860X
282 help
283 Say Y to enable the backlight driver for Marvell 88PM8606.
284
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 9a405548874c..09d1f14d6257 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -3,6 +3,7 @@
3obj-$(CONFIG_LCD_CLASS_DEVICE) += lcd.o 3obj-$(CONFIG_LCD_CLASS_DEVICE) += lcd.o
4obj-$(CONFIG_LCD_CORGI) += corgi_lcd.o 4obj-$(CONFIG_LCD_CORGI) += corgi_lcd.o
5obj-$(CONFIG_LCD_HP700) += jornada720_lcd.o 5obj-$(CONFIG_LCD_HP700) += jornada720_lcd.o
6obj-$(CONFIG_LCD_L4F00242T03) += l4f00242t03.o
6obj-$(CONFIG_LCD_LMS283GF05) += lms283gf05.o 7obj-$(CONFIG_LCD_LMS283GF05) += lms283gf05.o
7obj-$(CONFIG_LCD_LTV350QV) += ltv350qv.o 8obj-$(CONFIG_LCD_LTV350QV) += ltv350qv.o
8obj-$(CONFIG_LCD_ILI9320) += ili9320.o 9obj-$(CONFIG_LCD_ILI9320) += ili9320.o
@@ -22,10 +23,12 @@ obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
22obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o 23obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
23obj-$(CONFIG_BACKLIGHT_PWM) += pwm_bl.o 24obj-$(CONFIG_BACKLIGHT_PWM) += pwm_bl.o
24obj-$(CONFIG_BACKLIGHT_DA903X) += da903x_bl.o 25obj-$(CONFIG_BACKLIGHT_DA903X) += da903x_bl.o
26obj-$(CONFIG_BACKLIGHT_MAX8925) += max8925_bl.o
25obj-$(CONFIG_BACKLIGHT_MBP_NVIDIA) += mbp_nvidia_bl.o 27obj-$(CONFIG_BACKLIGHT_MBP_NVIDIA) += mbp_nvidia_bl.o
26obj-$(CONFIG_BACKLIGHT_TOSA) += tosa_bl.o 28obj-$(CONFIG_BACKLIGHT_TOSA) += tosa_bl.o
27obj-$(CONFIG_BACKLIGHT_SAHARA) += kb3886_bl.o 29obj-$(CONFIG_BACKLIGHT_SAHARA) += kb3886_bl.o
28obj-$(CONFIG_BACKLIGHT_WM831X) += wm831x_bl.o 30obj-$(CONFIG_BACKLIGHT_WM831X) += wm831x_bl.o
29obj-$(CONFIG_BACKLIGHT_ADX) += adx_bl.o 31obj-$(CONFIG_BACKLIGHT_ADX) += adx_bl.o
30obj-$(CONFIG_BACKLIGHT_ADP5520) += adp5520_bl.o 32obj-$(CONFIG_BACKLIGHT_ADP5520) += adp5520_bl.o
33obj-$(CONFIG_BACKLIGHT_88PM860X) += 88pm860x_bl.o
31 34
diff --git a/drivers/video/backlight/adp5520_bl.c b/drivers/video/backlight/adp5520_bl.c
index ad05da5ba3c7..9f436e014f85 100644
--- a/drivers/video/backlight/adp5520_bl.c
+++ b/drivers/video/backlight/adp5520_bl.c
@@ -12,10 +12,11 @@
12#include <linux/fb.h> 12#include <linux/fb.h>
13#include <linux/backlight.h> 13#include <linux/backlight.h>
14#include <linux/mfd/adp5520.h> 14#include <linux/mfd/adp5520.h>
15#include <linux/slab.h>
15 16
16struct adp5520_bl { 17struct adp5520_bl {
17 struct device *master; 18 struct device *master;
18 struct adp5520_backlight_platfrom_data *pdata; 19 struct adp5520_backlight_platform_data *pdata;
19 struct mutex lock; 20 struct mutex lock;
20 unsigned long cached_daylight_max; 21 unsigned long cached_daylight_max;
21 int id; 22 int id;
@@ -31,29 +32,30 @@ static int adp5520_bl_set(struct backlight_device *bl, int brightness)
31 if (data->pdata->en_ambl_sens) { 32 if (data->pdata->en_ambl_sens) {
32 if ((brightness > 0) && (brightness < ADP5020_MAX_BRIGHTNESS)) { 33 if ((brightness > 0) && (brightness < ADP5020_MAX_BRIGHTNESS)) {
33 /* Disable Ambient Light auto adjust */ 34 /* Disable Ambient Light auto adjust */
34 ret |= adp5520_clr_bits(master, BL_CONTROL, 35 ret |= adp5520_clr_bits(master, ADP5520_BL_CONTROL,
35 BL_AUTO_ADJ); 36 ADP5520_BL_AUTO_ADJ);
36 ret |= adp5520_write(master, DAYLIGHT_MAX, brightness); 37 ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX,
38 brightness);
37 } else { 39 } else {
38 /* 40 /*
39 * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust 41 * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust
40 * restore daylight l3 sysfs brightness 42 * restore daylight l3 sysfs brightness
41 */ 43 */
42 ret |= adp5520_write(master, DAYLIGHT_MAX, 44 ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX,
43 data->cached_daylight_max); 45 data->cached_daylight_max);
44 ret |= adp5520_set_bits(master, BL_CONTROL, 46 ret |= adp5520_set_bits(master, ADP5520_BL_CONTROL,
45 BL_AUTO_ADJ); 47 ADP5520_BL_AUTO_ADJ);
46 } 48 }
47 } else { 49 } else {
48 ret |= adp5520_write(master, DAYLIGHT_MAX, brightness); 50 ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX, brightness);
49 } 51 }
50 52
51 if (data->current_brightness && brightness == 0) 53 if (data->current_brightness && brightness == 0)
52 ret |= adp5520_set_bits(master, 54 ret |= adp5520_set_bits(master,
53 MODE_STATUS, DIM_EN); 55 ADP5520_MODE_STATUS, ADP5520_DIM_EN);
54 else if (data->current_brightness == 0 && brightness) 56 else if (data->current_brightness == 0 && brightness)
55 ret |= adp5520_clr_bits(master, 57 ret |= adp5520_clr_bits(master,
56 MODE_STATUS, DIM_EN); 58 ADP5520_MODE_STATUS, ADP5520_DIM_EN);
57 59
58 if (!ret) 60 if (!ret)
59 data->current_brightness = brightness; 61 data->current_brightness = brightness;
@@ -79,12 +81,12 @@ static int adp5520_bl_get_brightness(struct backlight_device *bl)
79 int error; 81 int error;
80 uint8_t reg_val; 82 uint8_t reg_val;
81 83
82 error = adp5520_read(data->master, BL_VALUE, &reg_val); 84 error = adp5520_read(data->master, ADP5520_BL_VALUE, &reg_val);
83 85
84 return error ? data->current_brightness : reg_val; 86 return error ? data->current_brightness : reg_val;
85} 87}
86 88
87static struct backlight_ops adp5520_bl_ops = { 89static const struct backlight_ops adp5520_bl_ops = {
88 .update_status = adp5520_bl_update_status, 90 .update_status = adp5520_bl_update_status,
89 .get_brightness = adp5520_bl_get_brightness, 91 .get_brightness = adp5520_bl_get_brightness,
90}; 92};
@@ -93,33 +95,46 @@ static int adp5520_bl_setup(struct backlight_device *bl)
93{ 95{
94 struct adp5520_bl *data = bl_get_data(bl); 96 struct adp5520_bl *data = bl_get_data(bl);
95 struct device *master = data->master; 97 struct device *master = data->master;
96 struct adp5520_backlight_platfrom_data *pdata = data->pdata; 98 struct adp5520_backlight_platform_data *pdata = data->pdata;
97 int ret = 0; 99 int ret = 0;
98 100
99 ret |= adp5520_write(master, DAYLIGHT_MAX, pdata->l1_daylight_max); 101 ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX,
100 ret |= adp5520_write(master, DAYLIGHT_DIM, pdata->l1_daylight_dim); 102 pdata->l1_daylight_max);
103 ret |= adp5520_write(master, ADP5520_DAYLIGHT_DIM,
104 pdata->l1_daylight_dim);
101 105
102 if (pdata->en_ambl_sens) { 106 if (pdata->en_ambl_sens) {
103 data->cached_daylight_max = pdata->l1_daylight_max; 107 data->cached_daylight_max = pdata->l1_daylight_max;
104 ret |= adp5520_write(master, OFFICE_MAX, pdata->l2_office_max); 108 ret |= adp5520_write(master, ADP5520_OFFICE_MAX,
105 ret |= adp5520_write(master, OFFICE_DIM, pdata->l2_office_dim); 109 pdata->l2_office_max);
106 ret |= adp5520_write(master, DARK_MAX, pdata->l3_dark_max); 110 ret |= adp5520_write(master, ADP5520_OFFICE_DIM,
107 ret |= adp5520_write(master, DARK_DIM, pdata->l3_dark_dim); 111 pdata->l2_office_dim);
108 ret |= adp5520_write(master, L2_TRIP, pdata->l2_trip); 112 ret |= adp5520_write(master, ADP5520_DARK_MAX,
109 ret |= adp5520_write(master, L2_HYS, pdata->l2_hyst); 113 pdata->l3_dark_max);
110 ret |= adp5520_write(master, L3_TRIP, pdata->l3_trip); 114 ret |= adp5520_write(master, ADP5520_DARK_DIM,
111 ret |= adp5520_write(master, L3_HYS, pdata->l3_hyst); 115 pdata->l3_dark_dim);
112 ret |= adp5520_write(master, ALS_CMPR_CFG, 116 ret |= adp5520_write(master, ADP5520_L2_TRIP,
113 ALS_CMPR_CFG_VAL(pdata->abml_filt, L3_EN)); 117 pdata->l2_trip);
118 ret |= adp5520_write(master, ADP5520_L2_HYS,
119 pdata->l2_hyst);
120 ret |= adp5520_write(master, ADP5520_L3_TRIP,
121 pdata->l3_trip);
122 ret |= adp5520_write(master, ADP5520_L3_HYS,
123 pdata->l3_hyst);
124 ret |= adp5520_write(master, ADP5520_ALS_CMPR_CFG,
125 ALS_CMPR_CFG_VAL(pdata->abml_filt,
126 ADP5520_L3_EN));
114 } 127 }
115 128
116 ret |= adp5520_write(master, BL_CONTROL, 129 ret |= adp5520_write(master, ADP5520_BL_CONTROL,
117 BL_CTRL_VAL(pdata->fade_led_law, pdata->en_ambl_sens)); 130 BL_CTRL_VAL(pdata->fade_led_law,
131 pdata->en_ambl_sens));
118 132
119 ret |= adp5520_write(master, BL_FADE, FADE_VAL(pdata->fade_in, 133 ret |= adp5520_write(master, ADP5520_BL_FADE, FADE_VAL(pdata->fade_in,
120 pdata->fade_out)); 134 pdata->fade_out));
121 135
122 ret |= adp5520_set_bits(master, MODE_STATUS, BL_EN | DIM_EN); 136 ret |= adp5520_set_bits(master, ADP5520_MODE_STATUS,
137 ADP5520_BL_EN | ADP5520_DIM_EN);
123 138
124 return ret; 139 return ret;
125} 140}
@@ -156,29 +171,31 @@ static ssize_t adp5520_store(struct device *dev, const char *buf,
156} 171}
157 172
158static ssize_t adp5520_bl_dark_max_show(struct device *dev, 173static ssize_t adp5520_bl_dark_max_show(struct device *dev,
159 struct device_attribute *attr, char *buf) 174 struct device_attribute *attr, char *buf)
160{ 175{
161 return adp5520_show(dev, buf, DARK_MAX); 176 return adp5520_show(dev, buf, ADP5520_DARK_MAX);
162} 177}
163 178
164static ssize_t adp5520_bl_dark_max_store(struct device *dev, 179static ssize_t adp5520_bl_dark_max_store(struct device *dev,
165 struct device_attribute *attr, const char *buf, size_t count) 180 struct device_attribute *attr,
181 const char *buf, size_t count)
166{ 182{
167 return adp5520_store(dev, buf, count, DARK_MAX); 183 return adp5520_store(dev, buf, count, ADP5520_DARK_MAX);
168} 184}
169static DEVICE_ATTR(dark_max, 0664, adp5520_bl_dark_max_show, 185static DEVICE_ATTR(dark_max, 0664, adp5520_bl_dark_max_show,
170 adp5520_bl_dark_max_store); 186 adp5520_bl_dark_max_store);
171 187
172static ssize_t adp5520_bl_office_max_show(struct device *dev, 188static ssize_t adp5520_bl_office_max_show(struct device *dev,
173 struct device_attribute *attr, char *buf) 189 struct device_attribute *attr, char *buf)
174{ 190{
175 return adp5520_show(dev, buf, OFFICE_MAX); 191 return adp5520_show(dev, buf, ADP5520_OFFICE_MAX);
176} 192}
177 193
178static ssize_t adp5520_bl_office_max_store(struct device *dev, 194static ssize_t adp5520_bl_office_max_store(struct device *dev,
179 struct device_attribute *attr, const char *buf, size_t count) 195 struct device_attribute *attr,
196 const char *buf, size_t count)
180{ 197{
181 return adp5520_store(dev, buf, count, OFFICE_MAX); 198 return adp5520_store(dev, buf, count, ADP5520_OFFICE_MAX);
182} 199}
183static DEVICE_ATTR(office_max, 0664, adp5520_bl_office_max_show, 200static DEVICE_ATTR(office_max, 0664, adp5520_bl_office_max_show,
184 adp5520_bl_office_max_store); 201 adp5520_bl_office_max_store);
@@ -186,16 +203,17 @@ static DEVICE_ATTR(office_max, 0664, adp5520_bl_office_max_show,
186static ssize_t adp5520_bl_daylight_max_show(struct device *dev, 203static ssize_t adp5520_bl_daylight_max_show(struct device *dev,
187 struct device_attribute *attr, char *buf) 204 struct device_attribute *attr, char *buf)
188{ 205{
189 return adp5520_show(dev, buf, DAYLIGHT_MAX); 206 return adp5520_show(dev, buf, ADP5520_DAYLIGHT_MAX);
190} 207}
191 208
192static ssize_t adp5520_bl_daylight_max_store(struct device *dev, 209static ssize_t adp5520_bl_daylight_max_store(struct device *dev,
193 struct device_attribute *attr, const char *buf, size_t count) 210 struct device_attribute *attr,
211 const char *buf, size_t count)
194{ 212{
195 struct adp5520_bl *data = dev_get_drvdata(dev); 213 struct adp5520_bl *data = dev_get_drvdata(dev);
196 214
197 strict_strtoul(buf, 10, &data->cached_daylight_max); 215 strict_strtoul(buf, 10, &data->cached_daylight_max);
198 return adp5520_store(dev, buf, count, DAYLIGHT_MAX); 216 return adp5520_store(dev, buf, count, ADP5520_DAYLIGHT_MAX);
199} 217}
200static DEVICE_ATTR(daylight_max, 0664, adp5520_bl_daylight_max_show, 218static DEVICE_ATTR(daylight_max, 0664, adp5520_bl_daylight_max_show,
201 adp5520_bl_daylight_max_store); 219 adp5520_bl_daylight_max_store);
@@ -203,14 +221,14 @@ static DEVICE_ATTR(daylight_max, 0664, adp5520_bl_daylight_max_show,
203static ssize_t adp5520_bl_dark_dim_show(struct device *dev, 221static ssize_t adp5520_bl_dark_dim_show(struct device *dev,
204 struct device_attribute *attr, char *buf) 222 struct device_attribute *attr, char *buf)
205{ 223{
206 return adp5520_show(dev, buf, DARK_DIM); 224 return adp5520_show(dev, buf, ADP5520_DARK_DIM);
207} 225}
208 226
209static ssize_t adp5520_bl_dark_dim_store(struct device *dev, 227static ssize_t adp5520_bl_dark_dim_store(struct device *dev,
210 struct device_attribute *attr, 228 struct device_attribute *attr,
211 const char *buf, size_t count) 229 const char *buf, size_t count)
212{ 230{
213 return adp5520_store(dev, buf, count, DARK_DIM); 231 return adp5520_store(dev, buf, count, ADP5520_DARK_DIM);
214} 232}
215static DEVICE_ATTR(dark_dim, 0664, adp5520_bl_dark_dim_show, 233static DEVICE_ATTR(dark_dim, 0664, adp5520_bl_dark_dim_show,
216 adp5520_bl_dark_dim_store); 234 adp5520_bl_dark_dim_store);
@@ -218,29 +236,29 @@ static DEVICE_ATTR(dark_dim, 0664, adp5520_bl_dark_dim_show,
218static ssize_t adp5520_bl_office_dim_show(struct device *dev, 236static ssize_t adp5520_bl_office_dim_show(struct device *dev,
219 struct device_attribute *attr, char *buf) 237 struct device_attribute *attr, char *buf)
220{ 238{
221 return adp5520_show(dev, buf, OFFICE_DIM); 239 return adp5520_show(dev, buf, ADP5520_OFFICE_DIM);
222} 240}
223 241
224static ssize_t adp5520_bl_office_dim_store(struct device *dev, 242static ssize_t adp5520_bl_office_dim_store(struct device *dev,
225 struct device_attribute *attr, 243 struct device_attribute *attr,
226 const char *buf, size_t count) 244 const char *buf, size_t count)
227{ 245{
228 return adp5520_store(dev, buf, count, OFFICE_DIM); 246 return adp5520_store(dev, buf, count, ADP5520_OFFICE_DIM);
229} 247}
230static DEVICE_ATTR(office_dim, 0664, adp5520_bl_office_dim_show, 248static DEVICE_ATTR(office_dim, 0664, adp5520_bl_office_dim_show,
231 adp5520_bl_office_dim_store); 249 adp5520_bl_office_dim_store);
232 250
233static ssize_t adp5520_bl_daylight_dim_show(struct device *dev, 251static ssize_t adp5520_bl_daylight_dim_show(struct device *dev,
234 struct device_attribute *attr, char *buf) 252 struct device_attribute *attr, char *buf)
235{ 253{
236 return adp5520_show(dev, buf, DAYLIGHT_DIM); 254 return adp5520_show(dev, buf, ADP5520_DAYLIGHT_DIM);
237} 255}
238 256
239static ssize_t adp5520_bl_daylight_dim_store(struct device *dev, 257static ssize_t adp5520_bl_daylight_dim_store(struct device *dev,
240 struct device_attribute *attr, 258 struct device_attribute *attr,
241 const char *buf, size_t count) 259 const char *buf, size_t count)
242{ 260{
243 return adp5520_store(dev, buf, count, DAYLIGHT_DIM); 261 return adp5520_store(dev, buf, count, ADP5520_DAYLIGHT_DIM);
244} 262}
245static DEVICE_ATTR(daylight_dim, 0664, adp5520_bl_daylight_dim_show, 263static DEVICE_ATTR(daylight_dim, 0664, adp5520_bl_daylight_dim_show,
246 adp5520_bl_daylight_dim_store); 264 adp5520_bl_daylight_dim_store);
@@ -261,6 +279,7 @@ static const struct attribute_group adp5520_bl_attr_group = {
261 279
262static int __devinit adp5520_bl_probe(struct platform_device *pdev) 280static int __devinit adp5520_bl_probe(struct platform_device *pdev)
263{ 281{
282 struct backlight_properties props;
264 struct backlight_device *bl; 283 struct backlight_device *bl;
265 struct adp5520_bl *data; 284 struct adp5520_bl *data;
266 int ret = 0; 285 int ret = 0;
@@ -283,17 +302,17 @@ static int __devinit adp5520_bl_probe(struct platform_device *pdev)
283 302
284 mutex_init(&data->lock); 303 mutex_init(&data->lock);
285 304
286 bl = backlight_device_register(pdev->name, data->master, 305 memset(&props, 0, sizeof(struct backlight_properties));
287 data, &adp5520_bl_ops); 306 props.max_brightness = ADP5020_MAX_BRIGHTNESS;
307 bl = backlight_device_register(pdev->name, data->master, data,
308 &adp5520_bl_ops, &props);
288 if (IS_ERR(bl)) { 309 if (IS_ERR(bl)) {
289 dev_err(&pdev->dev, "failed to register backlight\n"); 310 dev_err(&pdev->dev, "failed to register backlight\n");
290 kfree(data); 311 kfree(data);
291 return PTR_ERR(bl); 312 return PTR_ERR(bl);
292 } 313 }
293 314
294 bl->props.max_brightness = 315 bl->props.brightness = ADP5020_MAX_BRIGHTNESS;
295 bl->props.brightness = ADP5020_MAX_BRIGHTNESS;
296
297 if (data->pdata->en_ambl_sens) 316 if (data->pdata->en_ambl_sens)
298 ret = sysfs_create_group(&bl->dev.kobj, 317 ret = sysfs_create_group(&bl->dev.kobj,
299 &adp5520_bl_attr_group); 318 &adp5520_bl_attr_group);
@@ -316,7 +335,7 @@ static int __devexit adp5520_bl_remove(struct platform_device *pdev)
316 struct backlight_device *bl = platform_get_drvdata(pdev); 335 struct backlight_device *bl = platform_get_drvdata(pdev);
317 struct adp5520_bl *data = bl_get_data(bl); 336 struct adp5520_bl *data = bl_get_data(bl);
318 337
319 adp5520_clr_bits(data->master, MODE_STATUS, BL_EN); 338 adp5520_clr_bits(data->master, ADP5520_MODE_STATUS, ADP5520_BL_EN);
320 339
321 if (data->pdata->en_ambl_sens) 340 if (data->pdata->en_ambl_sens)
322 sysfs_remove_group(&bl->dev.kobj, 341 sysfs_remove_group(&bl->dev.kobj,
diff --git a/drivers/video/backlight/adx_bl.c b/drivers/video/backlight/adx_bl.c
index 2c3bdfc620b7..7f4a7c30a98b 100644
--- a/drivers/video/backlight/adx_bl.c
+++ b/drivers/video/backlight/adx_bl.c
@@ -12,6 +12,7 @@
12 12
13#include <linux/backlight.h> 13#include <linux/backlight.h>
14#include <linux/fb.h> 14#include <linux/fb.h>
15#include <linux/gfp.h>
15#include <linux/io.h> 16#include <linux/io.h>
16#include <linux/module.h> 17#include <linux/module.h>
17#include <linux/platform_device.h> 18#include <linux/platform_device.h>
@@ -56,12 +57,12 @@ static int adx_backlight_get_brightness(struct backlight_device *bldev)
56 return brightness & 0xff; 57 return brightness & 0xff;
57} 58}
58 59
59static int adx_backlight_check_fb(struct fb_info *fb) 60static int adx_backlight_check_fb(struct backlight_device *bldev, struct fb_info *fb)
60{ 61{
61 return 1; 62 return 1;
62} 63}
63 64
64static struct backlight_ops adx_backlight_ops = { 65static const struct backlight_ops adx_backlight_ops = {
65 .options = 0, 66 .options = 0,
66 .update_status = adx_backlight_update_status, 67 .update_status = adx_backlight_update_status,
67 .get_brightness = adx_backlight_get_brightness, 68 .get_brightness = adx_backlight_get_brightness,
@@ -70,6 +71,7 @@ static struct backlight_ops adx_backlight_ops = {
70 71
71static int __devinit adx_backlight_probe(struct platform_device *pdev) 72static int __devinit adx_backlight_probe(struct platform_device *pdev)
72{ 73{
74 struct backlight_properties props;
73 struct backlight_device *bldev; 75 struct backlight_device *bldev;
74 struct resource *res; 76 struct resource *res;
75 struct adxbl *bl; 77 struct adxbl *bl;
@@ -101,14 +103,15 @@ static int __devinit adx_backlight_probe(struct platform_device *pdev)
101 goto out; 103 goto out;
102 } 104 }
103 105
104 bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, bl, 106 memset(&props, 0, sizeof(struct backlight_properties));
105 &adx_backlight_ops); 107 props.max_brightness = 0xff;
108 bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
109 bl, &adx_backlight_ops, &props);
106 if (!bldev) { 110 if (!bldev) {
107 ret = -ENOMEM; 111 ret = -ENOMEM;
108 goto out; 112 goto out;
109 } 113 }
110 114
111 bldev->props.max_brightness = 0xff;
112 bldev->props.brightness = 0xff; 115 bldev->props.brightness = 0xff;
113 bldev->props.power = FB_BLANK_UNBLANK; 116 bldev->props.power = FB_BLANK_UNBLANK;
114 117
diff --git a/drivers/video/backlight/atmel-pwm-bl.c b/drivers/video/backlight/atmel-pwm-bl.c
index 505c0823a105..e6a66dab088c 100644
--- a/drivers/video/backlight/atmel-pwm-bl.c
+++ b/drivers/video/backlight/atmel-pwm-bl.c
@@ -17,6 +17,7 @@
17#include <linux/backlight.h> 17#include <linux/backlight.h>
18#include <linux/atmel_pwm.h> 18#include <linux/atmel_pwm.h>
19#include <linux/atmel-pwm-bl.h> 19#include <linux/atmel-pwm-bl.h>
20#include <linux/slab.h>
20 21
21struct atmel_pwm_bl { 22struct atmel_pwm_bl {
22 const struct atmel_pwm_bl_platform_data *pdata; 23 const struct atmel_pwm_bl_platform_data *pdata;
@@ -113,13 +114,14 @@ static int atmel_pwm_bl_init_pwm(struct atmel_pwm_bl *pwmbl)
113 return pwm_channel_enable(&pwmbl->pwmc); 114 return pwm_channel_enable(&pwmbl->pwmc);
114} 115}
115 116
116static struct backlight_ops atmel_pwm_bl_ops = { 117static const struct backlight_ops atmel_pwm_bl_ops = {
117 .get_brightness = atmel_pwm_bl_get_intensity, 118 .get_brightness = atmel_pwm_bl_get_intensity,
118 .update_status = atmel_pwm_bl_set_intensity, 119 .update_status = atmel_pwm_bl_set_intensity,
119}; 120};
120 121
121static int atmel_pwm_bl_probe(struct platform_device *pdev) 122static int atmel_pwm_bl_probe(struct platform_device *pdev)
122{ 123{
124 struct backlight_properties props;
123 const struct atmel_pwm_bl_platform_data *pdata; 125 const struct atmel_pwm_bl_platform_data *pdata;
124 struct backlight_device *bldev; 126 struct backlight_device *bldev;
125 struct atmel_pwm_bl *pwmbl; 127 struct atmel_pwm_bl *pwmbl;
@@ -158,15 +160,17 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
158 goto err_free_pwm; 160 goto err_free_pwm;
159 } 161 }
160 162
161 /* Turn display off by defatult. */ 163 /* Turn display off by default. */
162 retval = gpio_direction_output(pwmbl->gpio_on, 164 retval = gpio_direction_output(pwmbl->gpio_on,
163 0 ^ pdata->on_active_low); 165 0 ^ pdata->on_active_low);
164 if (retval) 166 if (retval)
165 goto err_free_gpio; 167 goto err_free_gpio;
166 } 168 }
167 169
168 bldev = backlight_device_register("atmel-pwm-bl", 170 memset(&props, 0, sizeof(struct backlight_properties));
169 &pdev->dev, pwmbl, &atmel_pwm_bl_ops); 171 props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
172 bldev = backlight_device_register("atmel-pwm-bl", &pdev->dev, pwmbl,
173 &atmel_pwm_bl_ops, &props);
170 if (IS_ERR(bldev)) { 174 if (IS_ERR(bldev)) {
171 retval = PTR_ERR(bldev); 175 retval = PTR_ERR(bldev);
172 goto err_free_gpio; 176 goto err_free_gpio;
@@ -178,7 +182,6 @@ static int atmel_pwm_bl_probe(struct platform_device *pdev)
178 182
179 /* Power up the backlight by default at middle intesity. */ 183 /* Power up the backlight by default at middle intesity. */
180 bldev->props.power = FB_BLANK_UNBLANK; 184 bldev->props.power = FB_BLANK_UNBLANK;
181 bldev->props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min;
182 bldev->props.brightness = bldev->props.max_brightness / 2; 185 bldev->props.brightness = bldev->props.max_brightness / 2;
183 186
184 retval = atmel_pwm_bl_init_pwm(pwmbl); 187 retval = atmel_pwm_bl_init_pwm(pwmbl);
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 6615ac7fa60a..e207810bba3c 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -13,6 +13,7 @@
13#include <linux/ctype.h> 13#include <linux/ctype.h>
14#include <linux/err.h> 14#include <linux/err.h>
15#include <linux/fb.h> 15#include <linux/fb.h>
16#include <linux/slab.h>
16 17
17#ifdef CONFIG_PMAC_BACKLIGHT 18#ifdef CONFIG_PMAC_BACKLIGHT
18#include <asm/backlight.h> 19#include <asm/backlight.h>
@@ -38,7 +39,7 @@ static int fb_notifier_callback(struct notifier_block *self,
38 mutex_lock(&bd->ops_lock); 39 mutex_lock(&bd->ops_lock);
39 if (bd->ops) 40 if (bd->ops)
40 if (!bd->ops->check_fb || 41 if (!bd->ops->check_fb ||
41 bd->ops->check_fb(evdata->info)) { 42 bd->ops->check_fb(bd, evdata->info)) {
42 bd->props.fb_blank = *(int *)evdata->data; 43 bd->props.fb_blank = *(int *)evdata->data;
43 if (bd->props.fb_blank == FB_BLANK_UNBLANK) 44 if (bd->props.fb_blank == FB_BLANK_UNBLANK)
44 bd->props.state &= ~BL_CORE_FBBLANK; 45 bd->props.state &= ~BL_CORE_FBBLANK;
@@ -269,7 +270,8 @@ EXPORT_SYMBOL(backlight_force_update);
269 * ERR_PTR() or a pointer to the newly allocated device. 270 * ERR_PTR() or a pointer to the newly allocated device.
270 */ 271 */
271struct backlight_device *backlight_device_register(const char *name, 272struct backlight_device *backlight_device_register(const char *name,
272 struct device *parent, void *devdata, struct backlight_ops *ops) 273 struct device *parent, void *devdata, const struct backlight_ops *ops,
274 const struct backlight_properties *props)
273{ 275{
274 struct backlight_device *new_bd; 276 struct backlight_device *new_bd;
275 int rc; 277 int rc;
@@ -289,6 +291,11 @@ struct backlight_device *backlight_device_register(const char *name,
289 dev_set_name(&new_bd->dev, name); 291 dev_set_name(&new_bd->dev, name);
290 dev_set_drvdata(&new_bd->dev, devdata); 292 dev_set_drvdata(&new_bd->dev, devdata);
291 293
294 /* Set default properties */
295 if (props)
296 memcpy(&new_bd->props, props,
297 sizeof(struct backlight_properties));
298
292 rc = device_register(&new_bd->dev); 299 rc = device_register(&new_bd->dev);
293 if (rc) { 300 if (rc) {
294 kfree(new_bd); 301 kfree(new_bd);
diff --git a/drivers/video/backlight/corgi_lcd.c b/drivers/video/backlight/corgi_lcd.c
index 96774949cd30..1e71c35083bb 100644
--- a/drivers/video/backlight/corgi_lcd.c
+++ b/drivers/video/backlight/corgi_lcd.c
@@ -24,6 +24,7 @@
24#include <linux/lcd.h> 24#include <linux/lcd.h>
25#include <linux/spi/spi.h> 25#include <linux/spi/spi.h>
26#include <linux/spi/corgi_lcd.h> 26#include <linux/spi/corgi_lcd.h>
27#include <linux/slab.h>
27#include <asm/mach/sharpsl_param.h> 28#include <asm/mach/sharpsl_param.h>
28 29
29#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL) 30#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL)
@@ -451,7 +452,7 @@ void corgi_lcd_limit_intensity(int limit)
451} 452}
452EXPORT_SYMBOL(corgi_lcd_limit_intensity); 453EXPORT_SYMBOL(corgi_lcd_limit_intensity);
453 454
454static struct backlight_ops corgi_bl_ops = { 455static const struct backlight_ops corgi_bl_ops = {
455 .get_brightness = corgi_bl_get_intensity, 456 .get_brightness = corgi_bl_get_intensity,
456 .update_status = corgi_bl_update_status, 457 .update_status = corgi_bl_update_status,
457}; 458};
@@ -533,6 +534,7 @@ err_free_backlight_on:
533 534
534static int __devinit corgi_lcd_probe(struct spi_device *spi) 535static int __devinit corgi_lcd_probe(struct spi_device *spi)
535{ 536{
537 struct backlight_properties props;
536 struct corgi_lcd_platform_data *pdata = spi->dev.platform_data; 538 struct corgi_lcd_platform_data *pdata = spi->dev.platform_data;
537 struct corgi_lcd *lcd; 539 struct corgi_lcd *lcd;
538 int ret = 0; 540 int ret = 0;
@@ -559,13 +561,14 @@ static int __devinit corgi_lcd_probe(struct spi_device *spi)
559 lcd->power = FB_BLANK_POWERDOWN; 561 lcd->power = FB_BLANK_POWERDOWN;
560 lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA; 562 lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA;
561 563
562 lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev, 564 memset(&props, 0, sizeof(struct backlight_properties));
563 lcd, &corgi_bl_ops); 565 props.max_brightness = pdata->max_intensity;
566 lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev, lcd,
567 &corgi_bl_ops, &props);
564 if (IS_ERR(lcd->bl_dev)) { 568 if (IS_ERR(lcd->bl_dev)) {
565 ret = PTR_ERR(lcd->bl_dev); 569 ret = PTR_ERR(lcd->bl_dev);
566 goto err_unregister_lcd; 570 goto err_unregister_lcd;
567 } 571 }
568 lcd->bl_dev->props.max_brightness = pdata->max_intensity;
569 lcd->bl_dev->props.brightness = pdata->default_intensity; 572 lcd->bl_dev->props.brightness = pdata->default_intensity;
570 lcd->bl_dev->props.power = FB_BLANK_UNBLANK; 573 lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
571 574
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
index b9fe62b475c6..a4f4546f0be0 100644
--- a/drivers/video/backlight/cr_bllcd.c
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -36,6 +36,7 @@
36#include <linux/backlight.h> 36#include <linux/backlight.h>
37#include <linux/lcd.h> 37#include <linux/lcd.h>
38#include <linux/pci.h> 38#include <linux/pci.h>
39#include <linux/slab.h>
39 40
40/* The LVDS- and panel power controls sits on the 41/* The LVDS- and panel power controls sits on the
41 * GPIO port of the ISA bridge. 42 * GPIO port of the ISA bridge.
@@ -108,7 +109,7 @@ static int cr_backlight_get_intensity(struct backlight_device *bd)
108 return intensity; 109 return intensity;
109} 110}
110 111
111static struct backlight_ops cr_backlight_ops = { 112static const struct backlight_ops cr_backlight_ops = {
112 .get_brightness = cr_backlight_get_intensity, 113 .get_brightness = cr_backlight_get_intensity,
113 .update_status = cr_backlight_set_intensity, 114 .update_status = cr_backlight_set_intensity,
114}; 115};
@@ -170,6 +171,7 @@ static struct lcd_ops cr_lcd_ops = {
170 171
171static int cr_backlight_probe(struct platform_device *pdev) 172static int cr_backlight_probe(struct platform_device *pdev)
172{ 173{
174 struct backlight_properties props;
173 struct backlight_device *bdp; 175 struct backlight_device *bdp;
174 struct lcd_device *ldp; 176 struct lcd_device *ldp;
175 struct cr_panel *crp; 177 struct cr_panel *crp;
@@ -190,8 +192,9 @@ static int cr_backlight_probe(struct platform_device *pdev)
190 return -ENODEV; 192 return -ENODEV;
191 } 193 }
192 194
193 bdp = backlight_device_register("cr-backlight", 195 memset(&props, 0, sizeof(struct backlight_properties));
194 &pdev->dev, NULL, &cr_backlight_ops); 196 bdp = backlight_device_register("cr-backlight", &pdev->dev, NULL,
197 &cr_backlight_ops, &props);
195 if (IS_ERR(bdp)) { 198 if (IS_ERR(bdp)) {
196 pci_dev_put(lpc_dev); 199 pci_dev_put(lpc_dev);
197 return PTR_ERR(bdp); 200 return PTR_ERR(bdp);
@@ -201,7 +204,7 @@ static int cr_backlight_probe(struct platform_device *pdev)
201 if (IS_ERR(ldp)) { 204 if (IS_ERR(ldp)) {
202 backlight_device_unregister(bdp); 205 backlight_device_unregister(bdp);
203 pci_dev_put(lpc_dev); 206 pci_dev_put(lpc_dev);
204 return PTR_ERR(bdp); 207 return PTR_ERR(ldp);
205 } 208 }
206 209
207 pci_read_config_dword(lpc_dev, CRVML_REG_GPIOBAR, 210 pci_read_config_dword(lpc_dev, CRVML_REG_GPIOBAR,
@@ -220,9 +223,7 @@ static int cr_backlight_probe(struct platform_device *pdev)
220 crp->cr_lcd_device = ldp; 223 crp->cr_lcd_device = ldp;
221 crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK; 224 crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK;
222 crp->cr_backlight_device->props.brightness = 0; 225 crp->cr_backlight_device->props.brightness = 0;
223 crp->cr_backlight_device->props.max_brightness = 0;
224 cr_backlight_set_intensity(crp->cr_backlight_device); 226 cr_backlight_set_intensity(crp->cr_backlight_device);
225
226 cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK); 227 cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK);
227 228
228 platform_set_drvdata(pdev, crp); 229 platform_set_drvdata(pdev, crp);
diff --git a/drivers/video/backlight/da903x_bl.c b/drivers/video/backlight/da903x_bl.c
index 701a1081e199..87659ed79bd7 100644
--- a/drivers/video/backlight/da903x_bl.c
+++ b/drivers/video/backlight/da903x_bl.c
@@ -18,6 +18,7 @@
18#include <linux/fb.h> 18#include <linux/fb.h>
19#include <linux/backlight.h> 19#include <linux/backlight.h>
20#include <linux/mfd/da903x.h> 20#include <linux/mfd/da903x.h>
21#include <linux/slab.h>
21 22
22#define DA9030_WLED_CONTROL 0x25 23#define DA9030_WLED_CONTROL 0x25
23#define DA9030_WLED_CP_EN (1 << 6) 24#define DA9030_WLED_CP_EN (1 << 6)
@@ -25,6 +26,7 @@
25 26
26#define DA9034_WLED_CONTROL1 0x3C 27#define DA9034_WLED_CONTROL1 0x3C
27#define DA9034_WLED_CONTROL2 0x3D 28#define DA9034_WLED_CONTROL2 0x3D
29#define DA9034_WLED_ISET(x) ((x) & 0x1f)
28 30
29#define DA9034_WLED_BOOST_EN (1 << 5) 31#define DA9034_WLED_BOOST_EN (1 << 5)
30 32
@@ -94,15 +96,17 @@ static int da903x_backlight_get_brightness(struct backlight_device *bl)
94 return data->current_brightness; 96 return data->current_brightness;
95} 97}
96 98
97static struct backlight_ops da903x_backlight_ops = { 99static const struct backlight_ops da903x_backlight_ops = {
98 .update_status = da903x_backlight_update_status, 100 .update_status = da903x_backlight_update_status,
99 .get_brightness = da903x_backlight_get_brightness, 101 .get_brightness = da903x_backlight_get_brightness,
100}; 102};
101 103
102static int da903x_backlight_probe(struct platform_device *pdev) 104static int da903x_backlight_probe(struct platform_device *pdev)
103{ 105{
106 struct da9034_backlight_pdata *pdata = pdev->dev.platform_data;
104 struct da903x_backlight_data *data; 107 struct da903x_backlight_data *data;
105 struct backlight_device *bl; 108 struct backlight_device *bl;
109 struct backlight_properties props;
106 int max_brightness; 110 int max_brightness;
107 111
108 data = kzalloc(sizeof(*data), GFP_KERNEL); 112 data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -127,15 +131,20 @@ static int da903x_backlight_probe(struct platform_device *pdev)
127 data->da903x_dev = pdev->dev.parent; 131 data->da903x_dev = pdev->dev.parent;
128 data->current_brightness = 0; 132 data->current_brightness = 0;
129 133
130 bl = backlight_device_register(pdev->name, data->da903x_dev, 134 /* adjust the WLED output current */
131 data, &da903x_backlight_ops); 135 if (pdata)
136 da903x_write(data->da903x_dev, DA9034_WLED_CONTROL2,
137 DA9034_WLED_ISET(pdata->output_current));
138
139 props.max_brightness = max_brightness;
140 bl = backlight_device_register(pdev->name, data->da903x_dev, data,
141 &da903x_backlight_ops, &props);
132 if (IS_ERR(bl)) { 142 if (IS_ERR(bl)) {
133 dev_err(&pdev->dev, "failed to register backlight\n"); 143 dev_err(&pdev->dev, "failed to register backlight\n");
134 kfree(data); 144 kfree(data);
135 return PTR_ERR(bl); 145 return PTR_ERR(bl);
136 } 146 }
137 147
138 bl->props.max_brightness = max_brightness;
139 bl->props.brightness = max_brightness; 148 bl->props.brightness = max_brightness;
140 149
141 platform_set_drvdata(pdev, bl); 150 platform_set_drvdata(pdev, bl);
@@ -170,7 +179,7 @@ static int da903x_backlight_resume(struct device *dev)
170 return 0; 179 return 0;
171} 180}
172 181
173static struct dev_pm_ops da903x_backlight_pm_ops = { 182static const struct dev_pm_ops da903x_backlight_pm_ops = {
174 .suspend = da903x_backlight_suspend, 183 .suspend = da903x_backlight_suspend,
175 .resume = da903x_backlight_resume, 184 .resume = da903x_backlight_resume,
176}; 185};
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
index 6d27f62fdcd0..312ca619735d 100644
--- a/drivers/video/backlight/generic_bl.c
+++ b/drivers/video/backlight/generic_bl.c
@@ -70,7 +70,7 @@ void corgibl_limit_intensity(int limit)
70} 70}
71EXPORT_SYMBOL(corgibl_limit_intensity); 71EXPORT_SYMBOL(corgibl_limit_intensity);
72 72
73static struct backlight_ops genericbl_ops = { 73static const struct backlight_ops genericbl_ops = {
74 .options = BL_CORE_SUSPENDRESUME, 74 .options = BL_CORE_SUSPENDRESUME,
75 .get_brightness = genericbl_get_intensity, 75 .get_brightness = genericbl_get_intensity,
76 .update_status = genericbl_send_intensity, 76 .update_status = genericbl_send_intensity,
@@ -78,6 +78,7 @@ static struct backlight_ops genericbl_ops = {
78 78
79static int genericbl_probe(struct platform_device *pdev) 79static int genericbl_probe(struct platform_device *pdev)
80{ 80{
81 struct backlight_properties props;
81 struct generic_bl_info *machinfo = pdev->dev.platform_data; 82 struct generic_bl_info *machinfo = pdev->dev.platform_data;
82 const char *name = "generic-bl"; 83 const char *name = "generic-bl";
83 struct backlight_device *bd; 84 struct backlight_device *bd;
@@ -89,14 +90,15 @@ static int genericbl_probe(struct platform_device *pdev)
89 if (machinfo->name) 90 if (machinfo->name)
90 name = machinfo->name; 91 name = machinfo->name;
91 92
92 bd = backlight_device_register (name, 93 memset(&props, 0, sizeof(struct backlight_properties));
93 &pdev->dev, NULL, &genericbl_ops); 94 props.max_brightness = machinfo->max_intensity;
95 bd = backlight_device_register(name, &pdev->dev, NULL, &genericbl_ops,
96 &props);
94 if (IS_ERR (bd)) 97 if (IS_ERR (bd))
95 return PTR_ERR (bd); 98 return PTR_ERR (bd);
96 99
97 platform_set_drvdata(pdev, bd); 100 platform_set_drvdata(pdev, bd);
98 101
99 bd->props.max_brightness = machinfo->max_intensity;
100 bd->props.power = FB_BLANK_UNBLANK; 102 bd->props.power = FB_BLANK_UNBLANK;
101 bd->props.brightness = machinfo->default_intensity; 103 bd->props.brightness = machinfo->default_intensity;
102 backlight_update_status(bd); 104 backlight_update_status(bd);
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index 7fb4eefff80d..267d23f8d645 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -98,23 +98,25 @@ static int hp680bl_get_intensity(struct backlight_device *bd)
98 return current_intensity; 98 return current_intensity;
99} 99}
100 100
101static struct backlight_ops hp680bl_ops = { 101static const struct backlight_ops hp680bl_ops = {
102 .get_brightness = hp680bl_get_intensity, 102 .get_brightness = hp680bl_get_intensity,
103 .update_status = hp680bl_set_intensity, 103 .update_status = hp680bl_set_intensity,
104}; 104};
105 105
106static int __devinit hp680bl_probe(struct platform_device *pdev) 106static int __devinit hp680bl_probe(struct platform_device *pdev)
107{ 107{
108 struct backlight_properties props;
108 struct backlight_device *bd; 109 struct backlight_device *bd;
109 110
110 bd = backlight_device_register ("hp680-bl", &pdev->dev, NULL, 111 memset(&props, 0, sizeof(struct backlight_properties));
111 &hp680bl_ops); 112 props.max_brightness = HP680_MAX_INTENSITY;
113 bd = backlight_device_register("hp680-bl", &pdev->dev, NULL,
114 &hp680bl_ops, &props);
112 if (IS_ERR(bd)) 115 if (IS_ERR(bd))
113 return PTR_ERR(bd); 116 return PTR_ERR(bd);
114 117
115 platform_set_drvdata(pdev, bd); 118 platform_set_drvdata(pdev, bd);
116 119
117 bd->props.max_brightness = HP680_MAX_INTENSITY;
118 bd->props.brightness = HP680_DEFAULT_INTENSITY; 120 bd->props.brightness = HP680_DEFAULT_INTENSITY;
119 hp680bl_send_intensity(bd); 121 hp680bl_send_intensity(bd);
120 122
diff --git a/drivers/video/backlight/ili9320.c b/drivers/video/backlight/ili9320.c
index ba89b41b639c..5118a9f029ab 100644
--- a/drivers/video/backlight/ili9320.c
+++ b/drivers/video/backlight/ili9320.c
@@ -17,6 +17,7 @@
17#include <linux/init.h> 17#include <linux/init.h>
18#include <linux/lcd.h> 18#include <linux/lcd.h>
19#include <linux/module.h> 19#include <linux/module.h>
20#include <linux/slab.h>
20 21
21#include <linux/spi/spi.h> 22#include <linux/spi/spi.h>
22 23
diff --git a/drivers/video/backlight/jornada720_bl.c b/drivers/video/backlight/jornada720_bl.c
index 7aed2565c1bd..2f177b3a4885 100644
--- a/drivers/video/backlight/jornada720_bl.c
+++ b/drivers/video/backlight/jornada720_bl.c
@@ -93,7 +93,7 @@ out:
93 return ret; 93 return ret;
94} 94}
95 95
96static struct backlight_ops jornada_bl_ops = { 96static const struct backlight_ops jornada_bl_ops = {
97 .get_brightness = jornada_bl_get_brightness, 97 .get_brightness = jornada_bl_get_brightness,
98 .update_status = jornada_bl_update_status, 98 .update_status = jornada_bl_update_status,
99 .options = BL_CORE_SUSPENDRESUME, 99 .options = BL_CORE_SUSPENDRESUME,
@@ -101,10 +101,14 @@ static struct backlight_ops jornada_bl_ops = {
101 101
102static int jornada_bl_probe(struct platform_device *pdev) 102static int jornada_bl_probe(struct platform_device *pdev)
103{ 103{
104 struct backlight_properties props;
104 int ret; 105 int ret;
105 struct backlight_device *bd; 106 struct backlight_device *bd;
106 107
107 bd = backlight_device_register(S1D_DEVICENAME, &pdev->dev, NULL, &jornada_bl_ops); 108 memset(&props, 0, sizeof(struct backlight_properties));
109 props.max_brightness = BL_MAX_BRIGHT;
110 bd = backlight_device_register(S1D_DEVICENAME, &pdev->dev, NULL,
111 &jornada_bl_ops, &props);
108 112
109 if (IS_ERR(bd)) { 113 if (IS_ERR(bd)) {
110 ret = PTR_ERR(bd); 114 ret = PTR_ERR(bd);
@@ -117,7 +121,6 @@ static int jornada_bl_probe(struct platform_device *pdev)
117 /* note. make sure max brightness is set otherwise 121 /* note. make sure max brightness is set otherwise
118 you will get seemingly non-related errors when 122 you will get seemingly non-related errors when
119 trying to change brightness */ 123 trying to change brightness */
120 bd->props.max_brightness = BL_MAX_BRIGHT;
121 jornada_bl_update_status(bd); 124 jornada_bl_update_status(bd);
122 125
123 platform_set_drvdata(pdev, bd); 126 platform_set_drvdata(pdev, bd);
diff --git a/drivers/video/backlight/kb3886_bl.c b/drivers/video/backlight/kb3886_bl.c
index a38fda1742dd..f439a8632287 100644
--- a/drivers/video/backlight/kb3886_bl.c
+++ b/drivers/video/backlight/kb3886_bl.c
@@ -134,27 +134,31 @@ static int kb3886bl_get_intensity(struct backlight_device *bd)
134 return kb3886bl_intensity; 134 return kb3886bl_intensity;
135} 135}
136 136
137static struct backlight_ops kb3886bl_ops = { 137static const struct backlight_ops kb3886bl_ops = {
138 .get_brightness = kb3886bl_get_intensity, 138 .get_brightness = kb3886bl_get_intensity,
139 .update_status = kb3886bl_send_intensity, 139 .update_status = kb3886bl_send_intensity,
140}; 140};
141 141
142static int kb3886bl_probe(struct platform_device *pdev) 142static int kb3886bl_probe(struct platform_device *pdev)
143{ 143{
144 struct backlight_properties props;
144 struct kb3886bl_machinfo *machinfo = pdev->dev.platform_data; 145 struct kb3886bl_machinfo *machinfo = pdev->dev.platform_data;
145 146
146 bl_machinfo = machinfo; 147 bl_machinfo = machinfo;
147 if (!machinfo->limit_mask) 148 if (!machinfo->limit_mask)
148 machinfo->limit_mask = -1; 149 machinfo->limit_mask = -1;
149 150
151 memset(&props, 0, sizeof(struct backlight_properties));
152 props.max_brightness = machinfo->max_intensity;
150 kb3886_backlight_device = backlight_device_register("kb3886-bl", 153 kb3886_backlight_device = backlight_device_register("kb3886-bl",
151 &pdev->dev, NULL, &kb3886bl_ops); 154 &pdev->dev, NULL,
155 &kb3886bl_ops,
156 &props);
152 if (IS_ERR(kb3886_backlight_device)) 157 if (IS_ERR(kb3886_backlight_device))
153 return PTR_ERR(kb3886_backlight_device); 158 return PTR_ERR(kb3886_backlight_device);
154 159
155 platform_set_drvdata(pdev, kb3886_backlight_device); 160 platform_set_drvdata(pdev, kb3886_backlight_device);
156 161
157 kb3886_backlight_device->props.max_brightness = machinfo->max_intensity;
158 kb3886_backlight_device->props.power = FB_BLANK_UNBLANK; 162 kb3886_backlight_device->props.power = FB_BLANK_UNBLANK;
159 kb3886_backlight_device->props.brightness = machinfo->default_intensity; 163 kb3886_backlight_device->props.brightness = machinfo->default_intensity;
160 backlight_update_status(kb3886_backlight_device); 164 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..bcdb12c93efd
--- /dev/null
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -0,0 +1,258 @@
1/*
2 * l4f00242t03.c -- support for Epson L4F00242T03 LCD
3 *
4 * Copyright 2007-2009 Freescale Semiconductor, Inc. All Rights Reserved.
5 *
6 * Copyright (c) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
7 * Inspired by Marek Vasut work in l4f00242t03.c
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/device.h>
15#include <linux/kernel.h>
16#include <linux/delay.h>
17#include <linux/gpio.h>
18#include <linux/lcd.h>
19#include <linux/slab.h>
20#include <linux/regulator/consumer.h>
21
22#include <linux/spi/spi.h>
23#include <linux/spi/l4f00242t03.h>
24
25struct l4f00242t03_priv {
26 struct spi_device *spi;
27 struct lcd_device *ld;
28 int lcd_on:1;
29 struct regulator *io_reg;
30 struct regulator *core_reg;
31};
32
33
34static void l4f00242t03_reset(unsigned int gpio)
35{
36 pr_debug("l4f00242t03_reset.\n");
37 gpio_set_value(gpio, 1);
38 mdelay(100);
39 gpio_set_value(gpio, 0);
40 mdelay(10); /* tRES >= 100us */
41 gpio_set_value(gpio, 1);
42 mdelay(20);
43}
44
45#define param(x) ((x) | 0x100)
46
47static void l4f00242t03_lcd_init(struct spi_device *spi)
48{
49 struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
50 struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
51 const u16 cmd[] = { 0x36, param(0), 0x3A, param(0x60) };
52
53 dev_dbg(&spi->dev, "initializing LCD\n");
54
55 if (priv->io_reg) {
56 regulator_set_voltage(priv->io_reg, 1800000, 1800000);
57 regulator_enable(priv->io_reg);
58 }
59
60 if (priv->core_reg) {
61 regulator_set_voltage(priv->core_reg, 2800000, 2800000);
62 regulator_enable(priv->core_reg);
63 }
64
65 gpio_set_value(pdata->data_enable_gpio, 1);
66 msleep(60);
67 spi_write(spi, (const u8 *)cmd, ARRAY_SIZE(cmd) * sizeof(u16));
68}
69
70static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
71{
72 struct l4f00242t03_priv *priv = lcd_get_data(ld);
73 struct spi_device *spi = priv->spi;
74
75 const u16 slpout = 0x11;
76 const u16 dison = 0x29;
77
78 const u16 slpin = 0x10;
79 const u16 disoff = 0x28;
80
81 if (power) {
82 if (priv->lcd_on)
83 return 0;
84
85 dev_dbg(&spi->dev, "turning on LCD\n");
86
87 spi_write(spi, (const u8 *)&slpout, sizeof(u16));
88 msleep(60);
89 spi_write(spi, (const u8 *)&dison, sizeof(u16));
90
91 priv->lcd_on = 1;
92 } else {
93 if (!priv->lcd_on)
94 return 0;
95
96 dev_dbg(&spi->dev, "turning off LCD\n");
97
98 spi_write(spi, (const u8 *)&disoff, sizeof(u16));
99 msleep(60);
100 spi_write(spi, (const u8 *)&slpin, sizeof(u16));
101
102 priv->lcd_on = 0;
103 }
104
105 return 0;
106}
107
108static struct lcd_ops l4f_ops = {
109 .set_power = l4f00242t03_lcd_power_set,
110 .get_power = NULL,
111};
112
113static int __devinit l4f00242t03_probe(struct spi_device *spi)
114{
115 struct l4f00242t03_priv *priv;
116 struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
117 int ret;
118
119 if (pdata == NULL) {
120 dev_err(&spi->dev, "Uninitialized platform data.\n");
121 return -EINVAL;
122 }
123
124 priv = kzalloc(sizeof(struct l4f00242t03_priv), GFP_KERNEL);
125
126 if (priv == NULL) {
127 dev_err(&spi->dev, "No memory for this device.\n");
128 ret = -ENOMEM;
129 goto err;
130 }
131
132 dev_set_drvdata(&spi->dev, priv);
133 spi->bits_per_word = 9;
134 spi_setup(spi);
135
136 priv->spi = spi;
137
138 ret = gpio_request(pdata->reset_gpio, "lcd l4f00242t03 reset");
139 if (ret) {
140 dev_err(&spi->dev,
141 "Unable to get the lcd l4f00242t03 reset gpio.\n");
142 return ret;
143 }
144
145 ret = gpio_direction_output(pdata->reset_gpio, 1);
146 if (ret)
147 goto err2;
148
149 ret = gpio_request(pdata->data_enable_gpio,
150 "lcd l4f00242t03 data enable");
151 if (ret) {
152 dev_err(&spi->dev,
153 "Unable to get the lcd l4f00242t03 data en gpio.\n");
154 return ret;
155 }
156
157 ret = gpio_direction_output(pdata->data_enable_gpio, 0);
158 if (ret)
159 goto err3;
160
161 if (pdata->io_supply) {
162 priv->io_reg = regulator_get(NULL, pdata->io_supply);
163
164 if (IS_ERR(priv->io_reg)) {
165 pr_err("%s: Unable to get the IO regulator\n",
166 __func__);
167 goto err3;
168 }
169 }
170
171 if (pdata->core_supply) {
172 priv->core_reg = regulator_get(NULL, pdata->core_supply);
173
174 if (IS_ERR(priv->core_reg)) {
175 pr_err("%s: Unable to get the core regulator\n",
176 __func__);
177 goto err4;
178 }
179 }
180
181 priv->ld = lcd_device_register("l4f00242t03",
182 &spi->dev, priv, &l4f_ops);
183 if (IS_ERR(priv->ld)) {
184 ret = PTR_ERR(priv->ld);
185 goto err5;
186 }
187
188 /* Init the LCD */
189 l4f00242t03_reset(pdata->reset_gpio);
190 l4f00242t03_lcd_init(spi);
191 l4f00242t03_lcd_power_set(priv->ld, 1);
192
193 dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");
194
195 return 0;
196
197err5:
198 if (priv->core_reg)
199 regulator_put(priv->core_reg);
200err4:
201 if (priv->io_reg)
202 regulator_put(priv->io_reg);
203err3:
204 gpio_free(pdata->data_enable_gpio);
205err2:
206 gpio_free(pdata->reset_gpio);
207err:
208 kfree(priv);
209
210 return ret;
211}
212
213static int __devexit l4f00242t03_remove(struct spi_device *spi)
214{
215 struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
216 struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
217
218 l4f00242t03_lcd_power_set(priv->ld, 0);
219 lcd_device_unregister(priv->ld);
220
221 gpio_free(pdata->data_enable_gpio);
222 gpio_free(pdata->reset_gpio);
223
224 if (priv->io_reg)
225 regulator_put(priv->core_reg);
226 if (priv->core_reg)
227 regulator_put(priv->io_reg);
228
229 kfree(priv);
230
231 return 0;
232}
233
234static struct spi_driver l4f00242t03_driver = {
235 .driver = {
236 .name = "l4f00242t03",
237 .owner = THIS_MODULE,
238 },
239 .probe = l4f00242t03_probe,
240 .remove = __devexit_p(l4f00242t03_remove),
241};
242
243static __init int l4f00242t03_init(void)
244{
245 return spi_register_driver(&l4f00242t03_driver);
246}
247
248static __exit void l4f00242t03_exit(void)
249{
250 spi_unregister_driver(&l4f00242t03_driver);
251}
252
253module_init(l4f00242t03_init);
254module_exit(l4f00242t03_exit);
255
256MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
257MODULE_DESCRIPTION("EPSON L4F00242T03 LCD");
258MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c
index a482dd7b0311..71a11cadffc4 100644
--- a/drivers/video/backlight/lcd.c
+++ b/drivers/video/backlight/lcd.c
@@ -13,6 +13,7 @@
13#include <linux/ctype.h> 13#include <linux/ctype.h>
14#include <linux/err.h> 14#include <linux/err.h>
15#include <linux/fb.h> 15#include <linux/fb.h>
16#include <linux/slab.h>
16 17
17#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \ 18#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
18 defined(CONFIG_LCD_CLASS_DEVICE_MODULE)) 19 defined(CONFIG_LCD_CLASS_DEVICE_MODULE))
@@ -101,7 +102,7 @@ static ssize_t lcd_store_power(struct device *dev,
101 int power = simple_strtoul(buf, &endp, 0); 102 int power = simple_strtoul(buf, &endp, 0);
102 size_t size = endp - buf; 103 size_t size = endp - buf;
103 104
104 if (*endp && isspace(*endp)) 105 if (isspace(*endp))
105 size++; 106 size++;
106 if (size != count) 107 if (size != count)
107 return -EINVAL; 108 return -EINVAL;
@@ -140,7 +141,7 @@ static ssize_t lcd_store_contrast(struct device *dev,
140 int contrast = simple_strtoul(buf, &endp, 0); 141 int contrast = simple_strtoul(buf, &endp, 0);
141 size_t size = endp - buf; 142 size_t size = endp - buf;
142 143
143 if (*endp && isspace(*endp)) 144 if (isspace(*endp))
144 size++; 145 size++;
145 if (size != count) 146 if (size != count)
146 return -EINVAL; 147 return -EINVAL;
diff --git a/drivers/video/backlight/lms283gf05.c b/drivers/video/backlight/lms283gf05.c
index 447b542a20ca..abc43a0eb97d 100644
--- a/drivers/video/backlight/lms283gf05.c
+++ b/drivers/video/backlight/lms283gf05.c
@@ -11,6 +11,7 @@
11#include <linux/device.h> 11#include <linux/device.h>
12#include <linux/kernel.h> 12#include <linux/kernel.h>
13#include <linux/delay.h> 13#include <linux/delay.h>
14#include <linux/slab.h>
14#include <linux/gpio.h> 15#include <linux/gpio.h>
15#include <linux/lcd.h> 16#include <linux/lcd.h>
16 17
diff --git a/drivers/video/backlight/locomolcd.c b/drivers/video/backlight/locomolcd.c
index 6b488b8a7eee..7571bc26071e 100644
--- a/drivers/video/backlight/locomolcd.c
+++ b/drivers/video/backlight/locomolcd.c
@@ -141,7 +141,7 @@ static int locomolcd_get_intensity(struct backlight_device *bd)
141 return current_intensity; 141 return current_intensity;
142} 142}
143 143
144static struct backlight_ops locomobl_data = { 144static const struct backlight_ops locomobl_data = {
145 .get_brightness = locomolcd_get_intensity, 145 .get_brightness = locomolcd_get_intensity,
146 .update_status = locomolcd_set_intensity, 146 .update_status = locomolcd_set_intensity,
147}; 147};
@@ -167,6 +167,7 @@ static int locomolcd_resume(struct locomo_dev *dev)
167 167
168static int locomolcd_probe(struct locomo_dev *ldev) 168static int locomolcd_probe(struct locomo_dev *ldev)
169{ 169{
170 struct backlight_properties props;
170 unsigned long flags; 171 unsigned long flags;
171 172
172 local_irq_save(flags); 173 local_irq_save(flags);
@@ -182,13 +183,16 @@ static int locomolcd_probe(struct locomo_dev *ldev)
182 183
183 local_irq_restore(flags); 184 local_irq_restore(flags);
184 185
185 locomolcd_bl_device = backlight_device_register("locomo-bl", &ldev->dev, NULL, &locomobl_data); 186 memset(&props, 0, sizeof(struct backlight_properties));
187 props.max_brightness = 4;
188 locomolcd_bl_device = backlight_device_register("locomo-bl",
189 &ldev->dev, NULL,
190 &locomobl_data, &props);
186 191
187 if (IS_ERR (locomolcd_bl_device)) 192 if (IS_ERR (locomolcd_bl_device))
188 return PTR_ERR (locomolcd_bl_device); 193 return PTR_ERR (locomolcd_bl_device);
189 194
190 /* Set up frontlight so that screen is readable */ 195 /* Set up frontlight so that screen is readable */
191 locomolcd_bl_device->props.max_brightness = 4,
192 locomolcd_bl_device->props.brightness = 2; 196 locomolcd_bl_device->props.brightness = 2;
193 locomolcd_set_intensity(locomolcd_bl_device); 197 locomolcd_set_intensity(locomolcd_bl_device);
194 198
diff --git a/drivers/video/backlight/ltv350qv.c b/drivers/video/backlight/ltv350qv.c
index 4631ca8fa4a4..8010aaeb5adb 100644
--- a/drivers/video/backlight/ltv350qv.c
+++ b/drivers/video/backlight/ltv350qv.c
@@ -13,6 +13,7 @@
13#include <linux/init.h> 13#include <linux/init.h>
14#include <linux/lcd.h> 14#include <linux/lcd.h>
15#include <linux/module.h> 15#include <linux/module.h>
16#include <linux/slab.h>
16#include <linux/spi/spi.h> 17#include <linux/spi/spi.h>
17 18
18#include "ltv350qv.h" 19#include "ltv350qv.h"
diff --git a/drivers/video/backlight/max8925_bl.c b/drivers/video/backlight/max8925_bl.c
new file mode 100644
index 000000000000..b5accc957ad3
--- /dev/null
+++ b/drivers/video/backlight/max8925_bl.c
@@ -0,0 +1,203 @@
1/*
2 * Backlight driver for Maxim MAX8925
3 *
4 * Copyright (C) 2009 Marvell International Ltd.
5 * Haojian Zhuang <haojian.zhuang@marvell.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/init.h>
13#include <linux/kernel.h>
14#include <linux/platform_device.h>
15#include <linux/fb.h>
16#include <linux/i2c.h>
17#include <linux/backlight.h>
18#include <linux/mfd/max8925.h>
19#include <linux/slab.h>
20
21#define MAX_BRIGHTNESS (0xff)
22#define MIN_BRIGHTNESS (0)
23
24#define LWX_FREQ(x) (((x - 601) / 100) & 0x7)
25
26struct max8925_backlight_data {
27 struct max8925_chip *chip;
28
29 int current_brightness;
30};
31
32static int max8925_backlight_set(struct backlight_device *bl, int brightness)
33{
34 struct max8925_backlight_data *data = bl_get_data(bl);
35 struct max8925_chip *chip = data->chip;
36 unsigned char value;
37 int ret;
38
39 if (brightness > MAX_BRIGHTNESS)
40 value = MAX_BRIGHTNESS;
41 else
42 value = brightness;
43
44 ret = max8925_reg_write(chip->i2c, MAX8925_WLED_CNTL, value);
45 if (ret < 0)
46 goto out;
47
48 if (!data->current_brightness && brightness)
49 /* enable WLED output */
50 ret = max8925_set_bits(chip->i2c, MAX8925_WLED_MODE_CNTL, 1, 1);
51 else if (!brightness)
52 /* disable WLED output */
53 ret = max8925_set_bits(chip->i2c, MAX8925_WLED_MODE_CNTL, 1, 0);
54 if (ret < 0)
55 goto out;
56 dev_dbg(chip->dev, "set brightness %d\n", value);
57 data->current_brightness = value;
58 return 0;
59out:
60 dev_dbg(chip->dev, "set brightness %d failure with return value:%d\n",
61 value, ret);
62 return ret;
63}
64
65static int max8925_backlight_update_status(struct backlight_device *bl)
66{
67 int brightness = bl->props.brightness;
68
69 if (bl->props.power != FB_BLANK_UNBLANK)
70 brightness = 0;
71
72 if (bl->props.fb_blank != FB_BLANK_UNBLANK)
73 brightness = 0;
74
75 if (bl->props.state & BL_CORE_SUSPENDED)
76 brightness = 0;
77
78 return max8925_backlight_set(bl, brightness);
79}
80
81static int max8925_backlight_get_brightness(struct backlight_device *bl)
82{
83 struct max8925_backlight_data *data = bl_get_data(bl);
84 struct max8925_chip *chip = data->chip;
85 int ret;
86
87 ret = max8925_reg_read(chip->i2c, MAX8925_WLED_CNTL);
88 if (ret < 0)
89 return -EINVAL;
90 data->current_brightness = ret;
91 dev_dbg(chip->dev, "get brightness %d\n", data->current_brightness);
92 return ret;
93}
94
95static struct backlight_ops max8925_backlight_ops = {
96 .options = BL_CORE_SUSPENDRESUME,
97 .update_status = max8925_backlight_update_status,
98 .get_brightness = max8925_backlight_get_brightness,
99};
100
101static int __devinit max8925_backlight_probe(struct platform_device *pdev)
102{
103 struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
104 struct max8925_platform_data *max8925_pdata;
105 struct max8925_backlight_pdata *pdata = NULL;
106 struct max8925_backlight_data *data;
107 struct backlight_device *bl;
108 struct backlight_properties props;
109 struct resource *res;
110 char name[MAX8925_NAME_SIZE];
111 unsigned char value;
112 int ret;
113
114 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
115 if (res == NULL) {
116 dev_err(&pdev->dev, "No I/O resource!\n");
117 return -EINVAL;
118 }
119
120 if (pdev->dev.parent->platform_data) {
121 max8925_pdata = pdev->dev.parent->platform_data;
122 pdata = max8925_pdata->backlight;
123 }
124
125 if (!pdata) {
126 dev_err(&pdev->dev, "platform data isn't assigned to "
127 "backlight\n");
128 return -EINVAL;
129 }
130
131 data = kzalloc(sizeof(struct max8925_backlight_data), GFP_KERNEL);
132 if (data == NULL)
133 return -ENOMEM;
134 strncpy(name, res->name, MAX8925_NAME_SIZE);
135 data->chip = chip;
136 data->current_brightness = 0;
137
138 memset(&props, 0, sizeof(struct backlight_properties));
139 props.max_brightness = MAX_BRIGHTNESS;
140 bl = backlight_device_register(name, &pdev->dev, data,
141 &max8925_backlight_ops, &props);
142 if (IS_ERR(bl)) {
143 dev_err(&pdev->dev, "failed to register backlight\n");
144 kfree(data);
145 return PTR_ERR(bl);
146 }
147 bl->props.brightness = MAX_BRIGHTNESS;
148
149 platform_set_drvdata(pdev, bl);
150
151 value = 0;
152 if (pdata->lxw_scl)
153 value |= (1 << 7);
154 if (pdata->lxw_freq)
155 value |= (LWX_FREQ(pdata->lxw_freq) << 4);
156 if (pdata->dual_string)
157 value |= (1 << 1);
158 ret = max8925_set_bits(chip->i2c, MAX8925_WLED_MODE_CNTL, 0xfe, value);
159 if (ret < 0)
160 goto out;
161
162 backlight_update_status(bl);
163 return 0;
164out:
165 kfree(data);
166 return ret;
167}
168
169static int __devexit max8925_backlight_remove(struct platform_device *pdev)
170{
171 struct backlight_device *bl = platform_get_drvdata(pdev);
172 struct max8925_backlight_data *data = bl_get_data(bl);
173
174 backlight_device_unregister(bl);
175 kfree(data);
176 return 0;
177}
178
179static struct platform_driver max8925_backlight_driver = {
180 .driver = {
181 .name = "max8925-backlight",
182 .owner = THIS_MODULE,
183 },
184 .probe = max8925_backlight_probe,
185 .remove = __devexit_p(max8925_backlight_remove),
186};
187
188static int __init max8925_backlight_init(void)
189{
190 return platform_driver_register(&max8925_backlight_driver);
191}
192module_init(max8925_backlight_init);
193
194static void __exit max8925_backlight_exit(void)
195{
196 platform_driver_unregister(&max8925_backlight_driver);
197};
198module_exit(max8925_backlight_exit);
199
200MODULE_DESCRIPTION("Backlight Driver for Maxim MAX8925");
201MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
202MODULE_LICENSE("GPL");
203MODULE_ALIAS("platform:max8925-backlight");
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
index 9edb8d7c295f..1b5d3fe6bbbc 100644
--- a/drivers/video/backlight/mbp_nvidia_bl.c
+++ b/drivers/video/backlight/mbp_nvidia_bl.c
@@ -33,7 +33,7 @@ struct dmi_match_data {
33 unsigned long iostart; 33 unsigned long iostart;
34 unsigned long iolen; 34 unsigned long iolen;
35 /* Backlight operations structure. */ 35 /* Backlight operations structure. */
36 struct backlight_ops backlight_ops; 36 const struct backlight_ops backlight_ops;
37}; 37};
38 38
39/* Module parameters. */ 39/* Module parameters. */
@@ -139,6 +139,51 @@ static int mbp_dmi_match(const struct dmi_system_id *id)
139static const struct dmi_system_id __initdata mbp_device_table[] = { 139static const struct dmi_system_id __initdata mbp_device_table[] = {
140 { 140 {
141 .callback = mbp_dmi_match, 141 .callback = mbp_dmi_match,
142 .ident = "MacBook 1,1",
143 .matches = {
144 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
145 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"),
146 },
147 .driver_data = (void *)&intel_chipset_data,
148 },
149 {
150 .callback = mbp_dmi_match,
151 .ident = "MacBook 2,1",
152 .matches = {
153 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
154 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook2,1"),
155 },
156 .driver_data = (void *)&intel_chipset_data,
157 },
158 {
159 .callback = mbp_dmi_match,
160 .ident = "MacBook 3,1",
161 .matches = {
162 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
163 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook3,1"),
164 },
165 .driver_data = (void *)&intel_chipset_data,
166 },
167 {
168 .callback = mbp_dmi_match,
169 .ident = "MacBook 4,1",
170 .matches = {
171 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
172 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,1"),
173 },
174 .driver_data = (void *)&intel_chipset_data,
175 },
176 {
177 .callback = mbp_dmi_match,
178 .ident = "MacBook 4,2",
179 .matches = {
180 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
181 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4,2"),
182 },
183 .driver_data = (void *)&intel_chipset_data,
184 },
185 {
186 .callback = mbp_dmi_match,
142 .ident = "MacBookPro 3,1", 187 .ident = "MacBookPro 3,1",
143 .matches = { 188 .matches = {
144 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 189 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
@@ -220,6 +265,24 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
220 }, 265 },
221 { 266 {
222 .callback = mbp_dmi_match, 267 .callback = mbp_dmi_match,
268 .ident = "MacBookPro 5,3",
269 .matches = {
270 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
271 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,3"),
272 },
273 .driver_data = (void *)&nvidia_chipset_data,
274 },
275 {
276 .callback = mbp_dmi_match,
277 .ident = "MacBookPro 5,4",
278 .matches = {
279 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
280 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,4"),
281 },
282 .driver_data = (void *)&nvidia_chipset_data,
283 },
284 {
285 .callback = mbp_dmi_match,
223 .ident = "MacBookPro 5,5", 286 .ident = "MacBookPro 5,5",
224 .matches = { 287 .matches = {
225 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 288 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
@@ -232,6 +295,7 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
232 295
233static int __init mbp_init(void) 296static int __init mbp_init(void)
234{ 297{
298 struct backlight_properties props;
235 if (!dmi_check_system(mbp_device_table)) 299 if (!dmi_check_system(mbp_device_table))
236 return -ENODEV; 300 return -ENODEV;
237 301
@@ -239,14 +303,17 @@ static int __init mbp_init(void)
239 "Macbook Pro backlight")) 303 "Macbook Pro backlight"))
240 return -ENXIO; 304 return -ENXIO;
241 305
242 mbp_backlight_device = backlight_device_register("mbp_backlight", 306 memset(&props, 0, sizeof(struct backlight_properties));
243 NULL, NULL, &driver_data->backlight_ops); 307 props.max_brightness = 15;
308 mbp_backlight_device = backlight_device_register("mbp_backlight", NULL,
309 NULL,
310 &driver_data->backlight_ops,
311 &props);
244 if (IS_ERR(mbp_backlight_device)) { 312 if (IS_ERR(mbp_backlight_device)) {
245 release_region(driver_data->iostart, driver_data->iolen); 313 release_region(driver_data->iostart, driver_data->iolen);
246 return PTR_ERR(mbp_backlight_device); 314 return PTR_ERR(mbp_backlight_device);
247 } 315 }
248 316
249 mbp_backlight_device->props.max_brightness = 15;
250 mbp_backlight_device->props.brightness = 317 mbp_backlight_device->props.brightness =
251 driver_data->backlight_ops.get_brightness(mbp_backlight_device); 318 driver_data->backlight_ops.get_brightness(mbp_backlight_device);
252 backlight_update_status(mbp_backlight_device); 319 backlight_update_status(mbp_backlight_device);
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index cbad67e89826..d3bc56296c8d 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -24,10 +24,11 @@
24#include <linux/platform_device.h> 24#include <linux/platform_device.h>
25#include <linux/fb.h> 25#include <linux/fb.h>
26#include <linux/backlight.h> 26#include <linux/backlight.h>
27#include <linux/slab.h>
27 28
28#include <mach/hardware.h> 29#include <mach/hardware.h>
29#include <mach/board.h> 30#include <plat/board.h>
30#include <mach/mux.h> 31#include <plat/mux.h>
31 32
32#define OMAPBL_MAX_INTENSITY 0xff 33#define OMAPBL_MAX_INTENSITY 0xff
33 34
@@ -125,13 +126,14 @@ static int omapbl_get_intensity(struct backlight_device *dev)
125 return bl->current_intensity; 126 return bl->current_intensity;
126} 127}
127 128
128static struct backlight_ops omapbl_ops = { 129static const struct backlight_ops omapbl_ops = {
129 .get_brightness = omapbl_get_intensity, 130 .get_brightness = omapbl_get_intensity,
130 .update_status = omapbl_update_status, 131 .update_status = omapbl_update_status,
131}; 132};
132 133
133static int omapbl_probe(struct platform_device *pdev) 134static int omapbl_probe(struct platform_device *pdev)
134{ 135{
136 struct backlight_properties props;
135 struct backlight_device *dev; 137 struct backlight_device *dev;
136 struct omap_backlight *bl; 138 struct omap_backlight *bl;
137 struct omap_backlight_config *pdata = pdev->dev.platform_data; 139 struct omap_backlight_config *pdata = pdev->dev.platform_data;
@@ -139,13 +141,14 @@ static int omapbl_probe(struct platform_device *pdev)
139 if (!pdata) 141 if (!pdata)
140 return -ENXIO; 142 return -ENXIO;
141 143
142 omapbl_ops.check_fb = pdata->check_fb;
143
144 bl = kzalloc(sizeof(struct omap_backlight), GFP_KERNEL); 144 bl = kzalloc(sizeof(struct omap_backlight), GFP_KERNEL);
145 if (unlikely(!bl)) 145 if (unlikely(!bl))
146 return -ENOMEM; 146 return -ENOMEM;
147 147
148 dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops); 148 memset(&props, 0, sizeof(struct backlight_properties));
149 props.max_brightness = OMAPBL_MAX_INTENSITY;
150 dev = backlight_device_register("omap-bl", &pdev->dev, bl, &omapbl_ops,
151 &props);
149 if (IS_ERR(dev)) { 152 if (IS_ERR(dev)) {
150 kfree(bl); 153 kfree(bl);
151 return PTR_ERR(dev); 154 return PTR_ERR(dev);
@@ -162,7 +165,6 @@ static int omapbl_probe(struct platform_device *pdev)
162 omap_cfg_reg(PWL); /* Conflicts with UART3 */ 165 omap_cfg_reg(PWL); /* Conflicts with UART3 */
163 166
164 dev->props.fb_blank = FB_BLANK_UNBLANK; 167 dev->props.fb_blank = FB_BLANK_UNBLANK;
165 dev->props.max_brightness = OMAPBL_MAX_INTENSITY;
166 dev->props.brightness = pdata->default_intensity; 168 dev->props.brightness = pdata->default_intensity;
167 omapbl_update_status(dev); 169 omapbl_update_status(dev);
168 170
diff --git a/drivers/video/backlight/platform_lcd.c b/drivers/video/backlight/platform_lcd.c
index 738694d23889..302330acf628 100644
--- a/drivers/video/backlight/platform_lcd.c
+++ b/drivers/video/backlight/platform_lcd.c
@@ -16,6 +16,7 @@
16#include <linux/fb.h> 16#include <linux/fb.h>
17#include <linux/backlight.h> 17#include <linux/backlight.h>
18#include <linux/lcd.h> 18#include <linux/lcd.h>
19#include <linux/slab.h>
19 20
20#include <video/platform_lcd.h> 21#include <video/platform_lcd.h>
21 22
diff --git a/drivers/video/backlight/progear_bl.c b/drivers/video/backlight/progear_bl.c
index 9edaf24fd82d..809278c90738 100644
--- a/drivers/video/backlight/progear_bl.c
+++ b/drivers/video/backlight/progear_bl.c
@@ -54,15 +54,17 @@ static int progearbl_get_intensity(struct backlight_device *bd)
54 return intensity - HW_LEVEL_MIN; 54 return intensity - HW_LEVEL_MIN;
55} 55}
56 56
57static struct backlight_ops progearbl_ops = { 57static const struct backlight_ops progearbl_ops = {
58 .get_brightness = progearbl_get_intensity, 58 .get_brightness = progearbl_get_intensity,
59 .update_status = progearbl_set_intensity, 59 .update_status = progearbl_set_intensity,
60}; 60};
61 61
62static int progearbl_probe(struct platform_device *pdev) 62static int progearbl_probe(struct platform_device *pdev)
63{ 63{
64 struct backlight_properties props;
64 u8 temp; 65 u8 temp;
65 struct backlight_device *progear_backlight_device; 66 struct backlight_device *progear_backlight_device;
67 int ret;
66 68
67 pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL); 69 pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL);
68 if (!pmu_dev) { 70 if (!pmu_dev) {
@@ -73,28 +75,37 @@ static int progearbl_probe(struct platform_device *pdev)
73 sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL); 75 sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
74 if (!sb_dev) { 76 if (!sb_dev) {
75 printk("ALI 1533 SB not found.\n"); 77 printk("ALI 1533 SB not found.\n");
76 pci_dev_put(pmu_dev); 78 ret = -ENODEV;
77 return -ENODEV; 79 goto put_pmu;
78 } 80 }
79 81
80 /* Set SB_MPS1 to enable brightness control. */ 82 /* Set SB_MPS1 to enable brightness control. */
81 pci_read_config_byte(sb_dev, SB_MPS1, &temp); 83 pci_read_config_byte(sb_dev, SB_MPS1, &temp);
82 pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20); 84 pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20);
83 85
86 memset(&props, 0, sizeof(struct backlight_properties));
87 props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
84 progear_backlight_device = backlight_device_register("progear-bl", 88 progear_backlight_device = backlight_device_register("progear-bl",
85 &pdev->dev, NULL, 89 &pdev->dev, NULL,
86 &progearbl_ops); 90 &progearbl_ops,
87 if (IS_ERR(progear_backlight_device)) 91 &props);
88 return PTR_ERR(progear_backlight_device); 92 if (IS_ERR(progear_backlight_device)) {
93 ret = PTR_ERR(progear_backlight_device);
94 goto put_sb;
95 }
89 96
90 platform_set_drvdata(pdev, progear_backlight_device); 97 platform_set_drvdata(pdev, progear_backlight_device);
91 98
92 progear_backlight_device->props.power = FB_BLANK_UNBLANK; 99 progear_backlight_device->props.power = FB_BLANK_UNBLANK;
93 progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN; 100 progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
94 progear_backlight_device->props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
95 progearbl_set_intensity(progear_backlight_device); 101 progearbl_set_intensity(progear_backlight_device);
96 102
97 return 0; 103 return 0;
104put_sb:
105 pci_dev_put(sb_dev);
106put_pmu:
107 pci_dev_put(pmu_dev);
108 return ret;
98} 109}
99 110
100static int progearbl_remove(struct platform_device *pdev) 111static int progearbl_remove(struct platform_device *pdev)
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index 887166267443..550443518891 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -19,11 +19,14 @@
19#include <linux/err.h> 19#include <linux/err.h>
20#include <linux/pwm.h> 20#include <linux/pwm.h>
21#include <linux/pwm_backlight.h> 21#include <linux/pwm_backlight.h>
22#include <linux/slab.h>
22 23
23struct pwm_bl_data { 24struct pwm_bl_data {
24 struct pwm_device *pwm; 25 struct pwm_device *pwm;
26 struct device *dev;
25 unsigned int period; 27 unsigned int period;
26 int (*notify)(int brightness); 28 int (*notify)(struct device *,
29 int brightness);
27}; 30};
28 31
29static int pwm_backlight_update_status(struct backlight_device *bl) 32static int pwm_backlight_update_status(struct backlight_device *bl)
@@ -39,7 +42,7 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
39 brightness = 0; 42 brightness = 0;
40 43
41 if (pb->notify) 44 if (pb->notify)
42 brightness = pb->notify(brightness); 45 brightness = pb->notify(pb->dev, brightness);
43 46
44 if (brightness == 0) { 47 if (brightness == 0) {
45 pwm_config(pb->pwm, 0, pb->period); 48 pwm_config(pb->pwm, 0, pb->period);
@@ -56,13 +59,14 @@ static int pwm_backlight_get_brightness(struct backlight_device *bl)
56 return bl->props.brightness; 59 return bl->props.brightness;
57} 60}
58 61
59static struct backlight_ops pwm_backlight_ops = { 62static const struct backlight_ops pwm_backlight_ops = {
60 .update_status = pwm_backlight_update_status, 63 .update_status = pwm_backlight_update_status,
61 .get_brightness = pwm_backlight_get_brightness, 64 .get_brightness = pwm_backlight_get_brightness,
62}; 65};
63 66
64static int pwm_backlight_probe(struct platform_device *pdev) 67static int pwm_backlight_probe(struct platform_device *pdev)
65{ 68{
69 struct backlight_properties props;
66 struct platform_pwm_backlight_data *data = pdev->dev.platform_data; 70 struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
67 struct backlight_device *bl; 71 struct backlight_device *bl;
68 struct pwm_bl_data *pb; 72 struct pwm_bl_data *pb;
@@ -88,6 +92,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
88 92
89 pb->period = data->pwm_period_ns; 93 pb->period = data->pwm_period_ns;
90 pb->notify = data->notify; 94 pb->notify = data->notify;
95 pb->dev = &pdev->dev;
91 96
92 pb->pwm = pwm_request(data->pwm_id, "backlight"); 97 pb->pwm = pwm_request(data->pwm_id, "backlight");
93 if (IS_ERR(pb->pwm)) { 98 if (IS_ERR(pb->pwm)) {
@@ -97,15 +102,16 @@ static int pwm_backlight_probe(struct platform_device *pdev)
97 } else 102 } else
98 dev_dbg(&pdev->dev, "got pwm for backlight\n"); 103 dev_dbg(&pdev->dev, "got pwm for backlight\n");
99 104
100 bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, 105 memset(&props, 0, sizeof(struct backlight_properties));
101 pb, &pwm_backlight_ops); 106 props.max_brightness = data->max_brightness;
107 bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
108 &pwm_backlight_ops, &props);
102 if (IS_ERR(bl)) { 109 if (IS_ERR(bl)) {
103 dev_err(&pdev->dev, "failed to register backlight\n"); 110 dev_err(&pdev->dev, "failed to register backlight\n");
104 ret = PTR_ERR(bl); 111 ret = PTR_ERR(bl);
105 goto err_bl; 112 goto err_bl;
106 } 113 }
107 114
108 bl->props.max_brightness = data->max_brightness;
109 bl->props.brightness = data->dft_brightness; 115 bl->props.brightness = data->dft_brightness;
110 backlight_update_status(bl); 116 backlight_update_status(bl);
111 117
@@ -146,7 +152,7 @@ static int pwm_backlight_suspend(struct platform_device *pdev,
146 struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); 152 struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev);
147 153
148 if (pb->notify) 154 if (pb->notify)
149 pb->notify(0); 155 pb->notify(pb->dev, 0);
150 pwm_config(pb->pwm, 0, pb->period); 156 pwm_config(pb->pwm, 0, pb->period);
151 pwm_disable(pb->pwm); 157 pwm_disable(pb->pwm);
152 return 0; 158 return 0;
diff --git a/drivers/video/backlight/tdo24m.c b/drivers/video/backlight/tdo24m.c
index bbfb502add67..1997e12a1057 100644
--- a/drivers/video/backlight/tdo24m.c
+++ b/drivers/video/backlight/tdo24m.c
@@ -17,6 +17,7 @@
17#include <linux/spi/tdo24m.h> 17#include <linux/spi/tdo24m.h>
18#include <linux/fb.h> 18#include <linux/fb.h>
19#include <linux/lcd.h> 19#include <linux/lcd.h>
20#include <linux/slab.h>
20 21
21#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL) 22#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL)
22 23
@@ -367,6 +368,7 @@ static int __devinit tdo24m_probe(struct spi_device *spi)
367 368
368 spi_message_init(m); 369 spi_message_init(m);
369 370
371 x->cs_change = 1;
370 x->tx_buf = &lcd->buf[0]; 372 x->tx_buf = &lcd->buf[0];
371 spi_message_add_tail(x, m); 373 spi_message_add_tail(x, m);
372 374
diff --git a/drivers/video/backlight/tosa_bl.c b/drivers/video/backlight/tosa_bl.c
index 43edbada12d1..e03e60bbfd85 100644
--- a/drivers/video/backlight/tosa_bl.c
+++ b/drivers/video/backlight/tosa_bl.c
@@ -18,6 +18,7 @@
18#include <linux/gpio.h> 18#include <linux/gpio.h>
19#include <linux/fb.h> 19#include <linux/fb.h>
20#include <linux/backlight.h> 20#include <linux/backlight.h>
21#include <linux/slab.h>
21 22
22#include <asm/mach/sharpsl_param.h> 23#include <asm/mach/sharpsl_param.h>
23 24
@@ -72,7 +73,7 @@ static int tosa_bl_get_brightness(struct backlight_device *dev)
72 return props->brightness; 73 return props->brightness;
73} 74}
74 75
75static struct backlight_ops bl_ops = { 76static const struct backlight_ops bl_ops = {
76 .get_brightness = tosa_bl_get_brightness, 77 .get_brightness = tosa_bl_get_brightness,
77 .update_status = tosa_bl_update_status, 78 .update_status = tosa_bl_update_status,
78}; 79};
@@ -80,6 +81,7 @@ static struct backlight_ops bl_ops = {
80static int __devinit tosa_bl_probe(struct i2c_client *client, 81static int __devinit tosa_bl_probe(struct i2c_client *client,
81 const struct i2c_device_id *id) 82 const struct i2c_device_id *id)
82{ 83{
84 struct backlight_properties props;
83 struct tosa_bl_data *data = kzalloc(sizeof(struct tosa_bl_data), GFP_KERNEL); 85 struct tosa_bl_data *data = kzalloc(sizeof(struct tosa_bl_data), GFP_KERNEL);
84 int ret = 0; 86 int ret = 0;
85 if (!data) 87 if (!data)
@@ -99,15 +101,16 @@ static int __devinit tosa_bl_probe(struct i2c_client *client,
99 i2c_set_clientdata(client, data); 101 i2c_set_clientdata(client, data);
100 data->i2c = client; 102 data->i2c = client;
101 103
102 data->bl = backlight_device_register("tosa-bl", &client->dev, 104 memset(&props, 0, sizeof(struct backlight_properties));
103 data, &bl_ops); 105 props.max_brightness = 512 - 1;
106 data->bl = backlight_device_register("tosa-bl", &client->dev, data,
107 &bl_ops, &props);
104 if (IS_ERR(data->bl)) { 108 if (IS_ERR(data->bl)) {
105 ret = PTR_ERR(data->bl); 109 ret = PTR_ERR(data->bl);
106 goto err_reg; 110 goto err_reg;
107 } 111 }
108 112
109 data->bl->props.brightness = 69; 113 data->bl->props.brightness = 69;
110 data->bl->props.max_brightness = 512 - 1;
111 data->bl->props.power = FB_BLANK_UNBLANK; 114 data->bl->props.power = FB_BLANK_UNBLANK;
112 115
113 backlight_update_status(data->bl); 116 backlight_update_status(data->bl);
diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c
index 50ec17dfc517..772f6015219a 100644
--- a/drivers/video/backlight/tosa_lcd.c
+++ b/drivers/video/backlight/tosa_lcd.c
@@ -15,6 +15,7 @@
15#include <linux/device.h> 15#include <linux/device.h>
16#include <linux/spi/spi.h> 16#include <linux/spi/spi.h>
17#include <linux/i2c.h> 17#include <linux/i2c.h>
18#include <linux/slab.h>
18#include <linux/gpio.h> 19#include <linux/gpio.h>
19#include <linux/delay.h> 20#include <linux/delay.h>
20#include <linux/lcd.h> 21#include <linux/lcd.h>
@@ -177,7 +178,7 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
177 if (!data) 178 if (!data)
178 return -ENOMEM; 179 return -ENOMEM;
179 180
180 data->is_vga = true; /* defaut to VGA mode */ 181 data->is_vga = true; /* default to VGA mode */
181 182
182 /* 183 /*
183 * bits_per_word cannot be configured in platform data 184 * bits_per_word cannot be configured in platform data
diff --git a/drivers/video/backlight/wm831x_bl.c b/drivers/video/backlight/wm831x_bl.c
index 467bdb7efb23..08fd87f3aecc 100644
--- a/drivers/video/backlight/wm831x_bl.c
+++ b/drivers/video/backlight/wm831x_bl.c
@@ -13,6 +13,7 @@
13#include <linux/platform_device.h> 13#include <linux/platform_device.h>
14#include <linux/fb.h> 14#include <linux/fb.h>
15#include <linux/backlight.h> 15#include <linux/backlight.h>
16#include <linux/slab.h>
16 17
17#include <linux/mfd/wm831x/core.h> 18#include <linux/mfd/wm831x/core.h>
18#include <linux/mfd/wm831x/pdata.h> 19#include <linux/mfd/wm831x/pdata.h>
@@ -112,7 +113,7 @@ static int wm831x_backlight_get_brightness(struct backlight_device *bl)
112 return data->current_brightness; 113 return data->current_brightness;
113} 114}
114 115
115static struct backlight_ops wm831x_backlight_ops = { 116static const struct backlight_ops wm831x_backlight_ops = {
116 .options = BL_CORE_SUSPENDRESUME, 117 .options = BL_CORE_SUSPENDRESUME,
117 .update_status = wm831x_backlight_update_status, 118 .update_status = wm831x_backlight_update_status,
118 .get_brightness = wm831x_backlight_get_brightness, 119 .get_brightness = wm831x_backlight_get_brightness,
@@ -125,6 +126,7 @@ static int wm831x_backlight_probe(struct platform_device *pdev)
125 struct wm831x_backlight_pdata *pdata; 126 struct wm831x_backlight_pdata *pdata;
126 struct wm831x_backlight_data *data; 127 struct wm831x_backlight_data *data;
127 struct backlight_device *bl; 128 struct backlight_device *bl;
129 struct backlight_properties props;
128 int ret, i, max_isel, isink_reg, dcdc_cfg; 130 int ret, i, max_isel, isink_reg, dcdc_cfg;
129 131
130 /* We need platform data */ 132 /* We need platform data */
@@ -191,15 +193,15 @@ static int wm831x_backlight_probe(struct platform_device *pdev)
191 data->current_brightness = 0; 193 data->current_brightness = 0;
192 data->isink_reg = isink_reg; 194 data->isink_reg = isink_reg;
193 195
194 bl = backlight_device_register("wm831x", &pdev->dev, 196 props.max_brightness = max_isel;
195 data, &wm831x_backlight_ops); 197 bl = backlight_device_register("wm831x", &pdev->dev, data,
198 &wm831x_backlight_ops, &props);
196 if (IS_ERR(bl)) { 199 if (IS_ERR(bl)) {
197 dev_err(&pdev->dev, "failed to register backlight\n"); 200 dev_err(&pdev->dev, "failed to register backlight\n");
198 kfree(data); 201 kfree(data);
199 return PTR_ERR(bl); 202 return PTR_ERR(bl);
200 } 203 }
201 204
202 bl->props.max_brightness = max_isel;
203 bl->props.brightness = max_isel; 205 bl->props.brightness = max_isel;
204 206
205 platform_set_drvdata(pdev, bl); 207 platform_set_drvdata(pdev, bl);
generated by cgit v1.2.2 (git 2.25.0) at 2025-07-23 05:07:26 -0400