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