1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Simple driver for Texas Instruments LM3630A Backlight driver chip
4 * Copyright (C) 2012 Texas Instruments
5 */
6 #include <linux/module.h>
7 #include <linux/slab.h>
8 #include <linux/i2c.h>
9 #include <linux/backlight.h>
10 #include <linux/err.h>
11 #include <linux/delay.h>
12 #include <linux/uaccess.h>
13 #include <linux/interrupt.h>
14 #include <linux/regmap.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/pwm.h>
17 #include <linux/platform_data/lm3630a_bl.h>
18 
19 #define REG_CTRL	0x00
20 #define REG_BOOST	0x02
21 #define REG_CONFIG	0x01
22 #define REG_BRT_A	0x03
23 #define REG_BRT_B	0x04
24 #define REG_I_A		0x05
25 #define REG_I_B		0x06
26 #define REG_INT_STATUS	0x09
27 #define REG_INT_EN	0x0A
28 #define REG_FAULT	0x0B
29 #define REG_PWM_OUTLOW	0x12
30 #define REG_PWM_OUTHIGH	0x13
31 #define REG_FILTER_STRENGTH	0x50
32 #define REG_MAX		0x50
33 
34 #define INT_DEBOUNCE_MSEC	10
35 
36 #define LM3630A_BANK_0		0
37 #define LM3630A_BANK_1		1
38 
39 #define LM3630A_NUM_SINKS	2
40 #define LM3630A_SINK_0		0
41 #define LM3630A_SINK_1		1
42 
43 struct lm3630a_chip {
44 	struct device *dev;
45 	struct delayed_work work;
46 
47 	int irq;
48 	struct workqueue_struct *irqthread;
49 	struct lm3630a_platform_data *pdata;
50 	struct backlight_device *bleda;
51 	struct backlight_device *bledb;
52 	struct gpio_desc *enable_gpio;
53 	struct regmap *regmap;
54 	struct pwm_device *pwmd;
55 	struct pwm_state pwmd_state;
56 };
57 
58 /* i2c access */
59 static int lm3630a_read(struct lm3630a_chip *pchip, unsigned int reg)
60 {
61 	int rval;
62 	unsigned int reg_val;
63 
64 	rval = regmap_read(pchip->regmap, reg, &reg_val);
65 	if (rval < 0)
66 		return rval;
67 	return reg_val & 0xFF;
68 }
69 
70 static int lm3630a_write(struct lm3630a_chip *pchip,
71 			 unsigned int reg, unsigned int data)
72 {
73 	return regmap_write(pchip->regmap, reg, data);
74 }
75 
76 static int lm3630a_update(struct lm3630a_chip *pchip,
77 			  unsigned int reg, unsigned int mask,
78 			  unsigned int data)
79 {
80 	return regmap_update_bits(pchip->regmap, reg, mask, data);
81 }
82 
83 /* initialize chip */
84 static int lm3630a_chip_init(struct lm3630a_chip *pchip)
85 {
86 	int rval;
87 	struct lm3630a_platform_data *pdata = pchip->pdata;
88 
89 	usleep_range(1000, 2000);
90 	/* set Filter Strength Register */
91 	rval = lm3630a_write(pchip, REG_FILTER_STRENGTH, 0x03);
92 	/* set Cofig. register */
93 	rval |= lm3630a_update(pchip, REG_CONFIG, 0x07, pdata->pwm_ctrl);
94 	/* set boost control */
95 	rval |= lm3630a_write(pchip, REG_BOOST, 0x38);
96 	/* set current A */
97 	rval |= lm3630a_update(pchip, REG_I_A, 0x1F, 0x1F);
98 	/* set current B */
99 	rval |= lm3630a_write(pchip, REG_I_B, 0x1F);
100 	/* set control */
101 	rval |= lm3630a_update(pchip, REG_CTRL, 0x14, pdata->leda_ctrl);
102 	rval |= lm3630a_update(pchip, REG_CTRL, 0x0B, pdata->ledb_ctrl);
103 	usleep_range(1000, 2000);
104 	/* set brightness A and B */
105 	rval |= lm3630a_write(pchip, REG_BRT_A, pdata->leda_init_brt);
106 	rval |= lm3630a_write(pchip, REG_BRT_B, pdata->ledb_init_brt);
107 
108 	if (rval < 0)
109 		dev_err(pchip->dev, "i2c failed to access register\n");
110 	return rval;
111 }
112 
113 /* interrupt handling */
114 static void lm3630a_delayed_func(struct work_struct *work)
115 {
116 	int rval;
117 	struct lm3630a_chip *pchip;
118 
119 	pchip = container_of(work, struct lm3630a_chip, work.work);
120 
121 	rval = lm3630a_read(pchip, REG_INT_STATUS);
122 	if (rval < 0) {
123 		dev_err(pchip->dev,
124 			"i2c failed to access REG_INT_STATUS Register\n");
125 		return;
126 	}
127 
128 	dev_info(pchip->dev, "REG_INT_STATUS Register is 0x%x\n", rval);
129 }
130 
131 static irqreturn_t lm3630a_isr_func(int irq, void *chip)
132 {
133 	int rval;
134 	struct lm3630a_chip *pchip = chip;
135 	unsigned long delay = msecs_to_jiffies(INT_DEBOUNCE_MSEC);
136 
137 	queue_delayed_work(pchip->irqthread, &pchip->work, delay);
138 
139 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
140 	if (rval < 0) {
141 		dev_err(pchip->dev, "i2c failed to access register\n");
142 		return IRQ_NONE;
143 	}
144 	return IRQ_HANDLED;
145 }
146 
147 static int lm3630a_intr_config(struct lm3630a_chip *pchip)
148 {
149 	int rval;
150 
151 	rval = lm3630a_write(pchip, REG_INT_EN, 0x87);
152 	if (rval < 0)
153 		return rval;
154 
155 	INIT_DELAYED_WORK(&pchip->work, lm3630a_delayed_func);
156 	pchip->irqthread = create_singlethread_workqueue("lm3630a-irqthd");
157 	if (!pchip->irqthread) {
158 		dev_err(pchip->dev, "create irq thread fail\n");
159 		return -ENOMEM;
160 	}
161 	if (request_threaded_irq
162 	    (pchip->irq, NULL, lm3630a_isr_func,
163 	     IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm3630a_irq", pchip)) {
164 		dev_err(pchip->dev, "request threaded irq fail\n");
165 		destroy_workqueue(pchip->irqthread);
166 		return -ENOMEM;
167 	}
168 	return rval;
169 }
170 
171 static int lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max)
172 {
173 	int err;
174 
175 	pchip->pwmd_state.period = pchip->pdata->pwm_period;
176 
177 	err = pwm_set_relative_duty_cycle(&pchip->pwmd_state, br, br_max);
178 	if (err)
179 		return err;
180 
181 	pchip->pwmd_state.enabled = pchip->pwmd_state.duty_cycle ? true : false;
182 
183 	return pwm_apply_state(pchip->pwmd, &pchip->pwmd_state);
184 }
185 
186 /* update and get brightness */
187 static int lm3630a_bank_a_update_status(struct backlight_device *bl)
188 {
189 	int ret;
190 	struct lm3630a_chip *pchip = bl_get_data(bl);
191 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
192 
193 	/* pwm control */
194 	if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0)
195 		return lm3630a_pwm_ctrl(pchip, bl->props.brightness,
196 					bl->props.max_brightness);
197 
198 	/* disable sleep */
199 	ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
200 	if (ret < 0)
201 		goto out_i2c_err;
202 	usleep_range(1000, 2000);
203 	/* minimum brightness is 0x04 */
204 	ret = lm3630a_write(pchip, REG_BRT_A, bl->props.brightness);
205 
206 	if (backlight_is_blank(bl) || (backlight_get_brightness(bl) < 0x4))
207 		/* turn the string off  */
208 		ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDA_ENABLE, 0);
209 	else
210 		ret |= lm3630a_update(pchip, REG_CTRL,
211 				      LM3630A_LEDA_ENABLE, LM3630A_LEDA_ENABLE);
212 	if (ret < 0)
213 		goto out_i2c_err;
214 	return 0;
215 
216 out_i2c_err:
217 	dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret));
218 	return ret;
219 }
220 
221 static int lm3630a_bank_a_get_brightness(struct backlight_device *bl)
222 {
223 	int brightness, rval;
224 	struct lm3630a_chip *pchip = bl_get_data(bl);
225 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
226 
227 	if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) {
228 		rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
229 		if (rval < 0)
230 			goto out_i2c_err;
231 		brightness = (rval & 0x01) << 8;
232 		rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
233 		if (rval < 0)
234 			goto out_i2c_err;
235 		brightness |= rval;
236 		return brightness;
237 	}
238 
239 	/* disable sleep */
240 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
241 	if (rval < 0)
242 		goto out_i2c_err;
243 	usleep_range(1000, 2000);
244 	rval = lm3630a_read(pchip, REG_BRT_A);
245 	if (rval < 0)
246 		goto out_i2c_err;
247 	return rval;
248 
249 out_i2c_err:
250 	dev_err(pchip->dev, "i2c failed to access register\n");
251 	return 0;
252 }
253 
254 static const struct backlight_ops lm3630a_bank_a_ops = {
255 	.options = BL_CORE_SUSPENDRESUME,
256 	.update_status = lm3630a_bank_a_update_status,
257 	.get_brightness = lm3630a_bank_a_get_brightness,
258 };
259 
260 /* update and get brightness */
261 static int lm3630a_bank_b_update_status(struct backlight_device *bl)
262 {
263 	int ret;
264 	struct lm3630a_chip *pchip = bl_get_data(bl);
265 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
266 
267 	/* pwm control */
268 	if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0)
269 		return lm3630a_pwm_ctrl(pchip, bl->props.brightness,
270 					bl->props.max_brightness);
271 
272 	/* disable sleep */
273 	ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
274 	if (ret < 0)
275 		goto out_i2c_err;
276 	usleep_range(1000, 2000);
277 	/* minimum brightness is 0x04 */
278 	ret = lm3630a_write(pchip, REG_BRT_B, bl->props.brightness);
279 
280 	if (backlight_is_blank(bl) || (backlight_get_brightness(bl) < 0x4))
281 		/* turn the string off  */
282 		ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDB_ENABLE, 0);
283 	else
284 		ret |= lm3630a_update(pchip, REG_CTRL,
285 				      LM3630A_LEDB_ENABLE, LM3630A_LEDB_ENABLE);
286 	if (ret < 0)
287 		goto out_i2c_err;
288 	return 0;
289 
290 out_i2c_err:
291 	dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret));
292 	return ret;
293 }
294 
295 static int lm3630a_bank_b_get_brightness(struct backlight_device *bl)
296 {
297 	int brightness, rval;
298 	struct lm3630a_chip *pchip = bl_get_data(bl);
299 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
300 
301 	if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) {
302 		rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
303 		if (rval < 0)
304 			goto out_i2c_err;
305 		brightness = (rval & 0x01) << 8;
306 		rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
307 		if (rval < 0)
308 			goto out_i2c_err;
309 		brightness |= rval;
310 		return brightness;
311 	}
312 
313 	/* disable sleep */
314 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
315 	if (rval < 0)
316 		goto out_i2c_err;
317 	usleep_range(1000, 2000);
318 	rval = lm3630a_read(pchip, REG_BRT_B);
319 	if (rval < 0)
320 		goto out_i2c_err;
321 	return rval;
322 
323 out_i2c_err:
324 	dev_err(pchip->dev, "i2c failed to access register\n");
325 	return 0;
326 }
327 
328 static const struct backlight_ops lm3630a_bank_b_ops = {
329 	.options = BL_CORE_SUSPENDRESUME,
330 	.update_status = lm3630a_bank_b_update_status,
331 	.get_brightness = lm3630a_bank_b_get_brightness,
332 };
333 
334 static int lm3630a_backlight_register(struct lm3630a_chip *pchip)
335 {
336 	struct lm3630a_platform_data *pdata = pchip->pdata;
337 	struct backlight_properties props;
338 	const char *label;
339 
340 	memset(&props, 0, sizeof(struct backlight_properties));
341 	props.type = BACKLIGHT_RAW;
342 	if (pdata->leda_ctrl != LM3630A_LEDA_DISABLE) {
343 		props.brightness = pdata->leda_init_brt;
344 		props.max_brightness = pdata->leda_max_brt;
345 		label = pdata->leda_label ? pdata->leda_label : "lm3630a_leda";
346 		pchip->bleda =
347 		    devm_backlight_device_register(pchip->dev, label,
348 						   pchip->dev, pchip,
349 						   &lm3630a_bank_a_ops, &props);
350 		if (IS_ERR(pchip->bleda))
351 			return PTR_ERR(pchip->bleda);
352 	}
353 
354 	if ((pdata->ledb_ctrl != LM3630A_LEDB_DISABLE) &&
355 	    (pdata->ledb_ctrl != LM3630A_LEDB_ON_A)) {
356 		props.brightness = pdata->ledb_init_brt;
357 		props.max_brightness = pdata->ledb_max_brt;
358 		label = pdata->ledb_label ? pdata->ledb_label : "lm3630a_ledb";
359 		pchip->bledb =
360 		    devm_backlight_device_register(pchip->dev, label,
361 						   pchip->dev, pchip,
362 						   &lm3630a_bank_b_ops, &props);
363 		if (IS_ERR(pchip->bledb))
364 			return PTR_ERR(pchip->bledb);
365 	}
366 	return 0;
367 }
368 
369 static const struct regmap_config lm3630a_regmap = {
370 	.reg_bits = 8,
371 	.val_bits = 8,
372 	.max_register = REG_MAX,
373 };
374 
375 static int lm3630a_parse_led_sources(struct fwnode_handle *node,
376 				     int default_led_sources)
377 {
378 	u32 sources[LM3630A_NUM_SINKS];
379 	int ret, num_sources, i;
380 
381 	num_sources = fwnode_property_count_u32(node, "led-sources");
382 	if (num_sources < 0)
383 		return default_led_sources;
384 	else if (num_sources > ARRAY_SIZE(sources))
385 		return -EINVAL;
386 
387 	ret = fwnode_property_read_u32_array(node, "led-sources", sources,
388 					     num_sources);
389 	if (ret)
390 		return ret;
391 
392 	for (i = 0; i < num_sources; i++) {
393 		if (sources[i] != LM3630A_SINK_0 && sources[i] != LM3630A_SINK_1)
394 			return -EINVAL;
395 
396 		ret |= BIT(sources[i]);
397 	}
398 
399 	return ret;
400 }
401 
402 static int lm3630a_parse_bank(struct lm3630a_platform_data *pdata,
403 			      struct fwnode_handle *node, int *seen_led_sources)
404 {
405 	int led_sources, ret;
406 	const char *label;
407 	u32 bank, val;
408 	bool linear;
409 
410 	ret = fwnode_property_read_u32(node, "reg", &bank);
411 	if (ret)
412 		return ret;
413 
414 	if (bank != LM3630A_BANK_0 && bank != LM3630A_BANK_1)
415 		return -EINVAL;
416 
417 	led_sources = lm3630a_parse_led_sources(node, BIT(bank));
418 	if (led_sources < 0)
419 		return led_sources;
420 
421 	if (*seen_led_sources & led_sources)
422 		return -EINVAL;
423 
424 	*seen_led_sources |= led_sources;
425 
426 	linear = fwnode_property_read_bool(node,
427 					   "ti,linear-mapping-mode");
428 	if (bank) {
429 		if (led_sources & BIT(LM3630A_SINK_0) ||
430 		    !(led_sources & BIT(LM3630A_SINK_1)))
431 			return -EINVAL;
432 
433 		pdata->ledb_ctrl = linear ?
434 			LM3630A_LEDB_ENABLE_LINEAR :
435 			LM3630A_LEDB_ENABLE;
436 	} else {
437 		if (!(led_sources & BIT(LM3630A_SINK_0)))
438 			return -EINVAL;
439 
440 		pdata->leda_ctrl = linear ?
441 			LM3630A_LEDA_ENABLE_LINEAR :
442 			LM3630A_LEDA_ENABLE;
443 
444 		if (led_sources & BIT(LM3630A_SINK_1))
445 			pdata->ledb_ctrl = LM3630A_LEDB_ON_A;
446 	}
447 
448 	ret = fwnode_property_read_string(node, "label", &label);
449 	if (!ret) {
450 		if (bank)
451 			pdata->ledb_label = label;
452 		else
453 			pdata->leda_label = label;
454 	}
455 
456 	ret = fwnode_property_read_u32(node, "default-brightness",
457 				       &val);
458 	if (!ret) {
459 		if (bank)
460 			pdata->ledb_init_brt = val;
461 		else
462 			pdata->leda_init_brt = val;
463 	}
464 
465 	ret = fwnode_property_read_u32(node, "max-brightness", &val);
466 	if (!ret) {
467 		if (bank)
468 			pdata->ledb_max_brt = val;
469 		else
470 			pdata->leda_max_brt = val;
471 	}
472 
473 	return 0;
474 }
475 
476 static int lm3630a_parse_node(struct lm3630a_chip *pchip,
477 			      struct lm3630a_platform_data *pdata)
478 {
479 	int ret = -ENODEV, seen_led_sources = 0;
480 	struct fwnode_handle *node;
481 
482 	device_for_each_child_node(pchip->dev, node) {
483 		ret = lm3630a_parse_bank(pdata, node, &seen_led_sources);
484 		if (ret) {
485 			fwnode_handle_put(node);
486 			return ret;
487 		}
488 	}
489 
490 	return ret;
491 }
492 
493 static int lm3630a_probe(struct i2c_client *client)
494 {
495 	struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev);
496 	struct lm3630a_chip *pchip;
497 	int rval;
498 
499 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
500 		dev_err(&client->dev, "fail : i2c functionality check\n");
501 		return -EOPNOTSUPP;
502 	}
503 
504 	pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip),
505 			     GFP_KERNEL);
506 	if (!pchip)
507 		return -ENOMEM;
508 	pchip->dev = &client->dev;
509 
510 	pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap);
511 	if (IS_ERR(pchip->regmap)) {
512 		rval = PTR_ERR(pchip->regmap);
513 		dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval);
514 		return rval;
515 	}
516 
517 	i2c_set_clientdata(client, pchip);
518 	if (pdata == NULL) {
519 		pdata = devm_kzalloc(pchip->dev,
520 				     sizeof(struct lm3630a_platform_data),
521 				     GFP_KERNEL);
522 		if (pdata == NULL)
523 			return -ENOMEM;
524 
525 		/* default values */
526 		pdata->leda_max_brt = LM3630A_MAX_BRIGHTNESS;
527 		pdata->ledb_max_brt = LM3630A_MAX_BRIGHTNESS;
528 		pdata->leda_init_brt = LM3630A_MAX_BRIGHTNESS;
529 		pdata->ledb_init_brt = LM3630A_MAX_BRIGHTNESS;
530 
531 		rval = lm3630a_parse_node(pchip, pdata);
532 		if (rval) {
533 			dev_err(&client->dev, "fail : parse node\n");
534 			return rval;
535 		}
536 	}
537 	pchip->pdata = pdata;
538 
539 	pchip->enable_gpio = devm_gpiod_get_optional(&client->dev, "enable",
540 						GPIOD_OUT_HIGH);
541 	if (IS_ERR(pchip->enable_gpio)) {
542 		rval = PTR_ERR(pchip->enable_gpio);
543 		return rval;
544 	}
545 
546 	/* chip initialize */
547 	rval = lm3630a_chip_init(pchip);
548 	if (rval < 0) {
549 		dev_err(&client->dev, "fail : init chip\n");
550 		return rval;
551 	}
552 	/* backlight register */
553 	rval = lm3630a_backlight_register(pchip);
554 	if (rval < 0) {
555 		dev_err(&client->dev, "fail : backlight register.\n");
556 		return rval;
557 	}
558 	/* pwm */
559 	if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) {
560 		pchip->pwmd = devm_pwm_get(pchip->dev, "lm3630a-pwm");
561 		if (IS_ERR(pchip->pwmd)) {
562 			dev_err(&client->dev, "fail : get pwm device\n");
563 			return PTR_ERR(pchip->pwmd);
564 		}
565 
566 		pwm_init_state(pchip->pwmd, &pchip->pwmd_state);
567 	}
568 
569 	/* interrupt enable  : irq 0 is not allowed */
570 	pchip->irq = client->irq;
571 	if (pchip->irq) {
572 		rval = lm3630a_intr_config(pchip);
573 		if (rval < 0)
574 			return rval;
575 	}
576 	dev_info(&client->dev, "LM3630A backlight register OK.\n");
577 	return 0;
578 }
579 
580 static void lm3630a_remove(struct i2c_client *client)
581 {
582 	int rval;
583 	struct lm3630a_chip *pchip = i2c_get_clientdata(client);
584 
585 	rval = lm3630a_write(pchip, REG_BRT_A, 0);
586 	if (rval < 0)
587 		dev_err(pchip->dev, "i2c failed to access register\n");
588 
589 	rval = lm3630a_write(pchip, REG_BRT_B, 0);
590 	if (rval < 0)
591 		dev_err(pchip->dev, "i2c failed to access register\n");
592 
593 	if (pchip->irq) {
594 		free_irq(pchip->irq, pchip);
595 		destroy_workqueue(pchip->irqthread);
596 	}
597 }
598 
599 static const struct i2c_device_id lm3630a_id[] = {
600 	{LM3630A_NAME, 0},
601 	{}
602 };
603 
604 MODULE_DEVICE_TABLE(i2c, lm3630a_id);
605 
606 static const struct of_device_id lm3630a_match_table[] = {
607 	{ .compatible = "ti,lm3630a", },
608 	{ },
609 };
610 
611 MODULE_DEVICE_TABLE(of, lm3630a_match_table);
612 
613 static struct i2c_driver lm3630a_i2c_driver = {
614 	.driver = {
615 		   .name = LM3630A_NAME,
616 		   .of_match_table = lm3630a_match_table,
617 		   },
618 	.probe = lm3630a_probe,
619 	.remove = lm3630a_remove,
620 	.id_table = lm3630a_id,
621 };
622 
623 module_i2c_driver(lm3630a_i2c_driver);
624 
625 MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A");
626 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
627 MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>");
628 MODULE_LICENSE("GPL v2");
629