1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * TI LP8860 4-Channel LED Driver 4 * 5 * Copyright (C) 2014 Texas Instruments 6 * 7 * Author: Dan Murphy <dmurphy@ti.com> 8 */ 9 10 #include <linux/i2c.h> 11 #include <linux/init.h> 12 #include <linux/leds.h> 13 #include <linux/regmap.h> 14 #include <linux/regulator/consumer.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/of.h> 18 #include <linux/of_gpio.h> 19 #include <linux/gpio/consumer.h> 20 #include <linux/slab.h> 21 #include <uapi/linux/uleds.h> 22 23 #define LP8860_DISP_CL1_BRT_MSB 0x00 24 #define LP8860_DISP_CL1_BRT_LSB 0x01 25 #define LP8860_DISP_CL1_CURR_MSB 0x02 26 #define LP8860_DISP_CL1_CURR_LSB 0x03 27 #define LP8860_CL2_BRT_MSB 0x04 28 #define LP8860_CL2_BRT_LSB 0x05 29 #define LP8860_CL2_CURRENT 0x06 30 #define LP8860_CL3_BRT_MSB 0x07 31 #define LP8860_CL3_BRT_LSB 0x08 32 #define LP8860_CL3_CURRENT 0x09 33 #define LP8860_CL4_BRT_MSB 0x0a 34 #define LP8860_CL4_BRT_LSB 0x0b 35 #define LP8860_CL4_CURRENT 0x0c 36 #define LP8860_CONFIG 0x0d 37 #define LP8860_STATUS 0x0e 38 #define LP8860_FAULT 0x0f 39 #define LP8860_LED_FAULT 0x10 40 #define LP8860_FAULT_CLEAR 0x11 41 #define LP8860_ID 0x12 42 #define LP8860_TEMP_MSB 0x13 43 #define LP8860_TEMP_LSB 0x14 44 #define LP8860_DISP_LED_CURR_MSB 0x15 45 #define LP8860_DISP_LED_CURR_LSB 0x16 46 #define LP8860_DISP_LED_PWM_MSB 0x17 47 #define LP8860_DISP_LED_PWM_LSB 0x18 48 #define LP8860_EEPROM_CNTRL 0x19 49 #define LP8860_EEPROM_UNLOCK 0x1a 50 51 #define LP8860_EEPROM_REG_0 0x60 52 #define LP8860_EEPROM_REG_1 0x61 53 #define LP8860_EEPROM_REG_2 0x62 54 #define LP8860_EEPROM_REG_3 0x63 55 #define LP8860_EEPROM_REG_4 0x64 56 #define LP8860_EEPROM_REG_5 0x65 57 #define LP8860_EEPROM_REG_6 0x66 58 #define LP8860_EEPROM_REG_7 0x67 59 #define LP8860_EEPROM_REG_8 0x68 60 #define LP8860_EEPROM_REG_9 0x69 61 #define LP8860_EEPROM_REG_10 0x6a 62 #define LP8860_EEPROM_REG_11 0x6b 63 #define LP8860_EEPROM_REG_12 0x6c 64 #define LP8860_EEPROM_REG_13 0x6d 65 #define LP8860_EEPROM_REG_14 0x6e 66 #define LP8860_EEPROM_REG_15 0x6f 67 #define LP8860_EEPROM_REG_16 0x70 68 #define LP8860_EEPROM_REG_17 0x71 69 #define LP8860_EEPROM_REG_18 0x72 70 #define LP8860_EEPROM_REG_19 0x73 71 #define LP8860_EEPROM_REG_20 0x74 72 #define LP8860_EEPROM_REG_21 0x75 73 #define LP8860_EEPROM_REG_22 0x76 74 #define LP8860_EEPROM_REG_23 0x77 75 #define LP8860_EEPROM_REG_24 0x78 76 77 #define LP8860_LOCK_EEPROM 0x00 78 #define LP8860_UNLOCK_EEPROM 0x01 79 #define LP8860_PROGRAM_EEPROM 0x02 80 #define LP8860_EEPROM_CODE_1 0x08 81 #define LP8860_EEPROM_CODE_2 0xba 82 #define LP8860_EEPROM_CODE_3 0xef 83 84 #define LP8860_CLEAR_FAULTS 0x01 85 86 /** 87 * struct lp8860_led - 88 * @lock - Lock for reading/writing the device 89 * @client - Pointer to the I2C client 90 * @led_dev - led class device pointer 91 * @regmap - Devices register map 92 * @eeprom_regmap - EEPROM register map 93 * @enable_gpio - VDDIO/EN gpio to enable communication interface 94 * @regulator - LED supply regulator pointer 95 * @label - LED label 96 */ 97 struct lp8860_led { 98 struct mutex lock; 99 struct i2c_client *client; 100 struct led_classdev led_dev; 101 struct regmap *regmap; 102 struct regmap *eeprom_regmap; 103 struct gpio_desc *enable_gpio; 104 struct regulator *regulator; 105 char label[LED_MAX_NAME_SIZE]; 106 }; 107 108 struct lp8860_eeprom_reg { 109 uint8_t reg; 110 uint8_t value; 111 }; 112 113 static struct lp8860_eeprom_reg lp8860_eeprom_disp_regs[] = { 114 { LP8860_EEPROM_REG_0, 0xed }, 115 { LP8860_EEPROM_REG_1, 0xdf }, 116 { LP8860_EEPROM_REG_2, 0xdc }, 117 { LP8860_EEPROM_REG_3, 0xf0 }, 118 { LP8860_EEPROM_REG_4, 0xdf }, 119 { LP8860_EEPROM_REG_5, 0xe5 }, 120 { LP8860_EEPROM_REG_6, 0xf2 }, 121 { LP8860_EEPROM_REG_7, 0x77 }, 122 { LP8860_EEPROM_REG_8, 0x77 }, 123 { LP8860_EEPROM_REG_9, 0x71 }, 124 { LP8860_EEPROM_REG_10, 0x3f }, 125 { LP8860_EEPROM_REG_11, 0xb7 }, 126 { LP8860_EEPROM_REG_12, 0x17 }, 127 { LP8860_EEPROM_REG_13, 0xef }, 128 { LP8860_EEPROM_REG_14, 0xb0 }, 129 { LP8860_EEPROM_REG_15, 0x87 }, 130 { LP8860_EEPROM_REG_16, 0xce }, 131 { LP8860_EEPROM_REG_17, 0x72 }, 132 { LP8860_EEPROM_REG_18, 0xe5 }, 133 { LP8860_EEPROM_REG_19, 0xdf }, 134 { LP8860_EEPROM_REG_20, 0x35 }, 135 { LP8860_EEPROM_REG_21, 0x06 }, 136 { LP8860_EEPROM_REG_22, 0xdc }, 137 { LP8860_EEPROM_REG_23, 0x88 }, 138 { LP8860_EEPROM_REG_24, 0x3E }, 139 }; 140 141 static int lp8860_unlock_eeprom(struct lp8860_led *led, int lock) 142 { 143 int ret; 144 145 mutex_lock(&led->lock); 146 147 if (lock == LP8860_UNLOCK_EEPROM) { 148 ret = regmap_write(led->regmap, 149 LP8860_EEPROM_UNLOCK, 150 LP8860_EEPROM_CODE_1); 151 if (ret) { 152 dev_err(&led->client->dev, "EEPROM Unlock failed\n"); 153 goto out; 154 } 155 156 ret = regmap_write(led->regmap, 157 LP8860_EEPROM_UNLOCK, 158 LP8860_EEPROM_CODE_2); 159 if (ret) { 160 dev_err(&led->client->dev, "EEPROM Unlock failed\n"); 161 goto out; 162 } 163 ret = regmap_write(led->regmap, 164 LP8860_EEPROM_UNLOCK, 165 LP8860_EEPROM_CODE_3); 166 if (ret) { 167 dev_err(&led->client->dev, "EEPROM Unlock failed\n"); 168 goto out; 169 } 170 } else { 171 ret = regmap_write(led->regmap, 172 LP8860_EEPROM_UNLOCK, 173 LP8860_LOCK_EEPROM); 174 } 175 176 out: 177 mutex_unlock(&led->lock); 178 return ret; 179 } 180 181 static int lp8860_fault_check(struct lp8860_led *led) 182 { 183 int ret, fault; 184 unsigned int read_buf; 185 186 ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf); 187 if (ret) 188 goto out; 189 190 fault = read_buf; 191 192 ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf); 193 if (ret) 194 goto out; 195 196 fault |= read_buf; 197 198 /* Attempt to clear any faults */ 199 if (fault) 200 ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR, 201 LP8860_CLEAR_FAULTS); 202 out: 203 return ret; 204 } 205 206 static int lp8860_brightness_set(struct led_classdev *led_cdev, 207 enum led_brightness brt_val) 208 { 209 struct lp8860_led *led = 210 container_of(led_cdev, struct lp8860_led, led_dev); 211 int disp_brightness = brt_val * 255; 212 int ret; 213 214 mutex_lock(&led->lock); 215 216 ret = lp8860_fault_check(led); 217 if (ret) { 218 dev_err(&led->client->dev, "Cannot read/clear faults\n"); 219 goto out; 220 } 221 222 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB, 223 (disp_brightness & 0xff00) >> 8); 224 if (ret) { 225 dev_err(&led->client->dev, "Cannot write CL1 MSB\n"); 226 goto out; 227 } 228 229 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB, 230 disp_brightness & 0xff); 231 if (ret) { 232 dev_err(&led->client->dev, "Cannot write CL1 LSB\n"); 233 goto out; 234 } 235 out: 236 mutex_unlock(&led->lock); 237 return ret; 238 } 239 240 static int lp8860_init(struct lp8860_led *led) 241 { 242 unsigned int read_buf; 243 int ret, i, reg_count; 244 245 if (led->regulator) { 246 ret = regulator_enable(led->regulator); 247 if (ret) { 248 dev_err(&led->client->dev, 249 "Failed to enable regulator\n"); 250 return ret; 251 } 252 } 253 254 if (led->enable_gpio) 255 gpiod_direction_output(led->enable_gpio, 1); 256 257 ret = lp8860_fault_check(led); 258 if (ret) 259 goto out; 260 261 ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf); 262 if (ret) 263 goto out; 264 265 ret = lp8860_unlock_eeprom(led, LP8860_UNLOCK_EEPROM); 266 if (ret) { 267 dev_err(&led->client->dev, "Failed unlocking EEPROM\n"); 268 goto out; 269 } 270 271 reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]); 272 for (i = 0; i < reg_count; i++) { 273 ret = regmap_write(led->eeprom_regmap, 274 lp8860_eeprom_disp_regs[i].reg, 275 lp8860_eeprom_disp_regs[i].value); 276 if (ret) { 277 dev_err(&led->client->dev, "Failed writing EEPROM\n"); 278 goto out; 279 } 280 } 281 282 ret = lp8860_unlock_eeprom(led, LP8860_LOCK_EEPROM); 283 if (ret) 284 goto out; 285 286 ret = regmap_write(led->regmap, 287 LP8860_EEPROM_CNTRL, 288 LP8860_PROGRAM_EEPROM); 289 if (ret) { 290 dev_err(&led->client->dev, "Failed programming EEPROM\n"); 291 goto out; 292 } 293 294 return ret; 295 296 out: 297 if (ret) 298 if (led->enable_gpio) 299 gpiod_direction_output(led->enable_gpio, 0); 300 301 if (led->regulator) { 302 ret = regulator_disable(led->regulator); 303 if (ret) 304 dev_err(&led->client->dev, 305 "Failed to disable regulator\n"); 306 } 307 308 return ret; 309 } 310 311 static const struct reg_default lp8860_reg_defs[] = { 312 { LP8860_DISP_CL1_BRT_MSB, 0x00}, 313 { LP8860_DISP_CL1_BRT_LSB, 0x00}, 314 { LP8860_DISP_CL1_CURR_MSB, 0x00}, 315 { LP8860_DISP_CL1_CURR_LSB, 0x00}, 316 { LP8860_CL2_BRT_MSB, 0x00}, 317 { LP8860_CL2_BRT_LSB, 0x00}, 318 { LP8860_CL2_CURRENT, 0x00}, 319 { LP8860_CL3_BRT_MSB, 0x00}, 320 { LP8860_CL3_BRT_LSB, 0x00}, 321 { LP8860_CL3_CURRENT, 0x00}, 322 { LP8860_CL4_BRT_MSB, 0x00}, 323 { LP8860_CL4_BRT_LSB, 0x00}, 324 { LP8860_CL4_CURRENT, 0x00}, 325 { LP8860_CONFIG, 0x00}, 326 { LP8860_FAULT_CLEAR, 0x00}, 327 { LP8860_EEPROM_CNTRL, 0x80}, 328 { LP8860_EEPROM_UNLOCK, 0x00}, 329 }; 330 331 static const struct regmap_config lp8860_regmap_config = { 332 .reg_bits = 8, 333 .val_bits = 8, 334 335 .max_register = LP8860_EEPROM_UNLOCK, 336 .reg_defaults = lp8860_reg_defs, 337 .num_reg_defaults = ARRAY_SIZE(lp8860_reg_defs), 338 .cache_type = REGCACHE_NONE, 339 }; 340 341 static const struct reg_default lp8860_eeprom_defs[] = { 342 { LP8860_EEPROM_REG_0, 0x00 }, 343 { LP8860_EEPROM_REG_1, 0x00 }, 344 { LP8860_EEPROM_REG_2, 0x00 }, 345 { LP8860_EEPROM_REG_3, 0x00 }, 346 { LP8860_EEPROM_REG_4, 0x00 }, 347 { LP8860_EEPROM_REG_5, 0x00 }, 348 { LP8860_EEPROM_REG_6, 0x00 }, 349 { LP8860_EEPROM_REG_7, 0x00 }, 350 { LP8860_EEPROM_REG_8, 0x00 }, 351 { LP8860_EEPROM_REG_9, 0x00 }, 352 { LP8860_EEPROM_REG_10, 0x00 }, 353 { LP8860_EEPROM_REG_11, 0x00 }, 354 { LP8860_EEPROM_REG_12, 0x00 }, 355 { LP8860_EEPROM_REG_13, 0x00 }, 356 { LP8860_EEPROM_REG_14, 0x00 }, 357 { LP8860_EEPROM_REG_15, 0x00 }, 358 { LP8860_EEPROM_REG_16, 0x00 }, 359 { LP8860_EEPROM_REG_17, 0x00 }, 360 { LP8860_EEPROM_REG_18, 0x00 }, 361 { LP8860_EEPROM_REG_19, 0x00 }, 362 { LP8860_EEPROM_REG_20, 0x00 }, 363 { LP8860_EEPROM_REG_21, 0x00 }, 364 { LP8860_EEPROM_REG_22, 0x00 }, 365 { LP8860_EEPROM_REG_23, 0x00 }, 366 { LP8860_EEPROM_REG_24, 0x00 }, 367 }; 368 369 static const struct regmap_config lp8860_eeprom_regmap_config = { 370 .reg_bits = 8, 371 .val_bits = 8, 372 373 .max_register = LP8860_EEPROM_REG_24, 374 .reg_defaults = lp8860_eeprom_defs, 375 .num_reg_defaults = ARRAY_SIZE(lp8860_eeprom_defs), 376 .cache_type = REGCACHE_NONE, 377 }; 378 379 static int lp8860_probe(struct i2c_client *client, 380 const struct i2c_device_id *id) 381 { 382 int ret; 383 struct lp8860_led *led; 384 struct device_node *np = client->dev.of_node; 385 struct device_node *child_node; 386 const char *name; 387 388 led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL); 389 if (!led) 390 return -ENOMEM; 391 392 for_each_available_child_of_node(np, child_node) { 393 led->led_dev.default_trigger = of_get_property(child_node, 394 "linux,default-trigger", 395 NULL); 396 397 ret = of_property_read_string(child_node, "label", &name); 398 if (!ret) 399 snprintf(led->label, sizeof(led->label), "%s:%s", 400 id->name, name); 401 else 402 snprintf(led->label, sizeof(led->label), 403 "%s::display_cluster", id->name); 404 } 405 406 led->enable_gpio = devm_gpiod_get_optional(&client->dev, 407 "enable", GPIOD_OUT_LOW); 408 if (IS_ERR(led->enable_gpio)) { 409 ret = PTR_ERR(led->enable_gpio); 410 dev_err(&client->dev, "Failed to get enable gpio: %d\n", ret); 411 return ret; 412 } 413 414 led->regulator = devm_regulator_get(&client->dev, "vled"); 415 if (IS_ERR(led->regulator)) 416 led->regulator = NULL; 417 418 led->client = client; 419 led->led_dev.name = led->label; 420 led->led_dev.brightness_set_blocking = lp8860_brightness_set; 421 422 mutex_init(&led->lock); 423 424 i2c_set_clientdata(client, led); 425 426 led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config); 427 if (IS_ERR(led->regmap)) { 428 ret = PTR_ERR(led->regmap); 429 dev_err(&client->dev, "Failed to allocate register map: %d\n", 430 ret); 431 return ret; 432 } 433 434 led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config); 435 if (IS_ERR(led->eeprom_regmap)) { 436 ret = PTR_ERR(led->eeprom_regmap); 437 dev_err(&client->dev, "Failed to allocate register map: %d\n", 438 ret); 439 return ret; 440 } 441 442 ret = lp8860_init(led); 443 if (ret) 444 return ret; 445 446 ret = devm_led_classdev_register(&client->dev, &led->led_dev); 447 if (ret) { 448 dev_err(&client->dev, "led register err: %d\n", ret); 449 return ret; 450 } 451 452 return 0; 453 } 454 455 static int lp8860_remove(struct i2c_client *client) 456 { 457 struct lp8860_led *led = i2c_get_clientdata(client); 458 int ret; 459 460 if (led->enable_gpio) 461 gpiod_direction_output(led->enable_gpio, 0); 462 463 if (led->regulator) { 464 ret = regulator_disable(led->regulator); 465 if (ret) 466 dev_err(&led->client->dev, 467 "Failed to disable regulator\n"); 468 } 469 470 mutex_destroy(&led->lock); 471 472 return 0; 473 } 474 475 static const struct i2c_device_id lp8860_id[] = { 476 { "lp8860", 0 }, 477 { } 478 }; 479 MODULE_DEVICE_TABLE(i2c, lp8860_id); 480 481 static const struct of_device_id of_lp8860_leds_match[] = { 482 { .compatible = "ti,lp8860", }, 483 {}, 484 }; 485 MODULE_DEVICE_TABLE(of, of_lp8860_leds_match); 486 487 static struct i2c_driver lp8860_driver = { 488 .driver = { 489 .name = "lp8860", 490 .of_match_table = of_lp8860_leds_match, 491 }, 492 .probe = lp8860_probe, 493 .remove = lp8860_remove, 494 .id_table = lp8860_id, 495 }; 496 module_i2c_driver(lp8860_driver); 497 498 MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver"); 499 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>"); 500 MODULE_LICENSE("GPL v2"); 501