Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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 ''.
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");
849 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us