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