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