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