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/delay.h>
17 #include <linux/err.h>
18 #include <linux/of.h>
19 #include <linux/platform_data/lp855x.h>
20 #include <linux/pwm.h>
21 #include <linux/regulator/consumer.h>
22 
23 /* LP8550/1/2/3/6 Registers */
24 #define LP855X_BRIGHTNESS_CTRL		0x00
25 #define LP855X_DEVICE_CTRL		0x01
26 #define LP855X_EEPROM_START		0xA0
27 #define LP855X_EEPROM_END		0xA7
28 #define LP8556_EPROM_START		0xA0
29 #define LP8556_EPROM_END		0xAF
30 
31 /* LP8555/7 Registers */
32 #define LP8557_BL_CMD			0x00
33 #define LP8557_BL_MASK			0x01
34 #define LP8557_BL_ON			0x01
35 #define LP8557_BL_OFF			0x00
36 #define LP8557_BRIGHTNESS_CTRL		0x04
37 #define LP8557_CONFIG			0x10
38 #define LP8555_EPROM_START		0x10
39 #define LP8555_EPROM_END		0x7A
40 #define LP8557_EPROM_START		0x10
41 #define LP8557_EPROM_END		0x1E
42 
43 #define DEFAULT_BL_NAME		"lcd-backlight"
44 #define MAX_BRIGHTNESS		255
45 
46 enum lp855x_brightness_ctrl_mode {
47 	PWM_BASED = 1,
48 	REGISTER_BASED,
49 };
50 
51 struct lp855x;
52 
53 /*
54  * struct lp855x_device_config
55  * @pre_init_device: init device function call before updating the brightness
56  * @reg_brightness: register address for brigthenss control
57  * @reg_devicectrl: register address for device control
58  * @post_init_device: late init device function call
59  */
60 struct lp855x_device_config {
61 	int (*pre_init_device)(struct lp855x *);
62 	u8 reg_brightness;
63 	u8 reg_devicectrl;
64 	int (*post_init_device)(struct lp855x *);
65 };
66 
67 struct lp855x {
68 	const char *chipname;
69 	enum lp855x_chip_id chip_id;
70 	enum lp855x_brightness_ctrl_mode mode;
71 	struct lp855x_device_config *cfg;
72 	struct i2c_client *client;
73 	struct backlight_device *bl;
74 	struct device *dev;
75 	struct lp855x_platform_data *pdata;
76 	struct pwm_device *pwm;
77 	struct regulator *supply;	/* regulator for VDD input */
78 	struct regulator *enable;	/* regulator for EN/VDDIO input */
79 };
80 
81 static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data)
82 {
83 	return i2c_smbus_write_byte_data(lp->client, reg, data);
84 }
85 
86 static int lp855x_update_bit(struct lp855x *lp, u8 reg, u8 mask, u8 data)
87 {
88 	int ret;
89 	u8 tmp;
90 
91 	ret = i2c_smbus_read_byte_data(lp->client, reg);
92 	if (ret < 0) {
93 		dev_err(lp->dev, "failed to read 0x%.2x\n", reg);
94 		return ret;
95 	}
96 
97 	tmp = (u8)ret;
98 	tmp &= ~mask;
99 	tmp |= data & mask;
100 
101 	return lp855x_write_byte(lp, reg, tmp);
102 }
103 
104 static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr)
105 {
106 	u8 start, end;
107 
108 	switch (lp->chip_id) {
109 	case LP8550:
110 	case LP8551:
111 	case LP8552:
112 	case LP8553:
113 		start = LP855X_EEPROM_START;
114 		end = LP855X_EEPROM_END;
115 		break;
116 	case LP8556:
117 		start = LP8556_EPROM_START;
118 		end = LP8556_EPROM_END;
119 		break;
120 	case LP8555:
121 		start = LP8555_EPROM_START;
122 		end = LP8555_EPROM_END;
123 		break;
124 	case LP8557:
125 		start = LP8557_EPROM_START;
126 		end = LP8557_EPROM_END;
127 		break;
128 	default:
129 		return false;
130 	}
131 
132 	return addr >= start && addr <= end;
133 }
134 
135 static int lp8557_bl_off(struct lp855x *lp)
136 {
137 	/* BL_ON = 0 before updating EPROM settings */
138 	return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK,
139 				LP8557_BL_OFF);
140 }
141 
142 static int lp8557_bl_on(struct lp855x *lp)
143 {
144 	/* BL_ON = 1 after updating EPROM settings */
145 	return lp855x_update_bit(lp, LP8557_BL_CMD, LP8557_BL_MASK,
146 				LP8557_BL_ON);
147 }
148 
149 static struct lp855x_device_config lp855x_dev_cfg = {
150 	.reg_brightness = LP855X_BRIGHTNESS_CTRL,
151 	.reg_devicectrl = LP855X_DEVICE_CTRL,
152 };
153 
154 static struct lp855x_device_config lp8557_dev_cfg = {
155 	.reg_brightness = LP8557_BRIGHTNESS_CTRL,
156 	.reg_devicectrl = LP8557_CONFIG,
157 	.pre_init_device = lp8557_bl_off,
158 	.post_init_device = lp8557_bl_on,
159 };
160 
161 /*
162  * Device specific configuration flow
163  *
164  *    a) pre_init_device(optional)
165  *    b) update the brightness register
166  *    c) update device control register
167  *    d) update ROM area(optional)
168  *    e) post_init_device(optional)
169  *
170  */
171 static int lp855x_configure(struct lp855x *lp)
172 {
173 	u8 val, addr;
174 	int i, ret;
175 	struct lp855x_platform_data *pd = lp->pdata;
176 
177 	switch (lp->chip_id) {
178 	case LP8550:
179 	case LP8551:
180 	case LP8552:
181 	case LP8553:
182 	case LP8556:
183 		lp->cfg = &lp855x_dev_cfg;
184 		break;
185 	case LP8555:
186 	case LP8557:
187 		lp->cfg = &lp8557_dev_cfg;
188 		break;
189 	default:
190 		return -EINVAL;
191 	}
192 
193 	if (lp->cfg->pre_init_device) {
194 		ret = lp->cfg->pre_init_device(lp);
195 		if (ret) {
196 			dev_err(lp->dev, "pre init device err: %d\n", ret);
197 			goto err;
198 		}
199 	}
200 
201 	val = pd->initial_brightness;
202 	ret = lp855x_write_byte(lp, lp->cfg->reg_brightness, val);
203 	if (ret)
204 		goto err;
205 
206 	val = pd->device_control;
207 	ret = lp855x_write_byte(lp, lp->cfg->reg_devicectrl, val);
208 	if (ret)
209 		goto err;
210 
211 	if (pd->size_program > 0) {
212 		for (i = 0; i < pd->size_program; i++) {
213 			addr = pd->rom_data[i].addr;
214 			val = pd->rom_data[i].val;
215 			if (!lp855x_is_valid_rom_area(lp, addr))
216 				continue;
217 
218 			ret = lp855x_write_byte(lp, addr, val);
219 			if (ret)
220 				goto err;
221 		}
222 	}
223 
224 	if (lp->cfg->post_init_device) {
225 		ret = lp->cfg->post_init_device(lp);
226 		if (ret) {
227 			dev_err(lp->dev, "post init device err: %d\n", ret);
228 			goto err;
229 		}
230 	}
231 
232 	return 0;
233 
234 err:
235 	return ret;
236 }
237 
238 static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br)
239 {
240 	unsigned int period = lp->pdata->period_ns;
241 	unsigned int duty = br * period / max_br;
242 	struct pwm_device *pwm;
243 
244 	/* request pwm device with the consumer name */
245 	if (!lp->pwm) {
246 		pwm = devm_pwm_get(lp->dev, lp->chipname);
247 		if (IS_ERR(pwm))
248 			return;
249 
250 		lp->pwm = pwm;
251 
252 		/*
253 		 * FIXME: pwm_apply_args() should be removed when switching to
254 		 * the atomic PWM API.
255 		 */
256 		pwm_apply_args(pwm);
257 	}
258 
259 	pwm_config(lp->pwm, duty, period);
260 	if (duty)
261 		pwm_enable(lp->pwm);
262 	else
263 		pwm_disable(lp->pwm);
264 }
265 
266 static int lp855x_bl_update_status(struct backlight_device *bl)
267 {
268 	struct lp855x *lp = bl_get_data(bl);
269 	int brightness = bl->props.brightness;
270 
271 	if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK))
272 		brightness = 0;
273 
274 	if (lp->mode == PWM_BASED)
275 		lp855x_pwm_ctrl(lp, brightness, bl->props.max_brightness);
276 	else if (lp->mode == REGISTER_BASED)
277 		lp855x_write_byte(lp, lp->cfg->reg_brightness, (u8)brightness);
278 
279 	return 0;
280 }
281 
282 static const struct backlight_ops lp855x_bl_ops = {
283 	.options = BL_CORE_SUSPENDRESUME,
284 	.update_status = lp855x_bl_update_status,
285 };
286 
287 static int lp855x_backlight_register(struct lp855x *lp)
288 {
289 	struct backlight_device *bl;
290 	struct backlight_properties props;
291 	struct lp855x_platform_data *pdata = lp->pdata;
292 	const char *name = pdata->name ? : DEFAULT_BL_NAME;
293 
294 	memset(&props, 0, sizeof(props));
295 	props.type = BACKLIGHT_PLATFORM;
296 	props.max_brightness = MAX_BRIGHTNESS;
297 
298 	if (pdata->initial_brightness > props.max_brightness)
299 		pdata->initial_brightness = props.max_brightness;
300 
301 	props.brightness = pdata->initial_brightness;
302 
303 	bl = devm_backlight_device_register(lp->dev, name, lp->dev, lp,
304 				       &lp855x_bl_ops, &props);
305 	if (IS_ERR(bl))
306 		return PTR_ERR(bl);
307 
308 	lp->bl = bl;
309 
310 	return 0;
311 }
312 
313 static ssize_t lp855x_get_chip_id(struct device *dev,
314 				struct device_attribute *attr, char *buf)
315 {
316 	struct lp855x *lp = dev_get_drvdata(dev);
317 
318 	return scnprintf(buf, PAGE_SIZE, "%s\n", lp->chipname);
319 }
320 
321 static ssize_t lp855x_get_bl_ctl_mode(struct device *dev,
322 				     struct device_attribute *attr, char *buf)
323 {
324 	struct lp855x *lp = dev_get_drvdata(dev);
325 	char *strmode = NULL;
326 
327 	if (lp->mode == PWM_BASED)
328 		strmode = "pwm based";
329 	else if (lp->mode == REGISTER_BASED)
330 		strmode = "register based";
331 
332 	return scnprintf(buf, PAGE_SIZE, "%s\n", strmode);
333 }
334 
335 static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL);
336 static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL);
337 
338 static struct attribute *lp855x_attributes[] = {
339 	&dev_attr_chip_id.attr,
340 	&dev_attr_bl_ctl_mode.attr,
341 	NULL,
342 };
343 
344 static const struct attribute_group lp855x_attr_group = {
345 	.attrs = lp855x_attributes,
346 };
347 
348 #ifdef CONFIG_OF
349 static int lp855x_parse_dt(struct lp855x *lp)
350 {
351 	struct device *dev = lp->dev;
352 	struct device_node *node = dev->of_node;
353 	struct lp855x_platform_data *pdata;
354 	int rom_length;
355 
356 	if (!node) {
357 		dev_err(dev, "no platform data\n");
358 		return -EINVAL;
359 	}
360 
361 	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
362 	if (!pdata)
363 		return -ENOMEM;
364 
365 	of_property_read_string(node, "bl-name", &pdata->name);
366 	of_property_read_u8(node, "dev-ctrl", &pdata->device_control);
367 	of_property_read_u8(node, "init-brt", &pdata->initial_brightness);
368 	of_property_read_u32(node, "pwm-period", &pdata->period_ns);
369 
370 	/* Fill ROM platform data if defined */
371 	rom_length = of_get_child_count(node);
372 	if (rom_length > 0) {
373 		struct lp855x_rom_data *rom;
374 		struct device_node *child;
375 		int i = 0;
376 
377 		rom = devm_kcalloc(dev, rom_length, sizeof(*rom), GFP_KERNEL);
378 		if (!rom)
379 			return -ENOMEM;
380 
381 		for_each_child_of_node(node, child) {
382 			of_property_read_u8(child, "rom-addr", &rom[i].addr);
383 			of_property_read_u8(child, "rom-val", &rom[i].val);
384 			i++;
385 		}
386 
387 		pdata->size_program = rom_length;
388 		pdata->rom_data = &rom[0];
389 	}
390 
391 	lp->pdata = pdata;
392 
393 	return 0;
394 }
395 #else
396 static int lp855x_parse_dt(struct lp855x *lp)
397 {
398 	return -EINVAL;
399 }
400 #endif
401 
402 static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
403 {
404 	struct lp855x *lp;
405 	int ret;
406 
407 	if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
408 		return -EIO;
409 
410 	lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL);
411 	if (!lp)
412 		return -ENOMEM;
413 
414 	lp->client = cl;
415 	lp->dev = &cl->dev;
416 	lp->chipname = id->name;
417 	lp->chip_id = id->driver_data;
418 	lp->pdata = dev_get_platdata(&cl->dev);
419 
420 	if (!lp->pdata) {
421 		ret = lp855x_parse_dt(lp);
422 		if (ret < 0)
423 			return ret;
424 	}
425 
426 	if (lp->pdata->period_ns > 0)
427 		lp->mode = PWM_BASED;
428 	else
429 		lp->mode = REGISTER_BASED;
430 
431 	lp->supply = devm_regulator_get(lp->dev, "power");
432 	if (IS_ERR(lp->supply)) {
433 		if (PTR_ERR(lp->supply) == -EPROBE_DEFER)
434 			return -EPROBE_DEFER;
435 		lp->supply = NULL;
436 	}
437 
438 	lp->enable = devm_regulator_get_optional(lp->dev, "enable");
439 	if (IS_ERR(lp->enable)) {
440 		ret = PTR_ERR(lp->enable);
441 		if (ret == -ENODEV) {
442 			lp->enable = NULL;
443 		} else {
444 			if (ret != -EPROBE_DEFER)
445 				dev_err(lp->dev, "error getting enable regulator: %d\n",
446 					ret);
447 			return ret;
448 		}
449 	}
450 
451 	if (lp->supply) {
452 		ret = regulator_enable(lp->supply);
453 		if (ret < 0) {
454 			dev_err(&cl->dev, "failed to enable supply: %d\n", ret);
455 			return ret;
456 		}
457 	}
458 
459 	if (lp->enable) {
460 		ret = regulator_enable(lp->enable);
461 		if (ret < 0) {
462 			dev_err(lp->dev, "failed to enable vddio: %d\n", ret);
463 			return ret;
464 		}
465 
466 		/*
467 		 * LP8555 datasheet says t_RESPONSE (time between VDDIO and
468 		 * I2C) is 1ms.
469 		 */
470 		usleep_range(1000, 2000);
471 	}
472 
473 	i2c_set_clientdata(cl, lp);
474 
475 	ret = lp855x_configure(lp);
476 	if (ret) {
477 		dev_err(lp->dev, "device config err: %d", ret);
478 		return ret;
479 	}
480 
481 	ret = lp855x_backlight_register(lp);
482 	if (ret) {
483 		dev_err(lp->dev,
484 			"failed to register backlight. err: %d\n", ret);
485 		return ret;
486 	}
487 
488 	ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group);
489 	if (ret) {
490 		dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret);
491 		return ret;
492 	}
493 
494 	backlight_update_status(lp->bl);
495 	return 0;
496 }
497 
498 static int lp855x_remove(struct i2c_client *cl)
499 {
500 	struct lp855x *lp = i2c_get_clientdata(cl);
501 
502 	lp->bl->props.brightness = 0;
503 	backlight_update_status(lp->bl);
504 	if (lp->supply)
505 		regulator_disable(lp->supply);
506 	sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group);
507 
508 	return 0;
509 }
510 
511 static const struct of_device_id lp855x_dt_ids[] = {
512 	{ .compatible = "ti,lp8550", },
513 	{ .compatible = "ti,lp8551", },
514 	{ .compatible = "ti,lp8552", },
515 	{ .compatible = "ti,lp8553", },
516 	{ .compatible = "ti,lp8555", },
517 	{ .compatible = "ti,lp8556", },
518 	{ .compatible = "ti,lp8557", },
519 	{ }
520 };
521 MODULE_DEVICE_TABLE(of, lp855x_dt_ids);
522 
523 static const struct i2c_device_id lp855x_ids[] = {
524 	{"lp8550", LP8550},
525 	{"lp8551", LP8551},
526 	{"lp8552", LP8552},
527 	{"lp8553", LP8553},
528 	{"lp8555", LP8555},
529 	{"lp8556", LP8556},
530 	{"lp8557", LP8557},
531 	{ }
532 };
533 MODULE_DEVICE_TABLE(i2c, lp855x_ids);
534 
535 static struct i2c_driver lp855x_driver = {
536 	.driver = {
537 		   .name = "lp855x",
538 		   .of_match_table = of_match_ptr(lp855x_dt_ids),
539 		   },
540 	.probe = lp855x_probe,
541 	.remove = lp855x_remove,
542 	.id_table = lp855x_ids,
543 };
544 
545 module_i2c_driver(lp855x_driver);
546 
547 MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver");
548 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
549 MODULE_LICENSE("GPL");
550