root/drivers/leds/leds-tca6507.c

DEFINITIONS

1. TO_LEVEL
2. TO_BRIGHT
3. choose_times
4. set_select
5. set_code
6. set_level
7. set_times
8. tca6507_work
9. led_release
10. led_prepare
11. led_assign
12. tca6507_brightness_set
13. tca6507_blink_set
14. tca6507_gpio_set_value
15. tca6507_gpio_direction_output
16. tca6507_probe_gpios
17. tca6507_remove_gpio
18. tca6507_probe_gpios
19. tca6507_remove_gpio
20. tca6507_led_dt_init
21. tca6507_led_dt_init
22. tca6507_probe
23. tca6507_remove

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