From 1ec620df7f704788e460da85b655b0d499e90d7e Mon Sep 17 00:00:00 2001 From: edelweiseescala Date: Tue, 28 Oct 2025 15:52:13 +0800 Subject: [PATCH 1/4] dt-bindings: leds: ltc3220: Document LTC3220 18 channel LED Driver Add dt-binding for ltc3220. LTC3220 18 Channel LED driver Signed-off-by: Edelweise Escala --- .../bindings/leds/leds-ltc3220.yaml | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 Documentation/devicetree/bindings/leds/leds-ltc3220.yaml diff --git a/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml b/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml new file mode 100644 index 00000000000000..c275ca1590f604 --- /dev/null +++ b/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml @@ -0,0 +1,134 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/leds/leds-ltc3220.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices LTC3220 LED Drivers + +maintainers: + - Edelweise Escala + +description: Bindings for the Analog Devices LTC3220 18 channel LED Drivers. + + For more product information please see the link below + https://www.analog.com/en/products/ltc3220.html + +properties: + compatible: + enum: + - adi,ltc3220 + - adi,ltc3220-1 + + reg: + maxItems: 1 + + '#address-cells': + const: 1 + + '#size-cells': + const: 0 + + reset-gpios: + maxItems: 1 + description: GPIO attached to the chip's reset pin + + adi,force-cpo-mode: + $ref: /schemas/types.yaml#/definitions/uint32 + description: + Force charge pump operation mode. + 0 = Auto mode (default) - Automatically selects optimal charge pump mode + 1 = 1.5x mode - 1.5x voltage multiplication + 2 = 2x mode - 2x voltage multiplication + 3 = 1x mode - Charge pump bypass + minimum: 0 + maximum: 3 + default: 0 + + adi,quick-write-enable: + type: boolean + description: + Enable quick write mode. When enabled, writing to LED D1 (register 0x01) + will update all 18 LED outputs with the same brightness value. + +patternProperties: + "(^led@([1-9]|1[0-8])$|led)": + type: object + $ref: common.yaml# + unevaluatedProperties: false + properties: + reg: + description: Output channel for the LED. reg value to output to LED output number + enum: + - 1 # LED output D1 + - 2 # LED output D2 + - 3 # LED output D3 + - 4 # LED output D4 + - 5 # LED output D5 + - 6 # LED output D6 + - 7 # LED output D7 + - 8 # LED output D8 + - 9 # LED output D9 + - 10 # LED output D10 + - 11 # LED output D11 + - 12 # LED output D12 + - 13 # LED output D13 + - 14 # LED output D14 + - 15 # LED output D15 + - 16 # LED output D16 + - 17 # LED output D17 + - 18 # LED output D18 + required: + - reg + +required: + - compatible + - reg + +additionalProperties: false + +examples: + - | + #include + #include + + i2c { + #address-cells = <1>; + #size-cells = <0>; + + led-controller@1c { + compatible = "adi,ltc3220"; + reg = <0x1c>; + #address-cells = <1>; + #size-cells = <0>; + reset-gpios = <&gpio 17 GPIO_ACTIVE_LOW>; + adi,force-cpo-mode = <0>; + adi,quick-write-enable; + + led@1 { + reg = <1>; + }; + + led@2 { + reg = <2>; + }; + + led@3 { + reg = <3>; + }; + + led@4 { + reg = <4>; + }; + + led@5 { + reg = <5>; + }; + + led@6 { + reg = <6>; + }; + }; + }; + +... From c9c8754e38ddc1e296c376df1c3ae6994d02861d Mon Sep 17 00:00:00 2001 From: edelweiseescala Date: Tue, 11 Nov 2025 10:44:51 +0800 Subject: [PATCH 2/4] leds: ltc3220: Documentation for Custom ABI Add documentation for different Custom ABI added for LTC3220. Signed-off-by: Edelweise Escala --- .../testing/sysfs-class-led-driver-ltc3220 | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-class-led-driver-ltc3220 diff --git a/Documentation/ABI/testing/sysfs-class-led-driver-ltc3220 b/Documentation/ABI/testing/sysfs-class-led-driver-ltc3220 new file mode 100644 index 00000000000000..8bd6a7029b798d --- /dev/null +++ b/Documentation/ABI/testing/sysfs-class-led-driver-ltc3220 @@ -0,0 +1,26 @@ +What: /sys/class/leds//gradation_period_ms +Date: November 2025 +KernelVersion: 6.19 +Contact: Edelweise Escala +Description: LTC3220 gradation period where: + 0 - disabled + 313 - Ramp time of 0.24s and Period of 0.313s + 625 - Ramp time of 0.48s and Period of 0.625s + 1250 - Ramp time of 0.96s and Period of 1.25s + +What: /sys/class/leds//gradation_mode +Date: November 2025 +KernelVersion: 6.19 +Contact: Edelweise Escala +Description: LTC3220 gradation mode command. This sets if gradation + will ramp up or down. Possible values are: + "ramp_up" + "ramp_down" + +What: /sys/class/leds//gradation_mode_available +Date: November 2025 +KernelVersion: 6.19 +Contact: Edelweise Escala +Description: LTC3220 read only command to show possible gradiation mode such as: + "ramp_up" + "ramp_down" From c6dc5d6f2ff832f1516577484f81a48c8faef29a Mon Sep 17 00:00:00 2001 From: edelweiseescala Date: Tue, 28 Oct 2025 15:57:31 +0800 Subject: [PATCH 3/4] leds: ltc3220: add driver Add driver for ltc3220. LTC3220 18 Channel LED Driver Signed-off-by: Edelweise Escala --- drivers/leds/Kconfig | 10 + drivers/leds/Makefile | 1 + drivers/leds/leds-ltc3220.c | 536 ++++++++++++++++++++++++++++++++++++ 3 files changed, 547 insertions(+) create mode 100644 drivers/leds/leds-ltc3220.c diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig index b784bb74a8378a..af6bb652d6dc65 100644 --- a/drivers/leds/Kconfig +++ b/drivers/leds/Kconfig @@ -931,6 +931,16 @@ config LEDS_LM36274 Say Y to enable the LM36274 LED driver for TI LMU devices. This supports the LED device LM36274. +config LEDS_LTC3220 + tristate "LED Driver for LTC3220/LTC3220-1" + depends on I2C && LEDS_CLASS + help + If you have an 18-Channel LED Driver connected to LTC3220, or LTC3220-1 + say Y here to enable this driver. + + To compile this driver as a module, choose M here: the module will + be called ltc3220. + config LEDS_TPS6105X tristate "LED support for TI TPS6105X" depends on LEDS_CLASS diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile index 18afbb5a23ee5a..530bf81344ba84 100644 --- a/drivers/leds/Makefile +++ b/drivers/leds/Makefile @@ -58,6 +58,7 @@ obj-$(CONFIG_LEDS_LP8501) += leds-lp8501.o obj-$(CONFIG_LEDS_LP8788) += leds-lp8788.o obj-$(CONFIG_LEDS_LP8860) += leds-lp8860.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_MAX8997) += leds-max8997.o diff --git a/drivers/leds/leds-ltc3220.c b/drivers/leds/leds-ltc3220.c new file mode 100644 index 00000000000000..b1bb0f47c8e424 --- /dev/null +++ b/drivers/leds/leds-ltc3220.c @@ -0,0 +1,536 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * LTC3220 18-Channel LED Driver + * + * Copyright 2025 Analog Devices Inc. + * + * Author: Edelweise Escala + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* LTC3220 Registers */ +#define LTC3220_COMMAND 0x00 +#define LTC3220_ULED01 0x01 +#define LTC3220_ULED02 0x02 +#define LTC3220_ULED03 0x03 +#define LTC3220_ULED04 0x04 +#define LTC3220_ULED05 0x05 +#define LTC3220_ULED06 0x06 +#define LTC3220_ULED07 0x07 +#define LTC3220_ULED08 0x08 +#define LTC3220_ULED09 0x09 +#define LTC3220_ULED10 0x0A +#define LTC3220_ULED11 0x0B +#define LTC3220_ULED12 0x0C +#define LTC3220_ULED13 0x0D +#define LTC3220_ULED14 0x0E +#define LTC3220_ULED15 0x0F +#define LTC3220_ULED16 0x10 +#define LTC3220_ULED17 0x11 +#define LTC3220_ULED18 0x12 +#define LTC3220_GRAD_BLINK 0x13 + +#define LTC3220_GRAD_COUNT_UP BIT(0) +#define LTC3220_COMMAND_QUICK_WRITE BIT(0) +#define LTC3220_COMMAND_SHUTDOWN BIT(3) + +#define LTC3220_LED_CURRENT_MASK GENMASK(5, 0) +#define LTC3220_LED_MODE_MASK GENMASK(7, 6) +#define LTC3220_BLINK_MASK GENMASK(4, 3) +#define LTC3220_GRADATION_MASK GENMASK(2, 1) +#define LTC3220_CPO_COMMAND_MASK GENMASK(2, 1) + +#define LTC3220_NUM_LEDS 18 + +struct ltc3220_command_cfg { + bool is_quick_write; + bool is_shutdown; + u8 force_cpo_mode; +}; + +struct ltc3220_uled_cfg { + u8 led_index; + u8 reg_value; + struct led_classdev led_cdev; +}; + +struct ltc3220_grad_cfg { + bool is_increasing; + u8 gradation_period_ms; +}; + +struct ltc3220_state { + u8 blink_mode; + struct i2c_client *client; + struct ltc3220_command_cfg command_cfg; + struct ltc3220_uled_cfg uled_cfg[LTC3220_NUM_LEDS]; + struct ltc3220_grad_cfg grad_cfg; +}; + +static int ltc3220_set_command(struct ltc3220_state *ltc3220_state, + bool is_shutdown) +{ + u8 reg_val; + int ret; + struct i2c_client *client = ltc3220_state->client; + + reg_val = FIELD_PREP(LTC3220_COMMAND_SHUTDOWN, is_shutdown); + reg_val |= FIELD_PREP(LTC3220_CPO_COMMAND_MASK, + ltc3220_state->command_cfg.force_cpo_mode); + reg_val |= FIELD_PREP(LTC3220_COMMAND_QUICK_WRITE, + ltc3220_state->command_cfg.is_quick_write); + ret = i2c_smbus_write_byte_data(client, LTC3220_COMMAND, reg_val); + if (ret < 0) { + dev_err(&client->dev, "Set command fail\n"); + return ret; + } + + ltc3220_state->command_cfg.is_shutdown = is_shutdown; + + return 0; +} + +static int ltc3220_set_led_data(struct led_classdev *led_cdev, + enum led_brightness brightness) +{ + int ret; + int i = 0; + struct ltc3220_state *ltc3220_state; + struct ltc3220_uled_cfg *uled_cfg; + struct device *parent_dev; + struct i2c_client *client; + + if (!led_cdev->dev) + return -ENODEV; + + parent_dev = led_cdev->dev->parent; + if (!parent_dev) + return -ENODEV; + + if (!parent_dev || strcmp(parent_dev->bus->name, "i2c") != 0) + return -ENODEV; + + client = to_i2c_client(parent_dev); + uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + ltc3220_state = i2c_get_clientdata(client); + + ret = i2c_smbus_write_byte_data(client, + LTC3220_ULED01 + uled_cfg->led_index, brightness); + if (ret < 0) + return ret; + + if (ltc3220_state->command_cfg.is_quick_write && uled_cfg->led_index == 0) { + for (i = 0; i < LTC3220_NUM_LEDS; i++) + ltc3220_state->uled_cfg[i].reg_value = brightness; + } else { + uled_cfg->reg_value = brightness; + } + return 0; +} + +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; +} + +static int ltc3220_set_blink_and_gradation(struct ltc3220_state *ltc3220_state, + u8 blink_cfg, u8 gradation_period_ms, bool is_increasing) +{ + u8 reg_val; + int ret; + struct i2c_client *client = ltc3220_state->client; + + reg_val = FIELD_PREP(LTC3220_BLINK_MASK, blink_cfg); + reg_val |= FIELD_PREP(LTC3220_GRADATION_MASK, gradation_period_ms); + reg_val |= FIELD_PREP(LTC3220_GRAD_COUNT_UP, is_increasing); + + ret = i2c_smbus_write_byte_data(client, LTC3220_GRAD_BLINK, reg_val); + if (ret < 0) { + dev_err(&client->dev, "Set blinking and gradation fail\n"); + return ret; + } + + return 0; +} + +/* + * LTC3220 has a global blink configuration that affects all LEDs. + * This implementation allows per-LED blink requests, but the blink timing + * will be shared across all LEDs. The delay values are mapped to the + * hardware's discrete blink rates. + */ +static int ltc3220_blink_set(struct led_classdev *led_cdev, + unsigned long *delay_on, + unsigned long *delay_off) +{ + struct ltc3220_state *ltc3220_state; + struct device *parent_dev; + struct i2c_client *client; + u8 blink_mode; + unsigned long period; + int ret; + + if (!led_cdev->dev || !led_cdev->dev->parent) + return -ENODEV; + + parent_dev = led_cdev->dev->parent; + client = to_i2c_client(parent_dev); + ltc3220_state = i2c_get_clientdata(client); + + if (*delay_on == 0 && *delay_off == 0) { + blink_mode = 1; + *delay_on = 500; + *delay_off = 500; + } else { + period = *delay_on + *delay_off; + + if (period <= 750) { + blink_mode = 0; + *delay_on = 250; + *delay_off = 250; + } else if (period <= 1500) { + blink_mode = 1; + *delay_on = 500; + *delay_off = 500; + } else if (period <= 3000) { + blink_mode = 2; + *delay_on = 1000; + *delay_off = 1000; + } else { + blink_mode = 3; + *delay_on = 2000; + *delay_off = 2000; + } + } + + ret = ltc3220_set_blink_and_gradation(ltc3220_state, + blink_mode, + ltc3220_state->grad_cfg.gradation_period_ms, + ltc3220_state->grad_cfg.is_increasing); + if (ret < 0) + return ret; + + ltc3220_state->blink_mode = blink_mode; + + return 0; +} + +static ssize_t ltc3220_gradation_period_ms_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ltc3220_state *ltc3220_state = dev_get_drvdata(dev); + u16 period_ms; + + switch (ltc3220_state->grad_cfg.gradation_period_ms) { + case 0: + period_ms = 0; + break; + case 1: + period_ms = 313; + break; + case 2: + period_ms = 625; + break; + case 3: + period_ms = 1250; + break; + default: + period_ms = 0; + break; + } + + return sysfs_emit(buf, "%u\n", period_ms); +} + +static ssize_t ltc3220_gradation_period_ms_store(struct device *dev, + struct device_attribute *dev_attr, + const char *buf, size_t size) +{ + u8 hw_value; + int ret; + struct ltc3220_state *ltc3220_state = dev_get_drvdata(dev); + u16 period_ms; + + ret = kstrtou16(buf, 10, &period_ms); + if (ret) + return ret; + + if (period_ms > 1250) + period_ms = 1250; + + if (period_ms == 0) + hw_value = 0; + else if (period_ms <= 313) + hw_value = 1; + else if (period_ms <= 625) + hw_value = 2; + else + hw_value = 3; + + ret = ltc3220_set_blink_and_gradation(ltc3220_state, + ltc3220_state->blink_mode, + hw_value, + ltc3220_state->grad_cfg.is_increasing); + if (ret < 0) + return ret; + + ltc3220_state->grad_cfg.gradation_period_ms = hw_value; + + return size; +} +static DEVICE_ATTR(gradation_period_ms, 0644, + ltc3220_gradation_period_ms_show, + ltc3220_gradation_period_ms_store); + +static ssize_t ltc3220_gradation_mode_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct ltc3220_state *ltc3220_state = dev_get_drvdata(dev); + + return sysfs_emit(buf, "%s\n", + ltc3220_state->grad_cfg.is_increasing ? "ramp_up" : "ramp_down"); +} + +static ssize_t ltc3220_gradation_mode_store(struct device *dev, + struct device_attribute *dev_attr, + const char *buf, size_t size) +{ + bool is_increasing; + int ret; + struct ltc3220_state *ltc3220_state = dev_get_drvdata(dev); + + if (sysfs_streq(buf, "ramp_up")) { + is_increasing = true; + } else if (sysfs_streq(buf, "ramp_down")) { + is_increasing = false; + } else { + dev_err(<c3220_state->client->dev, + "Invalid gradation mode, must be 'ramp_up' or 'ramp_down'\n"); + return -EINVAL; + } + + ret = ltc3220_set_blink_and_gradation(ltc3220_state, + ltc3220_state->blink_mode, + ltc3220_state->grad_cfg.gradation_period_ms, + is_increasing); + if (ret < 0) + return ret; + + ltc3220_state->grad_cfg.is_increasing = is_increasing; + + return size; +} +static DEVICE_ATTR(gradation_mode, 0644, + ltc3220_gradation_mode_show, + ltc3220_gradation_mode_store); + +static ssize_t ltc3220_gradation_mode_available_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "ramp_up ramp_down\n"); +} +static DEVICE_ATTR(gradation_mode_available, 0444, + ltc3220_gradation_mode_available_show, + NULL); + +static struct attribute *device_cfg_attrs[] = { + &dev_attr_gradation_period_ms.attr, + &dev_attr_gradation_mode.attr, + &dev_attr_gradation_mode_available.attr, + NULL +}; + +static const struct attribute_group device_cfg_group = { + .attrs = device_cfg_attrs, +}; + +static void ltc3220_reset_gpio_action(void *data) +{ + struct gpio_desc *reset_gpio = data; + + gpiod_set_value_cansleep(reset_gpio, 0); +} + +static int ltc3220_reset(struct ltc3220_state *ltc3220_state, struct i2c_client *client) +{ + int i; + int ret; + struct gpio_desc *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 to set reset GPIO\n"); + + if (reset_gpio) { + gpiod_set_value_cansleep(reset_gpio, 0); + fsleep(20); + gpiod_set_value_cansleep(reset_gpio, 1); + + ret = devm_add_action_or_reset(&client->dev, ltc3220_reset_gpio_action, reset_gpio); + if (ret) + return ret; + + } else { + ret = ltc3220_set_command(ltc3220_state, 0); + if (ret < 0) + return ret; + + for (i = 0; i < LTC3220_NUM_LEDS; i++) { + ret = i2c_smbus_write_byte_data(client, LTC3220_ULED01 + i, 0); + if (ret < 0) + return ret; + } + + ret = ltc3220_set_blink_and_gradation(ltc3220_state, 0, 0, 0); + if (ret < 0) + return ret; + + } + + return 0; +} + +static void ltc3220_remove(struct i2c_client *client) +{ + struct ltc3220_state *ltc3220_state = i2c_get_clientdata(client); + + ltc3220_set_command(ltc3220_state, true); +} + +static int ltc3220_suspend(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct ltc3220_state *ltc3220_state = i2c_get_clientdata(client); + + return ltc3220_set_command(ltc3220_state, true); +} + +static int ltc3220_resume(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct ltc3220_state *ltc3220_state = i2c_get_clientdata(client); + + return ltc3220_set_command(ltc3220_state, false); +} + +static DEFINE_SIMPLE_DEV_PM_OPS(ltc3220_pm_ops, ltc3220_suspend, ltc3220_resume); + +static int ltc3220_probe(struct i2c_client *client) +{ + u8 i = 0; + int ret; + struct ltc3220_state *ltc3220_state; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA)) { + dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); + return -EIO; + } + + ltc3220_state = devm_kzalloc(&client->dev, sizeof(*ltc3220_state), GFP_KERNEL); + if (!ltc3220_state) + return -ENOMEM; + + ltc3220_state->client = client; + i2c_set_clientdata(client, ltc3220_state); + + ret = ltc3220_reset(ltc3220_state, client); + if (ret) + return ret; + + ret = device_property_read_u8(&client->dev, "adi,force-cpo-mode", + <c3220_state->command_cfg.force_cpo_mode); + if (ret) + ltc3220_state->command_cfg.force_cpo_mode = 0; + + if (ltc3220_state->command_cfg.force_cpo_mode > 3) { + dev_err(&client->dev, + "Invalid adi,force-cpo-mode %u, must be 0-3\n", + ltc3220_state->command_cfg.force_cpo_mode); + return -EINVAL; + } + + ltc3220_state->command_cfg.is_quick_write = + device_property_read_bool(&client->dev, "adi,quick-write-enable"); + + ret = ltc3220_set_command(ltc3220_state, 0); + if (ret < 0) + return ret; + + device_for_each_child_node_scoped(&client->dev, child) { + u32 source; + struct led_init_data init_data = {}; + char label_buffer[32]; + + ret = fwnode_property_read_u32(child, "reg", &source); + if (ret != 0 || !source || source > LTC3220_NUM_LEDS) { + dev_err(&client->dev, "Couldn't read LED address: %d\n", + ret); + return -EINVAL; + } + + /* LED node reg/index/address goes from 1 to 18 */ + i = source - 1; + init_data.fwnode = child; + init_data.devicename = "ltc3220"; + snprintf(label_buffer, sizeof(label_buffer), ":led%d", i); + init_data.default_label = label_buffer; + + ltc3220_state->uled_cfg[i].led_index = i; + ltc3220_state->uled_cfg[i].reg_value = 0; + ltc3220_state->uled_cfg[i].led_cdev.brightness_set_blocking = ltc3220_set_led_data; + ltc3220_state->uled_cfg[i].led_cdev.brightness_get = ltc3220_get_led_data; + ltc3220_state->uled_cfg[i].led_cdev.blink_set = ltc3220_blink_set; + + ret = devm_led_classdev_register_ext(&client->dev, + <c3220_state->uled_cfg[i].led_cdev, + &init_data); + if (ret) { + dev_err(&client->dev, "Fail LED class register\n"); + return ret; + } + } + + ret = devm_device_add_group(&client->dev, &device_cfg_group); + if (ret) { + dev_err(&client->dev, "Failed to create sysfs group\n"); + return ret; + } + + return 0; +} + +static const struct of_device_id ltc3220_of_match[] = { + { .compatible = "adi,ltc3220", }, + { .compatible = "adi,ltc3220-1", }, + { }, +}; +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(<c3220_pm_ops), + }, + .probe = ltc3220_probe, + .remove = ltc3220_remove, +}; + +module_i2c_driver(ltc3220_led_driver); + +MODULE_AUTHOR("Edelweise Escala "); +MODULE_DESCRIPTION("LED driver for LTC3220 controllers"); +MODULE_LICENSE("GPL"); From 5f3c45f3032e2c9456588585eaf39bb86effba47 Mon Sep 17 00:00:00 2001 From: edelweiseescala Date: Tue, 28 Oct 2025 15:59:40 +0800 Subject: [PATCH 4/4] leds: Kconfig.adi: imply ltc3220 Add entry for LTC3220 driver Signed-off-by: Edelweise Escala --- Kconfig.adi | 1 + 1 file changed, 1 insertion(+) diff --git a/Kconfig.adi b/Kconfig.adi index b55ae80169496b..1a83bd4be01e6a 100644 --- a/Kconfig.adi +++ b/Kconfig.adi @@ -71,6 +71,7 @@ config KERNEL_ALL_ADI_DRIVERS imply PMIC_ADP5520 imply PWM_AXI_PWMGEN imply LEDS_ADP5520 + imply LEDS_LTC3220 imply BACKLIGHT_ADP5520 imply BACKLIGHT_ADP8860 imply BACKLIGHT_ADP8870