From: Lee Jones <lee@kernel.org>
To: Daniil Demakov <t3127430@gmail.com>
Cc: linux-leds@vger.kernel.org, pavel@kernel.org,
linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH v4] leds: pca9532: Propagate I2C errors
Date: Mon, 16 Nov 2026 12:43:45 +0000 [thread overview]
Message-ID: <20261116124345.GN6323@joneslee-macbookpro.roam.internal> (raw)
In-Reply-To: <20261114185201.30519-1-t3127430@gmail.com>
INTENTIONAL TOP POST
Submitting patches as reply-to gets real confusing, real fast.
Please resubmit the latest version as an orthogonal patch/set.
On Sat, 14 Nov 2026, Daniil Demakov wrote:
> Check return values from SMBus read and write operations and
> propagate errors through LED, PWM, blink and GPIO operations.
>
> Restore previous LED and PWM state when hardware updates fail.
> Protect shared LED and PWM state with the update mutex.
>
> Check register writes during device initialization and register
> LED class devices only after successfully configuring the hardware.
>
> Signed-off-by: Daniil Demakov <t3127430@gmail.com>
> ---
> drivers/leds/leds-pca9532.c | 336 +++++++++++++++++++++++++++++-------
> 1 file changed, 270 insertions(+), 66 deletions(-)
>
> diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
> index c8085427696f..19b993d9ac9f 100644
> --- a/drivers/leds/leds-pca9532.c
> +++ b/drivers/leds/leds-pca9532.c
> @@ -14,6 +14,7 @@
> #include <linux/leds.h>
> #include <linux/input.h>
> #include <linux/mutex.h>
> +#include <linux/spinlock.h>
> #include <linux/workqueue.h>
> #include <linux/leds-pca9532.h>
> #include <linux/gpio/driver.h>
> @@ -42,6 +43,9 @@ struct pca9532_data {
> struct i2c_client *client;
> struct pca9532_led leds[16];
> struct mutex update_lock;
> + /* Protects beep_pwm between the event callback and workqueue. */
> + spinlock_t beep_lock;
> + u8 beep_pwm;
> struct input_dev *idev;
> struct work_struct work;
> #ifdef CONFIG_LEDS_PCA9532_GPIO
> @@ -144,68 +148,147 @@ static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
> return 0;
> }
>
> -static int pca9532_setpwm(struct i2c_client *client, int pwm)
> +static int __pca9532_setpwm(struct i2c_client *client, int pwm)
> {
> struct pca9532_data *data = i2c_get_clientdata(client);
> u8 maxleds = data->chip_info->num_leds;
> + int ret;
>
> - mutex_lock(&data->update_lock);
> - i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),
> - data->pwm[pwm]);
> - i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),
> - data->psc[pwm]);
> - mutex_unlock(&data->update_lock);
> - return 0;
> -}
> + if (pwm < 0 || pwm > 1)
> + return -EINVAL;
> +
> + ret = i2c_smbus_write_byte_data(client,
> + PCA9532_REG_PWM(maxleds, pwm),
> + data->pwm[pwm]);
> + if (ret < 0) {
> + dev_warn(&client->dev,
> + "Failed to write PWM register: %d\n", ret);
> + return ret;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client,
> + PCA9532_REG_PSC(maxleds, pwm),
> + data->psc[pwm]);
> + if (ret < 0)
> + dev_warn(&client->dev,
> + "Failed to write PSC register: %d\n", ret);
>
> + return ret;
> +}
> /* Set LED routing */
> -static void pca9532_setled(struct pca9532_led *led)
> +static int __pca9532_setled(struct pca9532_led *led)
> {
> struct i2c_client *client = led->client;
> struct pca9532_data *data = i2c_get_clientdata(client);
> u8 maxleds = data->chip_info->num_leds;
> - char reg;
> + int reg;
> + int ret;
>
> - mutex_lock(&data->update_lock);
> reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
> + if (reg < 0) {
> + ret = reg;
> + dev_warn(&client->dev, "Failed to read LED register: %d\n", ret);
> + return ret;
> + }
> +
> /* zero led bits */
> - reg = reg & ~LED_MASK(led->id);
> + reg &= ~LED_MASK(led->id);
> +
> /* set the new value */
> - reg = reg | (led->state << LED_SHIFT(led->id));
> - i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);
> + reg |= led->state << LED_SHIFT(led->id);
> +
> + ret = i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);
> +
> + if (ret < 0)
> + dev_warn(&client->dev, "Failed to write LED register: %d\n", ret);
> +
> + return ret;
> +}
> +
> +static int pca9532_setled(struct pca9532_led *led)
> +{
> + struct pca9532_data *data = i2c_get_clientdata(led->client);
> + int ret;
> +
> + mutex_lock(&data->update_lock);
> + ret = __pca9532_setled(led);
> mutex_unlock(&data->update_lock);
> +
> + return ret;
> }
>
> static int pca9532_set_brightness(struct led_classdev *led_cdev,
> - enum led_brightness value)
> + enum led_brightness value)
> {
> - int err = 0;
> struct pca9532_led *led = ldev_to_led(led_cdev);
> + struct pca9532_data *data = i2c_get_clientdata(led->client);
> + int old_state;
> + u8 old_pwm;
> + u8 old_psc;
> + bool pwm_updated = false;
> + int restore_err;
> + int err = 0;
> +
> + mutex_lock(&data->update_lock);
> + old_state = led->state;
> + old_pwm = data->pwm[PCA9532_PWM_ID_0];
> + old_psc = data->psc[PCA9532_PWM_ID_0];
>
> if (value == LED_OFF) {
> led->state = PCA9532_OFF;
> } else if (led->state == PCA9532_PWM1) {
> - return 0; /* Non-zero brightness shall not stop HW blinking */
> + goto out;
> } else if (value == LED_FULL) {
> led->state = PCA9532_ON;
> } else {
> - led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
> - err = pca9532_calcpwm(led->client, PCA9532_PWM_ID_0, 0, value);
> + led->state = PCA9532_PWM0;
> + err = pca9532_calcpwm(led->client, PCA9532_PWM_ID_0,
> + 0, value);
> if (err)
> - return err;
> + goto restore_state;
> + }
> +
> + if (led->state == PCA9532_PWM0) {
> + pwm_updated = true;
> + err = __pca9532_setpwm(led->client, PCA9532_PWM_ID_0);
> + if (err < 0)
> + goto restore_state;
> }
> - if (led->state == PCA9532_PWM0)
> - pca9532_setpwm(led->client, PCA9532_PWM_ID_0);
> - pca9532_setled(led);
> +
> + err = __pca9532_setled(led);
> + if (err < 0)
> + goto restore_state;
> +
> + goto out;
> +
> +restore_state:
> + led->state = old_state;
> + data->pwm[PCA9532_PWM_ID_0] = old_pwm;
> + data->psc[PCA9532_PWM_ID_0] = old_psc;
> +
> + if (pwm_updated) {
> + restore_err = __pca9532_setpwm(led->client,
> + PCA9532_PWM_ID_0);
> + if (restore_err < 0)
> + dev_warn(&led->client->dev,
> + "Failed to restore PWM settings: %d\n",
> + restore_err);
> + }
> +out:
> + mutex_unlock(&data->update_lock);
> return err;
> }
>
> static int pca9532_update_hw_blink(struct pca9532_led *led,
> - unsigned long delay_on, unsigned long delay_off)
> + unsigned long delay_on,
> + unsigned long delay_off)
> {
> struct pca9532_data *data = i2c_get_clientdata(led->client);
> unsigned int psc;
> - int i;
> + unsigned long period;
> + u8 old_pwm = data->pwm[PCA9532_PWM_ID_1];
> + u8 old_psc = data->psc[PCA9532_PWM_ID_1];
> + int i, ret;
>
> /* Look for others LEDs that already use PWM1 */
> for (i = 0; i < data->chip_info->num_leds; i++) {
> @@ -223,29 +306,64 @@ static int pca9532_update_hw_blink(struct pca9532_led *led,
> }
> }
>
> - psc = ((delay_on + delay_off) * PCA9532_PWM_PERIOD_DIV - 1) / 1000;
> - if (psc > U8_MAX) {
> - /* Blink period too long to be handled by hardware */
> + if (delay_on > ULONG_MAX - delay_off)
> return -EINVAL;
> +
> + period = delay_on + delay_off;
> +
> + if (!delay_on || !delay_off)
> + return -EINVAL;
> +
> + if (period > ((U8_MAX + 1) * 1000) /
> + PCA9532_PWM_PERIOD_DIV)
> + return -EINVAL;
> +
> + psc = (period * PCA9532_PWM_PERIOD_DIV - 1) / 1000;
> +
> + data->psc[PCA9532_PWM_ID_1] = psc;
> + data->pwm[PCA9532_PWM_ID_1] =
> + (delay_on * PCA9532_PWM_DUTY_DIV) / period;
> +
> + ret = __pca9532_setpwm(data->client, PCA9532_PWM_ID_1);
> + if (ret < 0) {
> + data->pwm[PCA9532_PWM_ID_1] = old_pwm;
> + data->psc[PCA9532_PWM_ID_1] = old_psc;
> +
> + if (__pca9532_setpwm(data->client, PCA9532_PWM_ID_1) < 0)
> + dev_warn(&data->client->dev,
> + "Failed to restore PWM settings\n");
> +
> + return ret;
> }
>
> led->state = PCA9532_PWM1;
> - data->psc[PCA9532_PWM_ID_1] = psc;
> - data->pwm[PCA9532_PWM_ID_1] = (delay_on * PCA9532_PWM_DUTY_DIV) / (delay_on + delay_off);
>
> - return pca9532_setpwm(data->client, PCA9532_PWM_ID_1);
> + return 0;
> }
>
> static int pca9532_set_blink(struct led_classdev *led_cdev,
> - unsigned long *delay_on, unsigned long *delay_off)
> + unsigned long *delay_on,
> + unsigned long *delay_off)
> {
> struct pca9532_led *led = ldev_to_led(led_cdev);
> struct i2c_client *client = led->client;
> struct pca9532_data *data = i2c_get_clientdata(client);
> + int old_state;
> + int restore_err;
> + u8 old_pwm;
> + u8 old_psc;
> int err;
>
> - if (!data->hw_blink)
> - return -EINVAL;
> + mutex_lock(&data->update_lock);
> +
> + old_state = led->state;
> + old_pwm = data->pwm[PCA9532_PWM_ID_1];
> + old_psc = data->psc[PCA9532_PWM_ID_1];
> +
> + if (!data->hw_blink) {
> + err = -EINVAL;
> + goto out;
> + }
>
> if (*delay_on == 0 && *delay_off == 0) {
> /* led subsystem ask us for a blink rate */
> @@ -255,26 +373,47 @@ static int pca9532_set_blink(struct led_classdev *led_cdev,
>
> err = pca9532_update_hw_blink(led, *delay_on, *delay_off);
> if (err)
> - return err;
> + goto restore_state;
> +
> + err = __pca9532_setled(led);
> + if (err < 0) {
> + led->state = old_state;
> + data->pwm[PCA9532_PWM_ID_1] = old_pwm;
> + data->psc[PCA9532_PWM_ID_1] = old_psc;
> +
> + restore_err = __pca9532_setpwm(client, PCA9532_PWM_ID_1);
> + if (restore_err < 0)
> + dev_warn(&client->dev,
> + "Failed to restore PWM settings: %d\n",
> + restore_err);
> + }
>
> - pca9532_setled(led);
> + goto out;
>
> - return 0;
> +restore_state:
> + led->state = old_state;
> +out:
> + mutex_unlock(&data->update_lock);
> + return err;
> }
>
> static int pca9532_event(struct input_dev *dev, unsigned int type,
> - unsigned int code, int value)
> + unsigned int code, int value)
> {
> struct pca9532_data *data = input_get_drvdata(dev);
> + unsigned long flags;
>
> if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE)))
> return -1;
>
> - /* XXX: allow different kind of beeps with psc/pwm modifications */
> + spin_lock_irqsave(&data->beep_lock, flags);
> +
> if (value > 1 && value < 32767)
> - data->pwm[PCA9532_PWM_ID_1] = 127;
> + data->beep_pwm = 127;
> else
> - data->pwm[PCA9532_PWM_ID_1] = 0;
> + data->beep_pwm = 0;
> +
> + spin_unlock_irqrestore(&data->beep_lock, flags);
>
> schedule_work(&data->work);
>
> @@ -286,27 +425,48 @@ static void pca9532_input_work(struct work_struct *work)
> struct pca9532_data *data =
> container_of(work, struct pca9532_data, work);
> u8 maxleds = data->chip_info->num_leds;
> + unsigned long flags;
> + u8 old_pwm;
> + u8 pwm;
> + int ret;
> +
> + spin_lock_irqsave(&data->beep_lock, flags);
> + pwm = data->beep_pwm;
> + spin_unlock_irqrestore(&data->beep_lock, flags);
>
> mutex_lock(&data->update_lock);
> - i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1),
> - data->pwm[PCA9532_PWM_ID_1]);
> +
> + old_pwm = data->pwm[PCA9532_PWM_ID_1];
> + data->pwm[PCA9532_PWM_ID_1] = pwm;
> +
> + ret = i2c_smbus_write_byte_data(data->client,
> + PCA9532_REG_PWM(maxleds, 1), pwm);
> + if (ret < 0) {
> + data->pwm[PCA9532_PWM_ID_1] = old_pwm;
> + dev_warn(&data->client->dev,
> + "Failed to write PWM register: %d\n", ret);
> + }
> +
> mutex_unlock(&data->update_lock);
> }
>
> -static enum pca9532_state pca9532_getled(struct pca9532_led *led)
> +static int pca9532_getled(struct pca9532_led *led)
> {
> struct i2c_client *client = led->client;
> struct pca9532_data *data = i2c_get_clientdata(client);
> u8 maxleds = data->chip_info->num_leds;
> int reg;
> - enum pca9532_state ret = PCA9532_OFF;
> + int ret;
>
> mutex_lock(&data->update_lock);
> reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
> - if (reg >= 0)
> +
> + if (reg >= 0) {
> ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id);
> - else
> - dev_warn(&client->dev, "failed to read LED register: %d\n", reg);
> + } else {
> + ret = reg;
> + dev_warn(&client->dev, "Failed to read LED register: %d\n", ret);
> + }
> mutex_unlock(&data->update_lock);
> return ret;
> }
> @@ -328,33 +488,42 @@ static int pca9532_gpio_set_value(struct gpio_chip *gc, unsigned int offset,
> {
> struct pca9532_data *data = gpiochip_get_data(gc);
> struct pca9532_led *led = &data->leds[offset];
> + int old_state;
> + int ret;
> +
> + mutex_lock(&data->update_lock);
> + old_state = led->state;
>
> if (val)
> led->state = PCA9532_OFF;
> else
> led->state = PCA9532_ON;
>
> - pca9532_setled(led);
> + ret = __pca9532_setled(led);
> + if (ret < 0)
> + led->state = old_state;
>
> - return 0;
> + mutex_unlock(&data->update_lock);
> +
> + return ret;
> }
>
> static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)
> {
> struct pca9532_data *data = gpiochip_get_data(gc);
> - unsigned char reg;
> + int reg;
>
> reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));
>
> + if (reg < 0)
> + return reg;
> +
> return !!(reg & (1 << (offset % 8)));
> }
>
> static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
> {
> - /* To use as input ensure pin is not driven */
> - pca9532_gpio_set_value(gc, offset, 1);
> -
> - return 0;
> + return pca9532_gpio_set_value(gc, offset, 1);
> }
>
> static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val)
> @@ -394,40 +563,57 @@ static int pca9532_configure(struct i2c_client *client,
> struct pca9532_data *data, struct pca9532_platform_data *pdata)
> {
> int i, err = 0;
> +#ifdef CONFIG_LEDS_PCA9532_GPIO
> int gpios = 0;
> +#endif
> u8 maxleds = data->chip_info->num_leds;
>
> - for (i = 0; i < 2; i++) {
> + for (i = 0; i < 2; i++) {
> data->pwm[i] = pdata->pwm[i];
> data->psc[i] = pdata->psc[i];
> - err = i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i),
> +
> + err = i2c_smbus_write_byte_data(client,
> + PCA9532_REG_PWM(maxleds, i),
> data->pwm[i]);
> if (err < 0)
> return err;
> - err = i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i),
> +
> + err = i2c_smbus_write_byte_data(client,
> + PCA9532_REG_PSC(maxleds, i),
> data->psc[i]);
> if (err < 0)
> return err;
> }
>
> data->hw_blink = true;
> +
> for (i = 0; i < data->chip_info->num_leds; i++) {
> struct pca9532_led *led = &data->leds[i];
> struct pca9532_led *pled = &pdata->leds[i];
> +
> led->client = client;
> led->id = i;
> led->type = pled->type;
> +
> switch (led->type) {
> case PCA9532_TYPE_NONE:
> break;
> case PCA9532_TYPE_GPIO:
> +#ifdef CONFIG_LEDS_PCA9532_GPIO
> gpios++;
> +#endif
> break;
> case PCA9532_TYPE_LED:
> - if (pled->state == PCA9532_KEEP)
> - led->state = pca9532_getled(led);
> - else
> + if (pled->state == PCA9532_KEEP) {
> + err = pca9532_getled(led);
> + if (err < 0)
> + goto exit;
> +
> + led->state = err;
> + } else {
> led->state = pled->state;
> + }
> +
> led->name = pled->name;
> led->ldev.name = led->name;
> led->ldev.default_trigger = pled->default_trigger;
> @@ -435,6 +621,15 @@ static int pca9532_configure(struct i2c_client *client,
> led->ldev.brightness_set_blocking =
> pca9532_set_brightness;
> led->ldev.blink_set = pca9532_set_blink;
> +
> + err = pca9532_setled(led);
> + if (err < 0) {
> + dev_err(&client->dev,
> + "couldn't set LED %s state\n",
> + led->name);
> + goto exit;
> + }
> +
> err = led_classdev_register(&client->dev, &led->ldev);
> if (err < 0) {
> dev_err(&client->dev,
> @@ -442,19 +637,26 @@ static int pca9532_configure(struct i2c_client *client,
> led->name);
> goto exit;
> }
> - pca9532_setled(led);
> break;
> case PCA9532_TYPE_N2100_BEEP:
> /* PWM1 is reserved for beeper so blink will not use hardware */
> data->hw_blink = false;
> BUG_ON(data->idev);
> +
> led->state = PCA9532_PWM1;
> - pca9532_setled(led);
> + err = pca9532_setled(led);
> + if (err < 0) {
> + dev_err(&client->dev,
> + "couldn't set beeper state\n");
> + goto exit;
> + }
> +
> data->idev = devm_input_allocate_device(&client->dev);
> if (data->idev == NULL) {
> err = -ENOMEM;
> goto exit;
> }
> +
> data->idev->name = pled->name;
> data->idev->phys = "i2c/pca9532";
> data->idev->id.bustype = BUS_HOST;
> @@ -467,6 +669,7 @@ static int pca9532_configure(struct i2c_client *client,
> data->idev->event = pca9532_event;
> input_set_drvdata(data->idev, data);
> INIT_WORK(&data->work, pca9532_input_work);
> +
> err = input_register_device(data->idev);
> if (err) {
> cancel_work_sync(&data->work);
> @@ -498,8 +701,8 @@ static int pca9532_configure(struct i2c_client *client,
> dev_warn(&client->dev, "could not add gpiochip\n");
> } else {
> dev_info(&client->dev, "gpios %i...%i\n",
> - data->gpio.base, data->gpio.base +
> - data->gpio.ngpio - 1);
> + data->gpio.base, data->gpio.base +
> + data->gpio.ngpio - 1);
> }
> }
> #endif
> @@ -591,6 +794,7 @@ static int pca9532_probe(struct i2c_client *client)
> i2c_set_clientdata(client, data);
> data->client = client;
> mutex_init(&data->update_lock);
> + spin_lock_init(&data->beep_lock);
>
> return pca9532_configure(client, data, pca9532_pdata);
> }
> --
> 2.56.0
>
--
Lee Jones
prev parent reply other threads:[~2026-11-16 12:43 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-14 14:19 [PATCH] " Daniil Demakov
2026-11-14 18:52 ` [PATCH v4] " Daniil Demakov
2026-11-16 12:43 ` Lee Jones [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261116124345.GN6323@joneslee-macbookpro.roam.internal \
--to=lee@kernel.org \
--cc=linux-gpio@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-leds@vger.kernel.org \
--cc=pavel@kernel.org \
--cc=t3127430@gmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®