FILE
leds-lp50xx.c
File preview with syntax highlighting.
linux-6.19.14/drivers/leds/leds-lp50xx.c
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(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[], 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(priv->regmap, LP50XX_LED_CFG0, led_config_lo); 364 if (ret) 365 return ret; 366 367 if (priv->chip_info->model_id >= LP5030) 368 ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi); 369 370 return ret; 371} 372 373static int lp50xx_reset(struct lp50xx *priv) 374{ 375 return regmap_write(priv->regmap, 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(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(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(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(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(child, "reg", led_banks, 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(child, "reg", &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(priv->dev, "enable", GPIOD_OUT_LOW); 473 if (IS_ERR(priv->enable_gpio)) 474 return dev_err_probe(priv->dev, PTR_ERR(priv->enable_gpio), 475 "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(priv->dev, "vled"); 482 if (IS_ERR(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(child, "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, 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(priv->dev, LP50XX_LEDS_PER_MODULE, 505 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(led_node, "color", 512 &color_id); 513 if (ret) { 514 fwnode_handle_put(led_node); 515 dev_err(priv->dev, "Cannot read color\n"); 516 return ret; 517 } 518 ret = fwnode_property_read_u32(led_node, "reg", &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(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 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(&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 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(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 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");
~/
Read-only file preview.