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 }; 96 97 #define TCA6507_MAKE_GPIO 1 98 99 enum { 100 BANK0, 101 BANK1, 102 MASTER, 103 }; 104 static int bank_source[3] = { 105 TCA6507_LS_LED_PWM0, 106 TCA6507_LS_LED_PWM1, 107 TCA6507_LS_LED_MIR, 108 }; 109 static int blink_source[2] = { 110 TCA6507_LS_BLINK0, 111 TCA6507_LS_BLINK1, 112 }; 113 114 /* PWM registers */ 115 #define TCA6507_REG_CNT 11 116 117 /* 118 * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output 119 * owns one bit in each register 120 */ 121 #define TCA6507_FADE_ON 0x03 122 #define TCA6507_FULL_ON 0x04 123 #define TCA6507_FADE_OFF 0x05 124 #define TCA6507_FIRST_OFF 0x06 125 #define TCA6507_SECOND_OFF 0x07 126 #define TCA6507_MAX_INTENSITY 0x08 127 #define TCA6507_MASTER_INTENSITY 0x09 128 #define TCA6507_INITIALIZE 0x0A 129 130 #define INIT_CODE 0x8 131 132 #define TIMECODES 16 133 static int time_codes[TIMECODES] = { 134 0, 64, 128, 192, 256, 384, 512, 768, 135 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320 136 }; 137 138 /* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */ 139 static inline int TO_LEVEL(int brightness) 140 { 141 return brightness >> 4; 142 } 143 144 /* ...and convert back */ 145 static inline int TO_BRIGHT(int level) 146 { 147 if (level) 148 return (level << 4) | 0xf; 149 return 0; 150 } 151 152 #define NUM_LEDS 7 153 struct tca6507_chip { 154 int reg_set; /* One bit per register where 155 * a '1' means the register 156 * should be written */ 157 u8 reg_file[TCA6507_REG_CNT]; 158 /* Bank 2 is Master Intensity and doesn't use times */ 159 struct bank { 160 int level; 161 int ontime, offtime; 162 int on_dflt, off_dflt; 163 int time_use, level_use; 164 } bank[3]; 165 struct i2c_client *client; 166 struct work_struct work; 167 spinlock_t lock; 168 169 struct tca6507_led { 170 struct tca6507_chip *chip; 171 struct led_classdev led_cdev; 172 int num; 173 int ontime, offtime; 174 int on_dflt, off_dflt; 175 int bank; /* Bank used, or -1 */ 176 int blink; /* Set if hardware-blinking */ 177 } leds[NUM_LEDS]; 178 #ifdef CONFIG_GPIOLIB 179 struct gpio_chip gpio; 180 int gpio_map[NUM_LEDS]; 181 #endif 182 }; 183 184 static const struct i2c_device_id tca6507_id[] = { 185 { "tca6507" }, 186 { } 187 }; 188 MODULE_DEVICE_TABLE(i2c, tca6507_id); 189 190 static int choose_times(int msec, int *c1p, int *c2p) 191 { 192 /* 193 * Choose two timecodes which add to 'msec' as near as 194 * possible. The first returned is the 'on' or 'off' time. 195 * The second is to be used as a 'fade-on' or 'fade-off' time. 196 * If 'msec' is even, the first will not be smaller than the 197 * second. If 'msec' is odd, the first will not be larger 198 * than the second. 199 * If we cannot get a sum within 1/8 of 'msec' fail with 200 * -EINVAL, otherwise return the sum that was achieved, plus 1 201 * if the first is smaller. 202 * If two possibilities are equally good (e.g. 512+0, 203 * 256+256), choose the first pair so there is more 204 * change-time visible (i.e. it is softer). 205 */ 206 int c1, c2; 207 int tmax = msec * 9 / 8; 208 int tmin = msec * 7 / 8; 209 int diff = 65536; 210 211 /* We start at '1' to ensure we never even think of choosing a 212 * total time of '0'. 213 */ 214 for (c1 = 1; c1 < TIMECODES; c1++) { 215 int t = time_codes[c1]; 216 if (t*2 < tmin) 217 continue; 218 if (t > tmax) 219 break; 220 for (c2 = 0; c2 <= c1; c2++) { 221 int tt = t + time_codes[c2]; 222 int d; 223 if (tt < tmin) 224 continue; 225 if (tt > tmax) 226 break; 227 /* This works! */ 228 d = abs(msec - tt); 229 if (d >= diff) 230 continue; 231 /* Best yet */ 232 *c1p = c1; 233 *c2p = c2; 234 diff = d; 235 if (d == 0) 236 return msec; 237 } 238 } 239 if (diff < 65536) { 240 int actual; 241 if (msec & 1) { 242 swap(*c2p, *c1p); 243 } 244 actual = time_codes[*c1p] + time_codes[*c2p]; 245 if (*c1p < *c2p) 246 return actual + 1; 247 else 248 return actual; 249 } 250 /* No close match */ 251 return -EINVAL; 252 } 253 254 /* 255 * Update the register file with the appropriate 3-bit state for the 256 * given led. 257 */ 258 static void set_select(struct tca6507_chip *tca, int led, int val) 259 { 260 int mask = (1 << led); 261 int bit; 262 263 for (bit = 0; bit < 3; bit++) { 264 int n = tca->reg_file[bit] & ~mask; 265 if (val & (1 << bit)) 266 n |= mask; 267 if (tca->reg_file[bit] != n) { 268 tca->reg_file[bit] = n; 269 tca->reg_set |= (1 << bit); 270 } 271 } 272 } 273 274 /* Update the register file with the appropriate 4-bit code for one 275 * bank or other. This can be used for timers, for levels, or for 276 * initialization. 277 */ 278 static void set_code(struct tca6507_chip *tca, int reg, int bank, int new) 279 { 280 int mask = 0xF; 281 int n; 282 if (bank) { 283 mask <<= 4; 284 new <<= 4; 285 } 286 n = tca->reg_file[reg] & ~mask; 287 n |= new; 288 if (tca->reg_file[reg] != n) { 289 tca->reg_file[reg] = n; 290 tca->reg_set |= 1 << reg; 291 } 292 } 293 294 /* Update brightness level. */ 295 static void set_level(struct tca6507_chip *tca, int bank, int level) 296 { 297 switch (bank) { 298 case BANK0: 299 case BANK1: 300 set_code(tca, TCA6507_MAX_INTENSITY, bank, level); 301 break; 302 case MASTER: 303 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level); 304 break; 305 } 306 tca->bank[bank].level = level; 307 } 308 309 /* Record all relevant time codes for a given bank */ 310 static void set_times(struct tca6507_chip *tca, int bank) 311 { 312 int c1, c2; 313 int result; 314 315 result = choose_times(tca->bank[bank].ontime, &c1, &c2); 316 if (result < 0) 317 return; 318 dev_dbg(&tca->client->dev, 319 "Chose on times %d(%d) %d(%d) for %dms\n", 320 c1, time_codes[c1], 321 c2, time_codes[c2], tca->bank[bank].ontime); 322 set_code(tca, TCA6507_FADE_ON, bank, c2); 323 set_code(tca, TCA6507_FULL_ON, bank, c1); 324 tca->bank[bank].ontime = result; 325 326 result = choose_times(tca->bank[bank].offtime, &c1, &c2); 327 dev_dbg(&tca->client->dev, 328 "Chose off times %d(%d) %d(%d) for %dms\n", 329 c1, time_codes[c1], 330 c2, time_codes[c2], tca->bank[bank].offtime); 331 set_code(tca, TCA6507_FADE_OFF, bank, c2); 332 set_code(tca, TCA6507_FIRST_OFF, bank, c1); 333 set_code(tca, TCA6507_SECOND_OFF, bank, c1); 334 tca->bank[bank].offtime = result; 335 336 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE); 337 } 338 339 /* Write all needed register of tca6507 */ 340 341 static void tca6507_work(struct work_struct *work) 342 { 343 struct tca6507_chip *tca = container_of(work, struct tca6507_chip, 344 work); 345 struct i2c_client *cl = tca->client; 346 int set; 347 u8 file[TCA6507_REG_CNT]; 348 int r; 349 350 spin_lock_irq(&tca->lock); 351 set = tca->reg_set; 352 memcpy(file, tca->reg_file, TCA6507_REG_CNT); 353 tca->reg_set = 0; 354 spin_unlock_irq(&tca->lock); 355 356 for (r = 0; r < TCA6507_REG_CNT; r++) 357 if (set & (1<<r)) 358 i2c_smbus_write_byte_data(cl, r, file[r]); 359 } 360 361 static void led_release(struct tca6507_led *led) 362 { 363 /* If led owns any resource, release it. */ 364 struct tca6507_chip *tca = led->chip; 365 if (led->bank >= 0) { 366 struct bank *b = tca->bank + led->bank; 367 if (led->blink) 368 b->time_use--; 369 b->level_use--; 370 } 371 led->blink = 0; 372 led->bank = -1; 373 } 374 375 static int led_prepare(struct tca6507_led *led) 376 { 377 /* Assign this led to a bank, configuring that bank if 378 * necessary. */ 379 int level = TO_LEVEL(led->led_cdev.brightness); 380 struct tca6507_chip *tca = led->chip; 381 int c1, c2; 382 int i; 383 struct bank *b; 384 int need_init = 0; 385 386 led->led_cdev.brightness = TO_BRIGHT(level); 387 if (level == 0) { 388 set_select(tca, led->num, TCA6507_LS_LED_OFF); 389 return 0; 390 } 391 392 if (led->ontime == 0 || led->offtime == 0) { 393 /* 394 * Just set the brightness, choosing first usable 395 * bank. If none perfect, choose best. Count 396 * backwards so we check MASTER bank first to avoid 397 * wasting a timer. 398 */ 399 int best = -1;/* full-on */ 400 int diff = 15-level; 401 402 if (level == 15) { 403 set_select(tca, led->num, TCA6507_LS_LED_ON); 404 return 0; 405 } 406 407 for (i = MASTER; i >= BANK0; i--) { 408 int d; 409 if (tca->bank[i].level == level || 410 tca->bank[i].level_use == 0) { 411 best = i; 412 break; 413 } 414 d = abs(level - tca->bank[i].level); 415 if (d < diff) { 416 diff = d; 417 best = i; 418 } 419 } 420 if (best == -1) { 421 /* Best brightness is full-on */ 422 set_select(tca, led->num, TCA6507_LS_LED_ON); 423 led->led_cdev.brightness = LED_FULL; 424 return 0; 425 } 426 427 if (!tca->bank[best].level_use) 428 set_level(tca, best, level); 429 430 tca->bank[best].level_use++; 431 led->bank = best; 432 set_select(tca, led->num, bank_source[best]); 433 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level); 434 return 0; 435 } 436 437 /* 438 * We have on/off time so we need to try to allocate a timing 439 * bank. First check if times are compatible with hardware 440 * and give up if not. 441 */ 442 if (choose_times(led->ontime, &c1, &c2) < 0) 443 return -EINVAL; 444 if (choose_times(led->offtime, &c1, &c2) < 0) 445 return -EINVAL; 446 447 for (i = BANK0; i <= BANK1; i++) { 448 if (tca->bank[i].level_use == 0) 449 /* not in use - it is ours! */ 450 break; 451 if (tca->bank[i].level != level) 452 /* Incompatible level - skip */ 453 /* FIX: if timer matches we maybe should consider 454 * this anyway... 455 */ 456 continue; 457 458 if (tca->bank[i].time_use == 0) 459 /* Timer not in use, and level matches - use it */ 460 break; 461 462 if (!(tca->bank[i].on_dflt || 463 led->on_dflt || 464 tca->bank[i].ontime == led->ontime)) 465 /* on time is incompatible */ 466 continue; 467 468 if (!(tca->bank[i].off_dflt || 469 led->off_dflt || 470 tca->bank[i].offtime == led->offtime)) 471 /* off time is incompatible */ 472 continue; 473 474 /* looks like a suitable match */ 475 break; 476 } 477 478 if (i > BANK1) 479 /* Nothing matches - how sad */ 480 return -EINVAL; 481 482 b = &tca->bank[i]; 483 if (b->level_use == 0) 484 set_level(tca, i, level); 485 b->level_use++; 486 led->bank = i; 487 488 if (b->on_dflt || 489 !led->on_dflt || 490 b->time_use == 0) { 491 b->ontime = led->ontime; 492 b->on_dflt = led->on_dflt; 493 need_init = 1; 494 } 495 496 if (b->off_dflt || 497 !led->off_dflt || 498 b->time_use == 0) { 499 b->offtime = led->offtime; 500 b->off_dflt = led->off_dflt; 501 need_init = 1; 502 } 503 504 if (need_init) 505 set_times(tca, i); 506 507 led->ontime = b->ontime; 508 led->offtime = b->offtime; 509 510 b->time_use++; 511 led->blink = 1; 512 led->led_cdev.brightness = TO_BRIGHT(b->level); 513 set_select(tca, led->num, blink_source[i]); 514 return 0; 515 } 516 517 static int led_assign(struct tca6507_led *led) 518 { 519 struct tca6507_chip *tca = led->chip; 520 int err; 521 unsigned long flags; 522 523 spin_lock_irqsave(&tca->lock, flags); 524 led_release(led); 525 err = led_prepare(led); 526 if (err) { 527 /* 528 * Can only fail on timer setup. In that case we need 529 * to re-establish as steady level. 530 */ 531 led->ontime = 0; 532 led->offtime = 0; 533 led_prepare(led); 534 } 535 spin_unlock_irqrestore(&tca->lock, flags); 536 537 if (tca->reg_set) 538 schedule_work(&tca->work); 539 return err; 540 } 541 542 static void tca6507_brightness_set(struct led_classdev *led_cdev, 543 enum led_brightness brightness) 544 { 545 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 546 led_cdev); 547 led->led_cdev.brightness = brightness; 548 led->ontime = 0; 549 led->offtime = 0; 550 led_assign(led); 551 } 552 553 static int tca6507_blink_set(struct led_classdev *led_cdev, 554 unsigned long *delay_on, 555 unsigned long *delay_off) 556 { 557 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 558 led_cdev); 559 560 if (*delay_on == 0) 561 led->on_dflt = 1; 562 else if (delay_on != &led_cdev->blink_delay_on) 563 led->on_dflt = 0; 564 led->ontime = *delay_on; 565 566 if (*delay_off == 0) 567 led->off_dflt = 1; 568 else if (delay_off != &led_cdev->blink_delay_off) 569 led->off_dflt = 0; 570 led->offtime = *delay_off; 571 572 if (led->ontime == 0) 573 led->ontime = 512; 574 if (led->offtime == 0) 575 led->offtime = 512; 576 577 if (led->led_cdev.brightness == LED_OFF) 578 led->led_cdev.brightness = LED_FULL; 579 if (led_assign(led) < 0) { 580 led->ontime = 0; 581 led->offtime = 0; 582 led->led_cdev.brightness = LED_OFF; 583 return -EINVAL; 584 } 585 *delay_on = led->ontime; 586 *delay_off = led->offtime; 587 return 0; 588 } 589 590 #ifdef CONFIG_GPIOLIB 591 static void tca6507_gpio_set_value(struct gpio_chip *gc, 592 unsigned offset, int val) 593 { 594 struct tca6507_chip *tca = gpiochip_get_data(gc); 595 unsigned long flags; 596 597 spin_lock_irqsave(&tca->lock, flags); 598 /* 599 * 'OFF' is floating high, and 'ON' is pulled down, so it has 600 * the inverse sense of 'val'. 601 */ 602 set_select(tca, tca->gpio_map[offset], 603 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON); 604 spin_unlock_irqrestore(&tca->lock, flags); 605 if (tca->reg_set) 606 schedule_work(&tca->work); 607 } 608 609 static int tca6507_gpio_direction_output(struct gpio_chip *gc, 610 unsigned offset, int val) 611 { 612 tca6507_gpio_set_value(gc, offset, val); 613 return 0; 614 } 615 616 static int tca6507_probe_gpios(struct device *dev, 617 struct tca6507_chip *tca, 618 struct tca6507_platform_data *pdata) 619 { 620 int err; 621 int i = 0; 622 int gpios = 0; 623 624 for (i = 0; i < NUM_LEDS; i++) 625 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) { 626 /* Configure as a gpio */ 627 tca->gpio_map[gpios] = i; 628 gpios++; 629 } 630 631 if (!gpios) 632 return 0; 633 634 tca->gpio.label = "gpio-tca6507"; 635 tca->gpio.ngpio = gpios; 636 tca->gpio.base = -1; 637 tca->gpio.owner = THIS_MODULE; 638 tca->gpio.direction_output = tca6507_gpio_direction_output; 639 tca->gpio.set = tca6507_gpio_set_value; 640 tca->gpio.parent = dev; 641 err = devm_gpiochip_add_data(dev, &tca->gpio, tca); 642 if (err) { 643 tca->gpio.ngpio = 0; 644 return err; 645 } 646 return 0; 647 } 648 #else /* CONFIG_GPIOLIB */ 649 static int tca6507_probe_gpios(struct device *dev, 650 struct tca6507_chip *tca, 651 struct tca6507_platform_data *pdata) 652 { 653 return 0; 654 } 655 #endif /* CONFIG_GPIOLIB */ 656 657 static struct tca6507_platform_data * 658 tca6507_led_dt_init(struct device *dev) 659 { 660 struct tca6507_platform_data *pdata; 661 struct fwnode_handle *child; 662 struct led_info *tca_leds; 663 int count; 664 665 count = device_get_child_node_count(dev); 666 if (!count || count > NUM_LEDS) 667 return ERR_PTR(-ENODEV); 668 669 tca_leds = devm_kcalloc(dev, NUM_LEDS, sizeof(struct led_info), 670 GFP_KERNEL); 671 if (!tca_leds) 672 return ERR_PTR(-ENOMEM); 673 674 device_for_each_child_node(dev, child) { 675 struct led_info led; 676 u32 reg; 677 int ret; 678 679 if (fwnode_property_read_string(child, "label", &led.name)) 680 led.name = fwnode_get_name(child); 681 682 if (fwnode_property_read_string(child, "linux,default-trigger", 683 &led.default_trigger)) 684 led.default_trigger = NULL; 685 686 led.flags = 0; 687 if (fwnode_device_is_compatible(child, "gpio")) 688 led.flags |= TCA6507_MAKE_GPIO; 689 690 ret = fwnode_property_read_u32(child, "reg", ®); 691 if (ret || reg >= NUM_LEDS) { 692 fwnode_handle_put(child); 693 return ERR_PTR(ret ? : -EINVAL); 694 } 695 696 tca_leds[reg] = led; 697 } 698 699 pdata = devm_kzalloc(dev, sizeof(struct tca6507_platform_data), 700 GFP_KERNEL); 701 if (!pdata) 702 return ERR_PTR(-ENOMEM); 703 704 pdata->leds.leds = tca_leds; 705 pdata->leds.num_leds = NUM_LEDS; 706 707 return pdata; 708 } 709 710 static const struct of_device_id __maybe_unused of_tca6507_leds_match[] = { 711 { .compatible = "ti,tca6507", }, 712 {}, 713 }; 714 MODULE_DEVICE_TABLE(of, of_tca6507_leds_match); 715 716 static int tca6507_probe(struct i2c_client *client) 717 { 718 struct device *dev = &client->dev; 719 struct i2c_adapter *adapter; 720 struct tca6507_chip *tca; 721 struct tca6507_platform_data *pdata; 722 int err; 723 int i = 0; 724 725 adapter = client->adapter; 726 727 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 728 return -EIO; 729 730 pdata = tca6507_led_dt_init(dev); 731 if (IS_ERR(pdata)) { 732 dev_err(dev, "Need %d entries in platform-data list\n", NUM_LEDS); 733 return PTR_ERR(pdata); 734 } 735 tca = devm_kzalloc(dev, sizeof(*tca), GFP_KERNEL); 736 if (!tca) 737 return -ENOMEM; 738 739 tca->client = client; 740 INIT_WORK(&tca->work, tca6507_work); 741 spin_lock_init(&tca->lock); 742 i2c_set_clientdata(client, tca); 743 744 for (i = 0; i < NUM_LEDS; i++) { 745 struct tca6507_led *l = tca->leds + i; 746 747 l->chip = tca; 748 l->num = i; 749 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) { 750 l->led_cdev.name = pdata->leds.leds[i].name; 751 l->led_cdev.default_trigger 752 = pdata->leds.leds[i].default_trigger; 753 l->led_cdev.brightness_set = tca6507_brightness_set; 754 l->led_cdev.blink_set = tca6507_blink_set; 755 l->bank = -1; 756 err = devm_led_classdev_register(dev, &l->led_cdev); 757 if (err < 0) 758 return err; 759 } 760 } 761 err = tca6507_probe_gpios(dev, tca, pdata); 762 if (err) 763 return err; 764 /* set all registers to known state - zero */ 765 tca->reg_set = 0x7f; 766 schedule_work(&tca->work); 767 768 return 0; 769 } 770 771 static void tca6507_remove(struct i2c_client *client) 772 { 773 struct tca6507_chip *tca = i2c_get_clientdata(client); 774 775 cancel_work_sync(&tca->work); 776 } 777 778 static struct i2c_driver tca6507_driver = { 779 .driver = { 780 .name = "leds-tca6507", 781 .of_match_table = of_match_ptr(of_tca6507_leds_match), 782 }, 783 .probe = tca6507_probe, 784 .remove = tca6507_remove, 785 .id_table = tca6507_id, 786 }; 787 788 module_i2c_driver(tca6507_driver); 789 790 MODULE_AUTHOR("NeilBrown <neilb@suse.de>"); 791 MODULE_DESCRIPTION("TCA6507 LED/GPO driver"); 792 MODULE_LICENSE("GPL v2"); 793