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