1 // SPDX-License-Identifier: GPL-2.0-only
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.
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.
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.
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'.
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
32 * Times that cannot be closely matched with these must be handled in
33 * software. This driver allows 12.5% error in matching.
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.
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,
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.
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.
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.
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
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.
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>
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 */
93 struct tca6507_platform_data
{
94 struct led_platform_data leds
;
100 #define TCA6507_MAKE_GPIO 1
107 static int bank_source
[3] = {
112 static int blink_source
[2] = {
118 #define TCA6507_REG_CNT 11
121 * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output
122 * owns one bit in each register
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
133 #define INIT_CODE 0x8
136 static int time_codes
[TIMECODES
] = {
137 0, 64, 128, 192, 256, 384, 512, 768,
138 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
141 /* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */
142 static inline int TO_LEVEL(int brightness
)
144 return brightness
>> 4;
147 /* ...and convert back */
148 static inline int TO_BRIGHT(int level
)
151 return (level
<< 4) | 0xf;
156 struct 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 */
165 int on_dflt
, off_dflt
;
166 int time_use
, level_use
;
168 struct i2c_client
*client
;
169 struct work_struct work
;
173 struct tca6507_chip
*chip
;
174 struct led_classdev led_cdev
;
177 int on_dflt
, off_dflt
;
178 int bank
; /* Bank used, or -1 */
179 int blink
; /* Set if hardware-blinking */
181 #ifdef CONFIG_GPIOLIB
182 struct gpio_chip gpio
;
183 int gpio_map
[NUM_LEDS
];
187 static const struct i2c_device_id tca6507_id
[] = {
191 MODULE_DEVICE_TABLE(i2c
, tca6507_id
);
193 static int choose_times(int msec
, int *c1p
, int *c2p
)
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
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).
210 int tmax
= msec
* 9 / 8;
211 int tmin
= msec
* 7 / 8;
214 /* We start at '1' to ensure we never even think of choosing a
217 for (c1
= 1; c1
< TIMECODES
; c1
++) {
218 int t
= time_codes
[c1
];
223 for (c2
= 0; c2
<= c1
; c2
++) {
224 int tt
= t
+ time_codes
[c2
];
249 actual
= time_codes
[*c1p
] + time_codes
[*c2p
];
260 * Update the register file with the appropriate 3-bit state for the
263 static void set_select(struct tca6507_chip
*tca
, int led
, int val
)
265 int mask
= (1 << led
);
268 for (bit
= 0; bit
< 3; bit
++) {
269 int n
= tca
->reg_file
[bit
] & ~mask
;
270 if (val
& (1 << bit
))
272 if (tca
->reg_file
[bit
] != n
) {
273 tca
->reg_file
[bit
] = n
;
274 tca
->reg_set
|= (1 << bit
);
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
283 static void set_code(struct tca6507_chip
*tca
, int reg
, int bank
, int new)
291 n
= tca
->reg_file
[reg
] & ~mask
;
293 if (tca
->reg_file
[reg
] != n
) {
294 tca
->reg_file
[reg
] = n
;
295 tca
->reg_set
|= 1 << reg
;
299 /* Update brightness level. */
300 static void set_level(struct tca6507_chip
*tca
, int bank
, int level
)
305 set_code(tca
, TCA6507_MAX_INTENSITY
, bank
, level
);
308 set_code(tca
, TCA6507_MASTER_INTENSITY
, 0, level
);
311 tca
->bank
[bank
].level
= level
;
314 /* Record all relevant time codes for a given bank */
315 static void set_times(struct tca6507_chip
*tca
, int bank
)
320 result
= choose_times(tca
->bank
[bank
].ontime
, &c1
, &c2
);
323 dev_dbg(&tca
->client
->dev
,
324 "Chose on times %d(%d) %d(%d) for %dms\n",
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
;
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",
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
;
341 set_code(tca
, TCA6507_INITIALIZE
, bank
, INIT_CODE
);
344 /* Write all needed register of tca6507 */
346 static void tca6507_work(struct work_struct
*work
)
348 struct tca6507_chip
*tca
= container_of(work
, struct tca6507_chip
,
350 struct i2c_client
*cl
= tca
->client
;
352 u8 file
[TCA6507_REG_CNT
];
355 spin_lock_irq(&tca
->lock
);
357 memcpy(file
, tca
->reg_file
, TCA6507_REG_CNT
);
359 spin_unlock_irq(&tca
->lock
);
361 for (r
= 0; r
< TCA6507_REG_CNT
; r
++)
363 i2c_smbus_write_byte_data(cl
, r
, file
[r
]);
366 static void led_release(struct tca6507_led
*led
)
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
;
380 static int led_prepare(struct tca6507_led
*led
)
382 /* Assign this led to a bank, configuring that bank if
384 int level
= TO_LEVEL(led
->led_cdev
.brightness
);
385 struct tca6507_chip
*tca
= led
->chip
;
391 led
->led_cdev
.brightness
= TO_BRIGHT(level
);
393 set_select(tca
, led
->num
, TCA6507_LS_LED_OFF
);
397 if (led
->ontime
== 0 || led
->offtime
== 0) {
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
404 int best
= -1;/* full-on */
408 set_select(tca
, led
->num
, TCA6507_LS_LED_ON
);
412 for (i
= MASTER
; i
>= BANK0
; i
--) {
414 if (tca
->bank
[i
].level
== level
||
415 tca
->bank
[i
].level_use
== 0) {
419 d
= abs(level
- tca
->bank
[i
].level
);
426 /* Best brightness is full-on */
427 set_select(tca
, led
->num
, TCA6507_LS_LED_ON
);
428 led
->led_cdev
.brightness
= LED_FULL
;
432 if (!tca
->bank
[best
].level_use
)
433 set_level(tca
, best
, level
);
435 tca
->bank
[best
].level_use
++;
437 set_select(tca
, led
->num
, bank_source
[best
]);
438 led
->led_cdev
.brightness
= TO_BRIGHT(tca
->bank
[best
].level
);
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.
447 if (choose_times(led
->ontime
, &c1
, &c2
) < 0)
449 if (choose_times(led
->offtime
, &c1
, &c2
) < 0)
452 for (i
= BANK0
; i
<= BANK1
; i
++) {
453 if (tca
->bank
[i
].level_use
== 0)
454 /* not in use - it is ours! */
456 if (tca
->bank
[i
].level
!= level
)
457 /* Incompatible level - skip */
458 /* FIX: if timer matches we maybe should consider
463 if (tca
->bank
[i
].time_use
== 0)
464 /* Timer not in use, and level matches - use it */
467 if (!(tca
->bank
[i
].on_dflt
||
469 tca
->bank
[i
].ontime
== led
->ontime
))
470 /* on time is incompatible */
473 if (!(tca
->bank
[i
].off_dflt
||
475 tca
->bank
[i
].offtime
== led
->offtime
))
476 /* off time is incompatible */
479 /* looks like a suitable match */
484 /* Nothing matches - how sad */
488 if (b
->level_use
== 0)
489 set_level(tca
, i
, level
);
496 b
->ontime
= led
->ontime
;
497 b
->on_dflt
= led
->on_dflt
;
504 b
->offtime
= led
->offtime
;
505 b
->off_dflt
= led
->off_dflt
;
512 led
->ontime
= b
->ontime
;
513 led
->offtime
= b
->offtime
;
517 led
->led_cdev
.brightness
= TO_BRIGHT(b
->level
);
518 set_select(tca
, led
->num
, blink_source
[i
]);
522 static int led_assign(struct tca6507_led
*led
)
524 struct tca6507_chip
*tca
= led
->chip
;
528 spin_lock_irqsave(&tca
->lock
, flags
);
530 err
= led_prepare(led
);
533 * Can only fail on timer setup. In that case we need
534 * to re-establish as steady level.
540 spin_unlock_irqrestore(&tca
->lock
, flags
);
543 schedule_work(&tca
->work
);
547 static void tca6507_brightness_set(struct led_classdev
*led_cdev
,
548 enum led_brightness brightness
)
550 struct tca6507_led
*led
= container_of(led_cdev
, struct tca6507_led
,
552 led
->led_cdev
.brightness
= brightness
;
558 static int tca6507_blink_set(struct led_classdev
*led_cdev
,
559 unsigned long *delay_on
,
560 unsigned long *delay_off
)
562 struct tca6507_led
*led
= container_of(led_cdev
, struct tca6507_led
,
567 else if (delay_on
!= &led_cdev
->blink_delay_on
)
569 led
->ontime
= *delay_on
;
573 else if (delay_off
!= &led_cdev
->blink_delay_off
)
575 led
->offtime
= *delay_off
;
577 if (led
->ontime
== 0)
579 if (led
->offtime
== 0)
582 if (led
->led_cdev
.brightness
== LED_OFF
)
583 led
->led_cdev
.brightness
= LED_FULL
;
584 if (led_assign(led
) < 0) {
587 led
->led_cdev
.brightness
= LED_OFF
;
590 *delay_on
= led
->ontime
;
591 *delay_off
= led
->offtime
;
595 #ifdef CONFIG_GPIOLIB
596 static void tca6507_gpio_set_value(struct gpio_chip
*gc
,
597 unsigned offset
, int val
)
599 struct tca6507_chip
*tca
= gpiochip_get_data(gc
);
602 spin_lock_irqsave(&tca
->lock
, flags
);
604 * 'OFF' is floating high, and 'ON' is pulled down, so it has
605 * the inverse sense of 'val'.
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
);
611 schedule_work(&tca
->work
);
614 static int tca6507_gpio_direction_output(struct gpio_chip
*gc
,
615 unsigned offset
, int val
)
617 tca6507_gpio_set_value(gc
, offset
, val
);
621 static int tca6507_probe_gpios(struct device
*dev
,
622 struct tca6507_chip
*tca
,
623 struct tca6507_platform_data
*pdata
)
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
;
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
));
649 err
= gpiochip_add_data(&tca
->gpio
, tca
);
657 static void tca6507_remove_gpio(struct tca6507_chip
*tca
)
660 gpiochip_remove(&tca
->gpio
);
662 #else /* CONFIG_GPIOLIB */
663 static int tca6507_probe_gpios(struct device
*dev
,
664 struct tca6507_chip
*tca
,
665 struct tca6507_platform_data
*pdata
)
669 static void tca6507_remove_gpio(struct tca6507_chip
*tca
)
672 #endif /* CONFIG_GPIOLIB */
674 static struct tca6507_platform_data
*
675 tca6507_led_dt_init(struct device
*dev
)
677 struct tca6507_platform_data
*pdata
;
678 struct fwnode_handle
*child
;
679 struct led_info
*tca_leds
;
682 count
= device_get_child_node_count(dev
);
683 if (!count
|| count
> NUM_LEDS
)
684 return ERR_PTR(-ENODEV
);
686 tca_leds
= devm_kcalloc(dev
, NUM_LEDS
, sizeof(struct led_info
),
689 return ERR_PTR(-ENOMEM
);
691 device_for_each_child_node(dev
, child
) {
696 if (fwnode_property_read_string(child
, "label", &led
.name
))
697 led
.name
= fwnode_get_name(child
);
699 fwnode_property_read_string(child
, "linux,default-trigger",
700 &led
.default_trigger
);
703 if (fwnode_property_match_string(child
, "compatible",
705 led
.flags
|= TCA6507_MAKE_GPIO
;
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
);
716 pdata
= devm_kzalloc(dev
, sizeof(struct tca6507_platform_data
),
719 return ERR_PTR(-ENOMEM
);
721 pdata
->leds
.leds
= tca_leds
;
722 pdata
->leds
.num_leds
= NUM_LEDS
;
723 #ifdef CONFIG_GPIOLIB
724 pdata
->gpio_base
= -1;
730 static const struct of_device_id __maybe_unused of_tca6507_leds_match
[] = {
731 { .compatible
= "ti,tca6507", },
734 MODULE_DEVICE_TABLE(of
, of_tca6507_leds_match
);
736 static int tca6507_probe(struct i2c_client
*client
,
737 const struct i2c_device_id
*id
)
739 struct device
*dev
= &client
->dev
;
740 struct i2c_adapter
*adapter
;
741 struct tca6507_chip
*tca
;
742 struct tca6507_platform_data
*pdata
;
746 adapter
= client
->adapter
;
748 if (!i2c_check_functionality(adapter
, I2C_FUNC_I2C
))
751 pdata
= tca6507_led_dt_init(dev
);
753 dev_err(dev
, "Need %d entries in platform-data list\n", NUM_LEDS
);
754 return PTR_ERR(pdata
);
756 tca
= devm_kzalloc(dev
, sizeof(*tca
), GFP_KERNEL
);
760 tca
->client
= client
;
761 INIT_WORK(&tca
->work
, tca6507_work
);
762 spin_lock_init(&tca
->lock
);
763 i2c_set_clientdata(client
, tca
);
765 for (i
= 0; i
< NUM_LEDS
; i
++) {
766 struct tca6507_led
*l
= tca
->leds
+ 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
;
777 err
= led_classdev_register(dev
, &l
->led_cdev
);
782 err
= tca6507_probe_gpios(dev
, tca
, pdata
);
785 /* set all registers to known state - zero */
787 schedule_work(&tca
->work
);
792 if (tca
->leds
[i
].led_cdev
.name
)
793 led_classdev_unregister(&tca
->leds
[i
].led_cdev
);
798 static int tca6507_remove(struct i2c_client
*client
)
801 struct tca6507_chip
*tca
= i2c_get_clientdata(client
);
802 struct tca6507_led
*tca_leds
= tca
->leds
;
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
);
808 tca6507_remove_gpio(tca
);
809 cancel_work_sync(&tca
->work
);
814 static struct i2c_driver tca6507_driver
= {
816 .name
= "leds-tca6507",
817 .of_match_table
= of_match_ptr(of_tca6507_leds_match
),
819 .probe
= tca6507_probe
,
820 .remove
= tca6507_remove
,
821 .id_table
= tca6507_id
,
824 module_i2c_driver(tca6507_driver
);
826 MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
827 MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
828 MODULE_LICENSE("GPL v2");