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 | |
54 | struct aw2013; |
55 | |
56 | struct aw2013_led { |
57 | struct aw2013 *chip; |
58 | struct led_classdev cdev; |
59 | u32 num; |
60 | unsigned int imax; |
61 | }; |
62 | |
63 | struct 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 | |
73 | static int aw2013_chip_init(struct aw2013 *chip) |
74 | { |
75 | int i, ret; |
76 | |
77 | ret = regmap_write(map: 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(map: chip->regmap, |
86 | AW2013_LCFG(chip->leds[i].num), |
87 | AW2013_LCFG_IMAX_MASK, |
88 | val: 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 | |
100 | static void aw2013_chip_disable(struct aw2013 *chip) |
101 | { |
102 | int ret; |
103 | |
104 | if (!chip->enabled) |
105 | return; |
106 | |
107 | regmap_write(map: chip->regmap, AW2013_GCR, val: 0); |
108 | |
109 | ret = regulator_bulk_disable(ARRAY_SIZE(chip->regulators), |
110 | consumers: 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 | |
120 | static 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 | consumers: 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 | |
143 | static 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 | |
154 | static 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(chip: led->chip)) { |
163 | ret = aw2013_chip_enable(chip: led->chip); |
164 | if (ret) |
165 | goto error; |
166 | } |
167 | |
168 | num = led->num; |
169 | |
170 | ret = regmap_write(map: led->chip->regmap, AW2013_REG_PWM(num), val: brightness); |
171 | if (ret) |
172 | goto error; |
173 | |
174 | if (brightness) { |
175 | ret = regmap_update_bits(map: led->chip->regmap, AW2013_LCTR, |
176 | AW2013_LCTR_LE(num), val: 0xFF); |
177 | } else { |
178 | ret = regmap_update_bits(map: led->chip->regmap, AW2013_LCTR, |
179 | AW2013_LCTR_LE(num), val: 0); |
180 | if (ret) |
181 | goto error; |
182 | ret = regmap_update_bits(map: led->chip->regmap, AW2013_LCFG(num), |
183 | AW2013_LCFG_MD, val: 0); |
184 | } |
185 | if (ret) |
186 | goto error; |
187 | |
188 | if (!aw2013_chip_in_use(chip: led->chip)) |
189 | aw2013_chip_disable(chip: led->chip); |
190 | |
191 | error: |
192 | mutex_unlock(lock: &led->chip->mutex); |
193 | |
194 | return ret; |
195 | } |
196 | |
197 | static 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(cdev: &led->cdev, brightness: 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(cdev: &led->cdev, brightness: 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(map: led->chip->regmap, AW2013_LCFG(num), |
228 | AW2013_LCFG_MD, val: 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(map: led->chip->regmap, |
241 | AW2013_LEDT0(num), AW2013_LEDT0_T2(on)); |
242 | if (ret) |
243 | goto out; |
244 | ret = regmap_write(map: 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(map: led->chip->regmap, AW2013_LCFG(num), |
251 | AW2013_LCFG_MD, val: 0xFF); |
252 | if (ret) |
253 | goto out; |
254 | |
255 | ret = regmap_update_bits(map: led->chip->regmap, AW2013_LCTR, |
256 | AW2013_LCTR_LE(num), val: 0xFF); |
257 | |
258 | out: |
259 | mutex_unlock(lock: &led->chip->mutex); |
260 | |
261 | return ret; |
262 | } |
263 | |
264 | static int aw2013_probe_dt(struct aw2013 *chip) |
265 | { |
266 | struct device_node *np = dev_of_node(dev: &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(map: 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(np: child, propname: "reg" , out_value: &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(np: child, propname: "led-max-microamp" , out_value: &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(parent: &chip->client->dev, |
306 | led_cdev: &led->cdev, init_data: &init_data); |
307 | if (ret < 0) { |
308 | of_node_put(node: 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 | |
323 | static const struct regmap_config aw2013_regmap_config = { |
324 | .reg_bits = 8, |
325 | .val_bits = 8, |
326 | .max_register = AW2013_REG_MAX, |
327 | }; |
328 | |
329 | static int aw2013_probe(struct i2c_client *client) |
330 | { |
331 | struct aw2013 *chip; |
332 | int ret; |
333 | unsigned int chipid; |
334 | |
335 | chip = devm_kzalloc(dev: &client->dev, size: 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, data: chip); |
344 | |
345 | chip->regmap = devm_regmap_init_i2c(client, &aw2013_regmap_config); |
346 | if (IS_ERR(ptr: chip->regmap)) { |
347 | ret = PTR_ERR(ptr: 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(dev: &client->dev, |
356 | ARRAY_SIZE(chip->regulators), |
357 | consumers: 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 | consumers: 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(map: chip->regmap, AW2013_RSTR, val: &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 | consumers: 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(lock: &chip->mutex); |
400 | |
401 | return 0; |
402 | |
403 | error_reg: |
404 | regulator_bulk_disable(ARRAY_SIZE(chip->regulators), |
405 | consumers: chip->regulators); |
406 | |
407 | error: |
408 | mutex_unlock(lock: &chip->mutex); |
409 | mutex_destroy(lock: &chip->mutex); |
410 | return ret; |
411 | } |
412 | |
413 | static 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(lock: &chip->mutex); |
420 | } |
421 | |
422 | static const struct of_device_id aw2013_match_table[] = { |
423 | { .compatible = "awinic,aw2013" , }, |
424 | { /* sentinel */ }, |
425 | }; |
426 | |
427 | MODULE_DEVICE_TABLE(of, aw2013_match_table); |
428 | |
429 | static 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 | |
438 | module_i2c_driver(aw2013_driver); |
439 | |
440 | MODULE_AUTHOR("Nikita Travkin <nikitos.tr@gmail.com>" ); |
441 | MODULE_DESCRIPTION("AW2013 LED driver" ); |
442 | MODULE_LICENSE("GPL v2" ); |
443 | |