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 };
56 
57 /* i2c access */
58 static int lm3630a_read(struct lm3630a_chip *pchip, unsigned int reg)
59 {
60 	int rval;
61 	unsigned int reg_val;
62 
63 	rval = regmap_read(pchip->regmap, reg, &reg_val);
64 	if (rval < 0)
65 		return rval;
66 	return reg_val & 0xFF;
67 }
68 
69 static int lm3630a_write(struct lm3630a_chip *pchip,
70 			 unsigned int reg, unsigned int data)
71 {
72 	return regmap_write(pchip->regmap, reg, data);
73 }
74 
75 static int lm3630a_update(struct lm3630a_chip *pchip,
76 			  unsigned int reg, unsigned int mask,
77 			  unsigned int data)
78 {
79 	return regmap_update_bits(pchip->regmap, reg, mask, data);
80 }
81 
82 /* initialize chip */
83 static int lm3630a_chip_init(struct lm3630a_chip *pchip)
84 {
85 	int rval;
86 	struct lm3630a_platform_data *pdata = pchip->pdata;
87 
88 	usleep_range(1000, 2000);
89 	/* set Filter Strength Register */
90 	rval = lm3630a_write(pchip, REG_FILTER_STRENGTH, 0x03);
91 	/* set Cofig. register */
92 	rval |= lm3630a_update(pchip, REG_CONFIG, 0x07, pdata->pwm_ctrl);
93 	/* set boost control */
94 	rval |= lm3630a_write(pchip, REG_BOOST, 0x38);
95 	/* set current A */
96 	rval |= lm3630a_update(pchip, REG_I_A, 0x1F, 0x1F);
97 	/* set current B */
98 	rval |= lm3630a_write(pchip, REG_I_B, 0x1F);
99 	/* set control */
100 	rval |= lm3630a_update(pchip, REG_CTRL, 0x14, pdata->leda_ctrl);
101 	rval |= lm3630a_update(pchip, REG_CTRL, 0x0B, pdata->ledb_ctrl);
102 	usleep_range(1000, 2000);
103 	/* set brightness A and B */
104 	rval |= lm3630a_write(pchip, REG_BRT_A, pdata->leda_init_brt);
105 	rval |= lm3630a_write(pchip, REG_BRT_B, pdata->ledb_init_brt);
106 
107 	if (rval < 0)
108 		dev_err(pchip->dev, "i2c failed to access register\n");
109 	return rval;
110 }
111 
112 /* interrupt handling */
113 static void lm3630a_delayed_func(struct work_struct *work)
114 {
115 	int rval;
116 	struct lm3630a_chip *pchip;
117 
118 	pchip = container_of(work, struct lm3630a_chip, work.work);
119 
120 	rval = lm3630a_read(pchip, REG_INT_STATUS);
121 	if (rval < 0) {
122 		dev_err(pchip->dev,
123 			"i2c failed to access REG_INT_STATUS Register\n");
124 		return;
125 	}
126 
127 	dev_info(pchip->dev, "REG_INT_STATUS Register is 0x%x\n", rval);
128 }
129 
130 static irqreturn_t lm3630a_isr_func(int irq, void *chip)
131 {
132 	int rval;
133 	struct lm3630a_chip *pchip = chip;
134 	unsigned long delay = msecs_to_jiffies(INT_DEBOUNCE_MSEC);
135 
136 	queue_delayed_work(pchip->irqthread, &pchip->work, delay);
137 
138 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
139 	if (rval < 0) {
140 		dev_err(pchip->dev, "i2c failed to access register\n");
141 		return IRQ_NONE;
142 	}
143 	return IRQ_HANDLED;
144 }
145 
146 static int lm3630a_intr_config(struct lm3630a_chip *pchip)
147 {
148 	int rval;
149 
150 	rval = lm3630a_write(pchip, REG_INT_EN, 0x87);
151 	if (rval < 0)
152 		return rval;
153 
154 	INIT_DELAYED_WORK(&pchip->work, lm3630a_delayed_func);
155 	pchip->irqthread = create_singlethread_workqueue("lm3630a-irqthd");
156 	if (!pchip->irqthread) {
157 		dev_err(pchip->dev, "create irq thread fail\n");
158 		return -ENOMEM;
159 	}
160 	if (request_threaded_irq
161 	    (pchip->irq, NULL, lm3630a_isr_func,
162 	     IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm3630a_irq", pchip)) {
163 		dev_err(pchip->dev, "request threaded irq fail\n");
164 		destroy_workqueue(pchip->irqthread);
165 		return -ENOMEM;
166 	}
167 	return rval;
168 }
169 
170 static void lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max)
171 {
172 	unsigned int period = pchip->pdata->pwm_period;
173 	unsigned int duty = br * period / br_max;
174 
175 	pwm_config(pchip->pwmd, duty, period);
176 	if (duty)
177 		pwm_enable(pchip->pwmd);
178 	else
179 		pwm_disable(pchip->pwmd);
180 }
181 
182 /* update and get brightness */
183 static int lm3630a_bank_a_update_status(struct backlight_device *bl)
184 {
185 	int ret;
186 	struct lm3630a_chip *pchip = bl_get_data(bl);
187 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
188 
189 	/* pwm control */
190 	if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) {
191 		lm3630a_pwm_ctrl(pchip, bl->props.brightness,
192 				 bl->props.max_brightness);
193 		return bl->props.brightness;
194 	}
195 
196 	/* disable sleep */
197 	ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
198 	if (ret < 0)
199 		goto out_i2c_err;
200 	usleep_range(1000, 2000);
201 	/* minimum brightness is 0x04 */
202 	ret = lm3630a_write(pchip, REG_BRT_A, bl->props.brightness);
203 	if (bl->props.brightness < 0x4)
204 		ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDA_ENABLE, 0);
205 	else
206 		ret |= lm3630a_update(pchip, REG_CTRL,
207 				      LM3630A_LEDA_ENABLE, LM3630A_LEDA_ENABLE);
208 	if (ret < 0)
209 		goto out_i2c_err;
210 	return 0;
211 
212 out_i2c_err:
213 	dev_err(pchip->dev, "i2c failed to access\n");
214 	return bl->props.brightness;
215 }
216 
217 static int lm3630a_bank_a_get_brightness(struct backlight_device *bl)
218 {
219 	int brightness, rval;
220 	struct lm3630a_chip *pchip = bl_get_data(bl);
221 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
222 
223 	if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) {
224 		rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
225 		if (rval < 0)
226 			goto out_i2c_err;
227 		brightness = (rval & 0x01) << 8;
228 		rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
229 		if (rval < 0)
230 			goto out_i2c_err;
231 		brightness |= rval;
232 		goto out;
233 	}
234 
235 	/* disable sleep */
236 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
237 	if (rval < 0)
238 		goto out_i2c_err;
239 	usleep_range(1000, 2000);
240 	rval = lm3630a_read(pchip, REG_BRT_A);
241 	if (rval < 0)
242 		goto out_i2c_err;
243 	brightness = rval;
244 
245 out:
246 	bl->props.brightness = brightness;
247 	return bl->props.brightness;
248 out_i2c_err:
249 	dev_err(pchip->dev, "i2c failed to access register\n");
250 	return 0;
251 }
252 
253 static const struct backlight_ops lm3630a_bank_a_ops = {
254 	.options = BL_CORE_SUSPENDRESUME,
255 	.update_status = lm3630a_bank_a_update_status,
256 	.get_brightness = lm3630a_bank_a_get_brightness,
257 };
258 
259 /* update and get brightness */
260 static int lm3630a_bank_b_update_status(struct backlight_device *bl)
261 {
262 	int ret;
263 	struct lm3630a_chip *pchip = bl_get_data(bl);
264 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
265 
266 	/* pwm control */
267 	if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) {
268 		lm3630a_pwm_ctrl(pchip, bl->props.brightness,
269 				 bl->props.max_brightness);
270 		return bl->props.brightness;
271 	}
272 
273 	/* disable sleep */
274 	ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
275 	if (ret < 0)
276 		goto out_i2c_err;
277 	usleep_range(1000, 2000);
278 	/* minimum brightness is 0x04 */
279 	ret = lm3630a_write(pchip, REG_BRT_B, bl->props.brightness);
280 	if (bl->props.brightness < 0x4)
281 		ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDB_ENABLE, 0);
282 	else
283 		ret |= lm3630a_update(pchip, REG_CTRL,
284 				      LM3630A_LEDB_ENABLE, LM3630A_LEDB_ENABLE);
285 	if (ret < 0)
286 		goto out_i2c_err;
287 	return 0;
288 
289 out_i2c_err:
290 	dev_err(pchip->dev, "i2c failed to access REG_CTRL\n");
291 	return bl->props.brightness;
292 }
293 
294 static int lm3630a_bank_b_get_brightness(struct backlight_device *bl)
295 {
296 	int brightness, rval;
297 	struct lm3630a_chip *pchip = bl_get_data(bl);
298 	enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
299 
300 	if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) {
301 		rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
302 		if (rval < 0)
303 			goto out_i2c_err;
304 		brightness = (rval & 0x01) << 8;
305 		rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
306 		if (rval < 0)
307 			goto out_i2c_err;
308 		brightness |= rval;
309 		goto out;
310 	}
311 
312 	/* disable sleep */
313 	rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
314 	if (rval < 0)
315 		goto out_i2c_err;
316 	usleep_range(1000, 2000);
317 	rval = lm3630a_read(pchip, REG_BRT_B);
318 	if (rval < 0)
319 		goto out_i2c_err;
320 	brightness = rval;
321 
322 out:
323 	bl->props.brightness = brightness;
324 	return bl->props.brightness;
325 out_i2c_err:
326 	dev_err(pchip->dev, "i2c failed to access register\n");
327 	return 0;
328 }
329 
330 static const struct backlight_ops lm3630a_bank_b_ops = {
331 	.options = BL_CORE_SUSPENDRESUME,
332 	.update_status = lm3630a_bank_b_update_status,
333 	.get_brightness = lm3630a_bank_b_get_brightness,
334 };
335 
336 static int lm3630a_backlight_register(struct lm3630a_chip *pchip)
337 {
338 	struct lm3630a_platform_data *pdata = pchip->pdata;
339 	struct backlight_properties props;
340 	const char *label;
341 
342 	props.type = BACKLIGHT_RAW;
343 	if (pdata->leda_ctrl != LM3630A_LEDA_DISABLE) {
344 		props.brightness = pdata->leda_init_brt;
345 		props.max_brightness = pdata->leda_max_brt;
346 		label = pdata->leda_label ? pdata->leda_label : "lm3630a_leda";
347 		pchip->bleda =
348 		    devm_backlight_device_register(pchip->dev, label,
349 						   pchip->dev, pchip,
350 						   &lm3630a_bank_a_ops, &props);
351 		if (IS_ERR(pchip->bleda))
352 			return PTR_ERR(pchip->bleda);
353 	}
354 
355 	if ((pdata->ledb_ctrl != LM3630A_LEDB_DISABLE) &&
356 	    (pdata->ledb_ctrl != LM3630A_LEDB_ON_A)) {
357 		props.brightness = pdata->ledb_init_brt;
358 		props.max_brightness = pdata->ledb_max_brt;
359 		label = pdata->ledb_label ? pdata->ledb_label : "lm3630a_ledb";
360 		pchip->bledb =
361 		    devm_backlight_device_register(pchip->dev, label,
362 						   pchip->dev, pchip,
363 						   &lm3630a_bank_b_ops, &props);
364 		if (IS_ERR(pchip->bledb))
365 			return PTR_ERR(pchip->bledb);
366 	}
367 	return 0;
368 }
369 
370 static const struct regmap_config lm3630a_regmap = {
371 	.reg_bits = 8,
372 	.val_bits = 8,
373 	.max_register = REG_MAX,
374 };
375 
376 static int lm3630a_parse_led_sources(struct fwnode_handle *node,
377 				     int default_led_sources)
378 {
379 	u32 sources[LM3630A_NUM_SINKS];
380 	int ret, num_sources, i;
381 
382 	num_sources = fwnode_property_count_u32(node, "led-sources");
383 	if (num_sources < 0)
384 		return default_led_sources;
385 	else if (num_sources > ARRAY_SIZE(sources))
386 		return -EINVAL;
387 
388 	ret = fwnode_property_read_u32_array(node, "led-sources", sources,
389 					     num_sources);
390 	if (ret)
391 		return ret;
392 
393 	for (i = 0; i < num_sources; i++) {
394 		if (sources[i] != LM3630A_SINK_0 && sources[i] != LM3630A_SINK_1)
395 			return -EINVAL;
396 
397 		ret |= BIT(sources[i]);
398 	}
399 
400 	return ret;
401 }
402 
403 static int lm3630a_parse_bank(struct lm3630a_platform_data *pdata,
404 			      struct fwnode_handle *node, int *seen_led_sources)
405 {
406 	int led_sources, ret;
407 	const char *label;
408 	u32 bank, val;
409 	bool linear;
410 
411 	ret = fwnode_property_read_u32(node, "reg", &bank);
412 	if (ret)
413 		return ret;
414 
415 	if (bank != LM3630A_BANK_0 && bank != LM3630A_BANK_1)
416 		return -EINVAL;
417 
418 	led_sources = lm3630a_parse_led_sources(node, BIT(bank));
419 	if (led_sources < 0)
420 		return led_sources;
421 
422 	if (*seen_led_sources & led_sources)
423 		return -EINVAL;
424 
425 	*seen_led_sources |= led_sources;
426 
427 	linear = fwnode_property_read_bool(node,
428 					   "ti,linear-mapping-mode");
429 	if (bank) {
430 		if (led_sources & BIT(LM3630A_SINK_0) ||
431 		    !(led_sources & BIT(LM3630A_SINK_1)))
432 			return -EINVAL;
433 
434 		pdata->ledb_ctrl = linear ?
435 			LM3630A_LEDB_ENABLE_LINEAR :
436 			LM3630A_LEDB_ENABLE;
437 	} else {
438 		if (!(led_sources & BIT(LM3630A_SINK_0)))
439 			return -EINVAL;
440 
441 		pdata->leda_ctrl = linear ?
442 			LM3630A_LEDA_ENABLE_LINEAR :
443 			LM3630A_LEDA_ENABLE;
444 
445 		if (led_sources & BIT(LM3630A_SINK_1))
446 			pdata->ledb_ctrl = LM3630A_LEDB_ON_A;
447 	}
448 
449 	ret = fwnode_property_read_string(node, "label", &label);
450 	if (!ret) {
451 		if (bank)
452 			pdata->ledb_label = label;
453 		else
454 			pdata->leda_label = label;
455 	}
456 
457 	ret = fwnode_property_read_u32(node, "default-brightness",
458 				       &val);
459 	if (!ret) {
460 		if (bank)
461 			pdata->ledb_init_brt = val;
462 		else
463 			pdata->leda_init_brt = val;
464 	}
465 
466 	ret = fwnode_property_read_u32(node, "max-brightness", &val);
467 	if (!ret) {
468 		if (bank)
469 			pdata->ledb_max_brt = val;
470 		else
471 			pdata->leda_max_brt = val;
472 	}
473 
474 	return 0;
475 }
476 
477 static int lm3630a_parse_node(struct lm3630a_chip *pchip,
478 			      struct lm3630a_platform_data *pdata)
479 {
480 	int ret = -ENODEV, seen_led_sources = 0;
481 	struct fwnode_handle *node;
482 
483 	device_for_each_child_node(pchip->dev, node) {
484 		ret = lm3630a_parse_bank(pdata, node, &seen_led_sources);
485 		if (ret)
486 			return ret;
487 	}
488 
489 	return ret;
490 }
491 
492 static int lm3630a_probe(struct i2c_client *client,
493 			 const struct i2c_device_id *id)
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 		/*
567 		 * FIXME: pwm_apply_args() should be removed when switching to
568 		 * the atomic PWM API.
569 		 */
570 		pwm_apply_args(pchip->pwmd);
571 	}
572 
573 	/* interrupt enable  : irq 0 is not allowed */
574 	pchip->irq = client->irq;
575 	if (pchip->irq) {
576 		rval = lm3630a_intr_config(pchip);
577 		if (rval < 0)
578 			return rval;
579 	}
580 	dev_info(&client->dev, "LM3630A backlight register OK.\n");
581 	return 0;
582 }
583 
584 static int lm3630a_remove(struct i2c_client *client)
585 {
586 	int rval;
587 	struct lm3630a_chip *pchip = i2c_get_clientdata(client);
588 
589 	rval = lm3630a_write(pchip, REG_BRT_A, 0);
590 	if (rval < 0)
591 		dev_err(pchip->dev, "i2c failed to access register\n");
592 
593 	rval = lm3630a_write(pchip, REG_BRT_B, 0);
594 	if (rval < 0)
595 		dev_err(pchip->dev, "i2c failed to access register\n");
596 
597 	if (pchip->irq) {
598 		free_irq(pchip->irq, pchip);
599 		flush_workqueue(pchip->irqthread);
600 		destroy_workqueue(pchip->irqthread);
601 	}
602 	return 0;
603 }
604 
605 static const struct i2c_device_id lm3630a_id[] = {
606 	{LM3630A_NAME, 0},
607 	{}
608 };
609 
610 MODULE_DEVICE_TABLE(i2c, lm3630a_id);
611 
612 static const struct of_device_id lm3630a_match_table[] = {
613 	{ .compatible = "ti,lm3630a", },
614 	{ },
615 };
616 
617 MODULE_DEVICE_TABLE(of, lm3630a_match_table);
618 
619 static struct i2c_driver lm3630a_i2c_driver = {
620 	.driver = {
621 		   .name = LM3630A_NAME,
622 		   .of_match_table = lm3630a_match_table,
623 		   },
624 	.probe = lm3630a_probe,
625 	.remove = lm3630a_remove,
626 	.id_table = lm3630a_id,
627 };
628 
629 module_i2c_driver(lm3630a_i2c_driver);
630 
631 MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A");
632 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
633 MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>");
634 MODULE_LICENSE("GPL v2");
635