github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-09-22 12:44:03 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

leds: ltc3220: Add Support for LTC3220 18 channel LED Driver

Browse Source 
Add driver for the LTC3220 18-channel LED driver
with I2C interface, individual brightness control, and hardware-assisted
blink/gradation features.

Signed-off-by: Edelweise Escala <edelweise.escala@analog.com>
Link: https://patch.msgid.link/20260709-ltc3220-driver-v13-2-9b53237642eb@analog.com
Signed-off-by: Lee Jones <lee@kernel.org>
This commit is contained in:
Edelweise Escala 2026-07-09 08:41:20 +08:00 committed by Lee Jones
parent 3c28d9d0b7
commit 07e028d93a
4 changed files with 601 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MAINTAINERS
View File

@ -15386,6 +15386,7 @@ L: linux-leds@vger.kernel.org
S: Maintained
W: https://ez.analog.com/linux-software-drivers
F: Documentation/devicetree/bindings/leds/adi,ltc3220.yaml
F: drivers/leds/leds-ltc3220.c
LTC4282 HARDWARE MONITOR DRIVER
M: Nuno Sa <nuno.sa@analog.com>

13
drivers/leds/Kconfig
View File

@ -1000,6 +1000,19 @@ config LEDS_ST1202
Say Y to enable support for LEDs connected to LED1202
LED driver chips accessed via the I2C bus.
config LEDS_LTC3220
tristate "LED Driver for Analog Devices Inc. LTC3220"
depends on I2C && LEDS_CLASS
select REGMAP_I2C
help
Say Y to enable support for the Analog Devices LTC3220
18-channel LED controller with I2C interface.
The driver supports individual LED brightness control (64 steps),
hardware-assisted blinking and gradation effects.
To compile this driver as a module, choose M here: the module will
be called leds-ltc3220.
config LEDS_TPS6105X
tristate "LED support for TI TPS6105X"
depends on LEDS_CLASS

1
drivers/leds/Makefile
View File

@ -61,6 +61,7 @@ obj-$(CONFIG_LEDS_LP8788) += leds-lp8788.o
obj-$(CONFIG_LEDS_LP8860) += leds-lp8860.o
obj-$(CONFIG_LEDS_LP8864) += leds-lp8864.o
obj-$(CONFIG_LEDS_LT3593) += leds-lt3593.o
obj-$(CONFIG_LEDS_LTC3220) += leds-ltc3220.o
obj-$(CONFIG_LEDS_MAX5970) += leds-max5970.o
obj-$(CONFIG_LEDS_MAX77650) += leds-max77650.o
obj-$(CONFIG_LEDS_MAX77705) += leds-max77705.o

586
drivers/leds/leds-ltc3220.c Normal file
View File

@ -0,0 +1,586 @@
// SPDX-License-Identifier: GPL-2.0
/*
* LTC3220 18-Channel LED Driver
*
* Copyright 2026 Analog Devices Inc.
*
* Author: Edelweise Escala <edelweise.escala@analog.com>
*/
#include <linux/bitfield.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/types.h>
/* LTC3220 Registers */
#define LTC3220_COMMAND_REG 0x00
#define LTC3220_QUICK_WRITE_MASK BIT(0)
#define LTC3220_SHUTDOWN_MASK BIT(3)
#define LTC3220_ULED_REG(x) (0x01 + (x))
#define LTC3220_LED_CURRENT_MASK GENMASK(5, 0)
#define LTC3220_LED_MODE_MASK GENMASK(7, 6)
#define LTC3220_GRAD_BLINK_REG 0x13
#define LTC3220_GRADATION_MASK GENMASK(2, 0)
#define LTC3220_GRADATION_DIRECTION_MASK BIT(0)
#define LTC3220_GRADATION_PERIOD_MASK GENMASK(2, 1)
#define LTC3220_BLINK_MASK GENMASK(4, 3)
#define LTC3220_NUM_LEDS 18
#define LTC3220_MAX_BRIGHTNESS 63
#define LTC3220_GRADATION_RAMP_TIME_240MS 240
#define LTC3220_GRADATION_RAMP_TIME_480MS 480
#define LTC3220_BLINK_ON_156MS 156
#define LTC3220_BLINK_ON_625MS 625
#define LTC3220_BLINK_PERIOD_1250MS 1250
#define LTC3220_BLINK_PERIOD_2500MS 2500
#define LTC3220_BLINK_SHORT_ON_TIME BIT(0)
#define LTC3220_BLINK_LONG_PERIOD BIT(1)
enum ltc3220_led_mode {
LTC3220_NORMAL_MODE,
LTC3220_BLINK_MODE,
LTC3220_GRADATION_MODE,
};
enum ltc3220_blink_mode {
LTC3220_BLINK_MODE_625MS_1250MS,
LTC3220_BLINK_MODE_156MS_1250MS,
LTC3220_BLINK_MODE_625MS_2500MS,
LTC3220_BLINK_MODE_156MS_2500MS
};
enum ltc3220_gradation_mode {
LTC3220_GRADATION_MODE_DISABLED,
LTC3220_GRADATION_MODE_240MS_RAMP_TIME,
LTC3220_GRADATION_MODE_480MS_RAMP_TIME,
LTC3220_GRADATION_MODE_960MS_RAMP_TIME
};
static const struct regmap_config ltc3220_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = LTC3220_GRAD_BLINK_REG,
.cache_type = REGCACHE_FLAT_S,
};
struct ltc3220_uled_cfg {
struct led_classdev led_cdev;
u8 reg_value;
u8 led_index;
bool registered;
};
struct ltc3220 {
struct ltc3220_uled_cfg uled_cfg[LTC3220_NUM_LEDS];
struct regmap *regmap;
struct mutex lock;
};
/*
* Set LED brightness. Hardware supports 0-63 brightness levels.
* Mode switching (blink/gradation) is handled through dedicated callbacks.
*
* In aggregated mode only a single LED (reg = 1) is registered and the
* hardware quick-write feature propagates the write to all 18 channels, so
* there is no need to update the other registers explicitly.
*/
static int __ltc3220_set_led_data(struct ltc3220 *ltc3220,
struct ltc3220_uled_cfg *uled_cfg,
enum led_brightness brightness)
{
int ret;
brightness &= LTC3220_LED_CURRENT_MASK;
ret = regmap_write(ltc3220->regmap, LTC3220_ULED_REG(uled_cfg->led_index),
brightness);
if (ret)
return ret;
uled_cfg->reg_value = brightness;
return 0;
}
static int ltc3220_set_led_data(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct ltc3220_uled_cfg *uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg,
led_cdev);
struct ltc3220 *ltc3220 = container_of(uled_cfg - uled_cfg->led_index, struct ltc3220,
uled_cfg[0]);
int ret;
mutex_lock(&ltc3220->lock);
ret = __ltc3220_set_led_data(ltc3220, uled_cfg, brightness);
mutex_unlock(&ltc3220->lock);
return ret;
}
static enum led_brightness ltc3220_get_led_data(struct led_classdev *led_cdev)
{
struct ltc3220_uled_cfg *uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg,
led_cdev);
return uled_cfg->reg_value;
}
/*
* LTC3220 pattern support for hardware-assisted breathing/gradation.
* The hardware supports 3 gradation ramp times (240ms, 480ms, 960ms)
* and can ramp up or down. The gradation period and direction are chip-global
* registers (LTC3220_GRAD_BLINK_REG), affecting all 18 channels simultaneously.
* This is a hardware limitation, not a driver bug.
*
* Pattern array interpretation:
* pattern[0].brightness = start brightness (0-63)
* pattern[0].delta_t = ramp time in milliseconds
* pattern[1].brightness = end brightness (0-63)
* pattern[1].delta_t = (optional, can be 0 or same as pattern[0].delta_t)
*/
static int ltc3220_pattern_set(struct led_classdev *led_cdev,
struct led_pattern *pattern,
u32 len, int repeat)
{
struct ltc3220_uled_cfg *uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg,
led_cdev);
struct ltc3220 *ltc3220 = container_of(uled_cfg - uled_cfg->led_index, struct ltc3220,
uled_cfg[0]);
u8 gradation_period;
u8 start_brightness;
u8 end_brightness;
u8 gradation_val;
u8 led_mode;
bool is_increasing;
int ret;
if (len != 2)
return -EINVAL;
start_brightness = clamp_val(pattern[0].brightness, 0, LTC3220_LED_CURRENT_MASK);
end_brightness = clamp_val(pattern[1].brightness, 0, LTC3220_LED_CURRENT_MASK);
is_increasing = end_brightness > start_brightness;
if (pattern[0].delta_t == 0)
gradation_period = LTC3220_GRADATION_MODE_DISABLED;
else if (pattern[0].delta_t <= LTC3220_GRADATION_RAMP_TIME_240MS)
gradation_period = LTC3220_GRADATION_MODE_240MS_RAMP_TIME;
else if (pattern[0].delta_t <= LTC3220_GRADATION_RAMP_TIME_480MS)
gradation_period = LTC3220_GRADATION_MODE_480MS_RAMP_TIME;
else
gradation_period = LTC3220_GRADATION_MODE_960MS_RAMP_TIME;
gradation_val = FIELD_PREP(LTC3220_GRADATION_PERIOD_MASK, gradation_period);
gradation_val |= FIELD_PREP(LTC3220_GRADATION_DIRECTION_MASK, is_increasing);
/*
* With the ramp disabled (delta_t == 0) there is no gradation to run,
* so apply the end brightness directly in NORMAL mode instead of
* leaving the channel in gradation mode with a disabled ramp.
*/
led_mode = gradation_period == LTC3220_GRADATION_MODE_DISABLED ?
LTC3220_NORMAL_MODE : LTC3220_GRADATION_MODE;
mutex_lock(&ltc3220->lock);
ret = regmap_update_bits(ltc3220->regmap, LTC3220_GRAD_BLINK_REG,
LTC3220_GRADATION_MASK, gradation_val);
if (ret)
goto unlock;
if (led_mode == LTC3220_GRADATION_MODE) {
ret = regmap_write(ltc3220->regmap, LTC3220_ULED_REG(uled_cfg->led_index),
start_brightness & LTC3220_LED_CURRENT_MASK);
if (ret)
goto unlock;
ret = regmap_write(ltc3220->regmap, LTC3220_ULED_REG(uled_cfg->led_index),
FIELD_PREP(LTC3220_LED_MODE_MASK, led_mode) |
(end_brightness & LTC3220_LED_CURRENT_MASK));
if (ret)
goto unlock;
uled_cfg->reg_value = end_brightness;
} else {
ret = __ltc3220_set_led_data(ltc3220, uled_cfg, end_brightness);
if (ret)
goto unlock;
}
unlock:
mutex_unlock(&ltc3220->lock);
return ret;
}
static int ltc3220_pattern_clear(struct led_classdev *led_cdev)
{
struct ltc3220_uled_cfg *uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg,
led_cdev);
struct ltc3220 *ltc3220 = container_of(uled_cfg - uled_cfg->led_index, struct ltc3220,
uled_cfg[0]);
int ret;
mutex_lock(&ltc3220->lock);
ret = regmap_update_bits(ltc3220->regmap, LTC3220_ULED_REG(uled_cfg->led_index),
LTC3220_LED_MODE_MASK, LTC3220_NORMAL_MODE);
if (ret)
goto unlock;
ret = __ltc3220_set_led_data(ltc3220, uled_cfg, LED_OFF);
unlock:
mutex_unlock(&ltc3220->lock);
return ret;
}
/*
* LTC3220 has a global blink configuration that affects all LEDs.
* This implementation allows per-LED blink requests via sysfs, but setting
* blink on any LED reprograms the timing for all 18 channels simultaneously.
* The delay values are mapped to the hardware's discrete blink rates.
*
* HARDWARE LIMITATION: This is not a driver bug. Per-LED blink timing control
* is not possible with this hardware due to the global blink register.
*/
static int ltc3220_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on,
unsigned long *delay_off)
{
struct ltc3220_uled_cfg *uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg,
led_cdev);
struct ltc3220 *ltc3220 = container_of(uled_cfg - uled_cfg->led_index, struct ltc3220,
uled_cfg[0]);
u8 blink_brightness;
u8 blink_mode = 0;
int ret;
if (*delay_on <= LTC3220_BLINK_ON_156MS)
blink_mode = LTC3220_BLINK_SHORT_ON_TIME;
if (*delay_on + *delay_off > LTC3220_BLINK_PERIOD_1250MS)
blink_mode |= LTC3220_BLINK_LONG_PERIOD;
switch (blink_mode) {
case LTC3220_BLINK_MODE_625MS_1250MS:
*delay_on = LTC3220_BLINK_ON_625MS;
*delay_off = LTC3220_BLINK_PERIOD_1250MS - LTC3220_BLINK_ON_625MS;
break;
case LTC3220_BLINK_MODE_156MS_1250MS:
*delay_on = LTC3220_BLINK_ON_156MS;
*delay_off = LTC3220_BLINK_PERIOD_1250MS - LTC3220_BLINK_ON_156MS;
break;
case LTC3220_BLINK_MODE_625MS_2500MS:
*delay_on = LTC3220_BLINK_ON_625MS;
*delay_off = LTC3220_BLINK_PERIOD_2500MS - LTC3220_BLINK_ON_625MS;
break;
case LTC3220_BLINK_MODE_156MS_2500MS:
*delay_on = LTC3220_BLINK_ON_156MS;
*delay_off = LTC3220_BLINK_PERIOD_2500MS - LTC3220_BLINK_ON_156MS;
break;
}
mutex_lock(&ltc3220->lock);
ret = regmap_update_bits(ltc3220->regmap, LTC3220_GRAD_BLINK_REG,
LTC3220_BLINK_MASK, FIELD_PREP(LTC3220_BLINK_MASK, blink_mode));
if (ret)
goto unlock;
blink_brightness = uled_cfg->reg_value ? : led_cdev->max_brightness;
ret = regmap_write(ltc3220->regmap, LTC3220_ULED_REG(uled_cfg->led_index),
FIELD_PREP(LTC3220_LED_MODE_MASK, LTC3220_BLINK_MODE) |
(blink_brightness & LTC3220_LED_CURRENT_MASK));
if (ret)
goto unlock;
uled_cfg->reg_value = blink_brightness;
unlock:
mutex_unlock(&ltc3220->lock);
return ret;
}
static void ltc3220_reset_gpio_action(void *data)
{
struct gpio_desc *reset_gpio = data;
gpiod_set_value_cansleep(reset_gpio, 1);
}
static int ltc3220_reset(struct ltc3220 *ltc3220, struct i2c_client *client)
{
struct gpio_desc *reset_gpio;
int ret;
reset_gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(reset_gpio))
return dev_err_probe(&client->dev, PTR_ERR(reset_gpio), "Failed on reset GPIO\n");
if (reset_gpio) {
usleep_range(10000, 12000);
gpiod_set_value_cansleep(reset_gpio, 0);
usleep_range(10000, 12000);
ret = devm_add_action_or_reset(&client->dev, ltc3220_reset_gpio_action,
reset_gpio);
if (ret)
return ret;
}
ret = regmap_write(ltc3220->regmap, LTC3220_COMMAND_REG, 0);
if (ret)
return ret;
for (int i = 0; i < LTC3220_NUM_LEDS; i++) {
ret = regmap_write(ltc3220->regmap, LTC3220_ULED_REG(i), 0);
if (ret)
return ret;
}
return regmap_write(ltc3220->regmap, LTC3220_GRAD_BLINK_REG, 0);
}
static int ltc3220_suspend(struct device *dev)
{
struct ltc3220 *ltc3220 = i2c_get_clientdata(to_i2c_client(dev));
int ret;
ret = regmap_update_bits(ltc3220->regmap, LTC3220_COMMAND_REG,
LTC3220_SHUTDOWN_MASK, LTC3220_SHUTDOWN_MASK);
if (ret)
return ret;
regcache_mark_dirty(ltc3220->regmap);
return 0;
}
static int ltc3220_resume(struct device *dev)
{
struct ltc3220 *ltc3220 = i2c_get_clientdata(to_i2c_client(dev));
bool quick_write_enabled;
unsigned int command_reg;
int ret;
ret = regmap_read(ltc3220->regmap, LTC3220_COMMAND_REG, &command_reg);
if (ret)
return ret;
quick_write_enabled = command_reg & LTC3220_QUICK_WRITE_MASK;
if (quick_write_enabled) {
ret = regmap_update_bits(ltc3220->regmap, LTC3220_COMMAND_REG,
LTC3220_QUICK_WRITE_MASK, 0);
if (ret)
return ret;
}
ret = regmap_update_bits(ltc3220->regmap, LTC3220_COMMAND_REG,
LTC3220_SHUTDOWN_MASK, 0);
if (ret)
return ret;
usleep_range(10000, 12000);
ret = regcache_sync(ltc3220->regmap);
if (ret)
return ret;
if (quick_write_enabled) {
ret = regmap_update_bits(ltc3220->regmap, LTC3220_COMMAND_REG,
LTC3220_QUICK_WRITE_MASK,
LTC3220_QUICK_WRITE_MASK);
if (ret)
return ret;
}
return 0;
}
static DEFINE_SIMPLE_DEV_PM_OPS(ltc3220_pm_ops, ltc3220_suspend, ltc3220_resume);
static int ltc3220_probe(struct i2c_client *client)
{
struct ltc3220 *ltc3220;
bool aggregated_led_found = false;
int num_leds = 0;
u8 led_index = 0;
int ret;
ltc3220 = devm_kzalloc(&client->dev, sizeof(*ltc3220), GFP_KERNEL);
if (!ltc3220)
return -ENOMEM;
ltc3220->regmap = devm_regmap_init_i2c(client, &ltc3220_regmap_config);
if (IS_ERR(ltc3220->regmap))
return dev_err_probe(&client->dev, PTR_ERR(ltc3220->regmap),
"Failed to initialize regmap\n");
ret = devm_mutex_init(&client->dev, &ltc3220->lock);
if (ret)
return ret;
i2c_set_clientdata(client, ltc3220);
ret = ltc3220_reset(ltc3220, client);
if (ret)
return dev_err_probe(&client->dev, ret, "Failed to reset device\n");
/* First pass: validate configuration and set up LED structures */
device_for_each_child_node_scoped(&client->dev, child) {
struct ltc3220_uled_cfg *led;
u32 source;
ret = fwnode_property_read_u32(child, "reg", &source);
if (ret)
return dev_err_probe(&client->dev, ret, "Couldn't read LED address\n");
if (!source || source > LTC3220_NUM_LEDS)
return dev_err_probe(&client->dev, -EINVAL, "LED address out of range\n");
if (fwnode_property_present(child, "led-sources")) {
u32 led_sources[LTC3220_NUM_LEDS];
int count;
if (source != 1)
return dev_err_probe(&client->dev, -EINVAL,
"Aggregated LED out of range\n");
if (aggregated_led_found)
return dev_err_probe(&client->dev, -EINVAL,
"One Aggregated LED only\n");
count = fwnode_property_count_u32(child, "led-sources");
if (count != LTC3220_NUM_LEDS)
return dev_err_probe(&client->dev, -EINVAL,
"Aggregated mode requires all %d outputs in led-sources, got %d\n",
LTC3220_NUM_LEDS, count);
ret = fwnode_property_read_u32_array(child, "led-sources",
led_sources, LTC3220_NUM_LEDS);
if (ret)
return dev_err_probe(&client->dev, ret,
"Failed to read led-sources array\n");
/*
* Validate array contents for DT correctness. The hardware
* quick-write broadcasts to all 18 channels regardless of
* array contents, but checking helps catch DT mistakes.
*/
for (int i = 0; i < LTC3220_NUM_LEDS; i++) {
if (led_sources[i] < 1 || led_sources[i] > LTC3220_NUM_LEDS)
return dev_err_probe(&client->dev, -EINVAL,
"Invalid output %u in led-sources\n",
led_sources[i]);
}
aggregated_led_found = true;
}
num_leds++;
/* LED node reg/index/address goes from 1 to 18 */
led_index = source - 1;
led = &ltc3220->uled_cfg[led_index];
if (led->registered)
return dev_err_probe(&client->dev, -EINVAL,
"Duplicate LED reg %u found\n", source);
led->registered = true;
led->led_index = led_index;
led->reg_value = 0;
led->led_cdev.brightness_set_blocking = ltc3220_set_led_data;
led->led_cdev.brightness_get = ltc3220_get_led_data;
led->led_cdev.max_brightness = LTC3220_MAX_BRIGHTNESS;
led->led_cdev.blink_set = ltc3220_blink_set;
led->led_cdev.pattern_set = ltc3220_pattern_set;
led->led_cdev.pattern_clear = ltc3220_pattern_clear;
}
/*
* Aggregated LED mode uses hardware quick-write to control all 18 LEDs
* simultaneously. This is mutually exclusive with individual LED control.
* See Documentation/devicetree/bindings/leds/adi,ltc3220.yaml for details
* on how to configure aggregated LED mode.
*/
if (aggregated_led_found && num_leds > 1)
return dev_err_probe(&client->dev, -EINVAL,
"Aggregated LED must be the only LED node\n");
if (num_leds == 0)
return dev_err_probe(&client->dev, -EINVAL,
"No LED nodes found in device tree\n");
if (aggregated_led_found) {
ret = regmap_update_bits(ltc3220->regmap,
LTC3220_COMMAND_REG,
LTC3220_QUICK_WRITE_MASK,
LTC3220_QUICK_WRITE_MASK);
if (ret)
return dev_err_probe(&client->dev, ret,
"Failed to set quick write mode\n");
}
/* Second pass: register LEDs after validation */
device_for_each_child_node_scoped(&client->dev, child) {
struct led_init_data init_data = {};
struct ltc3220_uled_cfg *led;
u32 source;
ret = fwnode_property_read_u32(child, "reg", &source);
if (ret)
return ret;
if (!source || source > LTC3220_NUM_LEDS)
return dev_err_probe(&client->dev, -EINVAL,
"LED address out of range in second pass\n");
init_data.fwnode = child;
init_data.devicename = "ltc3220";
led_index = source - 1;
led = &ltc3220->uled_cfg[led_index];
ret = devm_led_classdev_register_ext(&client->dev, &led->led_cdev, &init_data);
if (ret)
return dev_err_probe(&client->dev, ret, "Failed to register LED class\n");
}
return 0;
}
static const struct of_device_id ltc3220_of_match[] = {
{ .compatible = "adi,ltc3220" },
{ }
};
MODULE_DEVICE_TABLE(of, ltc3220_of_match);
static struct i2c_driver ltc3220_led_driver = {
.driver = {
.name = "ltc3220",
.of_match_table = ltc3220_of_match,
.pm = pm_sleep_ptr(&ltc3220_pm_ops),
},
.probe = ltc3220_probe,
};
module_i2c_driver(ltc3220_led_driver);
MODULE_AUTHOR("Edelweise Escala <edelweise.escala@analog.com>");
MODULE_DESCRIPTION("LED driver for LTC3220 controllers");
MODULE_LICENSE("GPL");