1// SPDX-License-Identifier: GPL-2.0+
2// Driver for Awinic AW2013 3-channel LED driver
3
4#include <linux/i2c.h>
5#include <linux/leds.h>
6#include <linux/module.h>
7#include <linux/regulator/consumer.h>
8#include <linux/mutex.h>
9#include <linux/of.h>
10#include <linux/regmap.h>
11
12#define AW2013_MAX_LEDS 3
13
14/* Reset and ID register */
15#define AW2013_RSTR 0x00
16#define AW2013_RSTR_RESET 0x55
17#define AW2013_RSTR_CHIP_ID 0x33
18
19/* Global control register */
20#define AW2013_GCR 0x01
21#define AW2013_GCR_ENABLE BIT(0)
22
23/* LED channel enable register */
24#define AW2013_LCTR 0x30
25#define AW2013_LCTR_LE(x) BIT((x))
26
27/* LED channel control registers */
28#define AW2013_LCFG(x) (0x31 + (x))
29#define AW2013_LCFG_IMAX_MASK (BIT(0) | BIT(1)) // Should be 0-3
30#define AW2013_LCFG_MD BIT(4)
31#define AW2013_LCFG_FI BIT(5)
32#define AW2013_LCFG_FO BIT(6)
33
34/* LED channel PWM registers */
35#define AW2013_REG_PWM(x) (0x34 + (x))
36
37/* LED channel timing registers */
38#define AW2013_LEDT0(x) (0x37 + (x) * 3)
39#define AW2013_LEDT0_T1(x) ((x) << 4) // Should be 0-7
40#define AW2013_LEDT0_T2(x) (x) // Should be 0-5
41
42#define AW2013_LEDT1(x) (0x38 + (x) * 3)
43#define AW2013_LEDT1_T3(x) ((x) << 4) // Should be 0-7
44#define AW2013_LEDT1_T4(x) (x) // Should be 0-7
45
46#define AW2013_LEDT2(x) (0x39 + (x) * 3)
47#define AW2013_LEDT2_T0(x) ((x) << 4) // Should be 0-8
48#define AW2013_LEDT2_REPEAT(x) (x) // Should be 0-15
49
50#define AW2013_REG_MAX 0x77
51
52#define AW2013_TIME_STEP 130 /* ms */
53
54struct aw2013;
55
56struct aw2013_led {
57	struct aw2013 *chip;
58	struct led_classdev cdev;
59	u32 num;
60	unsigned int imax;
61};
62
63struct aw2013 {
64	struct mutex mutex; /* held when writing to registers */
65	struct regulator_bulk_data regulators[2];
66	struct i2c_client *client;
67	struct aw2013_led leds[AW2013_MAX_LEDS];
68	struct regmap *regmap;
69	int num_leds;
70	bool enabled;
71};
72
73static int aw2013_chip_init(struct aw2013 *chip)
74{
75	int i, ret;
76
77	ret = regmap_write(chip->regmap, AW2013_GCR, AW2013_GCR_ENABLE);
78	if (ret) {
79		dev_err(&chip->client->dev, "Failed to enable the chip: %d\n",
80			ret);
81		return ret;
82	}
83
84	for (i = 0; i < chip->num_leds; i++) {
85		ret = regmap_update_bits(chip->regmap,
86					 AW2013_LCFG(chip->leds[i].num),
87					 AW2013_LCFG_IMAX_MASK,
88					 chip->leds[i].imax);
89		if (ret) {
90			dev_err(&chip->client->dev,
91				"Failed to set maximum current for led %d: %d\n",
92				chip->leds[i].num, ret);
93			return ret;
94		}
95	}
96
97	return ret;
98}
99
100static void aw2013_chip_disable(struct aw2013 *chip)
101{
102	int ret;
103
104	if (!chip->enabled)
105		return;
106
107	regmap_write(chip->regmap, AW2013_GCR, 0);
108
109	ret = regulator_bulk_disable(ARRAY_SIZE(chip->regulators),
110				     chip->regulators);
111	if (ret) {
112		dev_err(&chip->client->dev,
113			"Failed to disable regulators: %d\n", ret);
114		return;
115	}
116
117	chip->enabled = false;
118}
119
120static int aw2013_chip_enable(struct aw2013 *chip)
121{
122	int ret;
123
124	if (chip->enabled)
125		return 0;
126
127	ret = regulator_bulk_enable(ARRAY_SIZE(chip->regulators),
128				    chip->regulators);
129	if (ret) {
130		dev_err(&chip->client->dev,
131			"Failed to enable regulators: %d\n", ret);
132		return ret;
133	}
134	chip->enabled = true;
135
136	ret = aw2013_chip_init(chip);
137	if (ret)
138		aw2013_chip_disable(chip);
139
140	return ret;
141}
142
143static bool aw2013_chip_in_use(struct aw2013 *chip)
144{
145	int i;
146
147	for (i = 0; i < chip->num_leds; i++)
148		if (chip->leds[i].cdev.brightness)
149			return true;
150
151	return false;
152}
153
154static int aw2013_brightness_set(struct led_classdev *cdev,
155				 enum led_brightness brightness)
156{
157	struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
158	int ret, num;
159
160	mutex_lock(&led->chip->mutex);
161
162	if (aw2013_chip_in_use(led->chip)) {
163		ret = aw2013_chip_enable(led->chip);
164		if (ret)
165			goto error;
166	}
167
168	num = led->num;
169
170	ret = regmap_write(led->chip->regmap, AW2013_REG_PWM(num), brightness);
171	if (ret)
172		goto error;
173
174	if (brightness) {
175		ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
176					 AW2013_LCTR_LE(num), 0xFF);
177	} else {
178		ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
179					 AW2013_LCTR_LE(num), 0);
180		if (ret)
181			goto error;
182		ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
183					 AW2013_LCFG_MD, 0);
184	}
185	if (ret)
186		goto error;
187
188	if (!aw2013_chip_in_use(led->chip))
189		aw2013_chip_disable(led->chip);
190
191error:
192	mutex_unlock(&led->chip->mutex);
193
194	return ret;
195}
196
197static int aw2013_blink_set(struct led_classdev *cdev,
198			    unsigned long *delay_on, unsigned long *delay_off)
199{
200	struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
201	int ret, num = led->num;
202	unsigned long off = 0, on = 0;
203
204	/* If no blink specified, default to 1 Hz. */
205	if (!*delay_off && !*delay_on) {
206		*delay_off = 500;
207		*delay_on = 500;
208	}
209
210	if (!led->cdev.brightness) {
211		led->cdev.brightness = LED_FULL;
212		ret = aw2013_brightness_set(&led->cdev, led->cdev.brightness);
213		if (ret)
214			return ret;
215	}
216
217	/* Never on - just set to off */
218	if (!*delay_on) {
219		led->cdev.brightness = LED_OFF;
220		return aw2013_brightness_set(&led->cdev, LED_OFF);
221	}
222
223	mutex_lock(&led->chip->mutex);
224
225	/* Never off - brightness is already set, disable blinking */
226	if (!*delay_off) {
227		ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
228					 AW2013_LCFG_MD, 0);
229		goto out;
230	}
231
232	/* Convert into values the HW will understand. */
233	off = min(5, ilog2((*delay_off - 1) / AW2013_TIME_STEP) + 1);
234	on = min(7, ilog2((*delay_on - 1) / AW2013_TIME_STEP) + 1);
235
236	*delay_off = BIT(off) * AW2013_TIME_STEP;
237	*delay_on = BIT(on) * AW2013_TIME_STEP;
238
239	/* Set timings */
240	ret = regmap_write(led->chip->regmap,
241			   AW2013_LEDT0(num), AW2013_LEDT0_T2(on));
242	if (ret)
243		goto out;
244	ret = regmap_write(led->chip->regmap,
245			   AW2013_LEDT1(num), AW2013_LEDT1_T4(off));
246	if (ret)
247		goto out;
248
249	/* Finally, enable the LED */
250	ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
251				 AW2013_LCFG_MD, 0xFF);
252	if (ret)
253		goto out;
254
255	ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
256				 AW2013_LCTR_LE(num), 0xFF);
257
258out:
259	mutex_unlock(&led->chip->mutex);
260
261	return ret;
262}
263
264static int aw2013_probe_dt(struct aw2013 *chip)
265{
266	struct device_node *np = dev_of_node(&chip->client->dev), *child;
267	int count, ret = 0, i = 0;
268	struct aw2013_led *led;
269
270	count = of_get_available_child_count(np);
271	if (!count || count > AW2013_MAX_LEDS)
272		return -EINVAL;
273
274	regmap_write(chip->regmap, AW2013_RSTR, AW2013_RSTR_RESET);
275
276	for_each_available_child_of_node(np, child) {
277		struct led_init_data init_data = {};
278		u32 source;
279		u32 imax;
280
281		ret = of_property_read_u32(child, "reg", &source);
282		if (ret != 0 || source >= AW2013_MAX_LEDS) {
283			dev_err(&chip->client->dev,
284				"Couldn't read LED address: %d\n", ret);
285			count--;
286			continue;
287		}
288
289		led = &chip->leds[i];
290		led->num = source;
291		led->chip = chip;
292		init_data.fwnode = of_fwnode_handle(child);
293
294		if (!of_property_read_u32(child, "led-max-microamp", &imax)) {
295			led->imax = min_t(u32, imax / 5000, 3);
296		} else {
297			led->imax = 1; // 5mA
298			dev_info(&chip->client->dev,
299				 "DT property led-max-microamp is missing\n");
300		}
301
302		led->cdev.brightness_set_blocking = aw2013_brightness_set;
303		led->cdev.blink_set = aw2013_blink_set;
304
305		ret = devm_led_classdev_register_ext(&chip->client->dev,
306						     &led->cdev, &init_data);
307		if (ret < 0) {
308			of_node_put(child);
309			return ret;
310		}
311
312		i++;
313	}
314
315	if (!count)
316		return -EINVAL;
317
318	chip->num_leds = i;
319
320	return 0;
321}
322
323static const struct regmap_config aw2013_regmap_config = {
324	.reg_bits = 8,
325	.val_bits = 8,
326	.max_register = AW2013_REG_MAX,
327};
328
329static int aw2013_probe(struct i2c_client *client)
330{
331	struct aw2013 *chip;
332	int ret;
333	unsigned int chipid;
334
335	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
336	if (!chip)
337		return -ENOMEM;
338
339	mutex_init(&chip->mutex);
340	mutex_lock(&chip->mutex);
341
342	chip->client = client;
343	i2c_set_clientdata(client, chip);
344
345	chip->regmap = devm_regmap_init_i2c(client, &aw2013_regmap_config);
346	if (IS_ERR(chip->regmap)) {
347		ret = PTR_ERR(chip->regmap);
348		dev_err(&client->dev, "Failed to allocate register map: %d\n",
349			ret);
350		goto error;
351	}
352
353	chip->regulators[0].supply = "vcc";
354	chip->regulators[1].supply = "vio";
355	ret = devm_regulator_bulk_get(&client->dev,
356				      ARRAY_SIZE(chip->regulators),
357				      chip->regulators);
358	if (ret < 0) {
359		if (ret != -EPROBE_DEFER)
360			dev_err(&client->dev,
361				"Failed to request regulators: %d\n", ret);
362		goto error;
363	}
364
365	ret = regulator_bulk_enable(ARRAY_SIZE(chip->regulators),
366				    chip->regulators);
367	if (ret) {
368		dev_err(&client->dev,
369			"Failed to enable regulators: %d\n", ret);
370		goto error;
371	}
372
373	ret = regmap_read(chip->regmap, AW2013_RSTR, &chipid);
374	if (ret) {
375		dev_err(&client->dev, "Failed to read chip ID: %d\n",
376			ret);
377		goto error_reg;
378	}
379
380	if (chipid != AW2013_RSTR_CHIP_ID) {
381		dev_err(&client->dev, "Chip reported wrong ID: %x\n",
382			chipid);
383		ret = -ENODEV;
384		goto error_reg;
385	}
386
387	ret = aw2013_probe_dt(chip);
388	if (ret < 0)
389		goto error_reg;
390
391	ret = regulator_bulk_disable(ARRAY_SIZE(chip->regulators),
392				     chip->regulators);
393	if (ret) {
394		dev_err(&client->dev,
395			"Failed to disable regulators: %d\n", ret);
396		goto error;
397	}
398
399	mutex_unlock(&chip->mutex);
400
401	return 0;
402
403error_reg:
404	regulator_bulk_disable(ARRAY_SIZE(chip->regulators),
405			       chip->regulators);
406
407error:
408	mutex_unlock(&chip->mutex);
409	mutex_destroy(&chip->mutex);
410	return ret;
411}
412
413static void aw2013_remove(struct i2c_client *client)
414{
415	struct aw2013 *chip = i2c_get_clientdata(client);
416
417	aw2013_chip_disable(chip);
418
419	mutex_destroy(&chip->mutex);
420}
421
422static const struct of_device_id aw2013_match_table[] = {
423	{ .compatible = "awinic,aw2013", },
424	{ /* sentinel */ },
425};
426
427MODULE_DEVICE_TABLE(of, aw2013_match_table);
428
429static struct i2c_driver aw2013_driver = {
430	.driver = {
431		.name = "leds-aw2013",
432		.of_match_table = aw2013_match_table,
433	},
434	.probe = aw2013_probe,
435	.remove = aw2013_remove,
436};
437
438module_i2c_driver(aw2013_driver);
439
440MODULE_AUTHOR("Nikita Travkin <nikitos.tr@gmail.com>");
441MODULE_DESCRIPTION("AW2013 LED driver");
442MODULE_LICENSE("GPL v2");
443