1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * leds-tca6507 4 * 5 * The TCA6507 is a programmable LED controller that can drive 7 6 * separate lines either by holding them low, or by pulsing them 7 * with modulated width. 8 * The modulation can be varied in a simple pattern to produce a 9 * blink or double-blink. 10 * 11 * This driver can configure each line either as a 'GPIO' which is 12 * out-only (pull-up resistor required) or as an LED with variable 13 * brightness and hardware-assisted blinking. 14 * 15 * Apart from OFF and ON there are three programmable brightness 16 * levels which can be programmed from 0 to 15 and indicate how many 17 * 500usec intervals in each 8msec that the led is 'on'. The levels 18 * are named MASTER, BANK0 and BANK1. 19 * 20 * There are two different blink rates that can be programmed, each 21 * with separate time for rise, on, fall, off and second-off. Thus if 22 * 3 or more different non-trivial rates are required, software must 23 * be used for the extra rates. The two different blink rates must 24 * align with the two levels BANK0 and BANK1. This driver does not 25 * support double-blink so 'second-off' always matches 'off'. 26 * 27 * Only 16 different times can be programmed in a roughly logarithmic 28 * scale from 64ms to 16320ms. To be precise the possible times are: 29 * 0, 64, 128, 192, 256, 384, 512, 768, 30 * 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320 31 * 32 * Times that cannot be closely matched with these must be handled in 33 * software. This driver allows 12.5% error in matching. 34 * 35 * This driver does not allow rise/fall rates to be set explicitly. 36 * When trying to match a given 'on' or 'off' period, an appropriate 37 * pair of 'change' and 'hold' times are chosen to get a close match. 38 * If the target delay is even, the 'change' number will be the 39 * smaller; if odd, the 'hold' number will be the smaller. 40 41 * Choosing pairs of delays with 12.5% errors allows us to match 42 * delays in the ranges: 56-72, 112-144, 168-216, 224-27504, 43 * 28560-36720. 44 * 26% of the achievable sums can be matched by multiple pairings. 45 * For example 1536 == 1536+0, 1024+512, or 768+768. 46 * This driver will always choose the pairing with the least 47 * maximum - 768+768 in this case. Other pairings are not available. 48 * 49 * Access to the 3 levels and 2 blinks are on a first-come, 50 * first-served basis. Access can be shared by multiple leds if they 51 * have the same level and either same blink rates, or some don't 52 * blink. When a led changes, it relinquishes access and tries again, 53 * so it might lose access to hardware blink. 54 * 55 * If a blink engine cannot be allocated, software blink is used. If 56 * the desired brightness cannot be allocated, the closest available 57 * non-zero brightness is used. As 'full' is always available, the 58 * worst case would be to have two different blink rates at '1', with 59 * Max at '2', then other leds will have to choose between '2' and 60 * '16'. Hopefully this is not likely. 61 * 62 * Each bank (BANK0 and BANK1) has two usage counts - LEDs using the 63 * brightness and LEDs using the blink. It can only be reprogrammed 64 * when the appropriate counter is zero. The MASTER level has a 65 * single usage count. 66 * 67 * Each LED has programmable 'on' and 'off' time as milliseconds. 68 * With each there is a flag saying if it was explicitly requested or 69 * defaulted. Similarly the banks know if each time was explicit or a 70 * default. Defaults are permitted to be changed freely - they are 71 * not recognised when matching. 72 */ 73 74 #include <linux/module.h> 75 #include <linux/slab.h> 76 #include <linux/leds.h> 77 #include <linux/err.h> 78 #include <linux/i2c.h> 79 #include <linux/gpio/driver.h> 80 #include <linux/property.h> 81 #include <linux/workqueue.h> 82 83 /* LED select registers determine the source that drives LED outputs */ 84 #define TCA6507_LS_LED_OFF 0x0 /* Output HI-Z (off) */ 85 #define TCA6507_LS_LED_OFF1 0x1 /* Output HI-Z (off) - not used */ 86 #define TCA6507_LS_LED_PWM0 0x2 /* Output LOW with Bank0 rate */ 87 #define TCA6507_LS_LED_PWM1 0x3 /* Output LOW with Bank1 rate */ 88 #define TCA6507_LS_LED_ON 0x4 /* Output LOW (on) */ 89 #define TCA6507_LS_LED_MIR 0x5 /* Output LOW with Master Intensity */ 90 #define TCA6507_LS_BLINK0 0x6 /* Blink at Bank0 rate */ 91 #define TCA6507_LS_BLINK1 0x7 /* Blink at Bank1 rate */ 92 93 struct tca6507_platform_data { 94 struct led_platform_data leds; 95 #ifdef CONFIG_GPIOLIB 96 int gpio_base; 97 #endif 98 }; 99 100 #define TCA6507_MAKE_GPIO 1 101 102 enum { 103 BANK0, 104 BANK1, 105 MASTER, 106 }; 107 static int bank_source[3] = { 108 TCA6507_LS_LED_PWM0, 109 TCA6507_LS_LED_PWM1, 110 TCA6507_LS_LED_MIR, 111 }; 112 static int blink_source[2] = { 113 TCA6507_LS_BLINK0, 114 TCA6507_LS_BLINK1, 115 }; 116 117 /* PWM registers */ 118 #define TCA6507_REG_CNT 11 119 120 /* 121 * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output 122 * owns one bit in each register 123 */ 124 #define TCA6507_FADE_ON 0x03 125 #define TCA6507_FULL_ON 0x04 126 #define TCA6507_FADE_OFF 0x05 127 #define TCA6507_FIRST_OFF 0x06 128 #define TCA6507_SECOND_OFF 0x07 129 #define TCA6507_MAX_INTENSITY 0x08 130 #define TCA6507_MASTER_INTENSITY 0x09 131 #define TCA6507_INITIALIZE 0x0A 132 133 #define INIT_CODE 0x8 134 135 #define TIMECODES 16 136 static int time_codes[TIMECODES] = { 137 0, 64, 128, 192, 256, 384, 512, 768, 138 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320 139 }; 140 141 /* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */ 142 static inline int TO_LEVEL(int brightness) 143 { 144 return brightness >> 4; 145 } 146 147 /* ...and convert back */ 148 static inline int TO_BRIGHT(int level) 149 { 150 if (level) 151 return (level << 4) | 0xf; 152 return 0; 153 } 154 155 #define NUM_LEDS 7 156 struct tca6507_chip { 157 int reg_set; /* One bit per register where 158 * a '1' means the register 159 * should be written */ 160 u8 reg_file[TCA6507_REG_CNT]; 161 /* Bank 2 is Master Intensity and doesn't use times */ 162 struct bank { 163 int level; 164 int ontime, offtime; 165 int on_dflt, off_dflt; 166 int time_use, level_use; 167 } bank[3]; 168 struct i2c_client *client; 169 struct work_struct work; 170 spinlock_t lock; 171 172 struct tca6507_led { 173 struct tca6507_chip *chip; 174 struct led_classdev led_cdev; 175 int num; 176 int ontime, offtime; 177 int on_dflt, off_dflt; 178 int bank; /* Bank used, or -1 */ 179 int blink; /* Set if hardware-blinking */ 180 } leds[NUM_LEDS]; 181 #ifdef CONFIG_GPIOLIB 182 struct gpio_chip gpio; 183 int gpio_map[NUM_LEDS]; 184 #endif 185 }; 186 187 static const struct i2c_device_id tca6507_id[] = { 188 { "tca6507" }, 189 { } 190 }; 191 MODULE_DEVICE_TABLE(i2c, tca6507_id); 192 193 static int choose_times(int msec, int *c1p, int *c2p) 194 { 195 /* 196 * Choose two timecodes which add to 'msec' as near as 197 * possible. The first returned is the 'on' or 'off' time. 198 * The second is to be used as a 'fade-on' or 'fade-off' time. 199 * If 'msec' is even, the first will not be smaller than the 200 * second. If 'msec' is odd, the first will not be larger 201 * than the second. 202 * If we cannot get a sum within 1/8 of 'msec' fail with 203 * -EINVAL, otherwise return the sum that was achieved, plus 1 204 * if the first is smaller. 205 * If two possibilities are equally good (e.g. 512+0, 206 * 256+256), choose the first pair so there is more 207 * change-time visible (i.e. it is softer). 208 */ 209 int c1, c2; 210 int tmax = msec * 9 / 8; 211 int tmin = msec * 7 / 8; 212 int diff = 65536; 213 214 /* We start at '1' to ensure we never even think of choosing a 215 * total time of '0'. 216 */ 217 for (c1 = 1; c1 < TIMECODES; c1++) { 218 int t = time_codes[c1]; 219 if (t*2 < tmin) 220 continue; 221 if (t > tmax) 222 break; 223 for (c2 = 0; c2 <= c1; c2++) { 224 int tt = t + time_codes[c2]; 225 int d; 226 if (tt < tmin) 227 continue; 228 if (tt > tmax) 229 break; 230 /* This works! */ 231 d = abs(msec - tt); 232 if (d >= diff) 233 continue; 234 /* Best yet */ 235 *c1p = c1; 236 *c2p = c2; 237 diff = d; 238 if (d == 0) 239 return msec; 240 } 241 } 242 if (diff < 65536) { 243 int actual; 244 if (msec & 1) { 245 c1 = *c2p; 246 *c2p = *c1p; 247 *c1p = c1; 248 } 249 actual = time_codes[*c1p] + time_codes[*c2p]; 250 if (*c1p < *c2p) 251 return actual + 1; 252 else 253 return actual; 254 } 255 /* No close match */ 256 return -EINVAL; 257 } 258 259 /* 260 * Update the register file with the appropriate 3-bit state for the 261 * given led. 262 */ 263 static void set_select(struct tca6507_chip *tca, int led, int val) 264 { 265 int mask = (1 << led); 266 int bit; 267 268 for (bit = 0; bit < 3; bit++) { 269 int n = tca->reg_file[bit] & ~mask; 270 if (val & (1 << bit)) 271 n |= mask; 272 if (tca->reg_file[bit] != n) { 273 tca->reg_file[bit] = n; 274 tca->reg_set |= (1 << bit); 275 } 276 } 277 } 278 279 /* Update the register file with the appropriate 4-bit code for one 280 * bank or other. This can be used for timers, for levels, or for 281 * initialization. 282 */ 283 static void set_code(struct tca6507_chip *tca, int reg, int bank, int new) 284 { 285 int mask = 0xF; 286 int n; 287 if (bank) { 288 mask <<= 4; 289 new <<= 4; 290 } 291 n = tca->reg_file[reg] & ~mask; 292 n |= new; 293 if (tca->reg_file[reg] != n) { 294 tca->reg_file[reg] = n; 295 tca->reg_set |= 1 << reg; 296 } 297 } 298 299 /* Update brightness level. */ 300 static void set_level(struct tca6507_chip *tca, int bank, int level) 301 { 302 switch (bank) { 303 case BANK0: 304 case BANK1: 305 set_code(tca, TCA6507_MAX_INTENSITY, bank, level); 306 break; 307 case MASTER: 308 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level); 309 break; 310 } 311 tca->bank[bank].level = level; 312 } 313 314 /* Record all relevant time codes for a given bank */ 315 static void set_times(struct tca6507_chip *tca, int bank) 316 { 317 int c1, c2; 318 int result; 319 320 result = choose_times(tca->bank[bank].ontime, &c1, &c2); 321 if (result < 0) 322 return; 323 dev_dbg(&tca->client->dev, 324 "Chose on times %d(%d) %d(%d) for %dms\n", 325 c1, time_codes[c1], 326 c2, time_codes[c2], tca->bank[bank].ontime); 327 set_code(tca, TCA6507_FADE_ON, bank, c2); 328 set_code(tca, TCA6507_FULL_ON, bank, c1); 329 tca->bank[bank].ontime = result; 330 331 result = choose_times(tca->bank[bank].offtime, &c1, &c2); 332 dev_dbg(&tca->client->dev, 333 "Chose off times %d(%d) %d(%d) for %dms\n", 334 c1, time_codes[c1], 335 c2, time_codes[c2], tca->bank[bank].offtime); 336 set_code(tca, TCA6507_FADE_OFF, bank, c2); 337 set_code(tca, TCA6507_FIRST_OFF, bank, c1); 338 set_code(tca, TCA6507_SECOND_OFF, bank, c1); 339 tca->bank[bank].offtime = result; 340 341 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE); 342 } 343 344 /* Write all needed register of tca6507 */ 345 346 static void tca6507_work(struct work_struct *work) 347 { 348 struct tca6507_chip *tca = container_of(work, struct tca6507_chip, 349 work); 350 struct i2c_client *cl = tca->client; 351 int set; 352 u8 file[TCA6507_REG_CNT]; 353 int r; 354 355 spin_lock_irq(&tca->lock); 356 set = tca->reg_set; 357 memcpy(file, tca->reg_file, TCA6507_REG_CNT); 358 tca->reg_set = 0; 359 spin_unlock_irq(&tca->lock); 360 361 for (r = 0; r < TCA6507_REG_CNT; r++) 362 if (set & (1<<r)) 363 i2c_smbus_write_byte_data(cl, r, file[r]); 364 } 365 366 static void led_release(struct tca6507_led *led) 367 { 368 /* If led owns any resource, release it. */ 369 struct tca6507_chip *tca = led->chip; 370 if (led->bank >= 0) { 371 struct bank *b = tca->bank + led->bank; 372 if (led->blink) 373 b->time_use--; 374 b->level_use--; 375 } 376 led->blink = 0; 377 led->bank = -1; 378 } 379 380 static int led_prepare(struct tca6507_led *led) 381 { 382 /* Assign this led to a bank, configuring that bank if 383 * necessary. */ 384 int level = TO_LEVEL(led->led_cdev.brightness); 385 struct tca6507_chip *tca = led->chip; 386 int c1, c2; 387 int i; 388 struct bank *b; 389 int need_init = 0; 390 391 led->led_cdev.brightness = TO_BRIGHT(level); 392 if (level == 0) { 393 set_select(tca, led->num, TCA6507_LS_LED_OFF); 394 return 0; 395 } 396 397 if (led->ontime == 0 || led->offtime == 0) { 398 /* 399 * Just set the brightness, choosing first usable 400 * bank. If none perfect, choose best. Count 401 * backwards so we check MASTER bank first to avoid 402 * wasting a timer. 403 */ 404 int best = -1;/* full-on */ 405 int diff = 15-level; 406 407 if (level == 15) { 408 set_select(tca, led->num, TCA6507_LS_LED_ON); 409 return 0; 410 } 411 412 for (i = MASTER; i >= BANK0; i--) { 413 int d; 414 if (tca->bank[i].level == level || 415 tca->bank[i].level_use == 0) { 416 best = i; 417 break; 418 } 419 d = abs(level - tca->bank[i].level); 420 if (d < diff) { 421 diff = d; 422 best = i; 423 } 424 } 425 if (best == -1) { 426 /* Best brightness is full-on */ 427 set_select(tca, led->num, TCA6507_LS_LED_ON); 428 led->led_cdev.brightness = LED_FULL; 429 return 0; 430 } 431 432 if (!tca->bank[best].level_use) 433 set_level(tca, best, level); 434 435 tca->bank[best].level_use++; 436 led->bank = best; 437 set_select(tca, led->num, bank_source[best]); 438 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level); 439 return 0; 440 } 441 442 /* 443 * We have on/off time so we need to try to allocate a timing 444 * bank. First check if times are compatible with hardware 445 * and give up if not. 446 */ 447 if (choose_times(led->ontime, &c1, &c2) < 0) 448 return -EINVAL; 449 if (choose_times(led->offtime, &c1, &c2) < 0) 450 return -EINVAL; 451 452 for (i = BANK0; i <= BANK1; i++) { 453 if (tca->bank[i].level_use == 0) 454 /* not in use - it is ours! */ 455 break; 456 if (tca->bank[i].level != level) 457 /* Incompatible level - skip */ 458 /* FIX: if timer matches we maybe should consider 459 * this anyway... 460 */ 461 continue; 462 463 if (tca->bank[i].time_use == 0) 464 /* Timer not in use, and level matches - use it */ 465 break; 466 467 if (!(tca->bank[i].on_dflt || 468 led->on_dflt || 469 tca->bank[i].ontime == led->ontime)) 470 /* on time is incompatible */ 471 continue; 472 473 if (!(tca->bank[i].off_dflt || 474 led->off_dflt || 475 tca->bank[i].offtime == led->offtime)) 476 /* off time is incompatible */ 477 continue; 478 479 /* looks like a suitable match */ 480 break; 481 } 482 483 if (i > BANK1) 484 /* Nothing matches - how sad */ 485 return -EINVAL; 486 487 b = &tca->bank[i]; 488 if (b->level_use == 0) 489 set_level(tca, i, level); 490 b->level_use++; 491 led->bank = i; 492 493 if (b->on_dflt || 494 !led->on_dflt || 495 b->time_use == 0) { 496 b->ontime = led->ontime; 497 b->on_dflt = led->on_dflt; 498 need_init = 1; 499 } 500 501 if (b->off_dflt || 502 !led->off_dflt || 503 b->time_use == 0) { 504 b->offtime = led->offtime; 505 b->off_dflt = led->off_dflt; 506 need_init = 1; 507 } 508 509 if (need_init) 510 set_times(tca, i); 511 512 led->ontime = b->ontime; 513 led->offtime = b->offtime; 514 515 b->time_use++; 516 led->blink = 1; 517 led->led_cdev.brightness = TO_BRIGHT(b->level); 518 set_select(tca, led->num, blink_source[i]); 519 return 0; 520 } 521 522 static int led_assign(struct tca6507_led *led) 523 { 524 struct tca6507_chip *tca = led->chip; 525 int err; 526 unsigned long flags; 527 528 spin_lock_irqsave(&tca->lock, flags); 529 led_release(led); 530 err = led_prepare(led); 531 if (err) { 532 /* 533 * Can only fail on timer setup. In that case we need 534 * to re-establish as steady level. 535 */ 536 led->ontime = 0; 537 led->offtime = 0; 538 led_prepare(led); 539 } 540 spin_unlock_irqrestore(&tca->lock, flags); 541 542 if (tca->reg_set) 543 schedule_work(&tca->work); 544 return err; 545 } 546 547 static void tca6507_brightness_set(struct led_classdev *led_cdev, 548 enum led_brightness brightness) 549 { 550 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 551 led_cdev); 552 led->led_cdev.brightness = brightness; 553 led->ontime = 0; 554 led->offtime = 0; 555 led_assign(led); 556 } 557 558 static int tca6507_blink_set(struct led_classdev *led_cdev, 559 unsigned long *delay_on, 560 unsigned long *delay_off) 561 { 562 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 563 led_cdev); 564 565 if (*delay_on == 0) 566 led->on_dflt = 1; 567 else if (delay_on != &led_cdev->blink_delay_on) 568 led->on_dflt = 0; 569 led->ontime = *delay_on; 570 571 if (*delay_off == 0) 572 led->off_dflt = 1; 573 else if (delay_off != &led_cdev->blink_delay_off) 574 led->off_dflt = 0; 575 led->offtime = *delay_off; 576 577 if (led->ontime == 0) 578 led->ontime = 512; 579 if (led->offtime == 0) 580 led->offtime = 512; 581 582 if (led->led_cdev.brightness == LED_OFF) 583 led->led_cdev.brightness = LED_FULL; 584 if (led_assign(led) < 0) { 585 led->ontime = 0; 586 led->offtime = 0; 587 led->led_cdev.brightness = LED_OFF; 588 return -EINVAL; 589 } 590 *delay_on = led->ontime; 591 *delay_off = led->offtime; 592 return 0; 593 } 594 595 #ifdef CONFIG_GPIOLIB 596 static void tca6507_gpio_set_value(struct gpio_chip *gc, 597 unsigned offset, int val) 598 { 599 struct tca6507_chip *tca = gpiochip_get_data(gc); 600 unsigned long flags; 601 602 spin_lock_irqsave(&tca->lock, flags); 603 /* 604 * 'OFF' is floating high, and 'ON' is pulled down, so it has 605 * the inverse sense of 'val'. 606 */ 607 set_select(tca, tca->gpio_map[offset], 608 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON); 609 spin_unlock_irqrestore(&tca->lock, flags); 610 if (tca->reg_set) 611 schedule_work(&tca->work); 612 } 613 614 static int tca6507_gpio_direction_output(struct gpio_chip *gc, 615 unsigned offset, int val) 616 { 617 tca6507_gpio_set_value(gc, offset, val); 618 return 0; 619 } 620 621 static int tca6507_probe_gpios(struct device *dev, 622 struct tca6507_chip *tca, 623 struct tca6507_platform_data *pdata) 624 { 625 int err; 626 int i = 0; 627 int gpios = 0; 628 629 for (i = 0; i < NUM_LEDS; i++) 630 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) { 631 /* Configure as a gpio */ 632 tca->gpio_map[gpios] = i; 633 gpios++; 634 } 635 636 if (!gpios) 637 return 0; 638 639 tca->gpio.label = "gpio-tca6507"; 640 tca->gpio.ngpio = gpios; 641 tca->gpio.base = pdata->gpio_base; 642 tca->gpio.owner = THIS_MODULE; 643 tca->gpio.direction_output = tca6507_gpio_direction_output; 644 tca->gpio.set = tca6507_gpio_set_value; 645 tca->gpio.parent = dev; 646 #ifdef CONFIG_OF_GPIO 647 tca->gpio.of_node = of_node_get(dev_of_node(dev)); 648 #endif 649 err = gpiochip_add_data(&tca->gpio, tca); 650 if (err) { 651 tca->gpio.ngpio = 0; 652 return err; 653 } 654 return 0; 655 } 656 657 static void tca6507_remove_gpio(struct tca6507_chip *tca) 658 { 659 if (tca->gpio.ngpio) 660 gpiochip_remove(&tca->gpio); 661 } 662 #else /* CONFIG_GPIOLIB */ 663 static int tca6507_probe_gpios(struct device *dev, 664 struct tca6507_chip *tca, 665 struct tca6507_platform_data *pdata) 666 { 667 return 0; 668 } 669 static void tca6507_remove_gpio(struct tca6507_chip *tca) 670 { 671 } 672 #endif /* CONFIG_GPIOLIB */ 673 674 static struct tca6507_platform_data * 675 tca6507_led_dt_init(struct device *dev) 676 { 677 struct tca6507_platform_data *pdata; 678 struct fwnode_handle *child; 679 struct led_info *tca_leds; 680 int count; 681 682 count = device_get_child_node_count(dev); 683 if (!count || count > NUM_LEDS) 684 return ERR_PTR(-ENODEV); 685 686 tca_leds = devm_kcalloc(dev, NUM_LEDS, sizeof(struct led_info), 687 GFP_KERNEL); 688 if (!tca_leds) 689 return ERR_PTR(-ENOMEM); 690 691 device_for_each_child_node(dev, child) { 692 struct led_info led; 693 u32 reg; 694 int ret; 695 696 if (fwnode_property_read_string(child, "label", &led.name)) 697 led.name = fwnode_get_name(child); 698 699 fwnode_property_read_string(child, "linux,default-trigger", 700 &led.default_trigger); 701 702 led.flags = 0; 703 if (fwnode_property_match_string(child, "compatible", 704 "gpio") >= 0) 705 led.flags |= TCA6507_MAKE_GPIO; 706 707 ret = fwnode_property_read_u32(child, "reg", ®); 708 if (ret || reg >= NUM_LEDS) { 709 fwnode_handle_put(child); 710 return ERR_PTR(ret ? : -EINVAL); 711 } 712 713 tca_leds[reg] = led; 714 } 715 716 pdata = devm_kzalloc(dev, sizeof(struct tca6507_platform_data), 717 GFP_KERNEL); 718 if (!pdata) 719 return ERR_PTR(-ENOMEM); 720 721 pdata->leds.leds = tca_leds; 722 pdata->leds.num_leds = NUM_LEDS; 723 #ifdef CONFIG_GPIOLIB 724 pdata->gpio_base = -1; 725 #endif 726 727 return pdata; 728 } 729 730 static const struct of_device_id __maybe_unused of_tca6507_leds_match[] = { 731 { .compatible = "ti,tca6507", }, 732 {}, 733 }; 734 MODULE_DEVICE_TABLE(of, of_tca6507_leds_match); 735 736 static int tca6507_probe(struct i2c_client *client, 737 const struct i2c_device_id *id) 738 { 739 struct device *dev = &client->dev; 740 struct i2c_adapter *adapter; 741 struct tca6507_chip *tca; 742 struct tca6507_platform_data *pdata; 743 int err; 744 int i = 0; 745 746 adapter = client->adapter; 747 748 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 749 return -EIO; 750 751 pdata = tca6507_led_dt_init(dev); 752 if (IS_ERR(pdata)) { 753 dev_err(dev, "Need %d entries in platform-data list\n", NUM_LEDS); 754 return PTR_ERR(pdata); 755 } 756 tca = devm_kzalloc(dev, sizeof(*tca), GFP_KERNEL); 757 if (!tca) 758 return -ENOMEM; 759 760 tca->client = client; 761 INIT_WORK(&tca->work, tca6507_work); 762 spin_lock_init(&tca->lock); 763 i2c_set_clientdata(client, tca); 764 765 for (i = 0; i < NUM_LEDS; i++) { 766 struct tca6507_led *l = tca->leds + i; 767 768 l->chip = tca; 769 l->num = i; 770 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) { 771 l->led_cdev.name = pdata->leds.leds[i].name; 772 l->led_cdev.default_trigger 773 = pdata->leds.leds[i].default_trigger; 774 l->led_cdev.brightness_set = tca6507_brightness_set; 775 l->led_cdev.blink_set = tca6507_blink_set; 776 l->bank = -1; 777 err = led_classdev_register(dev, &l->led_cdev); 778 if (err < 0) 779 goto exit; 780 } 781 } 782 err = tca6507_probe_gpios(dev, tca, pdata); 783 if (err) 784 goto exit; 785 /* set all registers to known state - zero */ 786 tca->reg_set = 0x7f; 787 schedule_work(&tca->work); 788 789 return 0; 790 exit: 791 while (i--) { 792 if (tca->leds[i].led_cdev.name) 793 led_classdev_unregister(&tca->leds[i].led_cdev); 794 } 795 return err; 796 } 797 798 static int tca6507_remove(struct i2c_client *client) 799 { 800 int i; 801 struct tca6507_chip *tca = i2c_get_clientdata(client); 802 struct tca6507_led *tca_leds = tca->leds; 803 804 for (i = 0; i < NUM_LEDS; i++) { 805 if (tca_leds[i].led_cdev.name) 806 led_classdev_unregister(&tca_leds[i].led_cdev); 807 } 808 tca6507_remove_gpio(tca); 809 cancel_work_sync(&tca->work); 810 811 return 0; 812 } 813 814 static struct i2c_driver tca6507_driver = { 815 .driver = { 816 .name = "leds-tca6507", 817 .of_match_table = of_match_ptr(of_tca6507_leds_match), 818 }, 819 .probe = tca6507_probe, 820 .remove = tca6507_remove, 821 .id_table = tca6507_id, 822 }; 823 824 module_i2c_driver(tca6507_driver); 825 826 MODULE_AUTHOR("NeilBrown <neilb@suse.de>"); 827 MODULE_DESCRIPTION("TCA6507 LED/GPO driver"); 828 MODULE_LICENSE("GPL v2"); 829