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
43struct 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 */
59static 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
70static 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
76static 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 */
84static 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 */
114static 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
131static 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
147static 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
171static 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 */
187static 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
216out_i2c_err:
217	dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret));
218	return ret;
219}
220
221static 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
249out_i2c_err:
250	dev_err(pchip->dev, "i2c failed to access register\n");
251	return 0;
252}
253
254static 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 */
261static 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
290out_i2c_err:
291	dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret));
292	return ret;
293}
294
295static 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
323out_i2c_err:
324	dev_err(pchip->dev, "i2c failed to access register\n");
325	return 0;
326}
327
328static 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
334static 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
369static const struct regmap_config lm3630a_regmap = {
370	.reg_bits = 8,
371	.val_bits = 8,
372	.max_register = REG_MAX,
373};
374
375static 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
402static 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
476static 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
493static 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
580static 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
599static const struct i2c_device_id lm3630a_id[] = {
600	{LM3630A_NAME, 0},
601	{}
602};
603
604MODULE_DEVICE_TABLE(i2c, lm3630a_id);
605
606static const struct of_device_id lm3630a_match_table[] = {
607	{ .compatible = "ti,lm3630a", },
608	{ },
609};
610
611MODULE_DEVICE_TABLE(of, lm3630a_match_table);
612
613static 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
623module_i2c_driver(lm3630a_i2c_driver);
624
625MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A");
626MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
627MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>");
628MODULE_LICENSE("GPL v2");
629