[PATCH v2 0/2] Add Support for LTC3220 18 Channel LED Driver V2

[PATCH v2 0/2] Add Support for LTC3220 18 Channel LED Driver V2

[Edelweise Escala]

The LTC3220/LTC3220-1 is a multi-display LED driver, which contains a
high-efficiency, low-noise charge pump to provide power to up to
18 LED current sources. The LEDs are individually configurable to
64-step linear brightness control, blinking and gradation control
via 2-wire I2C interface. The blinking and gradation configuration
is shared across all LED.

LTC3220 has a quick write function which allows changing the brightness
on all LEDS simultaneously when the brightness is changed on led 1.
For this we made quick write a device property which user can set on the 
device tree. We would like to know if this approach is alright?
Another way we might want to know is, is it alright to just make a
virtual led for the quick write function. Changing brightness on 
the virtual led will change the brightness for all.

V2 Changelog:
leds-ltc3220.yaml changes
-Fix wrapping on description
-Improve description and commit messge to describe hardware
-Drop ltc3220-1
-Drop charge pump
ltc3220.c changes
-Fix wrapping
-Drop ltc3220-1
-Drop devname_mandatory 

Signed-off-by: Edelweise Escala <edelweise.escala@analog.com>
---
Changes in v2:
- EDITME: describe what is new in this series revision.
- EDITME: use bulletpoints and terse descriptions.
- Link to v1: https://lore.kernel.org/r/20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com

---
Edelweise Escala (2):
      dt-bindings: leds: Add LTC3220 18 channel LED Driver
      leds: ltc3220: Add Support for LTC3220 18 channel LED Driver

 .../devicetree/bindings/leds/leds-ltc3220.yaml     | 120 ++++++
 MAINTAINERS                                        |   8 +
 drivers/leds/Kconfig                               |  10 +
 drivers/leds/Makefile                              |   1 +
 drivers/leds/leds-ltc3220.c                        | 440 +++++++++++++++++++++
 5 files changed, 579 insertions(+)
---
base-commit: 8856d7fe1758937ac528770f552ec58c388c255b
change-id: 20260106-ltc3220-driver-f9ab6cc9d1e4

Best regards,
-- 
Edelweise Escala <edelweise.escala@analog.com>

[PATCH v2 1/2] dt-bindings: leds: Add LTC3220 18 channel LED Driver

[Edelweise Escala]

Document device tree bindings 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>
---
 .../devicetree/bindings/leds/leds-ltc3220.yaml     | 120 +++++++++++++++++++++
 MAINTAINERS                                        |   7 ++
 2 files changed, 127 insertions(+)

diff --git a/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml b/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml
new file mode 100644
index 000000000000..d0af38547b28
--- /dev/null
+++ b/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml
@@ -0,0 +1,120 @@
+# 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 Driver
+
+maintainers:
+  - Edelweise Escala <edelweise.escala@analog.com>
+
+description:
+  The LTC3220 is a multi-display LED driver, which contains a high-efficiency,
+  low-noise charge pump to provide power to up to 18 LED current sources.
+  The LEDs are individually configurable to 64-step linear brightness control,
+  blinking and gradation control via 2-wire I2C interface.
+
+  For more product information please see the link below
+    https://www.analog.com/en/products/ltc3220.html
+
+properties:
+  compatible:
+    const: adi,ltc3220
+
+  reg:
+    maxItems: 1
+
+  '#address-cells':
+    const: 1
+
+  '#size-cells':
+    const: 0
+
+  reset-gpios:
+    maxItems: 1
+
+  adi,quick-write:
+    type: boolean
+    description:
+      Enables the hardware quick-write feature where a write to the LED 1
+      output register simultaneously updates all 18 LED output registers
+      to the same value. Only applicable when LED 1 output is physically
+      present and defined in the device tree.
+
+patternProperties:
+  '^led@([1-9]|1[0-8])$':
+    type: object
+    $ref: /schemas/leds/common.yaml#
+    unevaluatedProperties: false
+    properties:
+      reg:
+        description: Output channel for the LED (1-18 maps to LED outputs D1-D18).
+        minimum: 1
+        maximum: 18
+
+    required:
+      - reg
+
+required:
+  - compatible
+  - reg
+
+additionalProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/gpio/gpio.h>
+    #include <dt-bindings/leds/common.h>
+
+    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,quick-write;
+
+             led@1 {
+                 reg = <1>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <1>;
+             };
+
+             led@2 {
+                 reg = <2>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <2>;
+             };
+
+             led@3 {
+                 reg = <3>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <3>;
+             };
+
+             led@4 {
+                 reg = <4>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <4>;
+             };
+
+             led@5 {
+                 reg = <5>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <5>;
+             };
+
+             led@6 {
+                 reg = <6>;
+                 function = LED_FUNCTION_INDICATOR;
+                 function-enumerator = <6>;
+             };
+        };
+    };
+
+...
diff --git a/MAINTAINERS b/MAINTAINERS
index 327d74ca7ecb..d640c35d1f93 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -14955,6 +14955,13 @@ W:	https://ez.analog.com/linux-software-drivers
 F:	Documentation/devicetree/bindings/iio/temperature/adi,ltc2983.yaml
 F:	drivers/iio/temperature/ltc2983.c
 
+LTC3220 LED DRIVER
+M:	Edelweise Escala <edelweise.escala@analog.com>
+L:	linux-leds@vger.kernel.org
+S:	Maintained
+W:	https://ez.analog.com/linux-software-drivers
+F:	Documentation/devicetree/bindings/leds/leds-ltc3220.yaml
+
 LTC4282 HARDWARE MONITOR DRIVER
 M:	Nuno Sa <nuno.sa@analog.com>
 L:	linux-hwmon@vger.kernel.org

-- 
2.43.0

Re: [PATCH v2 1/2] dt-bindings: leds: Add LTC3220 18 channel LED Driver

[Krzysztof Kozlowski]

On Mon, Jan 12, 2026 at 04:55:54PM +0800, Edelweise Escala wrote:
> Document device tree bindings 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>
> ---

No changelog in the cover letter, no changelog here.

>  .../devicetree/bindings/leds/leds-ltc3220.yaml     | 120 +++++++++++++++++++++
>  MAINTAINERS                                        |   7 ++
>  2 files changed, 127 insertions(+)
> 

> +  adi,quick-write:
> +    type: boolean
> +    description:
> +      Enables the hardware quick-write feature where a write to the LED 1
> +      output register simultaneously updates all 18 LED output registers
> +      to the same value. Only applicable when LED 1 output is physically
> +      present and defined in the device tree.

I have doubts that this works fine. If you define 18 different LED
nodes, each can be controlled by user-space or kernel independently, but
with this property updates to LED 1 would overwrite updates to other
LEDs.

Isn't this then an aggregated LED, so in such case only one LED can be
defined in DT (optionally with 18 led-sources)?

> +
> +patternProperties:
> +  '^led@([1-9]|1[0-8])$':
> +    type: object
> +    $ref: /schemas/leds/common.yaml#
> +    unevaluatedProperties: false
> +    properties:
> +      reg:
> +        description: Output channel for the LED (1-18 maps to LED outputs D1-D18).
> +        minimum: 1
> +        maximum: 18

Best regards,
Krzysztof

RE: [PATCH v2 1/2] dt-bindings: leds: Add LTC3220 18 channel LED Driver

[Escala, Edelweise]

> On Mon, Jan 12, 2026 at 04:55:54PM +0800, Edelweise Escala wrote:
> > Document device tree bindings 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>
> > ---
> 
> No changelog in the cover letter, no changelog here.

Apologies for my mistake in the changelog in the cover letter. For this file this should have been the changelog.
V2 Changelog:
leds-ltc3220.yaml changes
-Fix wrapping on description
-Improve description and commit messge to describe hardware
-Drop ltc3220-1
-Drop adi,force-cpo-level property

> >  .../devicetree/bindings/leds/leds-ltc3220.yaml     | 120
> +++++++++++++++++++++
> >  MAINTAINERS                                        |   7 ++
> >  2 files changed, 127 insertions(+)
> >
> 
> > +  adi,quick-write:
> > +    type: boolean
> > +    description:
> > +      Enables the hardware quick-write feature where a write to the LED 1
> > +      output register simultaneously updates all 18 LED output registers
> > +      to the same value. Only applicable when LED 1 output is physically
> > +      present and defined in the device tree.
> 
> I have doubts that this works fine. If you define 18 different LED nodes, each
> can be controlled by user-space or kernel independently, but with this
> property updates to LED 1 would overwrite updates to other LEDs.
> 
> Isn't this then an aggregated LED, so in such case only one LED can be defined
> in DT (optionally with 18 led-sources)?

Thank you for your feedback. Yes, with quick-write enabled, writing to LED 1 will overwrite the values of all other LEDs. To address this, the driver updates the cached brightness values for all LEDs whenever LED 1 is written, so that reading the brightness from any LED will always return the correct (overwritten) value. Having the property allows LED2-17 to still be used independently, while LED1 acts as a control for all LEDs.

Based on your comments, it would be better to drop the quick-write property from the device tree and binding:
-For the aggregated LED use case, the driver will automatically enable quick-write internally to efficiently update all outputs together.
-For the independent LED use case, if users want to change all LED values simultaneously, they can simply loop through each LED and set the desired value. In this scenario, the hardware quick-write feature is not used and becomes unnecessary.

Would it be useful to provide a runtime configuration (e.g., via sysfs) to allow switching between independent and quick-write modes? Please let me know your thoughts or if you have a preferred approach.

> > +
> > +patternProperties:
> > +  '^led@([1-9]|1[0-8])$':
> > +    type: object
> > +    $ref: /schemas/leds/common.yaml#
> > +    unevaluatedProperties: false
> > +    properties:
> > +      reg:
> > +        description: Output channel for the LED (1-18 maps to LED outputs
> D1-D18).
> > +        minimum: 1
> > +        maximum: 18

Best Regards,
Edelweise Escala

[PATCH v2 2/2] leds: ltc3220: Add Support for LTC3220 18 channel LED Driver

[Edelweise Escala]

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>
---
 MAINTAINERS                 |   1 +
 drivers/leds/Kconfig        |  10 +
 drivers/leds/Makefile       |   1 +
 drivers/leds/leds-ltc3220.c | 440 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 452 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index d640c35d1f93..fda0d2963c4f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -14961,6 +14961,7 @@ L:	linux-leds@vger.kernel.org
 S:	Maintained
 W:	https://ez.analog.com/linux-software-drivers
 F:	Documentation/devicetree/bindings/leds/leds-ltc3220.yaml
+F:	drivers/leds/leds-ltc3220.c
 
 LTC4282 HARDWARE MONITOR DRIVER
 M:	Nuno Sa <nuno.sa@analog.com>
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 597d7a79c988..a1c34b2deded 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -1001,6 +1001,16 @@ 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 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 8fdb45d5b439..5301568d9e00 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -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
diff --git a/drivers/leds/leds-ltc3220.c b/drivers/leds/leds-ltc3220.c
new file mode 100644
index 000000000000..ff92c67c1343
--- /dev/null
+++ b/drivers/leds/leds-ltc3220.c
@@ -0,0 +1,440 @@
+// 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/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+/* LTC3220 Registers */
+#define LTC3220_COMMAND				0x00
+#define LTC3220_ULED(x)				(0x01 + (x))
+#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_NUM_LEDS 18
+
+struct ltc3220_command_cfg {
+	bool quick_write;
+	bool is_shutdown;
+};
+
+struct ltc3220_uled_cfg {
+	struct ltc3220_state *ltc3220_state;
+	struct led_classdev led_cdev;
+	u8 reg_value;
+	u8 led_index;
+};
+
+struct ltc3220_grad_cfg {
+	bool is_increasing;
+	u8 gradation_period_ms;
+};
+
+struct ltc3220_state {
+	struct ltc3220_command_cfg command_cfg;
+	struct ltc3220_uled_cfg uled_cfg[LTC3220_NUM_LEDS];
+	struct ltc3220_grad_cfg grad_cfg;
+	struct i2c_client *client;
+	u8 blink_mode;
+};
+
+static int ltc3220_set_command(struct ltc3220_state *ltc3220_state)
+{
+	struct i2c_client *client = ltc3220_state->client;
+	u8 reg_val;
+
+	reg_val = FIELD_PREP(LTC3220_COMMAND_SHUTDOWN,
+			     ltc3220_state->command_cfg.is_shutdown);
+	reg_val |= FIELD_PREP(LTC3220_COMMAND_QUICK_WRITE,
+			      ltc3220_state->command_cfg.quick_write);
+
+	return i2c_smbus_write_byte_data(client, LTC3220_COMMAND, reg_val);
+}
+
+static int ltc3220_shutdown(struct ltc3220_state *ltc3220_state)
+{
+	int ret;
+
+	ltc3220_state->command_cfg.is_shutdown = true;
+	ret = ltc3220_set_command(ltc3220_state);
+	if (ret < 0)
+		ltc3220_state->command_cfg.is_shutdown = false;
+
+	return ret;
+}
+
+static int ltc3220_resume_from_shutdown(struct ltc3220_state *ltc3220_state)
+{
+	int ret;
+
+	ltc3220_state->command_cfg.is_shutdown = false;
+	ret = ltc3220_set_command(ltc3220_state);
+	if (ret < 0)
+		ltc3220_state->command_cfg.is_shutdown = true;
+
+	return ret;
+}
+
+/*
+ * Set LED brightness and mode.
+ * The brightness value determines both the LED current and operating mode:
+ * 0-63:    Normal mode - LED current from 0-63 (off to full brightness)
+ * 64-127:  Blink mode - LED blinks with current level (brightness - 64)
+ * 128-191: Gradation mode - LED gradually changes brightness (brightness - 128)
+ * 192-255: GPO mode - LED operates as general purpose output (brightness - 192)
+ */
+static int ltc3220_set_led_data(struct led_classdev *led_cdev,
+				enum led_brightness brightness)
+{
+	struct ltc3220_state *ltc3220_state;
+	struct ltc3220_uled_cfg *uled_cfg;
+	int ret;
+	int i;
+
+	uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev);
+	ltc3220_state = uled_cfg->ltc3220_state;
+
+	ret = i2c_smbus_write_byte_data(ltc3220_state->client,
+			LTC3220_ULED(uled_cfg->led_index), brightness);
+	if (ret < 0)
+		return ret;
+
+	uled_cfg->reg_value = brightness;
+
+	/*
+	 * When quick-write is enabled, writing to LED 1 updates all
+	 * LEDs simultaneously via quick-write mode. Update cached values for
+	 * all LEDs to reflect the synchronized state.
+	 */
+	if (ltc3220_state->command_cfg.quick_write && uled_cfg->led_index == 0) {
+		for (i = 0; i < LTC3220_NUM_LEDS; i++)
+			ltc3220_state->uled_cfg[i].reg_value = brightness;
+	}
+
+	return 0;
+}
+
+static enum led_brightness ltc3220_get_led_data(struct led_classdev *led_cdev)
+{
+	struct ltc3220_uled_cfg *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)
+{
+	struct i2c_client *client = ltc3220_state->client;
+	u8 reg_val;
+
+	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);
+
+	return i2c_smbus_write_byte_data(client, LTC3220_GRAD_BLINK, reg_val);
+}
+
+/*
+ * LTC3220 pattern support for hardware-assisted breathing/gradation.
+ * The hardware supports 3 gradation ramp time 240ms, 480ms, 960ms)
+ * and can ramp up or down.
+ *
+ * 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_state *ltc3220_state;
+	struct ltc3220_uled_cfg *uled_cfg;
+	u8 gradation_period;
+	u8 start_brightness;
+	u8 end_brightness;
+	bool is_increasing;
+	int ret;
+
+	if (len != 2)
+		return -EINVAL;
+
+	uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev);
+	ltc3220_state = uled_cfg->ltc3220_state;
+
+	start_brightness = pattern[0].brightness & LTC3220_LED_CURRENT_MASK;
+	end_brightness = pattern[1].brightness & LTC3220_LED_CURRENT_MASK;
+
+	is_increasing = end_brightness > start_brightness;
+
+	if (pattern[0].delta_t == 0)
+		gradation_period = 0;
+	else if (pattern[0].delta_t <= 240)
+		gradation_period = 1;
+	else if (pattern[0].delta_t <= 480)
+		gradation_period = 2;
+	else
+		gradation_period = 3;
+
+	ret = ltc3220_set_blink_and_gradation(ltc3220_state,
+					       ltc3220_state->blink_mode,
+					       gradation_period,
+					       is_increasing);
+	if (ret < 0)
+		return ret;
+
+	ltc3220_state->grad_cfg.gradation_period_ms = gradation_period;
+	ltc3220_state->grad_cfg.is_increasing = is_increasing;
+
+	ret = ltc3220_set_led_data(led_cdev, start_brightness);
+	if (ret < 0)
+		return ret;
+
+	return ltc3220_set_led_data(led_cdev, 128 + end_brightness);
+}
+
+static int ltc3220_pattern_clear(struct led_classdev *led_cdev)
+{
+	struct ltc3220_state *ltc3220_state;
+	struct ltc3220_uled_cfg *uled_cfg;
+	int ret;
+
+	uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev);
+	ltc3220_state = uled_cfg->ltc3220_state;
+
+	ret = ltc3220_set_blink_and_gradation(ltc3220_state,
+					       ltc3220_state->blink_mode,
+					       0, false);
+	if (ret < 0)
+		return ret;
+
+	ltc3220_state->grad_cfg.gradation_period_ms = 0;
+	ltc3220_state->grad_cfg.is_increasing = false;
+
+	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 ltc3220_uled_cfg *uled_cfg;
+	unsigned long period;
+	u8 blink_mode;
+	int ret;
+
+	uled_cfg = container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev);
+	ltc3220_state = uled_cfg->ltc3220_state;
+
+	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 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_state *ltc3220_state, struct i2c_client *client)
+{
+	struct gpio_desc *reset_gpio;
+	int ret;
+	int i;
+
+	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);
+
+		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);
+		if (ret < 0)
+			return ret;
+
+		for (i = 0; i < LTC3220_NUM_LEDS; i++) {
+			ret = i2c_smbus_write_byte_data(client, LTC3220_ULED(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 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_shutdown(ltc3220_state);
+}
+
+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_resume_from_shutdown(ltc3220_state);
+}
+
+static SIMPLE_DEV_PM_OPS(ltc3220_pm_ops, ltc3220_suspend, ltc3220_resume);
+
+static int ltc3220_probe(struct i2c_client *client)
+{
+	struct ltc3220_state *ltc3220_state;
+	u8 i = 0;
+	int ret;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+		return dev_err_probe(&client->dev, -EIO, "SMBUS Byte Data not Supported\n");
+
+	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);
+
+	if (device_property_read_bool(&client->dev, "adi,quick-write"))
+		ltc3220_state->command_cfg.quick_write = true;
+
+	ret = ltc3220_reset(ltc3220_state, client);
+	if (ret)
+		return dev_err_probe(&client->dev, ret, "Failed to reset device\n");
+
+	ret = ltc3220_set_command(ltc3220_state);
+	if (ret < 0)
+		return dev_err_probe(&client->dev, ret, "Failed to set command\n");
+
+	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 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");
+
+		init_data.fwnode = child;
+		init_data.devicename = "ltc3220";
+
+		/* LED node reg/index/address goes from 1 to 18 */
+		i = source - 1;
+		led = &ltc3220_state->uled_cfg[i];
+		led->led_index = i;
+		led->reg_value = 0;
+		led->ltc3220_state = ltc3220_state;
+		led->led_cdev.brightness_set_blocking = ltc3220_set_led_data;
+		led->led_cdev.brightness_get = ltc3220_get_led_data;
+		led->led_cdev.max_brightness = 255;
+		led->led_cdev.blink_set = ltc3220_blink_set;
+		led->led_cdev.pattern_set = ltc3220_pattern_set;
+		led->led_cdev.pattern_clear = ltc3220_pattern_clear;
+
+		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 device\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");

-- 
2.43.0

Re: [PATCH v2 2/2] leds: ltc3220: Add Support for LTC3220 18 channel LED Driver

[kernel test robot]

Hi Edelweise,

kernel test robot noticed the following build warnings:

[auto build test WARNING on 8856d7fe1758937ac528770f552ec58c388c255b]

url:    https://github.com/intel-lab-lkp/linux/commits/Edelweise-Escala/dt-bindings-leds-Add-LTC3220-18-channel-LED-Driver/20260112-170223
base:   8856d7fe1758937ac528770f552ec58c388c255b
patch link:    https://lore.kernel.org/r/20260112-ltc3220-driver-v2-2-d043058fc4df%40analog.com
patch subject: [PATCH v2 2/2] leds: ltc3220: Add Support for LTC3220 18 channel LED Driver
config: sh-allmodconfig (https://download.01.org/0day-ci/archive/20260112/202601122335.DZgiMBky-lkp@intel.com/config)
compiler: sh4-linux-gcc (GCC) 15.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260112/202601122335.DZgiMBky-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202601122335.DZgiMBky-lkp@intel.com/

All warnings (new ones prefixed by >>):

>> drivers/leds/leds-ltc3220.c:348:12: warning: 'ltc3220_resume' defined but not used [-Wunused-function]
     348 | static int ltc3220_resume(struct device *dev)
         |            ^~~~~~~~~~~~~~
>> drivers/leds/leds-ltc3220.c:340:12: warning: 'ltc3220_suspend' defined but not used [-Wunused-function]
     340 | static int ltc3220_suspend(struct device *dev)
         |            ^~~~~~~~~~~~~~~


vim +/ltc3220_resume +348 drivers/leds/leds-ltc3220.c

   339	
 > 340	static int ltc3220_suspend(struct device *dev)
   341	{
   342		struct i2c_client *client = to_i2c_client(dev);
   343		struct ltc3220_state *ltc3220_state = i2c_get_clientdata(client);
   344	
   345		return ltc3220_shutdown(ltc3220_state);
   346	}
   347	
 > 348	static int ltc3220_resume(struct device *dev)
   349	{
   350		struct i2c_client *client = to_i2c_client(dev);
   351		struct ltc3220_state *ltc3220_state = i2c_get_clientdata(client);
   352	
   353		return ltc3220_resume_from_shutdown(ltc3220_state);
   354	}
   355	

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Re: [PATCH v2 0/2] Add Support for LTC3220 18 Channel LED Driver V2

[Krzysztof Kozlowski]

On Mon, Jan 12, 2026 at 04:55:53PM +0800, Edelweise Escala wrote:
> The LTC3220/LTC3220-1 is a multi-display LED driver, which contains a
> high-efficiency, low-noise charge pump to provide power to up to
> 18 LED current sources. The LEDs are individually configurable to
> 64-step linear brightness control, blinking and gradation control
> via 2-wire I2C interface. The blinking and gradation configuration
> is shared across all LED.
> 
> LTC3220 has a quick write function which allows changing the brightness
> on all LEDS simultaneously when the brightness is changed on led 1.
> For this we made quick write a device property which user can set on the 
> device tree. We would like to know if this approach is alright?
> Another way we might want to know is, is it alright to just make a
> virtual led for the quick write function. Changing brightness on 
> the virtual led will change the brightness for all.
> 
> V2 Changelog:
> leds-ltc3220.yaml changes
> -Fix wrapping on description
> -Improve description and commit messge to describe hardware
> -Drop ltc3220-1
> -Drop charge pump
> ltc3220.c changes
> -Fix wrapping
> -Drop ltc3220-1
> -Drop devname_mandatory 
> 
> Signed-off-by: Edelweise Escala <edelweise.escala@analog.com>
> ---
> Changes in v2:
> - EDITME: describe what is new in this series revision.
> - EDITME: use bulletpoints and terse descriptions.

Huh?

> - Link to v1: https://lore.kernel.org/r/20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com

Best regards,
Krzysztof

RE: [PATCH v2 0/2] Add Support for LTC3220 18 Channel LED Driver V2

[Escala, Edelweise]

> Subject: Re: [PATCH v2 0/2] Add Support for LTC3220 18 Channel LED Driver
> V2
> 
> [External]
> 
> On Mon, Jan 12, 2026 at 04:55:53PM +0800, Edelweise Escala wrote:
> > The LTC3220/LTC3220-1 is a multi-display LED driver, which contains a
> > high-efficiency, low-noise charge pump to provide power to up to
> > 18 LED current sources. The LEDs are individually configurable to
> > 64-step linear brightness control, blinking and gradation control via
> > 2-wire I2C interface. The blinking and gradation configuration is
> > shared across all LED.
> >
> > LTC3220 has a quick write function which allows changing the
> > brightness on all LEDS simultaneously when the brightness is changed on
> led 1.
> > For this we made quick write a device property which user can set on
> > the device tree. We would like to know if this approach is alright?
> > Another way we might want to know is, is it alright to just make a
> > virtual led for the quick write function. Changing brightness on the
> > virtual led will change the brightness for all.
> >
> > V2 Changelog:
> > leds-ltc3220.yaml changes
> > -Fix wrapping on description
> > -Improve description and commit messge to describe hardware -Drop
> > ltc3220-1 -Drop charge pump ltc3220.c changes -Fix wrapping -Drop
> > ltc3220-1 -Drop devname_mandatory


Apologies my edit on the cover letter is wrong I wrote the changelog above. But this should be the changelog

> > Signed-off-by: Edelweise Escala <edelweise.escala@analog.com>
> > ---
> > Changes in v2:
> > - EDITME: describe what is new in this series revision.
> > - EDITME: use bulletpoints and terse descriptions.
> 
> Huh?

Best Regards,
Edelweise Escala