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 blink or 8 * double-blink. 9 * 10 * This driver can configure each line either as a 'GPIO' which is out-only 11 * (no pull-up) or as an LED with variable brightness and hardware-assisted 12 * blinking. 13 * 14 * Apart from OFF and ON there are three programmable brightness levels which 15 * can be programmed from 0 to 15 and indicate how many 500usec intervals in 16 * each 8msec that the led is 'on'. The levels are named MASTER, BANK0 and 17 * BANK1. 18 * 19 * There are two different blink rates that can be programmed, each with 20 * separate time for rise, on, fall, off and second-off. Thus if 3 or more 21 * different non-trivial rates are required, software must be used for the extra 22 * rates. The two different blink rates must align with the two levels BANK0 and 23 * BANK1. 24 * This driver does not support double-blink so 'second-off' always matches 25 * 'off'. 26 * 27 * Only 16 different times can be programmed in a roughly logarithmic scale from 28 * 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 33 * handled in software. This driver allows 12.5% error in matching. 34 * 35 * This driver does not allow rise/fall rates to be set explicitly. When trying 36 * to match a given 'on' or 'off' period, an appropriate pair of 'change' and 37 * 'hold' times are chosen to get a close match. If the target delay is even, 38 * the 'change' number will be the smaller; if odd, the 'hold' number will be 39 * the smaller. 40 41 * Choosing pairs of delays with 12.5% errors allows us to match delays in the 42 * ranges: 56-72, 112-144, 168-216, 224-27504, 28560-36720. 43 * 26% of the achievable sums can be matched by multiple pairings. For example 44 * 1536 == 1536+0, 1024+512, or 768+768. This driver will always choose the 45 * pairing with the least maximum - 768+768 in this case. Other pairings are 46 * not available. 47 * 48 * Access to the 3 levels and 2 blinks are on a first-come, first-served basis. 49 * Access can be shared by multiple leds if they have the same level and 50 * either same blink rates, or some don't blink. 51 * When a led changes, it relinquishes access and tries again, so it might 52 * lose access to hardware blink. 53 * If a blink engine cannot be allocated, software blink is used. 54 * If the desired brightness cannot be allocated, the closest available non-zero 55 * brightness is used. As 'full' is always available, the worst case would be 56 * to have two different blink rates at '1', with Max at '2', then other leds 57 * will have to choose between '2' and '16'. Hopefully this is not likely. 58 * 59 * Each bank (BANK0 and BANK1) has two usage counts - LEDs using the brightness 60 * and LEDs using the blink. It can only be reprogrammed when the appropriate 61 * counter is zero. The MASTER level has a single usage count. 62 * 63 * Each Led has programmable 'on' and 'off' time as milliseconds. With each 64 * there is a flag saying if it was explicitly requested or defaulted. 65 * Similarly the banks know if each time was explicit or a default. Defaults 66 * are permitted to be changed freely - they are not recognised when matching. 67 * 68 * 69 * An led-tca6507 device must be provided with platform data. This data 70 * lists for each output: the name, default trigger, and whether the signal 71 * is being used as a GPiO rather than an led. 'struct led_plaform_data' 72 * is used for this. If 'name' is NULL, the output isn't used. If 'flags' 73 * is TCA6507_MAKE_CPIO, the output is a GPO. 74 * The "struct led_platform_data" can be embedded in a 75 * "struct tca6507_platform_data" which adds a 'gpio_base' for the GPiOs, 76 * and a 'setup' callback which is called once the GPiOs are available. 77 * 78 */ 79 80 #include <linux/module.h> 81 #include <linux/slab.h> 82 #include <linux/leds.h> 83 #include <linux/err.h> 84 #include <linux/i2c.h> 85 #include <linux/gpio.h> 86 #include <linux/workqueue.h> 87 #include <linux/leds-tca6507.h> 88 89 /* LED select registers determine the source that drives LED outputs */ 90 #define TCA6507_LS_LED_OFF 0x0 /* Output HI-Z (off) */ 91 #define TCA6507_LS_LED_OFF1 0x1 /* Output HI-Z (off) - not used */ 92 #define TCA6507_LS_LED_PWM0 0x2 /* Output LOW with Bank0 rate */ 93 #define TCA6507_LS_LED_PWM1 0x3 /* Output LOW with Bank1 rate */ 94 #define TCA6507_LS_LED_ON 0x4 /* Output LOW (on) */ 95 #define TCA6507_LS_LED_MIR 0x5 /* Output LOW with Master Intensity */ 96 #define TCA6507_LS_BLINK0 0x6 /* Blink at Bank0 rate */ 97 #define TCA6507_LS_BLINK1 0x7 /* Blink at Bank1 rate */ 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 const char *gpio_name[NUM_LEDS]; 181 int gpio_map[NUM_LEDS]; 182 #endif 183 }; 184 185 static const struct i2c_device_id tca6507_id[] = { 186 { "tca6507" }, 187 { } 188 }; 189 MODULE_DEVICE_TABLE(i2c, tca6507_id); 190 191 static int choose_times(int msec, int *c1p, int *c2p) 192 { 193 /* 194 * Choose two timecodes which add to 'msec' as near as possible. 195 * The first returned is the 'on' or 'off' time. The second is to be 196 * used as a 'fade-on' or 'fade-off' time. If 'msec' is even, 197 * the first will not be smaller than the second. If 'msec' is odd, 198 * the first will not be larger than the second. 199 * If we cannot get a sum within 1/8 of 'msec' fail with -EINVAL, 200 * otherwise return the sum that was achieved, plus 1 if the first is 201 * smaller. 202 * If two possibilities are equally good (e.g. 512+0, 256+256), choose 203 * the first pair so there is more change-time visible (i.e. it is 204 * 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 c1 = *c2p; 243 *c2p = *c1p; 244 *c1p = c1; 245 } 246 actual = time_codes[*c1p] + time_codes[*c2p]; 247 if (*c1p < *c2p) 248 return actual + 1; 249 else 250 return actual; 251 } 252 /* No close match */ 253 return -EINVAL; 254 } 255 256 /* 257 * Update the register file with the appropriate 3-bit state for 258 * the given led. 259 */ 260 static void set_select(struct tca6507_chip *tca, int led, int val) 261 { 262 int mask = (1 << led); 263 int bit; 264 265 for (bit = 0; bit < 3; bit++) { 266 int n = tca->reg_file[bit] & ~mask; 267 if (val & (1 << bit)) 268 n |= mask; 269 if (tca->reg_file[bit] != n) { 270 tca->reg_file[bit] = n; 271 tca->reg_set |= (1 << bit); 272 } 273 } 274 } 275 276 /* Update the register file with the appropriate 4-bit code for 277 * one bank or other. This can be used for timers, for levels, or 278 * for initialisation. 279 */ 280 static void set_code(struct tca6507_chip *tca, int reg, int bank, int new) 281 { 282 int mask = 0xF; 283 int n; 284 if (bank) { 285 mask <<= 4; 286 new <<= 4; 287 } 288 n = tca->reg_file[reg] & ~mask; 289 n |= new; 290 if (tca->reg_file[reg] != n) { 291 tca->reg_file[reg] = n; 292 tca->reg_set |= 1 << reg; 293 } 294 } 295 296 /* Update brightness level. */ 297 static void set_level(struct tca6507_chip *tca, int bank, int level) 298 { 299 switch (bank) { 300 case BANK0: 301 case BANK1: 302 set_code(tca, TCA6507_MAX_INTENSITY, bank, level); 303 break; 304 case MASTER: 305 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level); 306 break; 307 } 308 tca->bank[bank].level = level; 309 } 310 311 /* Record all relevant time code for a given bank */ 312 static void set_times(struct tca6507_chip *tca, int bank) 313 { 314 int c1, c2; 315 int result; 316 317 result = choose_times(tca->bank[bank].ontime, &c1, &c2); 318 dev_dbg(&tca->client->dev, 319 "Chose on times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1], 320 c2, time_codes[c2], tca->bank[bank].ontime); 321 set_code(tca, TCA6507_FADE_ON, bank, c2); 322 set_code(tca, TCA6507_FULL_ON, bank, c1); 323 tca->bank[bank].ontime = result; 324 325 result = choose_times(tca->bank[bank].offtime, &c1, &c2); 326 dev_dbg(&tca->client->dev, 327 "Chose off times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1], 328 c2, time_codes[c2], tca->bank[bank].offtime); 329 set_code(tca, TCA6507_FADE_OFF, bank, c2); 330 set_code(tca, TCA6507_FIRST_OFF, bank, c1); 331 set_code(tca, TCA6507_SECOND_OFF, bank, c1); 332 tca->bank[bank].offtime = result; 333 334 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE); 335 } 336 337 /* Write all needed register of tca6507 */ 338 339 static void tca6507_work(struct work_struct *work) 340 { 341 struct tca6507_chip *tca = container_of(work, struct tca6507_chip, 342 work); 343 struct i2c_client *cl = tca->client; 344 int set; 345 u8 file[TCA6507_REG_CNT]; 346 int r; 347 348 spin_lock_irq(&tca->lock); 349 set = tca->reg_set; 350 memcpy(file, tca->reg_file, TCA6507_REG_CNT); 351 tca->reg_set = 0; 352 spin_unlock_irq(&tca->lock); 353 354 for (r = 0; r < TCA6507_REG_CNT; r++) 355 if (set & (1<<r)) 356 i2c_smbus_write_byte_data(cl, r, file[r]); 357 } 358 359 static void led_release(struct tca6507_led *led) 360 { 361 /* If led owns any resource, release it. */ 362 struct tca6507_chip *tca = led->chip; 363 if (led->bank >= 0) { 364 struct bank *b = tca->bank + led->bank; 365 if (led->blink) 366 b->time_use--; 367 b->level_use--; 368 } 369 led->blink = 0; 370 led->bank = -1; 371 } 372 373 static int led_prepare(struct tca6507_led *led) 374 { 375 /* Assign this led to a bank, configuring that bank if necessary. */ 376 int level = TO_LEVEL(led->led_cdev.brightness); 377 struct tca6507_chip *tca = led->chip; 378 int c1, c2; 379 int i; 380 struct bank *b; 381 int need_init = 0; 382 383 led->led_cdev.brightness = TO_BRIGHT(level); 384 if (level == 0) { 385 set_select(tca, led->num, TCA6507_LS_LED_OFF); 386 return 0; 387 } 388 389 if (led->ontime == 0 || led->offtime == 0) { 390 /* 391 * Just set the brightness, choosing first usable bank. 392 * If none perfect, choose best. 393 * Count backwards so we check MASTER bank first 394 * to avoid wasting a timer. 395 */ 396 int best = -1;/* full-on */ 397 int diff = 15-level; 398 399 if (level == 15) { 400 set_select(tca, led->num, TCA6507_LS_LED_ON); 401 return 0; 402 } 403 404 for (i = MASTER; i >= BANK0; i--) { 405 int d; 406 if (tca->bank[i].level == level || 407 tca->bank[i].level_use == 0) { 408 best = i; 409 break; 410 } 411 d = abs(level - tca->bank[i].level); 412 if (d < diff) { 413 diff = d; 414 best = i; 415 } 416 } 417 if (best == -1) { 418 /* Best brightness is full-on */ 419 set_select(tca, led->num, TCA6507_LS_LED_ON); 420 led->led_cdev.brightness = LED_FULL; 421 return 0; 422 } 423 424 if (!tca->bank[best].level_use) 425 set_level(tca, best, level); 426 427 tca->bank[best].level_use++; 428 led->bank = best; 429 set_select(tca, led->num, bank_source[best]); 430 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level); 431 return 0; 432 } 433 434 /* 435 * We have on/off time so we need to try to allocate a timing bank. 436 * First check if times are compatible with hardware and give up if 437 * not. 438 */ 439 if (choose_times(led->ontime, &c1, &c2) < 0) 440 return -EINVAL; 441 if (choose_times(led->offtime, &c1, &c2) < 0) 442 return -EINVAL; 443 444 for (i = BANK0; i <= BANK1; i++) { 445 if (tca->bank[i].level_use == 0) 446 /* not in use - it is ours! */ 447 break; 448 if (tca->bank[i].level != level) 449 /* Incompatible level - skip */ 450 /* FIX: if timer matches we maybe should consider 451 * this anyway... 452 */ 453 continue; 454 455 if (tca->bank[i].time_use == 0) 456 /* Timer not in use, and level matches - use it */ 457 break; 458 459 if (!(tca->bank[i].on_dflt || 460 led->on_dflt || 461 tca->bank[i].ontime == led->ontime)) 462 /* on time is incompatible */ 463 continue; 464 465 if (!(tca->bank[i].off_dflt || 466 led->off_dflt || 467 tca->bank[i].offtime == led->offtime)) 468 /* off time is incompatible */ 469 continue; 470 471 /* looks like a suitable match */ 472 break; 473 } 474 475 if (i > BANK1) 476 /* Nothing matches - how sad */ 477 return -EINVAL; 478 479 b = &tca->bank[i]; 480 if (b->level_use == 0) 481 set_level(tca, i, level); 482 b->level_use++; 483 led->bank = i; 484 485 if (b->on_dflt || 486 !led->on_dflt || 487 b->time_use == 0) { 488 b->ontime = led->ontime; 489 b->on_dflt = led->on_dflt; 490 need_init = 1; 491 } 492 493 if (b->off_dflt || 494 !led->off_dflt || 495 b->time_use == 0) { 496 b->offtime = led->offtime; 497 b->off_dflt = led->off_dflt; 498 need_init = 1; 499 } 500 501 if (need_init) 502 set_times(tca, i); 503 504 led->ontime = b->ontime; 505 led->offtime = b->offtime; 506 507 b->time_use++; 508 led->blink = 1; 509 led->led_cdev.brightness = TO_BRIGHT(b->level); 510 set_select(tca, led->num, blink_source[i]); 511 return 0; 512 } 513 514 static int led_assign(struct tca6507_led *led) 515 { 516 struct tca6507_chip *tca = led->chip; 517 int err; 518 unsigned long flags; 519 520 spin_lock_irqsave(&tca->lock, flags); 521 led_release(led); 522 err = led_prepare(led); 523 if (err) { 524 /* 525 * Can only fail on timer setup. In that case we need to 526 * re-establish as steady level. 527 */ 528 led->ontime = 0; 529 led->offtime = 0; 530 led_prepare(led); 531 } 532 spin_unlock_irqrestore(&tca->lock, flags); 533 534 if (tca->reg_set) 535 schedule_work(&tca->work); 536 return err; 537 } 538 539 static void tca6507_brightness_set(struct led_classdev *led_cdev, 540 enum led_brightness brightness) 541 { 542 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 543 led_cdev); 544 led->led_cdev.brightness = brightness; 545 led->ontime = 0; 546 led->offtime = 0; 547 led_assign(led); 548 } 549 550 static int tca6507_blink_set(struct led_classdev *led_cdev, 551 unsigned long *delay_on, 552 unsigned long *delay_off) 553 { 554 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led, 555 led_cdev); 556 557 if (*delay_on == 0) 558 led->on_dflt = 1; 559 else if (delay_on != &led_cdev->blink_delay_on) 560 led->on_dflt = 0; 561 led->ontime = *delay_on; 562 563 if (*delay_off == 0) 564 led->off_dflt = 1; 565 else if (delay_off != &led_cdev->blink_delay_off) 566 led->off_dflt = 0; 567 led->offtime = *delay_off; 568 569 if (led->ontime == 0) 570 led->ontime = 512; 571 if (led->offtime == 0) 572 led->offtime = 512; 573 574 if (led->led_cdev.brightness == LED_OFF) 575 led->led_cdev.brightness = LED_FULL; 576 if (led_assign(led) < 0) { 577 led->ontime = 0; 578 led->offtime = 0; 579 led->led_cdev.brightness = LED_OFF; 580 return -EINVAL; 581 } 582 *delay_on = led->ontime; 583 *delay_off = led->offtime; 584 return 0; 585 } 586 587 #ifdef CONFIG_GPIOLIB 588 static void tca6507_gpio_set_value(struct gpio_chip *gc, 589 unsigned offset, int val) 590 { 591 struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio); 592 unsigned long flags; 593 594 spin_lock_irqsave(&tca->lock, flags); 595 /* 596 * 'OFF' is floating high, and 'ON' is pulled down, so it has the 597 * inverse sense of 'val'. 598 */ 599 set_select(tca, tca->gpio_map[offset], 600 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON); 601 spin_unlock_irqrestore(&tca->lock, flags); 602 if (tca->reg_set) 603 schedule_work(&tca->work); 604 } 605 606 static int tca6507_gpio_direction_output(struct gpio_chip *gc, 607 unsigned offset, int val) 608 { 609 tca6507_gpio_set_value(gc, offset, val); 610 return 0; 611 } 612 613 static int tca6507_probe_gpios(struct i2c_client *client, 614 struct tca6507_chip *tca, 615 struct tca6507_platform_data *pdata) 616 { 617 int err; 618 int i = 0; 619 int gpios = 0; 620 621 for (i = 0; i < NUM_LEDS; i++) 622 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) { 623 /* Configure as a gpio */ 624 tca->gpio_name[gpios] = pdata->leds.leds[i].name; 625 tca->gpio_map[gpios] = i; 626 gpios++; 627 } 628 629 if (!gpios) 630 return 0; 631 632 tca->gpio.label = "gpio-tca6507"; 633 tca->gpio.names = tca->gpio_name; 634 tca->gpio.ngpio = gpios; 635 tca->gpio.base = pdata->gpio_base; 636 tca->gpio.owner = THIS_MODULE; 637 tca->gpio.direction_output = tca6507_gpio_direction_output; 638 tca->gpio.set = tca6507_gpio_set_value; 639 tca->gpio.dev = &client->dev; 640 err = gpiochip_add(&tca->gpio); 641 if (err) { 642 tca->gpio.ngpio = 0; 643 return err; 644 } 645 if (pdata->setup) 646 pdata->setup(tca->gpio.base, tca->gpio.ngpio); 647 return 0; 648 } 649 650 static void tca6507_remove_gpio(struct tca6507_chip *tca) 651 { 652 if (tca->gpio.ngpio) { 653 int err = gpiochip_remove(&tca->gpio); 654 dev_err(&tca->client->dev, "%s failed, %d\n", 655 "gpiochip_remove()", err); 656 } 657 } 658 #else /* CONFIG_GPIOLIB */ 659 static int tca6507_probe_gpios(struct i2c_client *client, 660 struct tca6507_chip *tca, 661 struct tca6507_platform_data *pdata) 662 { 663 return 0; 664 } 665 static void tca6507_remove_gpio(struct tca6507_chip *tca) 666 { 667 } 668 #endif /* CONFIG_GPIOLIB */ 669 670 static int __devinit tca6507_probe(struct i2c_client *client, 671 const struct i2c_device_id *id) 672 { 673 struct tca6507_chip *tca; 674 struct i2c_adapter *adapter; 675 struct tca6507_platform_data *pdata; 676 int err; 677 int i = 0; 678 679 adapter = to_i2c_adapter(client->dev.parent); 680 pdata = client->dev.platform_data; 681 682 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 683 return -EIO; 684 685 if (!pdata || pdata->leds.num_leds != NUM_LEDS) { 686 dev_err(&client->dev, "Need %d entries in platform-data list\n", 687 NUM_LEDS); 688 return -ENODEV; 689 } 690 tca = kzalloc(sizeof(*tca), GFP_KERNEL); 691 if (!tca) 692 return -ENOMEM; 693 694 tca->client = client; 695 INIT_WORK(&tca->work, tca6507_work); 696 spin_lock_init(&tca->lock); 697 i2c_set_clientdata(client, tca); 698 699 for (i = 0; i < NUM_LEDS; i++) { 700 struct tca6507_led *l = tca->leds + i; 701 702 l->chip = tca; 703 l->num = i; 704 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) { 705 l->led_cdev.name = pdata->leds.leds[i].name; 706 l->led_cdev.default_trigger 707 = pdata->leds.leds[i].default_trigger; 708 l->led_cdev.brightness_set = tca6507_brightness_set; 709 l->led_cdev.blink_set = tca6507_blink_set; 710 l->bank = -1; 711 err = led_classdev_register(&client->dev, 712 &l->led_cdev); 713 if (err < 0) 714 goto exit; 715 } 716 } 717 err = tca6507_probe_gpios(client, tca, pdata); 718 if (err) 719 goto exit; 720 /* set all registers to known state - zero */ 721 tca->reg_set = 0x7f; 722 schedule_work(&tca->work); 723 724 return 0; 725 exit: 726 while (i--) { 727 if (tca->leds[i].led_cdev.name) 728 led_classdev_unregister(&tca->leds[i].led_cdev); 729 } 730 kfree(tca); 731 return err; 732 } 733 734 static int __devexit tca6507_remove(struct i2c_client *client) 735 { 736 int i; 737 struct tca6507_chip *tca = i2c_get_clientdata(client); 738 struct tca6507_led *tca_leds = tca->leds; 739 740 for (i = 0; i < NUM_LEDS; i++) { 741 if (tca_leds[i].led_cdev.name) 742 led_classdev_unregister(&tca_leds[i].led_cdev); 743 } 744 tca6507_remove_gpio(tca); 745 cancel_work_sync(&tca->work); 746 kfree(tca); 747 748 return 0; 749 } 750 751 static struct i2c_driver tca6507_driver = { 752 .driver = { 753 .name = "leds-tca6507", 754 .owner = THIS_MODULE, 755 }, 756 .probe = tca6507_probe, 757 .remove = __devexit_p(tca6507_remove), 758 .id_table = tca6507_id, 759 }; 760 761 static int __init tca6507_leds_init(void) 762 { 763 return i2c_add_driver(&tca6507_driver); 764 } 765 766 static void __exit tca6507_leds_exit(void) 767 { 768 i2c_del_driver(&tca6507_driver); 769 } 770 771 module_init(tca6507_leds_init); 772 module_exit(tca6507_leds_exit); 773 774 MODULE_AUTHOR("NeilBrown <neilb@suse.de>"); 775 MODULE_DESCRIPTION("TCA6507 LED/GPO driver"); 776 MODULE_LICENSE("GPL v2"); 777