drivers/leds/leds-tca6507.c

   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         dev_dbg(&tca->client->dev,
 331                 "Chose on  times %d(%d) %d(%d) for %dms\n",
 332                 c1, time_codes[c1],
 333                 c2, time_codes[c2], tca->bank[bank].ontime);
 334         set_code(tca, TCA6507_FADE_ON, bank, c2);
 335         set_code(tca, TCA6507_FULL_ON, bank, c1);
 336         tca->bank[bank].ontime = result;
 337
 338         result = choose_times(tca->bank[bank].offtime, &c1, &c2);
 339         dev_dbg(&tca->client->dev,
 340                 "Chose off times %d(%d) %d(%d) for %dms\n",
 341                 c1, time_codes[c1],
 342                 c2, time_codes[c2], tca->bank[bank].offtime);
 343         set_code(tca, TCA6507_FADE_OFF, bank, c2);
 344         set_code(tca, TCA6507_FIRST_OFF, bank, c1);
 345         set_code(tca, TCA6507_SECOND_OFF, bank, c1);
 346         tca->bank[bank].offtime = result;
 347
 348         set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
 349 }
 350
 351 /* Write all needed register of tca6507 */
 352
 353 static void tca6507_work(struct work_struct *work)
 354 {
 355         struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
 356                                                 work);
 357         struct i2c_client *cl = tca->client;
 358         int set;
 359         u8 file[TCA6507_REG_CNT];
 360         int r;
 361
 362         spin_lock_irq(&tca->lock);
 363         set = tca->reg_set;
 364         memcpy(file, tca->reg_file, TCA6507_REG_CNT);
 365         tca->reg_set = 0;
 366         spin_unlock_irq(&tca->lock);
 367
 368         for (r = 0; r < TCA6507_REG_CNT; r++)
 369                 if (set & (1<<r))
 370                         i2c_smbus_write_byte_data(cl, r, file[r]);
 371 }
 372
 373 static void led_release(struct tca6507_led *led)
 374 {
 375         /* If led owns any resource, release it. */
 376         struct tca6507_chip *tca = led->chip;
 377         if (led->bank >= 0) {
 378                 struct bank *b = tca->bank + led->bank;
 379                 if (led->blink)
 380                         b->time_use--;
 381                 b->level_use--;
 382         }
 383         led->blink = 0;
 384         led->bank = -1;
 385 }
 386
 387 static int led_prepare(struct tca6507_led *led)
 388 {
 389         /* Assign this led to a bank, configuring that bank if
 390          * necessary. */
 391         int level = TO_LEVEL(led->led_cdev.brightness);
 392         struct tca6507_chip *tca = led->chip;
 393         int c1, c2;
 394         int i;
 395         struct bank *b;
 396         int need_init = 0;
 397
 398         led->led_cdev.brightness = TO_BRIGHT(level);
 399         if (level == 0) {
 400                 set_select(tca, led->num, TCA6507_LS_LED_OFF);
 401                 return 0;
 402         }
 403
 404         if (led->ontime == 0 || led->offtime == 0) {
 405                 /*
 406                  * Just set the brightness, choosing first usable
 407                  * bank.  If none perfect, choose best.  Count
 408                  * backwards so we check MASTER bank first to avoid
 409                  * wasting a timer.
 410                  */
 411                 int best = -1;/* full-on */
 412                 int diff = 15-level;
 413
 414                 if (level == 15) {
 415                         set_select(tca, led->num, TCA6507_LS_LED_ON);
 416                         return 0;
 417                 }
 418
 419                 for (i = MASTER; i >= BANK0; i--) {
 420                         int d;
 421                         if (tca->bank[i].level == level ||
 422                             tca->bank[i].level_use == 0) {
 423                                 best = i;
 424                                 break;
 425                         }
 426                         d = abs(level - tca->bank[i].level);
 427                         if (d < diff) {
 428                                 diff = d;
 429                                 best = i;
 430                         }
 431                 }
 432                 if (best == -1) {
 433                         /* Best brightness is full-on */
 434                         set_select(tca, led->num, TCA6507_LS_LED_ON);
 435                         led->led_cdev.brightness = LED_FULL;
 436                         return 0;
 437                 }
 438
 439                 if (!tca->bank[best].level_use)
 440                         set_level(tca, best, level);
 441
 442                 tca->bank[best].level_use++;
 443                 led->bank = best;
 444                 set_select(tca, led->num, bank_source[best]);
 445                 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
 446                 return 0;
 447         }
 448
 449         /*
 450          * We have on/off time so we need to try to allocate a timing
 451          * bank.  First check if times are compatible with hardware
 452          * and give up if not.
 453          */
 454         if (choose_times(led->ontime, &c1, &c2) < 0)
 455                 return -EINVAL;
 456         if (choose_times(led->offtime, &c1, &c2) < 0)
 457                 return -EINVAL;
 458
 459         for (i = BANK0; i <= BANK1; i++) {
 460                 if (tca->bank[i].level_use == 0)
 461                         /* not in use - it is ours! */
 462                         break;
 463                 if (tca->bank[i].level != level)
 464                         /* Incompatible level - skip */
 465                         /* FIX: if timer matches we maybe should consider
 466                          * this anyway...
 467                          */
 468                         continue;
 469
 470                 if (tca->bank[i].time_use == 0)
 471                         /* Timer not in use, and level matches - use it */
 472                         break;
 473
 474                 if (!(tca->bank[i].on_dflt ||
 475                       led->on_dflt ||
 476                       tca->bank[i].ontime == led->ontime))
 477                         /* on time is incompatible */
 478                         continue;
 479
 480                 if (!(tca->bank[i].off_dflt ||
 481                       led->off_dflt ||
 482                       tca->bank[i].offtime == led->offtime))
 483                         /* off time is incompatible */
 484                         continue;
 485
 486                 /* looks like a suitable match */
 487                 break;
 488         }
 489
 490         if (i > BANK1)
 491                 /* Nothing matches - how sad */
 492                 return -EINVAL;
 493
 494         b = &tca->bank[i];
 495         if (b->level_use == 0)
 496                 set_level(tca, i, level);
 497         b->level_use++;
 498         led->bank = i;
 499
 500         if (b->on_dflt ||
 501             !led->on_dflt ||
 502             b->time_use == 0) {
 503                 b->ontime = led->ontime;
 504                 b->on_dflt = led->on_dflt;
 505                 need_init = 1;
 506         }
 507
 508         if (b->off_dflt ||
 509             !led->off_dflt ||
 510             b->time_use == 0) {
 511                 b->offtime = led->offtime;
 512                 b->off_dflt = led->off_dflt;
 513                 need_init = 1;
 514         }
 515
 516         if (need_init)
 517                 set_times(tca, i);
 518
 519         led->ontime = b->ontime;
 520         led->offtime = b->offtime;
 521
 522         b->time_use++;
 523         led->blink = 1;
 524         led->led_cdev.brightness = TO_BRIGHT(b->level);
 525         set_select(tca, led->num, blink_source[i]);
 526         return 0;
 527 }
 528
 529 static int led_assign(struct tca6507_led *led)
 530 {
 531         struct tca6507_chip *tca = led->chip;
 532         int err;
 533         unsigned long flags;
 534
 535         spin_lock_irqsave(&tca->lock, flags);
 536         led_release(led);
 537         err = led_prepare(led);
 538         if (err) {
 539                 /*
 540                  * Can only fail on timer setup.  In that case we need
 541                  * to re-establish as steady level.
 542                  */
 543                 led->ontime = 0;
 544                 led->offtime = 0;
 545                 led_prepare(led);
 546         }
 547         spin_unlock_irqrestore(&tca->lock, flags);
 548
 549         if (tca->reg_set)
 550                 schedule_work(&tca->work);
 551         return err;
 552 }
 553
 554 static void tca6507_brightness_set(struct led_classdev *led_cdev,
 555                                    enum led_brightness brightness)
 556 {
 557         struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
 558                                                led_cdev);
 559         led->led_cdev.brightness = brightness;
 560         led->ontime = 0;
 561         led->offtime = 0;
 562         led_assign(led);
 563 }
 564
 565 static int tca6507_blink_set(struct led_classdev *led_cdev,
 566                              unsigned long *delay_on,
 567                              unsigned long *delay_off)
 568 {
 569         struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
 570                                                led_cdev);
 571
 572         if (*delay_on == 0)
 573                 led->on_dflt = 1;
 574         else if (delay_on != &led_cdev->blink_delay_on)
 575                 led->on_dflt = 0;
 576         led->ontime = *delay_on;
 577
 578         if (*delay_off == 0)
 579                 led->off_dflt = 1;
 580         else if (delay_off != &led_cdev->blink_delay_off)
 581                 led->off_dflt = 0;
 582         led->offtime = *delay_off;
 583
 584         if (led->ontime == 0)
 585                 led->ontime = 512;
 586         if (led->offtime == 0)
 587                 led->offtime = 512;
 588
 589         if (led->led_cdev.brightness == LED_OFF)
 590                 led->led_cdev.brightness = LED_FULL;
 591         if (led_assign(led) < 0) {
 592                 led->ontime = 0;
 593                 led->offtime = 0;
 594                 led->led_cdev.brightness = LED_OFF;
 595                 return -EINVAL;
 596         }
 597         *delay_on = led->ontime;
 598         *delay_off = led->offtime;
 599         return 0;
 600 }
 601
 602 #ifdef CONFIG_GPIOLIB
 603 static void tca6507_gpio_set_value(struct gpio_chip *gc,
 604                                    unsigned offset, int val)
 605 {
 606         struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio);
 607         unsigned long flags;
 608
 609         spin_lock_irqsave(&tca->lock, flags);
 610         /*
 611          * 'OFF' is floating high, and 'ON' is pulled down, so it has
 612          * the inverse sense of 'val'.
 613          */
 614         set_select(tca, tca->gpio_map[offset],
 615                    val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
 616         spin_unlock_irqrestore(&tca->lock, flags);
 617         if (tca->reg_set)
 618                 schedule_work(&tca->work);
 619 }
 620
 621 static int tca6507_gpio_direction_output(struct gpio_chip *gc,
 622                                           unsigned offset, int val)
 623 {
 624         tca6507_gpio_set_value(gc, offset, val);
 625         return 0;
 626 }
 627
 628 static int tca6507_probe_gpios(struct i2c_client *client,
 629                                struct tca6507_chip *tca,
 630                                struct tca6507_platform_data *pdata)
 631 {
 632         int err;
 633         int i = 0;
 634         int gpios = 0;
 635
 636         for (i = 0; i < NUM_LEDS; i++)
 637                 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
 638                         /* Configure as a gpio */
 639                         tca->gpio_name[gpios] = pdata->leds.leds[i].name;
 640                         tca->gpio_map[gpios] = i;
 641                         gpios++;
 642                 }
 643
 644         if (!gpios)
 645                 return 0;
 646
 647         tca->gpio.label = "gpio-tca6507";
 648         tca->gpio.names = tca->gpio_name;
 649         tca->gpio.ngpio = gpios;
 650         tca->gpio.base = pdata->gpio_base;
 651         tca->gpio.owner = THIS_MODULE;
 652         tca->gpio.direction_output = tca6507_gpio_direction_output;
 653         tca->gpio.set = tca6507_gpio_set_value;
 654         tca->gpio.dev = &client->dev;
 655 #ifdef CONFIG_OF_GPIO
 656         tca->gpio.of_node = of_node_get(client->dev.of_node);
 657 #endif
 658         err = gpiochip_add(&tca->gpio);
 659         if (err) {
 660                 tca->gpio.ngpio = 0;
 661                 return err;
 662         }
 663         if (pdata->setup)
 664                 pdata->setup(tca->gpio.base, tca->gpio.ngpio);
 665         return 0;
 666 }
 667
 668 static void tca6507_remove_gpio(struct tca6507_chip *tca)
 669 {
 670         if (tca->gpio.ngpio) {
 671                 int err = gpiochip_remove(&tca->gpio);
 672                 dev_err(&tca->client->dev, "%s failed, %d\n",
 673                         "gpiochip_remove()", err);
 674         }
 675 }
 676 #else /* CONFIG_GPIOLIB */
 677 static int tca6507_probe_gpios(struct i2c_client *client,
 678                                struct tca6507_chip *tca,
 679                                struct tca6507_platform_data *pdata)
 680 {
 681         return 0;
 682 }
 683 static void tca6507_remove_gpio(struct tca6507_chip *tca)
 684 {
 685 }
 686 #endif /* CONFIG_GPIOLIB */
 687
 688 #ifdef CONFIG_OF
 689 static struct tca6507_platform_data *
 690 tca6507_led_dt_init(struct i2c_client *client)
 691 {
 692         struct device_node *np = client->dev.of_node, *child;
 693         struct tca6507_platform_data *pdata;
 694         struct led_info *tca_leds;
 695         int count;
 696
 697         count = of_get_child_count(np);
 698         if (!count || count > NUM_LEDS)
 699                 return ERR_PTR(-ENODEV);
 700
 701         tca_leds = devm_kzalloc(&client->dev,
 702                         sizeof(struct led_info) * NUM_LEDS, GFP_KERNEL);
 703         if (!tca_leds)
 704                 return ERR_PTR(-ENOMEM);
 705
 706         for_each_child_of_node(np, child) {
 707                 struct led_info led;
 708                 u32 reg;
 709                 int ret;
 710
 711                 led.name =
 712                         of_get_property(child, "label", NULL) ? : child->name;
 713                 led.default_trigger =
 714                         of_get_property(child, "linux,default-trigger", NULL);
 715                 led.flags = 0;
 716                 if (of_property_match_string(child, "compatible", "gpio") >= 0)
 717                         led.flags |= TCA6507_MAKE_GPIO;
 718                 ret = of_property_read_u32(child, "reg", &reg);
 719                 if (ret != 0 || reg < 0 || reg >= NUM_LEDS)
 720                         continue;
 721
 722                 tca_leds[reg] = led;
 723         }
 724         pdata = devm_kzalloc(&client->dev,
 725                         sizeof(struct tca6507_platform_data), GFP_KERNEL);
 726         if (!pdata)
 727                 return ERR_PTR(-ENOMEM);
 728
 729         pdata->leds.leds = tca_leds;
 730         pdata->leds.num_leds = NUM_LEDS;
 731 #ifdef CONFIG_GPIOLIB
 732         pdata->gpio_base = -1;
 733 #endif
 734         return pdata;
 735 }
 736
 737 static const struct of_device_id of_tca6507_leds_match[] = {
 738         { .compatible = "ti,tca6507", },
 739         {},
 740 };
 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                 .owner   = THIS_MODULE,
 837                 .of_match_table = of_match_ptr(of_tca6507_leds_match),
 838         },
 839         .probe    = tca6507_probe,
 840         .remove   = tca6507_remove,
 841         .id_table = tca6507_id,
 842 };
 843
 844 module_i2c_driver(tca6507_driver);
 845
 846 MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
 847 MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
 848 MODULE_LICENSE("GPL v2");