1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * LP5521/LP5523/LP55231/LP5562 Common Driver 4 * 5 * Copyright 2012 Texas Instruments 6 * 7 * Author: Milo(Woogyom) Kim <milo.kim@ti.com> 8 * 9 * Derived from leds-lp5521.c, leds-lp5523.c 10 */ 11 12 #include <linux/bitfield.h> 13 #include <linux/cleanup.h> 14 #include <linux/clk.h> 15 #include <linux/delay.h> 16 #include <linux/firmware.h> 17 #include <linux/i2c.h> 18 #include <linux/iopoll.h> 19 #include <linux/leds.h> 20 #include <linux/module.h> 21 #include <linux/platform_data/leds-lp55xx.h> 22 #include <linux/slab.h> 23 #include <linux/gpio/consumer.h> 24 #include <dt-bindings/leds/leds-lp55xx.h> 25 26 #include "leds-lp55xx-common.h" 27 28 /* OP MODE require at least 153 us to clear regs */ 29 #define LP55XX_CMD_SLEEP 200 30 31 #define LP55xx_PROGRAM_PAGES 16 32 #define LP55xx_MAX_PROGRAM_LENGTH (LP55xx_BYTES_PER_PAGE * 4) /* 128 bytes (4 pages) */ 33 34 /* 35 * Program Memory Operations 36 * Same Mask for each engine for both mode and exec 37 * ENG1 GENMASK(3, 2) 38 * ENG2 GENMASK(5, 4) 39 * ENG3 GENMASK(7, 6) 40 */ 41 #define LP55xx_MODE_DISABLE_ALL_ENG 0x0 42 #define LP55xx_MODE_ENG_MASK GENMASK(1, 0) 43 #define LP55xx_MODE_DISABLE_ENG FIELD_PREP_CONST(LP55xx_MODE_ENG_MASK, 0x0) 44 #define LP55xx_MODE_LOAD_ENG FIELD_PREP_CONST(LP55xx_MODE_ENG_MASK, 0x1) 45 #define LP55xx_MODE_RUN_ENG FIELD_PREP_CONST(LP55xx_MODE_ENG_MASK, 0x2) 46 #define LP55xx_MODE_HALT_ENG FIELD_PREP_CONST(LP55xx_MODE_ENG_MASK, 0x3) 47 48 #define LP55xx_MODE_ENGn_SHIFT(n, shift) ((shift) + (2 * (3 - (n)))) 49 #define LP55xx_MODE_ENGn_MASK(n, shift) (LP55xx_MODE_ENG_MASK << LP55xx_MODE_ENGn_SHIFT(n, shift)) 50 #define LP55xx_MODE_ENGn_GET(n, mode, shift) \ 51 (((mode) >> LP55xx_MODE_ENGn_SHIFT(n, shift)) & LP55xx_MODE_ENG_MASK) 52 53 #define LP55xx_EXEC_ENG_MASK GENMASK(1, 0) 54 #define LP55xx_EXEC_HOLD_ENG FIELD_PREP_CONST(LP55xx_EXEC_ENG_MASK, 0x0) 55 #define LP55xx_EXEC_STEP_ENG FIELD_PREP_CONST(LP55xx_EXEC_ENG_MASK, 0x1) 56 #define LP55xx_EXEC_RUN_ENG FIELD_PREP_CONST(LP55xx_EXEC_ENG_MASK, 0x2) 57 #define LP55xx_EXEC_ONCE_ENG FIELD_PREP_CONST(LP55xx_EXEC_ENG_MASK, 0x3) 58 59 #define LP55xx_EXEC_ENGn_SHIFT(n, shift) ((shift) + (2 * (3 - (n)))) 60 #define LP55xx_EXEC_ENGn_MASK(n, shift) (LP55xx_EXEC_ENG_MASK << LP55xx_EXEC_ENGn_SHIFT(n, shift)) 61 62 /* Memory Page Selection */ 63 #define LP55xx_REG_PROG_PAGE_SEL 0x4f 64 /* If supported, each ENGINE have an equal amount of pages offset from page 0 */ 65 #define LP55xx_PAGE_OFFSET(n, pages) (((n) - 1) * (pages)) 66 67 #define LED_ACTIVE(mux, led) (!!((mux) & (0x0001 << (led)))) 68 69 /* MASTER FADER common property */ 70 #define LP55xx_FADER_MAPPING_MASK GENMASK(7, 6) 71 72 /* External clock rate */ 73 #define LP55XX_CLK_32K 32768 74 75 static struct lp55xx_led *cdev_to_lp55xx_led(struct led_classdev *cdev) 76 { 77 return container_of(cdev, struct lp55xx_led, cdev); 78 } 79 80 static struct lp55xx_led *dev_to_lp55xx_led(struct device *dev) 81 { 82 return cdev_to_lp55xx_led(dev_get_drvdata(dev)); 83 } 84 85 static struct lp55xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev) 86 { 87 return container_of(mc_cdev, struct lp55xx_led, mc_cdev); 88 } 89 90 static void lp55xx_wait_opmode_done(struct lp55xx_chip *chip) 91 { 92 const struct lp55xx_device_config *cfg = chip->cfg; 93 int __always_unused ret; 94 u8 val; 95 96 /* 97 * Recent chip supports BUSY bit for engine. 98 * Check support by checking if val is not 0. 99 * For legacy device, sleep at least 153 us. 100 */ 101 if (cfg->engine_busy.val) { 102 read_poll_timeout(lp55xx_read, ret, !(val & cfg->engine_busy.mask), 103 LP55XX_CMD_SLEEP, LP55XX_CMD_SLEEP * 10, false, 104 chip, cfg->engine_busy.addr, &val); 105 } else { 106 usleep_range(LP55XX_CMD_SLEEP, LP55XX_CMD_SLEEP * 2); 107 } 108 } 109 110 void lp55xx_stop_all_engine(struct lp55xx_chip *chip) 111 { 112 const struct lp55xx_device_config *cfg = chip->cfg; 113 114 lp55xx_write(chip, cfg->reg_op_mode.addr, LP55xx_MODE_DISABLE_ALL_ENG); 115 lp55xx_wait_opmode_done(chip); 116 } 117 EXPORT_SYMBOL_GPL(lp55xx_stop_all_engine); 118 119 void lp55xx_load_engine(struct lp55xx_chip *chip) 120 { 121 enum lp55xx_engine_index idx = chip->engine_idx; 122 const struct lp55xx_device_config *cfg = chip->cfg; 123 u8 mask, val; 124 125 mask = LP55xx_MODE_ENGn_MASK(idx, cfg->reg_op_mode.shift); 126 val = LP55xx_MODE_LOAD_ENG << LP55xx_MODE_ENGn_SHIFT(idx, cfg->reg_op_mode.shift); 127 128 lp55xx_update_bits(chip, cfg->reg_op_mode.addr, mask, val); 129 lp55xx_wait_opmode_done(chip); 130 131 /* Setup PAGE if supported (pages_per_engine not 0)*/ 132 if (cfg->pages_per_engine) 133 lp55xx_write(chip, LP55xx_REG_PROG_PAGE_SEL, 134 LP55xx_PAGE_OFFSET(idx, cfg->pages_per_engine)); 135 } 136 EXPORT_SYMBOL_GPL(lp55xx_load_engine); 137 138 int lp55xx_run_engine_common(struct lp55xx_chip *chip) 139 { 140 const struct lp55xx_device_config *cfg = chip->cfg; 141 u8 mode, exec; 142 int i, ret; 143 144 /* To run the engine, both OP MODE and EXEC needs to be put in RUN mode */ 145 ret = lp55xx_read(chip, cfg->reg_op_mode.addr, &mode); 146 if (ret) 147 return ret; 148 149 ret = lp55xx_read(chip, cfg->reg_exec.addr, &exec); 150 if (ret) 151 return ret; 152 153 /* Switch to RUN only for engine that were put in LOAD previously */ 154 for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) { 155 if (LP55xx_MODE_ENGn_GET(i, mode, cfg->reg_op_mode.shift) != LP55xx_MODE_LOAD_ENG) 156 continue; 157 158 mode &= ~LP55xx_MODE_ENGn_MASK(i, cfg->reg_op_mode.shift); 159 mode |= LP55xx_MODE_RUN_ENG << LP55xx_MODE_ENGn_SHIFT(i, cfg->reg_op_mode.shift); 160 exec &= ~LP55xx_EXEC_ENGn_MASK(i, cfg->reg_exec.shift); 161 exec |= LP55xx_EXEC_RUN_ENG << LP55xx_EXEC_ENGn_SHIFT(i, cfg->reg_exec.shift); 162 } 163 164 lp55xx_write(chip, cfg->reg_op_mode.addr, mode); 165 lp55xx_wait_opmode_done(chip); 166 lp55xx_write(chip, cfg->reg_exec.addr, exec); 167 168 return 0; 169 } 170 EXPORT_SYMBOL_GPL(lp55xx_run_engine_common); 171 172 int lp55xx_update_program_memory(struct lp55xx_chip *chip, 173 const u8 *data, size_t size) 174 { 175 enum lp55xx_engine_index idx = chip->engine_idx; 176 const struct lp55xx_device_config *cfg = chip->cfg; 177 u8 pattern[LP55xx_MAX_PROGRAM_LENGTH] = { }; 178 u8 start_addr = cfg->prog_mem_base.addr; 179 int page, i = 0, offset = 0; 180 int program_length, ret; 181 182 program_length = LP55xx_BYTES_PER_PAGE; 183 if (cfg->pages_per_engine) 184 program_length *= cfg->pages_per_engine; 185 186 while ((offset < size - 1) && (i < program_length)) { 187 unsigned int cmd; 188 int nrchars; 189 char c[3]; 190 191 /* separate sscanfs because length is working only for %s */ 192 ret = sscanf(data + offset, "%2s%n ", c, &nrchars); 193 if (ret != 1) 194 goto err; 195 196 ret = sscanf(c, "%2x", &cmd); 197 if (ret != 1) 198 goto err; 199 200 pattern[i] = (u8)cmd; 201 offset += nrchars; 202 i++; 203 } 204 205 /* Each instruction is 16bit long. Check that length is even */ 206 if (i % 2) 207 goto err; 208 209 /* 210 * For legacy LED chip with no page support, engine base address are 211 * one after another at offset of 32. 212 * For LED chip that support page, PAGE is already set in load_engine. 213 */ 214 if (!cfg->pages_per_engine) 215 start_addr += LP55xx_BYTES_PER_PAGE * idx; 216 217 for (page = 0; page < program_length / LP55xx_BYTES_PER_PAGE; page++) { 218 /* Write to the next page each 32 bytes (if supported) */ 219 if (cfg->pages_per_engine) 220 lp55xx_write(chip, LP55xx_REG_PROG_PAGE_SEL, 221 LP55xx_PAGE_OFFSET(idx, cfg->pages_per_engine) + page); 222 223 for (i = 0; i < LP55xx_BYTES_PER_PAGE; i++) { 224 ret = lp55xx_write(chip, start_addr + i, 225 pattern[i + (page * LP55xx_BYTES_PER_PAGE)]); 226 if (ret) 227 return -EINVAL; 228 } 229 } 230 231 return size; 232 233 err: 234 dev_err(&chip->cl->dev, "wrong pattern format\n"); 235 return -EINVAL; 236 } 237 EXPORT_SYMBOL_GPL(lp55xx_update_program_memory); 238 239 void lp55xx_firmware_loaded_cb(struct lp55xx_chip *chip) 240 { 241 const struct lp55xx_device_config *cfg = chip->cfg; 242 const struct firmware *fw = chip->fw; 243 int program_length; 244 245 program_length = LP55xx_BYTES_PER_PAGE; 246 if (cfg->pages_per_engine) 247 program_length *= cfg->pages_per_engine; 248 249 /* 250 * the firmware is encoded in ascii hex character, with 2 chars 251 * per byte 252 */ 253 if (fw->size > program_length * 2) { 254 dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n", 255 fw->size); 256 return; 257 } 258 259 /* 260 * Program memory sequence 261 * 1) set engine mode to "LOAD" 262 * 2) write firmware data into program memory 263 */ 264 265 lp55xx_load_engine(chip); 266 lp55xx_update_program_memory(chip, fw->data, fw->size); 267 } 268 EXPORT_SYMBOL_GPL(lp55xx_firmware_loaded_cb); 269 270 int lp55xx_led_brightness(struct lp55xx_led *led) 271 { 272 struct lp55xx_chip *chip = led->chip; 273 const struct lp55xx_device_config *cfg = chip->cfg; 274 int ret; 275 276 guard(mutex)(&chip->lock); 277 278 ret = lp55xx_write(chip, cfg->reg_led_pwm_base.addr + led->chan_nr, 279 led->brightness); 280 return ret; 281 } 282 EXPORT_SYMBOL_GPL(lp55xx_led_brightness); 283 284 int lp55xx_multicolor_brightness(struct lp55xx_led *led) 285 { 286 struct lp55xx_chip *chip = led->chip; 287 const struct lp55xx_device_config *cfg = chip->cfg; 288 int ret; 289 int i; 290 291 guard(mutex)(&chip->lock); 292 293 for (i = 0; i < led->mc_cdev.num_colors; i++) { 294 ret = lp55xx_write(chip, 295 cfg->reg_led_pwm_base.addr + 296 led->mc_cdev.subled_info[i].channel, 297 led->mc_cdev.subled_info[i].brightness); 298 if (ret) 299 break; 300 } 301 302 return ret; 303 } 304 EXPORT_SYMBOL_GPL(lp55xx_multicolor_brightness); 305 306 void lp55xx_set_led_current(struct lp55xx_led *led, u8 led_current) 307 { 308 struct lp55xx_chip *chip = led->chip; 309 const struct lp55xx_device_config *cfg = chip->cfg; 310 311 led->led_current = led_current; 312 lp55xx_write(led->chip, cfg->reg_led_current_base.addr + led->chan_nr, 313 led_current); 314 } 315 EXPORT_SYMBOL_GPL(lp55xx_set_led_current); 316 317 void lp55xx_turn_off_channels(struct lp55xx_chip *chip) 318 { 319 const struct lp55xx_device_config *cfg = chip->cfg; 320 int i; 321 322 for (i = 0; i < cfg->max_channel; i++) 323 lp55xx_write(chip, cfg->reg_led_pwm_base.addr + i, 0); 324 } 325 EXPORT_SYMBOL_GPL(lp55xx_turn_off_channels); 326 327 void lp55xx_stop_engine(struct lp55xx_chip *chip) 328 { 329 enum lp55xx_engine_index idx = chip->engine_idx; 330 const struct lp55xx_device_config *cfg = chip->cfg; 331 u8 mask; 332 333 mask = LP55xx_MODE_ENGn_MASK(idx, cfg->reg_op_mode.shift); 334 lp55xx_update_bits(chip, cfg->reg_op_mode.addr, mask, 0); 335 336 lp55xx_wait_opmode_done(chip); 337 } 338 EXPORT_SYMBOL_GPL(lp55xx_stop_engine); 339 340 static void lp55xx_reset_device(struct lp55xx_chip *chip) 341 { 342 const struct lp55xx_device_config *cfg = chip->cfg; 343 u8 addr = cfg->reset.addr; 344 u8 val = cfg->reset.val; 345 346 /* no error checking here because no ACK from the device after reset */ 347 lp55xx_write(chip, addr, val); 348 } 349 350 static int lp55xx_detect_device(struct lp55xx_chip *chip) 351 { 352 const struct lp55xx_device_config *cfg = chip->cfg; 353 u8 addr = cfg->enable.addr; 354 u8 val = cfg->enable.val; 355 int ret; 356 357 ret = lp55xx_write(chip, addr, val); 358 if (ret) 359 return ret; 360 361 usleep_range(1000, 2000); 362 363 ret = lp55xx_read(chip, addr, &val); 364 if (ret) 365 return ret; 366 367 if (val != cfg->enable.val) 368 return -ENODEV; 369 370 return 0; 371 } 372 373 static int lp55xx_post_init_device(struct lp55xx_chip *chip) 374 { 375 const struct lp55xx_device_config *cfg = chip->cfg; 376 377 if (!cfg->post_init_device) 378 return 0; 379 380 return cfg->post_init_device(chip); 381 } 382 383 static ssize_t led_current_show(struct device *dev, 384 struct device_attribute *attr, 385 char *buf) 386 { 387 struct lp55xx_led *led = dev_to_lp55xx_led(dev); 388 389 return sysfs_emit(buf, "%d\n", led->led_current); 390 } 391 392 static ssize_t led_current_store(struct device *dev, 393 struct device_attribute *attr, 394 const char *buf, size_t len) 395 { 396 struct lp55xx_led *led = dev_to_lp55xx_led(dev); 397 struct lp55xx_chip *chip = led->chip; 398 unsigned long curr; 399 400 if (kstrtoul(buf, 0, &curr)) 401 return -EINVAL; 402 403 if (curr > led->max_current) 404 return -EINVAL; 405 406 if (!chip->cfg->set_led_current) 407 return len; 408 409 guard(mutex)(&chip->lock); 410 411 chip->cfg->set_led_current(led, (u8)curr); 412 413 return len; 414 } 415 416 static ssize_t max_current_show(struct device *dev, 417 struct device_attribute *attr, 418 char *buf) 419 { 420 struct lp55xx_led *led = dev_to_lp55xx_led(dev); 421 422 return sysfs_emit(buf, "%d\n", led->max_current); 423 } 424 425 static DEVICE_ATTR_RW(led_current); 426 static DEVICE_ATTR_RO(max_current); 427 428 static struct attribute *lp55xx_led_attrs[] = { 429 &dev_attr_led_current.attr, 430 &dev_attr_max_current.attr, 431 NULL, 432 }; 433 ATTRIBUTE_GROUPS(lp55xx_led); 434 435 static int lp55xx_set_mc_brightness(struct led_classdev *cdev, 436 enum led_brightness brightness) 437 { 438 struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev); 439 struct lp55xx_led *led = mcled_cdev_to_led(mc_dev); 440 const struct lp55xx_device_config *cfg = led->chip->cfg; 441 442 led_mc_calc_color_components(&led->mc_cdev, brightness); 443 return cfg->multicolor_brightness_fn(led); 444 445 } 446 447 static int lp55xx_set_brightness(struct led_classdev *cdev, 448 enum led_brightness brightness) 449 { 450 struct lp55xx_led *led = cdev_to_lp55xx_led(cdev); 451 const struct lp55xx_device_config *cfg = led->chip->cfg; 452 453 led->brightness = (u8)brightness; 454 return cfg->brightness_fn(led); 455 } 456 457 static int lp55xx_init_led(struct lp55xx_led *led, 458 struct lp55xx_chip *chip, int chan) 459 { 460 struct lp55xx_platform_data *pdata = chip->pdata; 461 const struct lp55xx_device_config *cfg = chip->cfg; 462 struct device *dev = &chip->cl->dev; 463 int max_channel = cfg->max_channel; 464 struct mc_subled *mc_led_info; 465 struct led_classdev *led_cdev; 466 char name[32]; 467 int i; 468 int ret; 469 470 if (chan >= max_channel) { 471 dev_err(dev, "invalid channel: %d / %d\n", chan, max_channel); 472 return -EINVAL; 473 } 474 475 if (pdata->led_config[chan].led_current == 0) 476 return 0; 477 478 if (pdata->led_config[chan].name) { 479 led->cdev.name = pdata->led_config[chan].name; 480 } else { 481 snprintf(name, sizeof(name), "%s:channel%d", 482 pdata->label ? : chip->cl->name, chan); 483 led->cdev.name = name; 484 } 485 486 if (pdata->led_config[chan].num_colors > 1) { 487 mc_led_info = devm_kcalloc(dev, 488 pdata->led_config[chan].num_colors, 489 sizeof(*mc_led_info), GFP_KERNEL); 490 if (!mc_led_info) 491 return -ENOMEM; 492 493 led_cdev = &led->mc_cdev.led_cdev; 494 led_cdev->name = led->cdev.name; 495 led_cdev->brightness_set_blocking = lp55xx_set_mc_brightness; 496 led->mc_cdev.num_colors = pdata->led_config[chan].num_colors; 497 for (i = 0; i < led->mc_cdev.num_colors; i++) { 498 mc_led_info[i].color_index = 499 pdata->led_config[chan].color_id[i]; 500 mc_led_info[i].channel = 501 pdata->led_config[chan].output_num[i]; 502 } 503 504 led->mc_cdev.subled_info = mc_led_info; 505 } else { 506 led->cdev.brightness_set_blocking = lp55xx_set_brightness; 507 } 508 509 led->cdev.groups = lp55xx_led_groups; 510 led->cdev.default_trigger = pdata->led_config[chan].default_trigger; 511 led->led_current = pdata->led_config[chan].led_current; 512 led->max_current = pdata->led_config[chan].max_current; 513 led->chan_nr = pdata->led_config[chan].chan_nr; 514 515 if (led->chan_nr >= max_channel) { 516 dev_err(dev, "Use channel numbers between 0 and %d\n", 517 max_channel - 1); 518 return -EINVAL; 519 } 520 521 if (pdata->led_config[chan].num_colors > 1) 522 ret = devm_led_classdev_multicolor_register(dev, &led->mc_cdev); 523 else 524 ret = devm_led_classdev_register(dev, &led->cdev); 525 526 if (ret) { 527 dev_err(dev, "led register err: %d\n", ret); 528 return ret; 529 } 530 531 return 0; 532 } 533 534 static void lp55xx_firmware_loaded(const struct firmware *fw, void *context) 535 { 536 struct lp55xx_chip *chip = context; 537 struct device *dev = &chip->cl->dev; 538 enum lp55xx_engine_index idx = chip->engine_idx; 539 540 if (!fw) { 541 dev_err(dev, "firmware request failed\n"); 542 return; 543 } 544 545 /* handling firmware data is chip dependent */ 546 scoped_guard(mutex, &chip->lock) { 547 chip->engines[idx - 1].mode = LP55XX_ENGINE_LOAD; 548 chip->fw = fw; 549 if (chip->cfg->firmware_cb) 550 chip->cfg->firmware_cb(chip); 551 } 552 553 /* firmware should be released for other channel use */ 554 release_firmware(chip->fw); 555 chip->fw = NULL; 556 } 557 558 static int lp55xx_request_firmware(struct lp55xx_chip *chip) 559 { 560 const char *name = chip->cl->name; 561 struct device *dev = &chip->cl->dev; 562 563 return request_firmware_nowait(THIS_MODULE, false, name, dev, 564 GFP_KERNEL, chip, lp55xx_firmware_loaded); 565 } 566 567 static ssize_t select_engine_show(struct device *dev, 568 struct device_attribute *attr, 569 char *buf) 570 { 571 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 572 struct lp55xx_chip *chip = led->chip; 573 574 return sprintf(buf, "%d\n", chip->engine_idx); 575 } 576 577 static ssize_t select_engine_store(struct device *dev, 578 struct device_attribute *attr, 579 const char *buf, size_t len) 580 { 581 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 582 struct lp55xx_chip *chip = led->chip; 583 unsigned long val; 584 int ret; 585 586 if (kstrtoul(buf, 0, &val)) 587 return -EINVAL; 588 589 /* select the engine to be run */ 590 591 switch (val) { 592 case LP55XX_ENGINE_1: 593 case LP55XX_ENGINE_2: 594 case LP55XX_ENGINE_3: 595 scoped_guard(mutex, &chip->lock) { 596 chip->engine_idx = val; 597 ret = lp55xx_request_firmware(chip); 598 } 599 break; 600 default: 601 dev_err(dev, "%lu: invalid engine index. (1, 2, 3)\n", val); 602 return -EINVAL; 603 } 604 605 if (ret) { 606 dev_err(dev, "request firmware err: %d\n", ret); 607 return ret; 608 } 609 610 return len; 611 } 612 613 static inline void lp55xx_run_engine(struct lp55xx_chip *chip, bool start) 614 { 615 if (chip->cfg->run_engine) 616 chip->cfg->run_engine(chip, start); 617 } 618 619 static ssize_t run_engine_store(struct device *dev, 620 struct device_attribute *attr, 621 const char *buf, size_t len) 622 { 623 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 624 struct lp55xx_chip *chip = led->chip; 625 unsigned long val; 626 627 if (kstrtoul(buf, 0, &val)) 628 return -EINVAL; 629 630 /* run or stop the selected engine */ 631 632 if (val <= 0) { 633 lp55xx_run_engine(chip, false); 634 return len; 635 } 636 637 guard(mutex)(&chip->lock); 638 639 lp55xx_run_engine(chip, true); 640 641 return len; 642 } 643 644 static DEVICE_ATTR_RW(select_engine); 645 static DEVICE_ATTR_WO(run_engine); 646 647 ssize_t lp55xx_show_engine_mode(struct device *dev, 648 struct device_attribute *attr, 649 char *buf, int nr) 650 { 651 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 652 struct lp55xx_chip *chip = led->chip; 653 enum lp55xx_engine_mode mode = chip->engines[nr - 1].mode; 654 655 switch (mode) { 656 case LP55XX_ENGINE_RUN: 657 return sysfs_emit(buf, "run\n"); 658 case LP55XX_ENGINE_LOAD: 659 return sysfs_emit(buf, "load\n"); 660 case LP55XX_ENGINE_DISABLED: 661 default: 662 return sysfs_emit(buf, "disabled\n"); 663 } 664 } 665 EXPORT_SYMBOL_GPL(lp55xx_show_engine_mode); 666 667 ssize_t lp55xx_store_engine_mode(struct device *dev, 668 struct device_attribute *attr, 669 const char *buf, size_t len, int nr) 670 { 671 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 672 struct lp55xx_chip *chip = led->chip; 673 const struct lp55xx_device_config *cfg = chip->cfg; 674 struct lp55xx_engine *engine = &chip->engines[nr - 1]; 675 676 guard(mutex)(&chip->lock); 677 678 chip->engine_idx = nr; 679 680 if (!strncmp(buf, "run", 3)) { 681 cfg->run_engine(chip, true); 682 engine->mode = LP55XX_ENGINE_RUN; 683 } else if (!strncmp(buf, "load", 4)) { 684 lp55xx_stop_engine(chip); 685 lp55xx_load_engine(chip); 686 engine->mode = LP55XX_ENGINE_LOAD; 687 } else if (!strncmp(buf, "disabled", 8)) { 688 lp55xx_stop_engine(chip); 689 engine->mode = LP55XX_ENGINE_DISABLED; 690 } 691 692 return len; 693 } 694 EXPORT_SYMBOL_GPL(lp55xx_store_engine_mode); 695 696 ssize_t lp55xx_store_engine_load(struct device *dev, 697 struct device_attribute *attr, 698 const char *buf, size_t len, int nr) 699 { 700 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 701 struct lp55xx_chip *chip = led->chip; 702 int ret; 703 704 guard(mutex)(&chip->lock); 705 706 chip->engine_idx = nr; 707 lp55xx_load_engine(chip); 708 ret = lp55xx_update_program_memory(chip, buf, len); 709 710 return ret; 711 } 712 EXPORT_SYMBOL_GPL(lp55xx_store_engine_load); 713 714 static int lp55xx_mux_parse(struct lp55xx_chip *chip, const char *buf, 715 u16 *mux, size_t len) 716 { 717 const struct lp55xx_device_config *cfg = chip->cfg; 718 u16 tmp_mux = 0; 719 int i; 720 721 len = min_t(int, len, cfg->max_channel); 722 723 for (i = 0; i < len; i++) { 724 switch (buf[i]) { 725 case '1': 726 tmp_mux |= (1 << i); 727 break; 728 case '0': 729 break; 730 case '\n': 731 i = len; 732 break; 733 default: 734 return -1; 735 } 736 } 737 *mux = tmp_mux; 738 739 return 0; 740 } 741 742 ssize_t lp55xx_show_engine_leds(struct device *dev, 743 struct device_attribute *attr, 744 char *buf, int nr) 745 { 746 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 747 struct lp55xx_chip *chip = led->chip; 748 const struct lp55xx_device_config *cfg = chip->cfg; 749 unsigned int led_active; 750 int i, pos = 0; 751 752 for (i = 0; i < cfg->max_channel; i++) { 753 led_active = LED_ACTIVE(chip->engines[nr - 1].led_mux, i); 754 pos += sysfs_emit_at(buf, pos, "%x", led_active); 755 } 756 757 pos += sysfs_emit_at(buf, pos, "\n"); 758 759 return pos; 760 } 761 EXPORT_SYMBOL_GPL(lp55xx_show_engine_leds); 762 763 static int lp55xx_load_mux(struct lp55xx_chip *chip, u16 mux, int nr) 764 { 765 struct lp55xx_engine *engine = &chip->engines[nr - 1]; 766 const struct lp55xx_device_config *cfg = chip->cfg; 767 u8 mux_page; 768 int ret; 769 770 lp55xx_load_engine(chip); 771 772 /* Derive the MUX page offset by starting at the end of the ENGINE pages */ 773 mux_page = cfg->pages_per_engine * LP55XX_ENGINE_MAX + (nr - 1); 774 ret = lp55xx_write(chip, LP55xx_REG_PROG_PAGE_SEL, mux_page); 775 if (ret) 776 return ret; 777 778 ret = lp55xx_write(chip, cfg->prog_mem_base.addr, (u8)(mux >> 8)); 779 if (ret) 780 return ret; 781 782 ret = lp55xx_write(chip, cfg->prog_mem_base.addr + 1, (u8)(mux)); 783 if (ret) 784 return ret; 785 786 engine->led_mux = mux; 787 return 0; 788 } 789 790 ssize_t lp55xx_store_engine_leds(struct device *dev, 791 struct device_attribute *attr, 792 const char *buf, size_t len, int nr) 793 { 794 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 795 struct lp55xx_chip *chip = led->chip; 796 struct lp55xx_engine *engine = &chip->engines[nr - 1]; 797 u16 mux = 0; 798 799 if (lp55xx_mux_parse(chip, buf, &mux, len)) 800 return -EINVAL; 801 802 guard(mutex)(&chip->lock); 803 804 chip->engine_idx = nr; 805 806 if (engine->mode != LP55XX_ENGINE_LOAD) 807 return -EINVAL; 808 809 if (lp55xx_load_mux(chip, mux, nr)) 810 return -EINVAL; 811 812 return len; 813 } 814 EXPORT_SYMBOL_GPL(lp55xx_store_engine_leds); 815 816 ssize_t lp55xx_show_master_fader(struct device *dev, 817 struct device_attribute *attr, 818 char *buf, int nr) 819 { 820 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 821 struct lp55xx_chip *chip = led->chip; 822 const struct lp55xx_device_config *cfg = chip->cfg; 823 int ret; 824 u8 val; 825 826 guard(mutex)(&chip->lock); 827 828 ret = lp55xx_read(chip, cfg->reg_master_fader_base.addr + nr - 1, &val); 829 830 return ret ? ret : sysfs_emit(buf, "%u\n", val); 831 } 832 EXPORT_SYMBOL_GPL(lp55xx_show_master_fader); 833 834 ssize_t lp55xx_store_master_fader(struct device *dev, 835 struct device_attribute *attr, 836 const char *buf, size_t len, int nr) 837 { 838 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 839 struct lp55xx_chip *chip = led->chip; 840 const struct lp55xx_device_config *cfg = chip->cfg; 841 int ret; 842 unsigned long val; 843 844 if (kstrtoul(buf, 0, &val)) 845 return -EINVAL; 846 847 if (val > 0xff) 848 return -EINVAL; 849 850 guard(mutex)(&chip->lock); 851 852 ret = lp55xx_write(chip, cfg->reg_master_fader_base.addr + nr - 1, 853 (u8)val); 854 855 return ret ? ret : len; 856 } 857 EXPORT_SYMBOL_GPL(lp55xx_store_master_fader); 858 859 ssize_t lp55xx_show_master_fader_leds(struct device *dev, 860 struct device_attribute *attr, 861 char *buf) 862 { 863 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 864 struct lp55xx_chip *chip = led->chip; 865 const struct lp55xx_device_config *cfg = chip->cfg; 866 int i, ret, pos = 0; 867 u8 val; 868 869 guard(mutex)(&chip->lock); 870 871 for (i = 0; i < cfg->max_channel; i++) { 872 ret = lp55xx_read(chip, cfg->reg_led_ctrl_base.addr + i, &val); 873 if (ret) 874 return ret; 875 876 val = FIELD_GET(LP55xx_FADER_MAPPING_MASK, val); 877 if (val > FIELD_MAX(LP55xx_FADER_MAPPING_MASK)) { 878 return -EINVAL; 879 } 880 buf[pos++] = val + '0'; 881 } 882 buf[pos++] = '\n'; 883 884 return pos; 885 } 886 EXPORT_SYMBOL_GPL(lp55xx_show_master_fader_leds); 887 888 ssize_t lp55xx_store_master_fader_leds(struct device *dev, 889 struct device_attribute *attr, 890 const char *buf, size_t len) 891 { 892 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev)); 893 struct lp55xx_chip *chip = led->chip; 894 const struct lp55xx_device_config *cfg = chip->cfg; 895 int i, n, ret; 896 u8 val; 897 898 n = min_t(int, len, cfg->max_channel); 899 900 guard(mutex)(&chip->lock); 901 902 for (i = 0; i < n; i++) { 903 if (buf[i] >= '0' && buf[i] <= '3') { 904 val = (buf[i] - '0') << __bf_shf(LP55xx_FADER_MAPPING_MASK); 905 ret = lp55xx_update_bits(chip, 906 cfg->reg_led_ctrl_base.addr + i, 907 LP55xx_FADER_MAPPING_MASK, 908 val); 909 if (ret) 910 return ret; 911 } else { 912 return -EINVAL; 913 } 914 } 915 916 return len; 917 } 918 EXPORT_SYMBOL_GPL(lp55xx_store_master_fader_leds); 919 920 static struct attribute *lp55xx_engine_attributes[] = { 921 &dev_attr_select_engine.attr, 922 &dev_attr_run_engine.attr, 923 NULL, 924 }; 925 926 static const struct attribute_group lp55xx_engine_attr_group = { 927 .attrs = lp55xx_engine_attributes, 928 }; 929 930 int lp55xx_write(struct lp55xx_chip *chip, u8 reg, u8 val) 931 { 932 return i2c_smbus_write_byte_data(chip->cl, reg, val); 933 } 934 EXPORT_SYMBOL_GPL(lp55xx_write); 935 936 int lp55xx_read(struct lp55xx_chip *chip, u8 reg, u8 *val) 937 { 938 s32 ret; 939 940 ret = i2c_smbus_read_byte_data(chip->cl, reg); 941 if (ret < 0) 942 return ret; 943 944 *val = ret; 945 return 0; 946 } 947 EXPORT_SYMBOL_GPL(lp55xx_read); 948 949 int lp55xx_update_bits(struct lp55xx_chip *chip, u8 reg, u8 mask, u8 val) 950 { 951 int ret; 952 u8 tmp; 953 954 ret = lp55xx_read(chip, reg, &tmp); 955 if (ret) 956 return ret; 957 958 tmp &= ~mask; 959 tmp |= val & mask; 960 961 return lp55xx_write(chip, reg, tmp); 962 } 963 EXPORT_SYMBOL_GPL(lp55xx_update_bits); 964 965 bool lp55xx_is_extclk_used(struct lp55xx_chip *chip) 966 { 967 struct clk *clk; 968 int err; 969 970 clk = devm_clk_get(&chip->cl->dev, "32k_clk"); 971 if (IS_ERR(clk)) 972 goto use_internal_clk; 973 974 err = clk_prepare_enable(clk); 975 if (err) 976 goto use_internal_clk; 977 978 if (clk_get_rate(clk) != LP55XX_CLK_32K) { 979 clk_disable_unprepare(clk); 980 goto use_internal_clk; 981 } 982 983 dev_info(&chip->cl->dev, "%dHz external clock used\n", LP55XX_CLK_32K); 984 985 chip->clk = clk; 986 return true; 987 988 use_internal_clk: 989 dev_info(&chip->cl->dev, "internal clock used\n"); 990 return false; 991 } 992 EXPORT_SYMBOL_GPL(lp55xx_is_extclk_used); 993 994 static void lp55xx_deinit_device(struct lp55xx_chip *chip) 995 { 996 struct lp55xx_platform_data *pdata = chip->pdata; 997 998 if (chip->clk) 999 clk_disable_unprepare(chip->clk); 1000 1001 if (pdata->enable_gpiod) 1002 gpiod_set_value(pdata->enable_gpiod, 0); 1003 } 1004 1005 static int lp55xx_init_device(struct lp55xx_chip *chip) 1006 { 1007 struct lp55xx_platform_data *pdata; 1008 const struct lp55xx_device_config *cfg; 1009 struct device *dev = &chip->cl->dev; 1010 int ret = 0; 1011 1012 WARN_ON(!chip); 1013 1014 pdata = chip->pdata; 1015 cfg = chip->cfg; 1016 1017 if (!pdata || !cfg) 1018 return -EINVAL; 1019 1020 if (pdata->enable_gpiod) { 1021 gpiod_direction_output(pdata->enable_gpiod, 0); 1022 1023 gpiod_set_consumer_name(pdata->enable_gpiod, "LP55xx enable"); 1024 gpiod_set_value_cansleep(pdata->enable_gpiod, 0); 1025 usleep_range(1000, 2000); /* Keep enable down at least 1ms */ 1026 gpiod_set_value_cansleep(pdata->enable_gpiod, 1); 1027 usleep_range(1000, 2000); /* 500us abs min. */ 1028 } 1029 1030 lp55xx_reset_device(chip); 1031 1032 /* 1033 * Exact value is not available. 10 - 20ms 1034 * appears to be enough for reset. 1035 */ 1036 usleep_range(10000, 20000); 1037 1038 ret = lp55xx_detect_device(chip); 1039 if (ret) { 1040 dev_err(dev, "device detection err: %d\n", ret); 1041 goto err; 1042 } 1043 1044 /* chip specific initialization */ 1045 ret = lp55xx_post_init_device(chip); 1046 if (ret) { 1047 dev_err(dev, "post init device err: %d\n", ret); 1048 goto err_post_init; 1049 } 1050 1051 return 0; 1052 1053 err_post_init: 1054 lp55xx_deinit_device(chip); 1055 err: 1056 return ret; 1057 } 1058 1059 static int lp55xx_register_leds(struct lp55xx_led *led, struct lp55xx_chip *chip) 1060 { 1061 struct lp55xx_platform_data *pdata = chip->pdata; 1062 const struct lp55xx_device_config *cfg = chip->cfg; 1063 int num_channels = pdata->num_channels; 1064 struct lp55xx_led *each; 1065 u8 led_current; 1066 int ret; 1067 int i; 1068 1069 if (!cfg->brightness_fn) { 1070 dev_err(&chip->cl->dev, "empty brightness configuration\n"); 1071 return -EINVAL; 1072 } 1073 1074 for (i = 0; i < num_channels; i++) { 1075 1076 /* do not initialize channels that are not connected */ 1077 if (pdata->led_config[i].led_current == 0) 1078 continue; 1079 1080 led_current = pdata->led_config[i].led_current; 1081 each = led + i; 1082 ret = lp55xx_init_led(each, chip, i); 1083 if (ret) 1084 goto err_init_led; 1085 1086 chip->num_leds++; 1087 each->chip = chip; 1088 1089 /* setting led current at each channel */ 1090 if (cfg->set_led_current) 1091 cfg->set_led_current(each, led_current); 1092 } 1093 1094 return 0; 1095 1096 err_init_led: 1097 return ret; 1098 } 1099 1100 static int lp55xx_register_sysfs(struct lp55xx_chip *chip) 1101 { 1102 struct device *dev = &chip->cl->dev; 1103 const struct lp55xx_device_config *cfg = chip->cfg; 1104 int ret; 1105 1106 if (!cfg->run_engine || !cfg->firmware_cb) 1107 goto dev_specific_attrs; 1108 1109 ret = sysfs_create_group(&dev->kobj, &lp55xx_engine_attr_group); 1110 if (ret) 1111 return ret; 1112 1113 dev_specific_attrs: 1114 return cfg->dev_attr_group ? 1115 sysfs_create_group(&dev->kobj, cfg->dev_attr_group) : 0; 1116 } 1117 1118 static void lp55xx_unregister_sysfs(struct lp55xx_chip *chip) 1119 { 1120 struct device *dev = &chip->cl->dev; 1121 const struct lp55xx_device_config *cfg = chip->cfg; 1122 1123 if (cfg->dev_attr_group) 1124 sysfs_remove_group(&dev->kobj, cfg->dev_attr_group); 1125 1126 sysfs_remove_group(&dev->kobj, &lp55xx_engine_attr_group); 1127 } 1128 1129 static int lp55xx_parse_common_child(struct device_node *np, 1130 struct lp55xx_led_config *cfg, 1131 int led_number, int *chan_nr) 1132 { 1133 int ret; 1134 1135 of_property_read_string(np, "chan-name", 1136 &cfg[led_number].name); 1137 of_property_read_u8(np, "led-cur", 1138 &cfg[led_number].led_current); 1139 of_property_read_u8(np, "max-cur", 1140 &cfg[led_number].max_current); 1141 1142 ret = of_property_read_u32(np, "reg", chan_nr); 1143 if (ret) 1144 return ret; 1145 1146 if (*chan_nr < 0 || *chan_nr > cfg->max_channel) 1147 return -EINVAL; 1148 1149 return 0; 1150 } 1151 1152 static int lp55xx_parse_multi_led_child(struct device_node *child, 1153 struct lp55xx_led_config *cfg, 1154 int child_number, int color_number) 1155 { 1156 int chan_nr, color_id, ret; 1157 1158 ret = lp55xx_parse_common_child(child, cfg, child_number, &chan_nr); 1159 if (ret) 1160 return ret; 1161 1162 ret = of_property_read_u32(child, "color", &color_id); 1163 if (ret) 1164 return ret; 1165 1166 cfg[child_number].color_id[color_number] = color_id; 1167 cfg[child_number].output_num[color_number] = chan_nr; 1168 1169 return 0; 1170 } 1171 1172 static int lp55xx_parse_multi_led(struct device_node *np, 1173 struct lp55xx_led_config *cfg, 1174 int child_number) 1175 { 1176 struct device_node *child; 1177 int num_colors = 0, ret; 1178 1179 for_each_available_child_of_node(np, child) { 1180 ret = lp55xx_parse_multi_led_child(child, cfg, child_number, 1181 num_colors); 1182 if (ret) { 1183 of_node_put(child); 1184 return ret; 1185 } 1186 num_colors++; 1187 } 1188 1189 cfg[child_number].num_colors = num_colors; 1190 1191 return 0; 1192 } 1193 1194 static int lp55xx_parse_logical_led(struct device_node *np, 1195 struct lp55xx_led_config *cfg, 1196 int child_number) 1197 { 1198 int led_color, ret; 1199 int chan_nr = 0; 1200 1201 cfg[child_number].default_trigger = 1202 of_get_property(np, "linux,default-trigger", NULL); 1203 1204 ret = of_property_read_u32(np, "color", &led_color); 1205 if (ret) 1206 return ret; 1207 1208 if (led_color == LED_COLOR_ID_RGB) 1209 return lp55xx_parse_multi_led(np, cfg, child_number); 1210 1211 ret = lp55xx_parse_common_child(np, cfg, child_number, &chan_nr); 1212 if (ret < 0) 1213 return ret; 1214 1215 cfg[child_number].chan_nr = chan_nr; 1216 1217 return ret; 1218 } 1219 1220 static struct lp55xx_platform_data *lp55xx_of_populate_pdata(struct device *dev, 1221 struct device_node *np, 1222 struct lp55xx_chip *chip) 1223 { 1224 struct device_node *child; 1225 struct lp55xx_platform_data *pdata; 1226 struct lp55xx_led_config *cfg; 1227 int num_channels; 1228 int i = 0; 1229 int ret; 1230 1231 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 1232 if (!pdata) 1233 return ERR_PTR(-ENOMEM); 1234 1235 num_channels = of_get_available_child_count(np); 1236 if (num_channels == 0) { 1237 dev_err(dev, "no LED channels\n"); 1238 return ERR_PTR(-EINVAL); 1239 } 1240 1241 cfg = devm_kcalloc(dev, num_channels, sizeof(*cfg), GFP_KERNEL); 1242 if (!cfg) 1243 return ERR_PTR(-ENOMEM); 1244 1245 pdata->led_config = &cfg[0]; 1246 pdata->num_channels = num_channels; 1247 cfg->max_channel = chip->cfg->max_channel; 1248 1249 for_each_available_child_of_node(np, child) { 1250 ret = lp55xx_parse_logical_led(child, cfg, i); 1251 if (ret) { 1252 of_node_put(child); 1253 return ERR_PTR(-EINVAL); 1254 } 1255 i++; 1256 } 1257 1258 if (of_property_read_u32(np, "ti,charge-pump-mode", &pdata->charge_pump_mode)) 1259 pdata->charge_pump_mode = LP55XX_CP_AUTO; 1260 1261 if (pdata->charge_pump_mode > LP55XX_CP_AUTO) { 1262 dev_err(dev, "invalid charge pump mode %d\n", pdata->charge_pump_mode); 1263 return ERR_PTR(-EINVAL); 1264 } 1265 1266 of_property_read_string(np, "label", &pdata->label); 1267 of_property_read_u8(np, "clock-mode", &pdata->clock_mode); 1268 1269 pdata->enable_gpiod = devm_gpiod_get_optional(dev, "enable", 1270 GPIOD_ASIS); 1271 if (IS_ERR(pdata->enable_gpiod)) 1272 return ERR_CAST(pdata->enable_gpiod); 1273 1274 /* LP8501 specific */ 1275 of_property_read_u8(np, "pwr-sel", (u8 *)&pdata->pwr_sel); 1276 1277 return pdata; 1278 } 1279 1280 int lp55xx_probe(struct i2c_client *client) 1281 { 1282 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1283 int program_length, ret; 1284 struct lp55xx_chip *chip; 1285 struct lp55xx_led *led; 1286 struct lp55xx_platform_data *pdata = dev_get_platdata(&client->dev); 1287 struct device_node *np = dev_of_node(&client->dev); 1288 1289 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 1290 if (!chip) 1291 return -ENOMEM; 1292 1293 chip->cfg = i2c_get_match_data(client); 1294 1295 if (!pdata) { 1296 if (np) { 1297 pdata = lp55xx_of_populate_pdata(&client->dev, np, 1298 chip); 1299 if (IS_ERR(pdata)) 1300 return PTR_ERR(pdata); 1301 } else { 1302 dev_err(&client->dev, "no platform data\n"); 1303 return -EINVAL; 1304 } 1305 } 1306 1307 /* Validate max program page */ 1308 program_length = LP55xx_BYTES_PER_PAGE; 1309 if (chip->cfg->pages_per_engine) 1310 program_length *= chip->cfg->pages_per_engine; 1311 1312 /* support a max of 128bytes */ 1313 if (program_length > LP55xx_MAX_PROGRAM_LENGTH) { 1314 dev_err(&client->dev, "invalid pages_per_engine configured\n"); 1315 return -EINVAL; 1316 } 1317 1318 led = devm_kcalloc(&client->dev, 1319 pdata->num_channels, sizeof(*led), GFP_KERNEL); 1320 if (!led) 1321 return -ENOMEM; 1322 1323 chip->cl = client; 1324 chip->pdata = pdata; 1325 1326 mutex_init(&chip->lock); 1327 1328 i2c_set_clientdata(client, led); 1329 1330 ret = lp55xx_init_device(chip); 1331 if (ret) 1332 goto err_init; 1333 1334 dev_info(&client->dev, "%s Programmable led chip found\n", id->name); 1335 1336 ret = lp55xx_register_leds(led, chip); 1337 if (ret) 1338 goto err_out; 1339 1340 ret = lp55xx_register_sysfs(chip); 1341 if (ret) { 1342 dev_err(&client->dev, "registering sysfs failed\n"); 1343 goto err_out; 1344 } 1345 1346 return 0; 1347 1348 err_out: 1349 lp55xx_deinit_device(chip); 1350 err_init: 1351 return ret; 1352 } 1353 EXPORT_SYMBOL_GPL(lp55xx_probe); 1354 1355 void lp55xx_remove(struct i2c_client *client) 1356 { 1357 struct lp55xx_led *led = i2c_get_clientdata(client); 1358 struct lp55xx_chip *chip = led->chip; 1359 1360 lp55xx_stop_all_engine(chip); 1361 lp55xx_unregister_sysfs(chip); 1362 lp55xx_deinit_device(chip); 1363 } 1364 EXPORT_SYMBOL_GPL(lp55xx_remove); 1365 1366 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); 1367 MODULE_DESCRIPTION("LP55xx Common Driver"); 1368 MODULE_LICENSE("GPL"); 1369