1// SPDX-License-Identifier: GPL-2.0
2// TI LP50XX LED chip family driver
3// Copyright (C) 2018-20 Texas Instruments Incorporated - https://www.ti.com/
4
5#include <linux/gpio/consumer.h>
6#include <linux/i2c.h>
7#include <linux/init.h>
8#include <linux/leds.h>
9#include <linux/mod_devicetable.h>
10#include <linux/module.h>
11#include <linux/mutex.h>
12#include <linux/regmap.h>
13#include <linux/regulator/consumer.h>
14#include <linux/slab.h>
15#include <uapi/linux/uleds.h>
16
17#include <linux/led-class-multicolor.h>
18
19#define LP50XX_DEV_CFG0 0x00
20#define LP50XX_DEV_CFG1 0x01
21#define LP50XX_LED_CFG0 0x02
22
23/* LP5009 and LP5012 registers */
24#define LP5012_BNK_BRT 0x03
25#define LP5012_BNKA_CLR 0x04
26#define LP5012_BNKB_CLR 0x05
27#define LP5012_BNKC_CLR 0x06
28#define LP5012_LED0_BRT 0x07
29#define LP5012_OUT0_CLR 0x0b
30#define LP5012_RESET 0x17
31
32/* LP5018 and LP5024 registers */
33#define LP5024_BNK_BRT 0x03
34#define LP5024_BNKA_CLR 0x04
35#define LP5024_BNKB_CLR 0x05
36#define LP5024_BNKC_CLR 0x06
37#define LP5024_LED0_BRT 0x07
38#define LP5024_OUT0_CLR 0x0f
39#define LP5024_RESET 0x27
40
41/* LP5030 and LP5036 registers */
42#define LP5036_LED_CFG1 0x03
43#define LP5036_BNK_BRT 0x04
44#define LP5036_BNKA_CLR 0x05
45#define LP5036_BNKB_CLR 0x06
46#define LP5036_BNKC_CLR 0x07
47#define LP5036_LED0_BRT 0x08
48#define LP5036_OUT0_CLR 0x14
49#define LP5036_RESET 0x38
50
51#define LP50XX_SW_RESET 0xff
52#define LP50XX_CHIP_EN BIT(6)
53#define LP50XX_CHIP_DISABLE 0x00
54#define LP50XX_START_TIME_US 500
55#define LP50XX_RESET_TIME_US 3
56
57#define LP50XX_EN_GPIO_LOW 0
58#define LP50XX_EN_GPIO_HIGH 1
59
60/* There are 3 LED outputs per bank */
61#define LP50XX_LEDS_PER_MODULE 3
62
63#define LP5009_MAX_LED_MODULES 3
64#define LP5012_MAX_LED_MODULES 4
65#define LP5018_MAX_LED_MODULES 6
66#define LP5024_MAX_LED_MODULES 8
67#define LP5030_MAX_LED_MODULES 10
68#define LP5036_MAX_LED_MODULES 12
69
70static const struct reg_default lp5012_reg_defs[] = {
71 {LP50XX_DEV_CFG0, 0x0},
72 {LP50XX_DEV_CFG1, 0x3c},
73 {LP50XX_LED_CFG0, 0x0},
74 {LP5012_BNK_BRT, 0xff},
75 {LP5012_BNKA_CLR, 0x0f},
76 {LP5012_BNKB_CLR, 0x0f},
77 {LP5012_BNKC_CLR, 0x0f},
78 {LP5012_LED0_BRT, 0x0f},
79 /* LEDX_BRT registers are all 0xff for defaults */
80 {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
81 {LP5012_OUT0_CLR, 0x0f},
82 /* OUTX_CLR registers are all 0x0 for defaults */
83 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
84 {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00},
85 {0x16, 0x00},
86 {LP5012_RESET, 0x00}
87};
88
89static const struct reg_default lp5024_reg_defs[] = {
90 {LP50XX_DEV_CFG0, 0x0},
91 {LP50XX_DEV_CFG1, 0x3c},
92 {LP50XX_LED_CFG0, 0x0},
93 {LP5024_BNK_BRT, 0xff},
94 {LP5024_BNKA_CLR, 0x0f},
95 {LP5024_BNKB_CLR, 0x0f},
96 {LP5024_BNKC_CLR, 0x0f},
97 {LP5024_LED0_BRT, 0x0f},
98 /* LEDX_BRT registers are all 0xff for defaults */
99 {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
100 {0x0d, 0xff}, {0x0e, 0xff},
101 {LP5024_OUT0_CLR, 0x0f},
102 /* OUTX_CLR registers are all 0x0 for defaults */
103 {0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
104 {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
105 {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
106 {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
107 {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
108 {LP5024_RESET, 0x00}
109};
110
111static const struct reg_default lp5036_reg_defs[] = {
112 {LP50XX_DEV_CFG0, 0x0},
113 {LP50XX_DEV_CFG1, 0x3c},
114 {LP50XX_LED_CFG0, 0x0},
115 {LP5036_LED_CFG1, 0x0},
116 {LP5036_BNK_BRT, 0xff},
117 {LP5036_BNKA_CLR, 0x0f},
118 {LP5036_BNKB_CLR, 0x0f},
119 {LP5036_BNKC_CLR, 0x0f},
120 {LP5036_LED0_BRT, 0x0f},
121 /* LEDX_BRT registers are all 0xff for defaults */
122 {0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
123 {0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
124 {0x12, 0xff}, {0x13, 0xff},
125 {LP5036_OUT0_CLR, 0x0f},
126 /* OUTX_CLR registers are all 0x0 for defaults */
127 {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
128 {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
129 {0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
130 {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
131 {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
132 {0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
133 {0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
134 {LP5036_RESET, 0x00}
135};
136
137static const struct regmap_config lp5012_regmap_config = {
138 .reg_bits = 8,
139 .val_bits = 8,
140
141 .max_register = LP5012_RESET,
142 .reg_defaults = lp5012_reg_defs,
143 .num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
144 .cache_type = REGCACHE_FLAT,
145};
146
147static const struct regmap_config lp5024_regmap_config = {
148 .reg_bits = 8,
149 .val_bits = 8,
150
151 .max_register = LP5024_RESET,
152 .reg_defaults = lp5024_reg_defs,
153 .num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
154 .cache_type = REGCACHE_FLAT,
155};
156
157static const struct regmap_config lp5036_regmap_config = {
158 .reg_bits = 8,
159 .val_bits = 8,
160
161 .max_register = LP5036_RESET,
162 .reg_defaults = lp5036_reg_defs,
163 .num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
164 .cache_type = REGCACHE_FLAT,
165};
166
167enum lp50xx_model {
168 LP5009,
169 LP5012,
170 LP5018,
171 LP5024,
172 LP5030,
173 LP5036,
174};
175
176/**
177 * struct lp50xx_chip_info -
178 * @lp50xx_regmap_config: regmap register configuration
179 * @model_id: LED device model
180 * @max_modules: total number of supported LED modules
181 * @num_leds: number of LED outputs available on the device
182 * @led_brightness0_reg: first brightness register of the device
183 * @mix_out0_reg: first color mix register of the device
184 * @bank_brt_reg: bank brightness register
185 * @bank_mix_reg: color mix register
186 * @reset_reg: device reset register
187 */
188struct lp50xx_chip_info {
189 const struct regmap_config *lp50xx_regmap_config;
190 int model_id;
191 u8 max_modules;
192 u8 num_leds;
193 u8 led_brightness0_reg;
194 u8 mix_out0_reg;
195 u8 bank_brt_reg;
196 u8 bank_mix_reg;
197 u8 reset_reg;
198};
199
200static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
201 [LP5009] = {
202 .model_id = LP5009,
203 .max_modules = LP5009_MAX_LED_MODULES,
204 .num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
205 .led_brightness0_reg = LP5012_LED0_BRT,
206 .mix_out0_reg = LP5012_OUT0_CLR,
207 .bank_brt_reg = LP5012_BNK_BRT,
208 .bank_mix_reg = LP5012_BNKA_CLR,
209 .reset_reg = LP5012_RESET,
210 .lp50xx_regmap_config = &lp5012_regmap_config,
211 },
212 [LP5012] = {
213 .model_id = LP5012,
214 .max_modules = LP5012_MAX_LED_MODULES,
215 .num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
216 .led_brightness0_reg = LP5012_LED0_BRT,
217 .mix_out0_reg = LP5012_OUT0_CLR,
218 .bank_brt_reg = LP5012_BNK_BRT,
219 .bank_mix_reg = LP5012_BNKA_CLR,
220 .reset_reg = LP5012_RESET,
221 .lp50xx_regmap_config = &lp5012_regmap_config,
222 },
223 [LP5018] = {
224 .model_id = LP5018,
225 .max_modules = LP5018_MAX_LED_MODULES,
226 .num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
227 .led_brightness0_reg = LP5024_LED0_BRT,
228 .mix_out0_reg = LP5024_OUT0_CLR,
229 .bank_brt_reg = LP5024_BNK_BRT,
230 .bank_mix_reg = LP5024_BNKA_CLR,
231 .reset_reg = LP5024_RESET,
232 .lp50xx_regmap_config = &lp5024_regmap_config,
233 },
234 [LP5024] = {
235 .model_id = LP5024,
236 .max_modules = LP5024_MAX_LED_MODULES,
237 .num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
238 .led_brightness0_reg = LP5024_LED0_BRT,
239 .mix_out0_reg = LP5024_OUT0_CLR,
240 .bank_brt_reg = LP5024_BNK_BRT,
241 .bank_mix_reg = LP5024_BNKA_CLR,
242 .reset_reg = LP5024_RESET,
243 .lp50xx_regmap_config = &lp5024_regmap_config,
244 },
245 [LP5030] = {
246 .model_id = LP5030,
247 .max_modules = LP5030_MAX_LED_MODULES,
248 .num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
249 .led_brightness0_reg = LP5036_LED0_BRT,
250 .mix_out0_reg = LP5036_OUT0_CLR,
251 .bank_brt_reg = LP5036_BNK_BRT,
252 .bank_mix_reg = LP5036_BNKA_CLR,
253 .reset_reg = LP5036_RESET,
254 .lp50xx_regmap_config = &lp5036_regmap_config,
255 },
256 [LP5036] = {
257 .model_id = LP5036,
258 .max_modules = LP5036_MAX_LED_MODULES,
259 .num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
260 .led_brightness0_reg = LP5036_LED0_BRT,
261 .mix_out0_reg = LP5036_OUT0_CLR,
262 .bank_brt_reg = LP5036_BNK_BRT,
263 .bank_mix_reg = LP5036_BNKA_CLR,
264 .reset_reg = LP5036_RESET,
265 .lp50xx_regmap_config = &lp5036_regmap_config,
266 },
267};
268
269struct lp50xx_led {
270 struct led_classdev_mc mc_cdev;
271 struct lp50xx *priv;
272 u8 ctrl_bank_enabled;
273 int led_number;
274};
275
276/**
277 * struct lp50xx -
278 * @enable_gpio: hardware enable gpio
279 * @regulator: LED supply regulator pointer
280 * @client: pointer to the I2C client
281 * @regmap: device register map
282 * @dev: pointer to the devices device struct
283 * @lock: lock for reading/writing the device
284 * @chip_info: chip specific information (ie num_leds)
285 * @leds: array of LED strings
286 */
287struct lp50xx {
288 struct gpio_desc *enable_gpio;
289 struct regulator *regulator;
290 struct i2c_client *client;
291 struct regmap *regmap;
292 struct device *dev;
293 struct mutex lock;
294 const struct lp50xx_chip_info *chip_info;
295
296 /* This needs to be at the end of the struct */
297 struct lp50xx_led leds[];
298};
299
300static struct lp50xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev)
301{
302 return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
303}
304
305static int lp50xx_brightness_set(struct led_classdev *cdev,
306 enum led_brightness brightness)
307{
308 struct led_classdev_mc *mc_dev = lcdev_to_mccdev(led_cdev: cdev);
309 struct lp50xx_led *led = mcled_cdev_to_led(mc_cdev: mc_dev);
310 const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
311 u8 led_offset, reg_val;
312 int ret = 0;
313 int i;
314
315 mutex_lock(&led->priv->lock);
316 if (led->ctrl_bank_enabled)
317 reg_val = led_chip->bank_brt_reg;
318 else
319 reg_val = led_chip->led_brightness0_reg +
320 led->led_number;
321
322 ret = regmap_write(map: led->priv->regmap, reg: reg_val, val: brightness);
323 if (ret) {
324 dev_err(led->priv->dev,
325 "Cannot write brightness value %d\n", ret);
326 goto out;
327 }
328
329 for (i = 0; i < led->mc_cdev.num_colors; i++) {
330 if (led->ctrl_bank_enabled) {
331 reg_val = led_chip->bank_mix_reg + i;
332 } else {
333 led_offset = (led->led_number * 3) + i;
334 reg_val = led_chip->mix_out0_reg + led_offset;
335 }
336
337 ret = regmap_write(map: led->priv->regmap, reg: reg_val,
338 val: mc_dev->subled_info[i].intensity);
339 if (ret) {
340 dev_err(led->priv->dev,
341 "Cannot write intensity value %d\n", ret);
342 goto out;
343 }
344 }
345out:
346 mutex_unlock(lock: &led->priv->lock);
347 return ret;
348}
349
350static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[], int num_leds)
351{
352 u8 led_config_lo, led_config_hi;
353 u32 bank_enable_mask = 0;
354 int ret;
355 int i;
356
357 for (i = 0; i < num_leds; i++)
358 bank_enable_mask |= (1 << led_banks[i]);
359
360 led_config_lo = bank_enable_mask;
361 led_config_hi = bank_enable_mask >> 8;
362
363 ret = regmap_write(map: priv->regmap, LP50XX_LED_CFG0, val: led_config_lo);
364 if (ret)
365 return ret;
366
367 if (priv->chip_info->model_id >= LP5030)
368 ret = regmap_write(map: priv->regmap, LP5036_LED_CFG1, val: led_config_hi);
369
370 return ret;
371}
372
373static int lp50xx_reset(struct lp50xx *priv)
374{
375 return regmap_write(map: priv->regmap, reg: priv->chip_info->reset_reg, LP50XX_SW_RESET);
376}
377
378static int lp50xx_enable(struct lp50xx *priv)
379{
380 int ret;
381
382 if (priv->enable_gpio) {
383 ret = gpiod_direction_output(desc: priv->enable_gpio, LP50XX_EN_GPIO_HIGH);
384 if (ret)
385 return ret;
386
387 udelay(LP50XX_START_TIME_US);
388 }
389
390 ret = lp50xx_reset(priv);
391 if (ret)
392 return ret;
393
394 return regmap_write(map: priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
395}
396
397static int lp50xx_disable(struct lp50xx *priv)
398{
399 int ret;
400
401 ret = regmap_write(map: priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_DISABLE);
402 if (ret)
403 return ret;
404
405 if (priv->enable_gpio) {
406 ret = gpiod_direction_output(desc: priv->enable_gpio, LP50XX_EN_GPIO_LOW);
407 if (ret)
408 return ret;
409
410 udelay(LP50XX_RESET_TIME_US);
411 }
412
413 return 0;
414}
415
416static int lp50xx_probe_leds(struct fwnode_handle *child, struct lp50xx *priv,
417 struct lp50xx_led *led, int num_leds)
418{
419 u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
420 int led_number;
421 int ret;
422
423 if (num_leds > 1) {
424 if (num_leds > priv->chip_info->max_modules) {
425 dev_err(priv->dev, "reg property is invalid\n");
426 return -EINVAL;
427 }
428
429 ret = fwnode_property_read_u32_array(fwnode: child, propname: "reg", val: led_banks, nval: num_leds);
430 if (ret) {
431 dev_err(priv->dev, "reg property is missing\n");
432 return ret;
433 }
434
435 ret = lp50xx_set_banks(priv, led_banks, num_leds);
436 if (ret) {
437 dev_err(priv->dev, "Cannot setup banked LEDs\n");
438 return ret;
439 }
440
441 led->ctrl_bank_enabled = 1;
442 } else {
443 ret = fwnode_property_read_u32(fwnode: child, propname: "reg", val: &led_number);
444 if (ret) {
445 dev_err(priv->dev, "led reg property missing\n");
446 return ret;
447 }
448
449 if (led_number > priv->chip_info->num_leds) {
450 dev_err(priv->dev, "led-sources property is invalid\n");
451 return -EINVAL;
452 }
453
454 led->led_number = led_number;
455 }
456
457 return 0;
458}
459
460static int lp50xx_probe_dt(struct lp50xx *priv)
461{
462 struct fwnode_handle *led_node = NULL;
463 struct led_init_data init_data = {};
464 struct led_classdev *led_cdev;
465 struct mc_subled *mc_led_info;
466 struct lp50xx_led *led;
467 int ret = -EINVAL;
468 int num_colors;
469 u32 color_id;
470 int i = 0;
471
472 priv->enable_gpio = devm_gpiod_get_optional(dev: priv->dev, con_id: "enable", flags: GPIOD_OUT_LOW);
473 if (IS_ERR(ptr: priv->enable_gpio))
474 return dev_err_probe(dev: priv->dev, err: PTR_ERR(ptr: priv->enable_gpio),
475 fmt: "Failed to get enable GPIO\n");
476
477 ret = lp50xx_enable(priv);
478 if (ret)
479 return ret;
480
481 priv->regulator = devm_regulator_get(dev: priv->dev, id: "vled");
482 if (IS_ERR(ptr: priv->regulator))
483 priv->regulator = NULL;
484
485 device_for_each_child_node_scoped(priv->dev, child) {
486 led = &priv->leds[i];
487 ret = fwnode_property_count_u32(fwnode: child, propname: "reg");
488 if (ret < 0) {
489 dev_err(priv->dev, "reg property is invalid\n");
490 return ret;
491 }
492
493 ret = lp50xx_probe_leds(child, priv, led, num_leds: ret);
494 if (ret)
495 return ret;
496
497 init_data.fwnode = child;
498 num_colors = 0;
499
500 /*
501 * There are only 3 LEDs per module otherwise they should be
502 * banked which also is presented as 3 LEDs.
503 */
504 mc_led_info = devm_kcalloc(dev: priv->dev, LP50XX_LEDS_PER_MODULE,
505 size: sizeof(*mc_led_info), GFP_KERNEL);
506 if (!mc_led_info)
507 return -ENOMEM;
508
509 fwnode_for_each_child_node(child, led_node) {
510 int multi_index;
511 ret = fwnode_property_read_u32(fwnode: led_node, propname: "color",
512 val: &color_id);
513 if (ret) {
514 fwnode_handle_put(fwnode: led_node);
515 dev_err(priv->dev, "Cannot read color\n");
516 return ret;
517 }
518 ret = fwnode_property_read_u32(fwnode: led_node, propname: "reg", val: &multi_index);
519 if (ret != 0) {
520 dev_err(priv->dev, "reg must be set\n");
521 return -EINVAL;
522 } else if (multi_index >= LP50XX_LEDS_PER_MODULE) {
523 dev_err(priv->dev, "reg %i out of range\n", multi_index);
524 return -EINVAL;
525 }
526
527 mc_led_info[multi_index].color_index = color_id;
528 num_colors++;
529 }
530
531 led->priv = priv;
532 led->mc_cdev.num_colors = num_colors;
533 led->mc_cdev.subled_info = mc_led_info;
534 led_cdev = &led->mc_cdev.led_cdev;
535 led_cdev->brightness_set_blocking = lp50xx_brightness_set;
536
537 ret = devm_led_classdev_multicolor_register_ext(parent: priv->dev,
538 mcled_cdev: &led->mc_cdev,
539 init_data: &init_data);
540 if (ret) {
541 dev_err(priv->dev, "led register err: %d\n", ret);
542 return ret;
543 }
544 i++;
545 }
546
547 return 0;
548}
549
550static int lp50xx_probe(struct i2c_client *client)
551{
552 struct lp50xx *led;
553 int count;
554 int ret;
555
556 count = device_get_child_node_count(dev: &client->dev);
557 if (!count) {
558 dev_err(&client->dev, "LEDs are not defined in device tree!");
559 return -ENODEV;
560 }
561
562 led = devm_kzalloc(dev: &client->dev, struct_size(led, leds, count),
563 GFP_KERNEL);
564 if (!led)
565 return -ENOMEM;
566
567 mutex_init(&led->lock);
568 led->client = client;
569 led->dev = &client->dev;
570 led->chip_info = device_get_match_data(dev: &client->dev);
571 i2c_set_clientdata(client, data: led);
572 led->regmap = devm_regmap_init_i2c(client,
573 led->chip_info->lp50xx_regmap_config);
574 if (IS_ERR(ptr: led->regmap)) {
575 ret = PTR_ERR(ptr: led->regmap);
576 dev_err(&client->dev, "Failed to allocate register map: %d\n",
577 ret);
578 return ret;
579 }
580
581 return lp50xx_probe_dt(priv: led);
582}
583
584static void lp50xx_remove(struct i2c_client *client)
585{
586 struct lp50xx *led = i2c_get_clientdata(client);
587 int ret;
588
589 ret = lp50xx_disable(priv: led);
590 if (ret)
591 dev_err(led->dev, "Failed to disable chip\n");
592
593 if (led->regulator) {
594 ret = regulator_disable(regulator: led->regulator);
595 if (ret)
596 dev_err(led->dev, "Failed to disable regulator\n");
597 }
598
599 mutex_destroy(lock: &led->lock);
600}
601
602static const struct i2c_device_id lp50xx_id[] = {
603 { "lp5009", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5009] },
604 { "lp5012", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5012] },
605 { "lp5018", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5018] },
606 { "lp5024", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5024] },
607 { "lp5030", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5030] },
608 { "lp5036", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5036] },
609 { }
610};
611MODULE_DEVICE_TABLE(i2c, lp50xx_id);
612
613static const struct of_device_id of_lp50xx_leds_match[] = {
614 { .compatible = "ti,lp5009", .data = &lp50xx_chip_info_tbl[LP5009] },
615 { .compatible = "ti,lp5012", .data = &lp50xx_chip_info_tbl[LP5012] },
616 { .compatible = "ti,lp5018", .data = &lp50xx_chip_info_tbl[LP5018] },
617 { .compatible = "ti,lp5024", .data = &lp50xx_chip_info_tbl[LP5024] },
618 { .compatible = "ti,lp5030", .data = &lp50xx_chip_info_tbl[LP5030] },
619 { .compatible = "ti,lp5036", .data = &lp50xx_chip_info_tbl[LP5036] },
620 {}
621};
622MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);
623
624static struct i2c_driver lp50xx_driver = {
625 .driver = {
626 .name = "lp50xx",
627 .of_match_table = of_lp50xx_leds_match,
628 },
629 .probe = lp50xx_probe,
630 .remove = lp50xx_remove,
631 .id_table = lp50xx_id,
632};
633module_i2c_driver(lp50xx_driver);
634
635MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
636MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
637MODULE_LICENSE("GPL v2");
638

source code of linux/drivers/leds/leds-lp50xx.c