Commit | Line | Data |
---|---|---|
7be865ab KM |
1 | /* |
2 | * TI LP855x Backlight Driver | |
3 | * | |
4 | * Copyright (C) 2011 Texas Instruments | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/slab.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/backlight.h> | |
16 | #include <linux/err.h> | |
f7f95056 | 17 | #include <linux/platform_data/lp855x.h> |
8cc9764c | 18 | #include <linux/pwm.h> |
7be865ab | 19 | |
26e8ccc2 KM |
20 | /* LP8550/1/2/3/6 Registers */ |
21 | #define LP855X_BRIGHTNESS_CTRL 0x00 | |
22 | #define LP855X_DEVICE_CTRL 0x01 | |
23 | #define LP855X_EEPROM_START 0xA0 | |
24 | #define LP855X_EEPROM_END 0xA7 | |
25 | #define LP8556_EPROM_START 0xA0 | |
26 | #define LP8556_EPROM_END 0xAF | |
27 | ||
28 | /* LP8557 Registers */ | |
29 | #define LP8557_BL_CMD 0x00 | |
30 | #define LP8557_BL_MASK 0x01 | |
31 | #define LP8557_BL_ON 0x01 | |
32 | #define LP8557_BL_OFF 0x00 | |
33 | #define LP8557_BRIGHTNESS_CTRL 0x04 | |
34 | #define LP8557_CONFIG 0x10 | |
35 | #define LP8557_EPROM_START 0x10 | |
36 | #define LP8557_EPROM_END 0x1E | |
7be865ab KM |
37 | |
38 | #define BUF_SIZE 20 | |
39 | #define DEFAULT_BL_NAME "lcd-backlight" | |
40 | #define MAX_BRIGHTNESS 255 | |
41 | ||
68853bc2 KM |
42 | struct lp855x; |
43 | ||
44 | /* | |
45 | * struct lp855x_device_config | |
46 | * @pre_init_device: init device function call before updating the brightness | |
47 | * @reg_brightness: register address for brigthenss control | |
48 | * @reg_devicectrl: register address for device control | |
49 | * @post_init_device: late init device function call | |
50 | */ | |
51 | struct lp855x_device_config { | |
52 | int (*pre_init_device)(struct lp855x *); | |
53 | u8 reg_brightness; | |
54 | u8 reg_devicectrl; | |
55 | int (*post_init_device)(struct lp855x *); | |
56 | }; | |
57 | ||
7be865ab KM |
58 | struct lp855x { |
59 | const char *chipname; | |
60 | enum lp855x_chip_id chip_id; | |
68853bc2 | 61 | struct lp855x_device_config *cfg; |
7be865ab KM |
62 | struct i2c_client *client; |
63 | struct backlight_device *bl; | |
64 | struct device *dev; | |
7be865ab | 65 | struct lp855x_platform_data *pdata; |
8cc9764c | 66 | struct pwm_device *pwm; |
7be865ab KM |
67 | }; |
68 | ||
7be865ab KM |
69 | static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data) |
70 | { | |
eaa4d02f | 71 | return i2c_smbus_write_byte_data(lp->client, reg, data); |
7be865ab KM |
72 | } |
73 | ||
26e8ccc2 KM |
74 | static int lp855x_update_bit(struct lp855x *lp, u8 reg, u8 mask, u8 data) |
75 | { | |
76 | int ret; | |
77 | u8 tmp; | |
78 | ||
79 | ret = i2c_smbus_read_byte_data(lp->client, reg); | |
80 | if (ret < 0) { | |
81 | dev_err(lp->dev, "failed to read 0x%.2x\n", reg); | |
82 | return ret; | |
83 | } | |
84 | ||
85 | tmp = (u8)ret; | |
86 | tmp &= ~mask; | |
87 | tmp |= data & mask; | |
88 | ||
89 | return lp855x_write_byte(lp, reg, tmp); | |
90 | } | |
91 | ||
7be865ab KM |
92 | static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr) |
93 | { | |
94 | u8 start, end; | |
95 | ||
96 | switch (lp->chip_id) { | |
97 | case LP8550: | |
98 | case LP8551: | |
99 | case LP8552: | |
100 | case LP8553: | |
26e8ccc2 KM |
101 | start = LP855X_EEPROM_START; |
102 | end = LP855X_EEPROM_END; | |
7be865ab KM |
103 | break; |
104 | case LP8556: | |
26e8ccc2 KM |
105 | start = LP8556_EPROM_START; |
106 | end = LP8556_EPROM_END; | |
107 | break; | |
108 | case LP8557: | |
109 | start = LP8557_EPROM_START; | |
110 | end = LP8557_EPROM_END; | |
7be865ab KM |
111 | break; |
112 | default: | |
113 | return false; | |
114 | } | |
115 | ||
116 | return (addr >= start && addr <= end); | |
117 | } | |
118 | ||
26e8ccc2 KM |
119 | static int lp8557_bl_off(struct lp855x *lp) |
120 | { | |
121 | /* BL_ON = 0 before updating EPROM settings */ | |
122 | return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, | |
123 | LP8557_BL_OFF); | |
124 | } | |
125 | ||
126 | static int lp8557_bl_on(struct lp855x *lp) | |
127 | { | |
128 | /* BL_ON = 1 after updating EPROM settings */ | |
129 | return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK, | |
130 | LP8557_BL_ON); | |
131 | } | |
132 | ||
68853bc2 | 133 | static struct lp855x_device_config lp855x_dev_cfg = { |
26e8ccc2 KM |
134 | .reg_brightness = LP855X_BRIGHTNESS_CTRL, |
135 | .reg_devicectrl = LP855X_DEVICE_CTRL, | |
136 | }; | |
137 | ||
138 | static struct lp855x_device_config lp8557_dev_cfg = { | |
139 | .reg_brightness = LP8557_BRIGHTNESS_CTRL, | |
140 | .reg_devicectrl = LP8557_CONFIG, | |
141 | .pre_init_device = lp8557_bl_off, | |
142 | .post_init_device = lp8557_bl_on, | |
68853bc2 KM |
143 | }; |
144 | ||
145 | /* | |
146 | * Device specific configuration flow | |
147 | * | |
148 | * a) pre_init_device(optional) | |
149 | * b) update the brightness register | |
150 | * c) update device control register | |
151 | * d) update ROM area(optional) | |
152 | * e) post_init_device(optional) | |
153 | * | |
154 | */ | |
155 | static int lp855x_configure(struct lp855x *lp) | |
7be865ab KM |
156 | { |
157 | u8 val, addr; | |
158 | int i, ret; | |
159 | struct lp855x_platform_data *pd = lp->pdata; | |
160 | ||
68853bc2 KM |
161 | switch (lp->chip_id) { |
162 | case LP8550 ... LP8556: | |
163 | lp->cfg = &lp855x_dev_cfg; | |
164 | break; | |
26e8ccc2 KM |
165 | case LP8557: |
166 | lp->cfg = &lp8557_dev_cfg; | |
167 | break; | |
68853bc2 KM |
168 | default: |
169 | return -EINVAL; | |
170 | } | |
171 | ||
172 | if (lp->cfg->pre_init_device) { | |
173 | ret = lp->cfg->pre_init_device(lp); | |
174 | if (ret) { | |
175 | dev_err(lp->dev, "pre init device err: %d\n", ret); | |
176 | goto err; | |
177 | } | |
178 | } | |
179 | ||
7be865ab | 180 | val = pd->initial_brightness; |
68853bc2 | 181 | ret = lp855x_write_byte(lp, lp->cfg->reg_brightness, val); |
7be865ab | 182 | if (ret) |
68853bc2 | 183 | goto err; |
7be865ab KM |
184 | |
185 | val = pd->device_control; | |
68853bc2 | 186 | ret = lp855x_write_byte(lp, lp->cfg->reg_devicectrl, val); |
7be865ab | 187 | if (ret) |
68853bc2 | 188 | goto err; |
7be865ab KM |
189 | |
190 | if (pd->load_new_rom_data && pd->size_program) { | |
191 | for (i = 0; i < pd->size_program; i++) { | |
192 | addr = pd->rom_data[i].addr; | |
193 | val = pd->rom_data[i].val; | |
194 | if (!lp855x_is_valid_rom_area(lp, addr)) | |
195 | continue; | |
196 | ||
197 | ret = lp855x_write_byte(lp, addr, val); | |
198 | if (ret) | |
68853bc2 KM |
199 | goto err; |
200 | } | |
201 | } | |
202 | ||
203 | if (lp->cfg->post_init_device) { | |
204 | ret = lp->cfg->post_init_device(lp); | |
205 | if (ret) { | |
206 | dev_err(lp->dev, "post init device err: %d\n", ret); | |
207 | goto err; | |
7be865ab KM |
208 | } |
209 | } | |
210 | ||
68853bc2 KM |
211 | return 0; |
212 | ||
213 | err: | |
7be865ab KM |
214 | return ret; |
215 | } | |
216 | ||
8cc9764c KM |
217 | static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br) |
218 | { | |
219 | unsigned int period = lp->pdata->period_ns; | |
220 | unsigned int duty = br * period / max_br; | |
221 | struct pwm_device *pwm; | |
222 | ||
223 | /* request pwm device with the consumer name */ | |
224 | if (!lp->pwm) { | |
225 | pwm = devm_pwm_get(lp->dev, lp->chipname); | |
226 | if (IS_ERR(pwm)) | |
227 | return; | |
228 | ||
229 | lp->pwm = pwm; | |
230 | } | |
231 | ||
232 | pwm_config(lp->pwm, duty, period); | |
233 | if (duty) | |
234 | pwm_enable(lp->pwm); | |
235 | else | |
236 | pwm_disable(lp->pwm); | |
237 | } | |
238 | ||
7be865ab KM |
239 | static int lp855x_bl_update_status(struct backlight_device *bl) |
240 | { | |
241 | struct lp855x *lp = bl_get_data(bl); | |
242 | enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; | |
243 | ||
244 | if (bl->props.state & BL_CORE_SUSPENDED) | |
245 | bl->props.brightness = 0; | |
246 | ||
247 | if (mode == PWM_BASED) { | |
7be865ab KM |
248 | int br = bl->props.brightness; |
249 | int max_br = bl->props.max_brightness; | |
250 | ||
8cc9764c | 251 | lp855x_pwm_ctrl(lp, br, max_br); |
7be865ab KM |
252 | |
253 | } else if (mode == REGISTER_BASED) { | |
254 | u8 val = bl->props.brightness; | |
26e8ccc2 | 255 | lp855x_write_byte(lp, lp->cfg->reg_brightness, val); |
7be865ab KM |
256 | } |
257 | ||
258 | return 0; | |
259 | } | |
260 | ||
261 | static int lp855x_bl_get_brightness(struct backlight_device *bl) | |
262 | { | |
7be865ab KM |
263 | return bl->props.brightness; |
264 | } | |
265 | ||
266 | static const struct backlight_ops lp855x_bl_ops = { | |
267 | .options = BL_CORE_SUSPENDRESUME, | |
268 | .update_status = lp855x_bl_update_status, | |
269 | .get_brightness = lp855x_bl_get_brightness, | |
270 | }; | |
271 | ||
272 | static int lp855x_backlight_register(struct lp855x *lp) | |
273 | { | |
274 | struct backlight_device *bl; | |
275 | struct backlight_properties props; | |
276 | struct lp855x_platform_data *pdata = lp->pdata; | |
277 | char *name = pdata->name ? : DEFAULT_BL_NAME; | |
278 | ||
279 | props.type = BACKLIGHT_PLATFORM; | |
280 | props.max_brightness = MAX_BRIGHTNESS; | |
281 | ||
282 | if (pdata->initial_brightness > props.max_brightness) | |
283 | pdata->initial_brightness = props.max_brightness; | |
284 | ||
285 | props.brightness = pdata->initial_brightness; | |
286 | ||
287 | bl = backlight_device_register(name, lp->dev, lp, | |
288 | &lp855x_bl_ops, &props); | |
289 | if (IS_ERR(bl)) | |
290 | return PTR_ERR(bl); | |
291 | ||
292 | lp->bl = bl; | |
293 | ||
294 | return 0; | |
295 | } | |
296 | ||
297 | static void lp855x_backlight_unregister(struct lp855x *lp) | |
298 | { | |
299 | if (lp->bl) | |
300 | backlight_device_unregister(lp->bl); | |
301 | } | |
302 | ||
303 | static ssize_t lp855x_get_chip_id(struct device *dev, | |
304 | struct device_attribute *attr, char *buf) | |
305 | { | |
306 | struct lp855x *lp = dev_get_drvdata(dev); | |
307 | return scnprintf(buf, BUF_SIZE, "%s\n", lp->chipname); | |
308 | } | |
309 | ||
310 | static ssize_t lp855x_get_bl_ctl_mode(struct device *dev, | |
311 | struct device_attribute *attr, char *buf) | |
312 | { | |
313 | struct lp855x *lp = dev_get_drvdata(dev); | |
314 | enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; | |
315 | char *strmode = NULL; | |
316 | ||
317 | if (mode == PWM_BASED) | |
318 | strmode = "pwm based"; | |
319 | else if (mode == REGISTER_BASED) | |
320 | strmode = "register based"; | |
321 | ||
322 | return scnprintf(buf, BUF_SIZE, "%s\n", strmode); | |
323 | } | |
324 | ||
325 | static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL); | |
326 | static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL); | |
327 | ||
328 | static struct attribute *lp855x_attributes[] = { | |
329 | &dev_attr_chip_id.attr, | |
330 | &dev_attr_bl_ctl_mode.attr, | |
331 | NULL, | |
332 | }; | |
333 | ||
334 | static const struct attribute_group lp855x_attr_group = { | |
335 | .attrs = lp855x_attributes, | |
336 | }; | |
337 | ||
338 | static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id) | |
339 | { | |
340 | struct lp855x *lp; | |
341 | struct lp855x_platform_data *pdata = cl->dev.platform_data; | |
342 | enum lp855x_brightness_ctrl_mode mode; | |
343 | int ret; | |
344 | ||
345 | if (!pdata) { | |
346 | dev_err(&cl->dev, "no platform data supplied\n"); | |
347 | return -EINVAL; | |
348 | } | |
349 | ||
350 | if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) | |
351 | return -EIO; | |
352 | ||
353 | lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL); | |
354 | if (!lp) | |
355 | return -ENOMEM; | |
356 | ||
357 | mode = pdata->mode; | |
358 | lp->client = cl; | |
359 | lp->dev = &cl->dev; | |
360 | lp->pdata = pdata; | |
361 | lp->chipname = id->name; | |
362 | lp->chip_id = id->driver_data; | |
363 | i2c_set_clientdata(cl, lp); | |
364 | ||
68853bc2 | 365 | ret = lp855x_configure(lp); |
7be865ab | 366 | if (ret) { |
68853bc2 KM |
367 | dev_err(lp->dev, "device config err: %d", ret); |
368 | goto err_dev; | |
7be865ab KM |
369 | } |
370 | ||
371 | ret = lp855x_backlight_register(lp); | |
372 | if (ret) { | |
373 | dev_err(lp->dev, | |
374 | "failed to register backlight. err: %d\n", ret); | |
375 | goto err_dev; | |
376 | } | |
377 | ||
378 | ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group); | |
379 | if (ret) { | |
380 | dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret); | |
381 | goto err_sysfs; | |
382 | } | |
383 | ||
384 | backlight_update_status(lp->bl); | |
385 | return 0; | |
386 | ||
387 | err_sysfs: | |
388 | lp855x_backlight_unregister(lp); | |
389 | err_dev: | |
390 | return ret; | |
391 | } | |
392 | ||
7e4b9d0b | 393 | static int lp855x_remove(struct i2c_client *cl) |
7be865ab KM |
394 | { |
395 | struct lp855x *lp = i2c_get_clientdata(cl); | |
396 | ||
397 | lp->bl->props.brightness = 0; | |
398 | backlight_update_status(lp->bl); | |
399 | sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group); | |
400 | lp855x_backlight_unregister(lp); | |
401 | ||
402 | return 0; | |
403 | } | |
404 | ||
405 | static const struct i2c_device_id lp855x_ids[] = { | |
406 | {"lp8550", LP8550}, | |
407 | {"lp8551", LP8551}, | |
408 | {"lp8552", LP8552}, | |
409 | {"lp8553", LP8553}, | |
410 | {"lp8556", LP8556}, | |
26e8ccc2 | 411 | {"lp8557", LP8557}, |
7be865ab KM |
412 | { } |
413 | }; | |
414 | MODULE_DEVICE_TABLE(i2c, lp855x_ids); | |
415 | ||
416 | static struct i2c_driver lp855x_driver = { | |
417 | .driver = { | |
418 | .name = "lp855x", | |
419 | }, | |
420 | .probe = lp855x_probe, | |
d1723fa2 | 421 | .remove = lp855x_remove, |
7be865ab KM |
422 | .id_table = lp855x_ids, |
423 | }; | |
424 | ||
425 | module_i2c_driver(lp855x_driver); | |
426 | ||
427 | MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver"); | |
428 | MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); | |
429 | MODULE_LICENSE("GPL"); |