Loading...
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 swap(*c2p, *c1p);
246 }
247 actual = time_codes[*c1p] + time_codes[*c2p];
248 if (*c1p < *c2p)
249 return actual + 1;
250 else
251 return actual;
252 }
253 /* No close match */
254 return -EINVAL;
255}
256
257/*
258 * Update the register file with the appropriate 3-bit state for the
259 * given led.
260 */
261static void set_select(struct tca6507_chip *tca, int led, int val)
262{
263 int mask = (1 << led);
264 int bit;
265
266 for (bit = 0; bit < 3; bit++) {
267 int n = tca->reg_file[bit] & ~mask;
268 if (val & (1 << bit))
269 n |= mask;
270 if (tca->reg_file[bit] != n) {
271 tca->reg_file[bit] = n;
272 tca->reg_set |= (1 << bit);
273 }
274 }
275}
276
277/* Update the register file with the appropriate 4-bit code for one
278 * bank or other. This can be used for timers, for levels, or for
279 * initialization.
280 */
281static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)
282{
283 int mask = 0xF;
284 int n;
285 if (bank) {
286 mask <<= 4;
287 new <<= 4;
288 }
289 n = tca->reg_file[reg] & ~mask;
290 n |= new;
291 if (tca->reg_file[reg] != n) {
292 tca->reg_file[reg] = n;
293 tca->reg_set |= 1 << reg;
294 }
295}
296
297/* Update brightness level. */
298static void set_level(struct tca6507_chip *tca, int bank, int level)
299{
300 switch (bank) {
301 case BANK0:
302 case BANK1:
303 set_code(tca, TCA6507_MAX_INTENSITY, bank, level);
304 break;
305 case MASTER:
306 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);
307 break;
308 }
309 tca->bank[bank].level = level;
310}
311
312/* Record all relevant time codes for a given bank */
313static void set_times(struct tca6507_chip *tca, int bank)
314{
315 int c1, c2;
316 int result;
317
318 result = choose_times(tca->bank[bank].ontime, &c1, &c2);
319 if (result < 0)
320 return;
321 dev_dbg(&tca->client->dev,
322 "Chose on times %d(%d) %d(%d) for %dms\n",
323 c1, time_codes[c1],
324 c2, time_codes[c2], tca->bank[bank].ontime);
325 set_code(tca, TCA6507_FADE_ON, bank, c2);
326 set_code(tca, TCA6507_FULL_ON, bank, c1);
327 tca->bank[bank].ontime = result;
328
329 result = choose_times(tca->bank[bank].offtime, &c1, &c2);
330 dev_dbg(&tca->client->dev,
331 "Chose off times %d(%d) %d(%d) for %dms\n",
332 c1, time_codes[c1],
333 c2, time_codes[c2], tca->bank[bank].offtime);
334 set_code(tca, TCA6507_FADE_OFF, bank, c2);
335 set_code(tca, TCA6507_FIRST_OFF, bank, c1);
336 set_code(tca, TCA6507_SECOND_OFF, bank, c1);
337 tca->bank[bank].offtime = result;
338
339 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
340}
341
342/* Write all needed register of tca6507 */
343
344static void tca6507_work(struct work_struct *work)
345{
346 struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
347 work);
348 struct i2c_client *cl = tca->client;
349 int set;
350 u8 file[TCA6507_REG_CNT];
351 int r;
352
353 spin_lock_irq(&tca->lock);
354 set = tca->reg_set;
355 memcpy(file, tca->reg_file, TCA6507_REG_CNT);
356 tca->reg_set = 0;
357 spin_unlock_irq(&tca->lock);
358
359 for (r = 0; r < TCA6507_REG_CNT; r++)
360 if (set & (1<<r))
361 i2c_smbus_write_byte_data(cl, r, file[r]);
362}
363
364static void led_release(struct tca6507_led *led)
365{
366 /* If led owns any resource, release it. */
367 struct tca6507_chip *tca = led->chip;
368 if (led->bank >= 0) {
369 struct bank *b = tca->bank + led->bank;
370 if (led->blink)
371 b->time_use--;
372 b->level_use--;
373 }
374 led->blink = 0;
375 led->bank = -1;
376}
377
378static int led_prepare(struct tca6507_led *led)
379{
380 /* Assign this led to a bank, configuring that bank if
381 * necessary. */
382 int level = TO_LEVEL(led->led_cdev.brightness);
383 struct tca6507_chip *tca = led->chip;
384 int c1, c2;
385 int i;
386 struct bank *b;
387 int need_init = 0;
388
389 led->led_cdev.brightness = TO_BRIGHT(level);
390 if (level == 0) {
391 set_select(tca, led->num, TCA6507_LS_LED_OFF);
392 return 0;
393 }
394
395 if (led->ontime == 0 || led->offtime == 0) {
396 /*
397 * Just set the brightness, choosing first usable
398 * bank. If none perfect, choose best. Count
399 * backwards so we check MASTER bank first to avoid
400 * wasting a timer.
401 */
402 int best = -1;/* full-on */
403 int diff = 15-level;
404
405 if (level == 15) {
406 set_select(tca, led->num, TCA6507_LS_LED_ON);
407 return 0;
408 }
409
410 for (i = MASTER; i >= BANK0; i--) {
411 int d;
412 if (tca->bank[i].level == level ||
413 tca->bank[i].level_use == 0) {
414 best = i;
415 break;
416 }
417 d = abs(level - tca->bank[i].level);
418 if (d < diff) {
419 diff = d;
420 best = i;
421 }
422 }
423 if (best == -1) {
424 /* Best brightness is full-on */
425 set_select(tca, led->num, TCA6507_LS_LED_ON);
426 led->led_cdev.brightness = LED_FULL;
427 return 0;
428 }
429
430 if (!tca->bank[best].level_use)
431 set_level(tca, best, level);
432
433 tca->bank[best].level_use++;
434 led->bank = best;
435 set_select(tca, led->num, bank_source[best]);
436 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
437 return 0;
438 }
439
440 /*
441 * We have on/off time so we need to try to allocate a timing
442 * bank. First check if times are compatible with hardware
443 * and give up if not.
444 */
445 if (choose_times(led->ontime, &c1, &c2) < 0)
446 return -EINVAL;
447 if (choose_times(led->offtime, &c1, &c2) < 0)
448 return -EINVAL;
449
450 for (i = BANK0; i <= BANK1; i++) {
451 if (tca->bank[i].level_use == 0)
452 /* not in use - it is ours! */
453 break;
454 if (tca->bank[i].level != level)
455 /* Incompatible level - skip */
456 /* FIX: if timer matches we maybe should consider
457 * this anyway...
458 */
459 continue;
460
461 if (tca->bank[i].time_use == 0)
462 /* Timer not in use, and level matches - use it */
463 break;
464
465 if (!(tca->bank[i].on_dflt ||
466 led->on_dflt ||
467 tca->bank[i].ontime == led->ontime))
468 /* on time is incompatible */
469 continue;
470
471 if (!(tca->bank[i].off_dflt ||
472 led->off_dflt ||
473 tca->bank[i].offtime == led->offtime))
474 /* off time is incompatible */
475 continue;
476
477 /* looks like a suitable match */
478 break;
479 }
480
481 if (i > BANK1)
482 /* Nothing matches - how sad */
483 return -EINVAL;
484
485 b = &tca->bank[i];
486 if (b->level_use == 0)
487 set_level(tca, i, level);
488 b->level_use++;
489 led->bank = i;
490
491 if (b->on_dflt ||
492 !led->on_dflt ||
493 b->time_use == 0) {
494 b->ontime = led->ontime;
495 b->on_dflt = led->on_dflt;
496 need_init = 1;
497 }
498
499 if (b->off_dflt ||
500 !led->off_dflt ||
501 b->time_use == 0) {
502 b->offtime = led->offtime;
503 b->off_dflt = led->off_dflt;
504 need_init = 1;
505 }
506
507 if (need_init)
508 set_times(tca, i);
509
510 led->ontime = b->ontime;
511 led->offtime = b->offtime;
512
513 b->time_use++;
514 led->blink = 1;
515 led->led_cdev.brightness = TO_BRIGHT(b->level);
516 set_select(tca, led->num, blink_source[i]);
517 return 0;
518}
519
520static int led_assign(struct tca6507_led *led)
521{
522 struct tca6507_chip *tca = led->chip;
523 int err;
524 unsigned long flags;
525
526 spin_lock_irqsave(&tca->lock, flags);
527 led_release(led);
528 err = led_prepare(led);
529 if (err) {
530 /*
531 * Can only fail on timer setup. In that case we need
532 * to re-establish as steady level.
533 */
534 led->ontime = 0;
535 led->offtime = 0;
536 led_prepare(led);
537 }
538 spin_unlock_irqrestore(&tca->lock, flags);
539
540 if (tca->reg_set)
541 schedule_work(&tca->work);
542 return err;
543}
544
545static void tca6507_brightness_set(struct led_classdev *led_cdev,
546 enum led_brightness brightness)
547{
548 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
549 led_cdev);
550 led->led_cdev.brightness = brightness;
551 led->ontime = 0;
552 led->offtime = 0;
553 led_assign(led);
554}
555
556static int tca6507_blink_set(struct led_classdev *led_cdev,
557 unsigned long *delay_on,
558 unsigned long *delay_off)
559{
560 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
561 led_cdev);
562
563 if (*delay_on == 0)
564 led->on_dflt = 1;
565 else if (delay_on != &led_cdev->blink_delay_on)
566 led->on_dflt = 0;
567 led->ontime = *delay_on;
568
569 if (*delay_off == 0)
570 led->off_dflt = 1;
571 else if (delay_off != &led_cdev->blink_delay_off)
572 led->off_dflt = 0;
573 led->offtime = *delay_off;
574
575 if (led->ontime == 0)
576 led->ontime = 512;
577 if (led->offtime == 0)
578 led->offtime = 512;
579
580 if (led->led_cdev.brightness == LED_OFF)
581 led->led_cdev.brightness = LED_FULL;
582 if (led_assign(led) < 0) {
583 led->ontime = 0;
584 led->offtime = 0;
585 led->led_cdev.brightness = LED_OFF;
586 return -EINVAL;
587 }
588 *delay_on = led->ontime;
589 *delay_off = led->offtime;
590 return 0;
591}
592
593#ifdef CONFIG_GPIOLIB
594static void tca6507_gpio_set_value(struct gpio_chip *gc,
595 unsigned offset, int val)
596{
597 struct tca6507_chip *tca = gpiochip_get_data(gc);
598 unsigned long flags;
599
600 spin_lock_irqsave(&tca->lock, flags);
601 /*
602 * 'OFF' is floating high, and 'ON' is pulled down, so it has
603 * the inverse sense of 'val'.
604 */
605 set_select(tca, tca->gpio_map[offset],
606 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
607 spin_unlock_irqrestore(&tca->lock, flags);
608 if (tca->reg_set)
609 schedule_work(&tca->work);
610}
611
612static int tca6507_gpio_direction_output(struct gpio_chip *gc,
613 unsigned offset, int val)
614{
615 tca6507_gpio_set_value(gc, offset, val);
616 return 0;
617}
618
619static int tca6507_probe_gpios(struct device *dev,
620 struct tca6507_chip *tca,
621 struct tca6507_platform_data *pdata)
622{
623 int err;
624 int i = 0;
625 int gpios = 0;
626
627 for (i = 0; i < NUM_LEDS; i++)
628 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
629 /* Configure as a gpio */
630 tca->gpio_map[gpios] = i;
631 gpios++;
632 }
633
634 if (!gpios)
635 return 0;
636
637 tca->gpio.label = "gpio-tca6507";
638 tca->gpio.ngpio = gpios;
639 tca->gpio.base = pdata->gpio_base;
640 tca->gpio.owner = THIS_MODULE;
641 tca->gpio.direction_output = tca6507_gpio_direction_output;
642 tca->gpio.set = tca6507_gpio_set_value;
643 tca->gpio.parent = dev;
644 err = gpiochip_add_data(&tca->gpio, tca);
645 if (err) {
646 tca->gpio.ngpio = 0;
647 return err;
648 }
649 return 0;
650}
651
652static void tca6507_remove_gpio(struct tca6507_chip *tca)
653{
654 if (tca->gpio.ngpio)
655 gpiochip_remove(&tca->gpio);
656}
657#else /* CONFIG_GPIOLIB */
658static int tca6507_probe_gpios(struct device *dev,
659 struct tca6507_chip *tca,
660 struct tca6507_platform_data *pdata)
661{
662 return 0;
663}
664static void tca6507_remove_gpio(struct tca6507_chip *tca)
665{
666}
667#endif /* CONFIG_GPIOLIB */
668
669static struct tca6507_platform_data *
670tca6507_led_dt_init(struct device *dev)
671{
672 struct tca6507_platform_data *pdata;
673 struct fwnode_handle *child;
674 struct led_info *tca_leds;
675 int count;
676
677 count = device_get_child_node_count(dev);
678 if (!count || count > NUM_LEDS)
679 return ERR_PTR(-ENODEV);
680
681 tca_leds = devm_kcalloc(dev, NUM_LEDS, sizeof(struct led_info),
682 GFP_KERNEL);
683 if (!tca_leds)
684 return ERR_PTR(-ENOMEM);
685
686 device_for_each_child_node(dev, child) {
687 struct led_info led;
688 u32 reg;
689 int ret;
690
691 if (fwnode_property_read_string(child, "label", &led.name))
692 led.name = fwnode_get_name(child);
693
694 fwnode_property_read_string(child, "linux,default-trigger",
695 &led.default_trigger);
696
697 led.flags = 0;
698 if (fwnode_property_match_string(child, "compatible",
699 "gpio") >= 0)
700 led.flags |= TCA6507_MAKE_GPIO;
701
702 ret = fwnode_property_read_u32(child, "reg", ®);
703 if (ret || reg >= NUM_LEDS) {
704 fwnode_handle_put(child);
705 return ERR_PTR(ret ? : -EINVAL);
706 }
707
708 tca_leds[reg] = led;
709 }
710
711 pdata = devm_kzalloc(dev, sizeof(struct tca6507_platform_data),
712 GFP_KERNEL);
713 if (!pdata)
714 return ERR_PTR(-ENOMEM);
715
716 pdata->leds.leds = tca_leds;
717 pdata->leds.num_leds = NUM_LEDS;
718#ifdef CONFIG_GPIOLIB
719 pdata->gpio_base = -1;
720#endif
721
722 return pdata;
723}
724
725static const struct of_device_id __maybe_unused of_tca6507_leds_match[] = {
726 { .compatible = "ti,tca6507", },
727 {},
728};
729MODULE_DEVICE_TABLE(of, of_tca6507_leds_match);
730
731static int tca6507_probe(struct i2c_client *client,
732 const struct i2c_device_id *id)
733{
734 struct device *dev = &client->dev;
735 struct i2c_adapter *adapter;
736 struct tca6507_chip *tca;
737 struct tca6507_platform_data *pdata;
738 int err;
739 int i = 0;
740
741 adapter = client->adapter;
742
743 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
744 return -EIO;
745
746 pdata = tca6507_led_dt_init(dev);
747 if (IS_ERR(pdata)) {
748 dev_err(dev, "Need %d entries in platform-data list\n", NUM_LEDS);
749 return PTR_ERR(pdata);
750 }
751 tca = devm_kzalloc(dev, sizeof(*tca), GFP_KERNEL);
752 if (!tca)
753 return -ENOMEM;
754
755 tca->client = client;
756 INIT_WORK(&tca->work, tca6507_work);
757 spin_lock_init(&tca->lock);
758 i2c_set_clientdata(client, tca);
759
760 for (i = 0; i < NUM_LEDS; i++) {
761 struct tca6507_led *l = tca->leds + i;
762
763 l->chip = tca;
764 l->num = i;
765 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {
766 l->led_cdev.name = pdata->leds.leds[i].name;
767 l->led_cdev.default_trigger
768 = pdata->leds.leds[i].default_trigger;
769 l->led_cdev.brightness_set = tca6507_brightness_set;
770 l->led_cdev.blink_set = tca6507_blink_set;
771 l->bank = -1;
772 err = led_classdev_register(dev, &l->led_cdev);
773 if (err < 0)
774 goto exit;
775 }
776 }
777 err = tca6507_probe_gpios(dev, tca, pdata);
778 if (err)
779 goto exit;
780 /* set all registers to known state - zero */
781 tca->reg_set = 0x7f;
782 schedule_work(&tca->work);
783
784 return 0;
785exit:
786 while (i--) {
787 if (tca->leds[i].led_cdev.name)
788 led_classdev_unregister(&tca->leds[i].led_cdev);
789 }
790 return err;
791}
792
793static void tca6507_remove(struct i2c_client *client)
794{
795 int i;
796 struct tca6507_chip *tca = i2c_get_clientdata(client);
797 struct tca6507_led *tca_leds = tca->leds;
798
799 for (i = 0; i < NUM_LEDS; i++) {
800 if (tca_leds[i].led_cdev.name)
801 led_classdev_unregister(&tca_leds[i].led_cdev);
802 }
803 tca6507_remove_gpio(tca);
804 cancel_work_sync(&tca->work);
805}
806
807static struct i2c_driver tca6507_driver = {
808 .driver = {
809 .name = "leds-tca6507",
810 .of_match_table = of_match_ptr(of_tca6507_leds_match),
811 },
812 .probe = tca6507_probe,
813 .remove = tca6507_remove,
814 .id_table = tca6507_id,
815};
816
817module_i2c_driver(tca6507_driver);
818
819MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
820MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
821MODULE_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 * 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
111enum {
112 BANK0,
113 BANK1,
114 MASTER,
115};
116static int bank_source[3] = {
117 TCA6507_LS_LED_PWM0,
118 TCA6507_LS_LED_PWM1,
119 TCA6507_LS_LED_MIR,
120};
121static 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
145static 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) */
151static inline int TO_LEVEL(int brightness)
152{
153 return brightness >> 4;
154}
155
156/* ...and convert back */
157static 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
165struct 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
197static const struct i2c_device_id tca6507_id[] = {
198 { "tca6507" },
199 { }
200};
201MODULE_DEVICE_TABLE(i2c, tca6507_id);
202
203static 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 */
273static 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 */
293static 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. */
310static 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 */
325static 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
356static 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
376static 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
390static 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
532static 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
557static 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
568static 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
606static 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
624static 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
631static 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
671static void tca6507_remove_gpio(struct tca6507_chip *tca)
672{
673 if (tca->gpio.ngpio)
674 gpiochip_remove(&tca->gpio);
675}
676#else /* CONFIG_GPIOLIB */
677static int tca6507_probe_gpios(struct i2c_client *client,
678 struct tca6507_chip *tca,
679 struct tca6507_platform_data *pdata)
680{
681 return 0;
682}
683static void tca6507_remove_gpio(struct tca6507_chip *tca)
684{
685}
686#endif /* CONFIG_GPIOLIB */
687
688#ifdef CONFIG_OF
689static struct tca6507_platform_data *
690tca6507_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", ®);
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
737static const struct of_device_id of_tca6507_leds_match[] = {
738 { .compatible = "ti,tca6507", },
739 {},
740};
741MODULE_DEVICE_TABLE(of, of_tca6507_leds_match);
742
743#else
744static struct tca6507_platform_data *
745tca6507_led_dt_init(struct i2c_client *client)
746{
747 return ERR_PTR(-ENODEV);
748}
749
750#endif
751
752static 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;
810exit:
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
818static 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
834static 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
844module_i2c_driver(tca6507_driver);
845
846MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
847MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
848MODULE_LICENSE("GPL v2");