1 // SPDX-License-Identifier: GPL-2.0 2 // TI LM3532 LED driver 3 // Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/ 4 5 #include <linux/i2c.h> 6 #include <linux/leds.h> 7 #include <linux/slab.h> 8 #include <linux/regmap.h> 9 #include <linux/types.h> 10 #include <linux/regulator/consumer.h> 11 #include <linux/module.h> 12 #include <uapi/linux/uleds.h> 13 #include <linux/gpio/consumer.h> 14 15 #define LM3532_NAME "lm3532-led" 16 #define LM3532_BL_MODE_MANUAL 0x00 17 #define LM3532_BL_MODE_ALS 0x01 18 19 #define LM3532_REG_OUTPUT_CFG 0x10 20 #define LM3532_REG_STARTSHUT_RAMP 0x11 21 #define LM3532_REG_RT_RAMP 0x12 22 #define LM3532_REG_PWM_A_CFG 0x13 23 #define LM3532_REG_PWM_B_CFG 0x14 24 #define LM3532_REG_PWM_C_CFG 0x15 25 #define LM3532_REG_ZONE_CFG_A 0x16 26 #define LM3532_REG_CTRL_A_BRT 0x17 27 #define LM3532_REG_ZONE_CFG_B 0x18 28 #define LM3532_REG_CTRL_B_BRT 0x19 29 #define LM3532_REG_ZONE_CFG_C 0x1a 30 #define LM3532_REG_CTRL_C_BRT 0x1b 31 #define LM3532_REG_ENABLE 0x1d 32 #define LM3532_ALS_CONFIG 0x23 33 #define LM3532_REG_ZN_0_HI 0x60 34 #define LM3532_REG_ZN_0_LO 0x61 35 #define LM3532_REG_ZN_1_HI 0x62 36 #define LM3532_REG_ZN_1_LO 0x63 37 #define LM3532_REG_ZN_2_HI 0x64 38 #define LM3532_REG_ZN_2_LO 0x65 39 #define LM3532_REG_ZN_3_HI 0x66 40 #define LM3532_REG_ZN_3_LO 0x67 41 #define LM3532_REG_MAX 0x7e 42 43 /* Contorl Enable */ 44 #define LM3532_CTRL_A_ENABLE BIT(0) 45 #define LM3532_CTRL_B_ENABLE BIT(1) 46 #define LM3532_CTRL_C_ENABLE BIT(2) 47 48 /* PWM Zone Control */ 49 #define LM3532_PWM_ZONE_MASK 0x7c 50 #define LM3532_PWM_ZONE_0_EN BIT(2) 51 #define LM3532_PWM_ZONE_1_EN BIT(3) 52 #define LM3532_PWM_ZONE_2_EN BIT(4) 53 #define LM3532_PWM_ZONE_3_EN BIT(5) 54 #define LM3532_PWM_ZONE_4_EN BIT(6) 55 56 /* Brightness Configuration */ 57 #define LM3532_I2C_CTRL BIT(0) 58 #define LM3532_ALS_CTRL 0 59 #define LM3532_LINEAR_MAP BIT(1) 60 #define LM3532_ZONE_MASK (BIT(2) | BIT(3) | BIT(4)) 61 #define LM3532_ZONE_0 0 62 #define LM3532_ZONE_1 BIT(2) 63 #define LM3532_ZONE_2 BIT(3) 64 #define LM3532_ZONE_3 (BIT(2) | BIT(3)) 65 #define LM3532_ZONE_4 BIT(4) 66 67 #define LM3532_ENABLE_ALS BIT(3) 68 #define LM3532_ALS_SEL_SHIFT 6 69 70 /* Zone Boundary Register */ 71 #define LM3532_ALS_WINDOW_mV 2000 72 #define LM3532_ALS_ZB_MAX 4 73 #define LM3532_ALS_OFFSET_mV 2 74 75 #define LM3532_CONTROL_A 0 76 #define LM3532_CONTROL_B 1 77 #define LM3532_CONTROL_C 2 78 #define LM3532_MAX_CONTROL_BANKS 3 79 #define LM3532_MAX_LED_STRINGS 3 80 81 #define LM3532_OUTPUT_CFG_MASK 0x3 82 #define LM3532_BRT_VAL_ADJUST 8 83 #define LM3532_RAMP_DOWN_SHIFT 3 84 85 #define LM3532_NUM_RAMP_VALS 8 86 #define LM3532_NUM_AVG_VALS 8 87 #define LM3532_NUM_IMP_VALS 32 88 89 /* 90 * struct lm3532_als_data 91 * @config - value of ALS configuration register 92 * @als1_imp_sel - value of ALS1 resistor select register 93 * @als2_imp_sel - value of ALS2 resistor select register 94 * @als_avrg_time - ALS averaging time 95 * @als_input_mode - ALS input mode for brightness control 96 * @als_vmin - Minimum ALS voltage 97 * @als_vmax - Maximum ALS voltage 98 * @zone_lo - values of ALS lo ZB(Zone Boundary) registers 99 * @zone_hi - values of ALS hi ZB(Zone Boundary) registers 100 */ 101 struct lm3532_als_data { 102 u8 config; 103 u8 als1_imp_sel; 104 u8 als2_imp_sel; 105 u8 als_avrg_time; 106 u8 als_input_mode; 107 u32 als_vmin; 108 u32 als_vmax; 109 u8 zones_lo[LM3532_ALS_ZB_MAX]; 110 u8 zones_hi[LM3532_ALS_ZB_MAX]; 111 }; 112 113 /** 114 * struct lm3532_led 115 * @led_dev: led class device 116 * @priv - Pointer the device data structure 117 * @control_bank - Control bank the LED is associated to 118 * @mode - Mode of the LED string 119 * @num_leds - Number of LED strings are supported in this array 120 * @led_strings - The LED strings supported in this array 121 * @label - LED label 122 */ 123 struct lm3532_led { 124 struct led_classdev led_dev; 125 struct lm3532_data *priv; 126 127 int control_bank; 128 int mode; 129 int num_leds; 130 u32 led_strings[LM3532_MAX_CONTROL_BANKS]; 131 char label[LED_MAX_NAME_SIZE]; 132 }; 133 134 /** 135 * struct lm3532_data 136 * @enable_gpio - Hardware enable gpio 137 * @regulator: regulator 138 * @client: i2c client 139 * @regmap - Devices register map 140 * @dev - Pointer to the devices device struct 141 * @lock - Lock for reading/writing the device 142 * @als_data - Pointer to the als data struct 143 * @runtime_ramp_up - Runtime ramp up setting 144 * @runtime_ramp_down - Runtime ramp down setting 145 * @leds - Array of LED strings 146 */ 147 struct lm3532_data { 148 struct gpio_desc *enable_gpio; 149 struct regulator *regulator; 150 struct i2c_client *client; 151 struct regmap *regmap; 152 struct device *dev; 153 struct mutex lock; 154 155 struct lm3532_als_data *als_data; 156 157 u32 runtime_ramp_up; 158 u32 runtime_ramp_down; 159 160 struct lm3532_led leds[]; 161 }; 162 163 static const struct reg_default lm3532_reg_defs[] = { 164 {LM3532_REG_OUTPUT_CFG, 0xe4}, 165 {LM3532_REG_STARTSHUT_RAMP, 0xc0}, 166 {LM3532_REG_RT_RAMP, 0xc0}, 167 {LM3532_REG_PWM_A_CFG, 0x82}, 168 {LM3532_REG_PWM_B_CFG, 0x82}, 169 {LM3532_REG_PWM_C_CFG, 0x82}, 170 {LM3532_REG_ZONE_CFG_A, 0xf1}, 171 {LM3532_REG_CTRL_A_BRT, 0xf3}, 172 {LM3532_REG_ZONE_CFG_B, 0xf1}, 173 {LM3532_REG_CTRL_B_BRT, 0xf3}, 174 {LM3532_REG_ZONE_CFG_C, 0xf1}, 175 {LM3532_REG_CTRL_C_BRT, 0xf3}, 176 {LM3532_REG_ENABLE, 0xf8}, 177 {LM3532_ALS_CONFIG, 0x44}, 178 {LM3532_REG_ZN_0_HI, 0x35}, 179 {LM3532_REG_ZN_0_LO, 0x33}, 180 {LM3532_REG_ZN_1_HI, 0x6a}, 181 {LM3532_REG_ZN_1_LO, 0x66}, 182 {LM3532_REG_ZN_2_HI, 0xa1}, 183 {LM3532_REG_ZN_2_LO, 0x99}, 184 {LM3532_REG_ZN_3_HI, 0xdc}, 185 {LM3532_REG_ZN_3_LO, 0xcc}, 186 }; 187 188 static const struct regmap_config lm3532_regmap_config = { 189 .reg_bits = 8, 190 .val_bits = 8, 191 192 .max_register = LM3532_REG_MAX, 193 .reg_defaults = lm3532_reg_defs, 194 .num_reg_defaults = ARRAY_SIZE(lm3532_reg_defs), 195 .cache_type = REGCACHE_FLAT, 196 }; 197 198 const static int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330, 199 92500, 7400, 6170, 5290, 200 4630, 4110, 3700, 3360, 201 3080, 2850, 2640, 2440, 202 2310, 2180, 2060, 1950, 203 1850, 1760, 1680, 1610, 204 1540, 1480, 1420, 1370, 205 1320, 1280, 1230, 1190}; 206 static int lm3532_get_als_imp_index(int als_imped) 207 { 208 int i; 209 210 if (als_imped > als_imp_table[1]) 211 return 0; 212 213 if (als_imped < als_imp_table[LM3532_NUM_IMP_VALS - 1]) 214 return LM3532_NUM_IMP_VALS - 1; 215 216 for (i = 1; i < LM3532_NUM_IMP_VALS; i++) { 217 if (als_imped == als_imp_table[i]) 218 return i; 219 220 /* Find an approximate index by looking up the table */ 221 if (als_imped < als_imp_table[i - 1] && 222 als_imped > als_imp_table[i]) { 223 if (als_imped - als_imp_table[i - 1] < 224 als_imp_table[i] - als_imped) 225 return i + 1; 226 else 227 return i; 228 } 229 } 230 231 return -EINVAL; 232 } 233 234 static int lm3532_get_index(const int table[], int size, int value) 235 { 236 int i; 237 238 for (i = 1; i < size; i++) { 239 if (value == table[i]) 240 return i; 241 242 /* Find an approximate index by looking up the table */ 243 if (value > table[i - 1] && 244 value < table[i]) { 245 if (value - table[i - 1] < table[i] - value) 246 return i - 1; 247 else 248 return i; 249 } 250 } 251 252 return -EINVAL; 253 } 254 255 const static int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680, 256 1433360, 286720, 573440, 257 1146880, 2293760}; 258 static int lm3532_get_als_avg_index(int avg_time) 259 { 260 if (avg_time <= als_avrg_table[0]) 261 return 0; 262 263 if (avg_time > als_avrg_table[LM3532_NUM_AVG_VALS - 1]) 264 return LM3532_NUM_AVG_VALS - 1; 265 266 return lm3532_get_index(&als_avrg_table[0], LM3532_NUM_AVG_VALS, 267 avg_time); 268 } 269 270 const static int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192, 271 16384, 32768, 65536}; 272 static int lm3532_get_ramp_index(int ramp_time) 273 { 274 if (ramp_time <= ramp_table[0]) 275 return 0; 276 277 if (ramp_time > ramp_table[LM3532_NUM_RAMP_VALS - 1]) 278 return LM3532_NUM_RAMP_VALS - 1; 279 280 return lm3532_get_index(&ramp_table[0], LM3532_NUM_RAMP_VALS, 281 ramp_time); 282 } 283 284 static int lm3532_led_enable(struct lm3532_led *led_data) 285 { 286 int ctrl_en_val = BIT(led_data->control_bank); 287 int ret; 288 289 ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE, 290 ctrl_en_val, ctrl_en_val); 291 if (ret) { 292 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret); 293 return ret; 294 } 295 296 return regulator_enable(led_data->priv->regulator); 297 } 298 299 static int lm3532_led_disable(struct lm3532_led *led_data) 300 { 301 int ctrl_en_val = BIT(led_data->control_bank); 302 int ret; 303 304 ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE, 305 ctrl_en_val, ~ctrl_en_val); 306 if (ret) { 307 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret); 308 return ret; 309 } 310 311 return regulator_disable(led_data->priv->regulator); 312 } 313 314 static int lm3532_brightness_set(struct led_classdev *led_cdev, 315 enum led_brightness brt_val) 316 { 317 struct lm3532_led *led = 318 container_of(led_cdev, struct lm3532_led, led_dev); 319 u8 brightness_reg; 320 int ret; 321 322 mutex_lock(&led->priv->lock); 323 324 if (led->mode == LM3532_BL_MODE_ALS) { 325 if (brt_val > LED_OFF) 326 ret = lm3532_led_enable(led); 327 else 328 ret = lm3532_led_disable(led); 329 330 goto unlock; 331 } 332 333 if (brt_val == LED_OFF) { 334 ret = lm3532_led_disable(led); 335 goto unlock; 336 } 337 338 ret = lm3532_led_enable(led); 339 if (ret) 340 goto unlock; 341 342 brightness_reg = LM3532_REG_CTRL_A_BRT + led->control_bank * 2; 343 brt_val = brt_val / LM3532_BRT_VAL_ADJUST; 344 345 ret = regmap_write(led->priv->regmap, brightness_reg, brt_val); 346 347 unlock: 348 mutex_unlock(&led->priv->lock); 349 return ret; 350 } 351 352 static int lm3532_init_registers(struct lm3532_led *led) 353 { 354 struct lm3532_data *drvdata = led->priv; 355 unsigned int runtime_ramp_val; 356 unsigned int output_cfg_val = 0; 357 unsigned int output_cfg_shift = 0; 358 unsigned int output_cfg_mask = 0; 359 int ret, i; 360 361 for (i = 0; i < led->num_leds; i++) { 362 output_cfg_shift = led->led_strings[i] * 2; 363 output_cfg_val |= (led->control_bank << output_cfg_shift); 364 output_cfg_mask |= LM3532_OUTPUT_CFG_MASK << output_cfg_shift; 365 } 366 367 ret = regmap_update_bits(drvdata->regmap, LM3532_REG_OUTPUT_CFG, 368 output_cfg_mask, output_cfg_val); 369 if (ret) 370 return ret; 371 372 runtime_ramp_val = drvdata->runtime_ramp_up | 373 (drvdata->runtime_ramp_down << LM3532_RAMP_DOWN_SHIFT); 374 375 return regmap_write(drvdata->regmap, LM3532_REG_RT_RAMP, 376 runtime_ramp_val); 377 } 378 379 static int lm3532_als_configure(struct lm3532_data *priv, 380 struct lm3532_led *led) 381 { 382 struct lm3532_als_data *als = priv->als_data; 383 u32 als_vmin, als_vmax, als_vstep; 384 int zone_reg = LM3532_REG_ZN_0_HI; 385 int brightnes_config_reg; 386 int ret; 387 int i; 388 389 als_vmin = als->als_vmin; 390 als_vmax = als->als_vmax; 391 392 als_vstep = (als_vmax - als_vmin) / ((LM3532_ALS_ZB_MAX + 1) * 2); 393 394 for (i = 0; i < LM3532_ALS_ZB_MAX; i++) { 395 als->zones_lo[i] = ((als_vmin + als_vstep + (i * als_vstep)) * 396 LED_FULL) / 1000; 397 als->zones_hi[i] = ((als_vmin + LM3532_ALS_OFFSET_mV + 398 als_vstep + (i * als_vstep)) * LED_FULL) / 1000; 399 400 zone_reg = LM3532_REG_ZN_0_HI + i * 2; 401 ret = regmap_write(priv->regmap, zone_reg, als->zones_lo[i]); 402 if (ret) 403 return ret; 404 405 zone_reg += 1; 406 ret = regmap_write(priv->regmap, zone_reg, als->zones_hi[i]); 407 if (ret) 408 return ret; 409 } 410 411 als->config = (als->als_avrg_time | (LM3532_ENABLE_ALS) | 412 (als->als_input_mode << LM3532_ALS_SEL_SHIFT)); 413 414 ret = regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config); 415 if (ret) 416 return ret; 417 418 brightnes_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2; 419 420 return regmap_update_bits(priv->regmap, brightnes_config_reg, 421 LM3532_I2C_CTRL, LM3532_ALS_CTRL); 422 } 423 424 static int lm3532_parse_als(struct lm3532_data *priv) 425 { 426 struct lm3532_als_data *als; 427 int als_avg_time; 428 int als_impedance; 429 int ret; 430 431 als = devm_kzalloc(priv->dev, sizeof(*als), GFP_KERNEL); 432 if (als == NULL) 433 return -ENOMEM; 434 435 ret = device_property_read_u32(&priv->client->dev, "ti,als-vmin", 436 &als->als_vmin); 437 if (ret) 438 als->als_vmin = 0; 439 440 ret = device_property_read_u32(&priv->client->dev, "ti,als-vmax", 441 &als->als_vmax); 442 if (ret) 443 als->als_vmax = LM3532_ALS_WINDOW_mV; 444 445 if (als->als_vmax > LM3532_ALS_WINDOW_mV) { 446 ret = -EINVAL; 447 return ret; 448 } 449 450 ret = device_property_read_u32(&priv->client->dev, "ti,als1-imp-sel", 451 &als_impedance); 452 if (ret) 453 als->als1_imp_sel = 0; 454 else 455 als->als1_imp_sel = lm3532_get_als_imp_index(als_impedance); 456 457 ret = device_property_read_u32(&priv->client->dev, "ti,als2-imp-sel", 458 &als_impedance); 459 if (ret) 460 als->als2_imp_sel = 0; 461 else 462 als->als2_imp_sel = lm3532_get_als_imp_index(als_impedance); 463 464 ret = device_property_read_u32(&priv->client->dev, "ti,als-avrg-time-us", 465 &als_avg_time); 466 if (ret) 467 als->als_avrg_time = 0; 468 else 469 als->als_avrg_time = lm3532_get_als_avg_index(als_avg_time); 470 471 ret = device_property_read_u8(&priv->client->dev, "ti,als-input-mode", 472 &als->als_input_mode); 473 if (ret) 474 als->als_input_mode = 0; 475 476 if (als->als_input_mode > LM3532_BL_MODE_ALS) { 477 ret = -EINVAL; 478 return ret; 479 } 480 481 priv->als_data = als; 482 483 return ret; 484 } 485 486 static int lm3532_parse_node(struct lm3532_data *priv) 487 { 488 struct fwnode_handle *child = NULL; 489 struct lm3532_led *led; 490 const char *name; 491 int control_bank; 492 u32 ramp_time; 493 size_t i = 0; 494 int ret; 495 496 priv->enable_gpio = devm_gpiod_get_optional(&priv->client->dev, 497 "enable", GPIOD_OUT_LOW); 498 if (IS_ERR(priv->enable_gpio)) 499 priv->enable_gpio = NULL; 500 501 priv->regulator = devm_regulator_get(&priv->client->dev, "vin"); 502 if (IS_ERR(priv->regulator)) 503 priv->regulator = NULL; 504 505 ret = device_property_read_u32(&priv->client->dev, "ramp-up-us", 506 &ramp_time); 507 if (ret) 508 dev_info(&priv->client->dev, "ramp-up-ms property missing\n"); 509 else 510 priv->runtime_ramp_up = lm3532_get_ramp_index(ramp_time); 511 512 ret = device_property_read_u32(&priv->client->dev, "ramp-down-us", 513 &ramp_time); 514 if (ret) 515 dev_info(&priv->client->dev, "ramp-down-ms property missing\n"); 516 else 517 priv->runtime_ramp_down = lm3532_get_ramp_index(ramp_time); 518 519 device_for_each_child_node(priv->dev, child) { 520 led = &priv->leds[i]; 521 522 ret = fwnode_property_read_u32(child, "reg", &control_bank); 523 if (ret) { 524 dev_err(&priv->client->dev, "reg property missing\n"); 525 fwnode_handle_put(child); 526 goto child_out; 527 } 528 529 if (control_bank > LM3532_CONTROL_C) { 530 dev_err(&priv->client->dev, "Control bank invalid\n"); 531 continue; 532 } 533 534 led->control_bank = control_bank; 535 536 ret = fwnode_property_read_u32(child, "ti,led-mode", 537 &led->mode); 538 if (ret) { 539 dev_err(&priv->client->dev, "ti,led-mode property missing\n"); 540 fwnode_handle_put(child); 541 goto child_out; 542 } 543 544 if (led->mode == LM3532_BL_MODE_ALS) { 545 ret = lm3532_parse_als(priv); 546 if (ret) 547 dev_err(&priv->client->dev, "Failed to parse als\n"); 548 else 549 lm3532_als_configure(priv, led); 550 } 551 552 led->num_leds = fwnode_property_read_u32_array(child, 553 "led-sources", 554 NULL, 0); 555 556 if (led->num_leds > LM3532_MAX_LED_STRINGS) { 557 dev_err(&priv->client->dev, "To many LED string defined\n"); 558 continue; 559 } 560 561 ret = fwnode_property_read_u32_array(child, "led-sources", 562 led->led_strings, 563 led->num_leds); 564 if (ret) { 565 dev_err(&priv->client->dev, "led-sources property missing\n"); 566 fwnode_handle_put(child); 567 goto child_out; 568 } 569 570 fwnode_property_read_string(child, "linux,default-trigger", 571 &led->led_dev.default_trigger); 572 573 ret = fwnode_property_read_string(child, "label", &name); 574 if (ret) 575 snprintf(led->label, sizeof(led->label), 576 "%s::", priv->client->name); 577 else 578 snprintf(led->label, sizeof(led->label), 579 "%s:%s", priv->client->name, name); 580 581 led->priv = priv; 582 led->led_dev.name = led->label; 583 led->led_dev.brightness_set_blocking = lm3532_brightness_set; 584 585 ret = devm_led_classdev_register(priv->dev, &led->led_dev); 586 if (ret) { 587 dev_err(&priv->client->dev, "led register err: %d\n", 588 ret); 589 fwnode_handle_put(child); 590 goto child_out; 591 } 592 593 lm3532_init_registers(led); 594 595 i++; 596 } 597 598 child_out: 599 return ret; 600 } 601 602 static int lm3532_probe(struct i2c_client *client, 603 const struct i2c_device_id *id) 604 { 605 struct lm3532_data *drvdata; 606 int ret = 0; 607 int count; 608 609 count = device_get_child_node_count(&client->dev); 610 if (!count) { 611 dev_err(&client->dev, "LEDs are not defined in device tree!"); 612 return -ENODEV; 613 } 614 615 drvdata = devm_kzalloc(&client->dev, struct_size(drvdata, leds, count), 616 GFP_KERNEL); 617 if (drvdata == NULL) 618 return -ENOMEM; 619 620 drvdata->client = client; 621 drvdata->dev = &client->dev; 622 623 drvdata->regmap = devm_regmap_init_i2c(client, &lm3532_regmap_config); 624 if (IS_ERR(drvdata->regmap)) { 625 ret = PTR_ERR(drvdata->regmap); 626 dev_err(&client->dev, "Failed to allocate register map: %d\n", 627 ret); 628 return ret; 629 } 630 631 mutex_init(&drvdata->lock); 632 i2c_set_clientdata(client, drvdata); 633 634 ret = lm3532_parse_node(drvdata); 635 if (ret) { 636 dev_err(&client->dev, "Failed to parse node\n"); 637 return ret; 638 } 639 640 if (drvdata->enable_gpio) 641 gpiod_direction_output(drvdata->enable_gpio, 1); 642 643 return ret; 644 } 645 646 static int lm3532_remove(struct i2c_client *client) 647 { 648 struct lm3532_data *drvdata = i2c_get_clientdata(client); 649 650 mutex_destroy(&drvdata->lock); 651 652 if (drvdata->enable_gpio) 653 gpiod_direction_output(drvdata->enable_gpio, 0); 654 655 return 0; 656 } 657 658 static const struct of_device_id of_lm3532_leds_match[] = { 659 { .compatible = "ti,lm3532", }, 660 {}, 661 }; 662 MODULE_DEVICE_TABLE(of, of_lm3532_leds_match); 663 664 static const struct i2c_device_id lm3532_id[] = { 665 {LM3532_NAME, 0}, 666 {} 667 }; 668 MODULE_DEVICE_TABLE(i2c, lm3532_id); 669 670 static struct i2c_driver lm3532_i2c_driver = { 671 .probe = lm3532_probe, 672 .remove = lm3532_remove, 673 .id_table = lm3532_id, 674 .driver = { 675 .name = LM3532_NAME, 676 .of_match_table = of_lm3532_leds_match, 677 }, 678 }; 679 module_i2c_driver(lm3532_i2c_driver); 680 681 MODULE_DESCRIPTION("Back Light driver for LM3532"); 682 MODULE_LICENSE("GPL v2"); 683 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>"); 684