The LTM8054 supports setting a fixed output current limit using a sense
resistor connected to a dedicated pin. This limit can then be lowered
dynamically by varying the voltage level of the CTL pin.

Support controlling the LTM8054's output current limit.

Signed-off-by: Romain Gantois <romain.gantois@bootlin.com>
---
 drivers/regulator/Kconfig             |   1 +
 drivers/regulator/ltm8054-regulator.c | 273 +++++++++++++++++++++++++++++++++-
 2 files changed, 268 insertions(+), 6 deletions(-)

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index f5c6d4a21a88..aad8c523420a 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -587,6 +587,7 @@ config REGULATOR_LTC3676
 
 config REGULATOR_LTM8054
 	tristate "LTM8054 Buck-Boost voltage regulator"
+	depends on IIO
 	help
 	  This driver provides support for the Analog Devices LTM8054
 	  Buck-Boost micromodule regulator. The LTM8054 has an adjustable
diff --git a/drivers/regulator/ltm8054-regulator.c b/drivers/regulator/ltm8054-regulator.c
index b5783f6629e3..38072231b8e4 100644
--- a/drivers/regulator/ltm8054-regulator.c
+++ b/drivers/regulator/ltm8054-regulator.c
@@ -6,6 +6,7 @@
  */
 
 #include <linux/array_size.h>
+#include <linux/completion.h>
 #include <linux/device.h>
 #include <linux/device/devres.h>
 #include <linux/device/driver.h>
@@ -15,7 +16,11 @@
 #include <linux/errno.h>
 
 #include <linux/gpio/consumer.h>
+#include <linux/iio/consumer.h>
+#include <linux/jiffies.h>
+#include <linux/lockdep.h>
 #include <linux/math64.h>
+#include <linux/minmax.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
@@ -26,10 +31,42 @@
 #include <linux/regulator/of_regulator.h>
 #include <linux/types.h>
 
+#include <linux/units.h>
+#include <linux/workqueue.h>
+
 /* The LTM8054 regulates its FB pin to 1.2V */
 #define LTM8054_FB_uV 1200000
 
+/* Threshold voltage between the Vout and Iout pins which triggers current
+ * limiting.
+ */
+#define LTM8054_VOUT_IOUT_MAX_uV 58000
+
+#define LTM8054_MAX_CTL_uV 1200000
+#define LTM8054_MIN_CTL_uV 50000
+
+#define LTM8054_CTL_RW_TIMEOUT msecs_to_jiffies(500)
+
+/* CTL pin read/write transaction */
+struct ltm8054_ctl_pin_work {
+	struct work_struct work;
+	unsigned int ctl_val;
+	bool write;
+	int ret;
+};
+
 struct ltm8054_priv {
+	struct device *dev;
+
+	struct iio_channel *ctl_dac;
+	struct ltm8054_ctl_pin_work ctl_work;
+	/* Lock for ctl_work. */
+	struct mutex ctl_work_lock;
+	struct completion ctl_rw_done;
+
+	int min_uA;
+	int max_uA;
+
 	struct regulator_desc rdesc;
 };
 
@@ -43,14 +80,190 @@ static int ltm8054_scale(unsigned int uV, u32 r1, u32 r2)
 	return uV + tmp;
 }
 
-static const struct regulator_ops ltm8054_regulator_ops = { };
+static void ltm8054_do_ctl_work(struct work_struct *work)
+{
+	struct ltm8054_ctl_pin_work *ctl_work = container_of_const(work,
+								   struct ltm8054_ctl_pin_work,
+								   work);
+	struct ltm8054_priv *priv = container_of_const(ctl_work,
+						       struct ltm8054_priv,
+						       ctl_work);
+	unsigned int val;
+	bool write;
+	int ret;
+
+	lockdep_assert_not_held(&priv->ctl_work_lock);
+
+	mutex_lock(&priv->ctl_work_lock);
+	val = ctl_work->ctl_val;
+	write = ctl_work->write;
+	mutex_unlock(&priv->ctl_work_lock);
+
+	/* Standard IIO voltage unit is mV, scale accordingly. */
+	if (write)
+		ret = iio_write_channel_processed_scale(priv->ctl_dac,
+							val, 1000);
+	else
+		ret = iio_read_channel_processed_scale(priv->ctl_dac,
+						       &val, 1000);
+
+	pr_debug("LTM8054: %s CTL IO channel, val: %duV\n", write ? "wrote" : "reading", val);
+
+	mutex_lock(&priv->ctl_work_lock);
+	ctl_work->ret = ret;
+	ctl_work->ctl_val = val;
+	mutex_unlock(&priv->ctl_work_lock);
+
+	complete(&priv->ctl_rw_done);
+}
+
+static int ltm8054_ctl_pin_rw(struct ltm8054_priv *priv, bool write, unsigned int *ctl_val)
+{
+	struct ltm8054_ctl_pin_work *ctl_work = &priv->ctl_work;
+	int ret = 0;
+
+	lockdep_assert_not_held(&priv->ctl_work_lock);
+
+	/* The get/set_current_limit() callbacks have an active regulator core
+	 * reservation ID (obtained with ww_acquire_init()).
+	 *
+	 * Or, the IO channel driver may call something like
+	 * regulator_enable(), meaning this thread would acquire a new
+	 * regulator core reservation ID before the current one is dropped
+	 * (using ww_acquire_fini()). This is forbidden.
+	 *
+	 * Thus, perform the IO channel read/write in a different thread, and
+	 * wait for it to complete, with a timeout to avoid deadlocking.
+	 */
+
+	scoped_guard(mutex, &priv->ctl_work_lock) {
+		if (work_busy(&ctl_work->work))
+			return -EBUSY;
+
+		if (write) {
+			ctl_work->ctl_val = *ctl_val;
+			ctl_work->write = 1;
+		} else {
+			ctl_work->write = 0;
+		}
+
+		schedule_work(&ctl_work->work);
+	}
+
+	ret = wait_for_completion_timeout(&priv->ctl_rw_done, LTM8054_CTL_RW_TIMEOUT);
+	reinit_completion(&priv->ctl_rw_done);
+
+	if (unlikely(!ret))
+		return -ETIMEDOUT;
+
+	scoped_guard(mutex, &priv->ctl_work_lock) {
+		ret = ctl_work->ret;
+
+		if (!ret && !write)
+			*ctl_val = ctl_work->ctl_val;
+	}
+
+	return ret;
+}
+
+static int ltm8054_set_current_limit(struct regulator_dev *rdev, int min_uA, int max_uA)
+{
+	struct ltm8054_priv *priv = rdev_get_drvdata(rdev);
+	unsigned int ctl_val;
+	u64 vdac_uV;
+
+	min_uA = clamp_t(int, min_uA, priv->min_uA, priv->max_uA);
+
+	/* adjusted current limit = Rsense current limit * CTL pin voltage / max CTL pin voltage */
+	vdac_uV = (u64)min_uA * LTM8054_MAX_CTL_uV;
+	do_div(vdac_uV, priv->max_uA);
+
+	dev_dbg(&rdev->dev,
+		"Setting current limit to %duA, CTL pin to %lluuV\n", min_uA, vdac_uV);
+
+	ctl_val = vdac_uV;
+
+	return ltm8054_ctl_pin_rw(priv, 1, &ctl_val);
+}
+
+static int ltm8054_get_current_limit(struct regulator_dev *rdev)
+{
+	struct ltm8054_priv *priv = rdev_get_drvdata(rdev);
+	unsigned int ctl_val;
+	int ret;
+	u64 uA;
+
+	ret = ltm8054_ctl_pin_rw(priv, 0, &ctl_val);
+	if (ret)
+		return ret;
+
+	uA = (u64)ctl_val * priv->max_uA;
+	do_div(uA, LTM8054_MAX_CTL_uV);
+
+	return uA;
+}
+
+static const struct regulator_ops ltm8054_no_ctl_ops = { };
+
+static const struct regulator_ops ltm8054_ctl_ops = {
+	.set_current_limit = ltm8054_set_current_limit,
+	.get_current_limit = ltm8054_get_current_limit,
+};
+
+static struct iio_channel *ltm8054_init_ctl_dac(struct platform_device *pdev)
+{
+	struct iio_channel *ctl_dac;
+	enum iio_chan_type type;
+	int ret;
+
+	ctl_dac = devm_iio_channel_get(&pdev->dev, "ctl");
+	if (IS_ERR(ctl_dac)) {
+		if (PTR_ERR(ctl_dac) == -ENODEV)
+			return ERR_PTR(-EPROBE_DEFER);
+
+		return ctl_dac;
+	}
+
+	ret = iio_get_channel_type(ctl_dac, &type);
+	if (ret)
+		return ERR_PTR(ret);
+
+	if (type != IIO_VOLTAGE)
+		return ERR_PTR(-EINVAL);
+
+	return ctl_dac;
+}
 
 static int ltm8054_of_parse(struct device *dev, struct ltm8054_priv *priv,
 			    struct regulator_config *config)
 {
+	u32 rsense;
 	u32 r[2];
+	u64 tmp;
 	int ret;
 
+	ret = device_property_read_u32(dev, "adi,iout-rsense-micro-ohms", &rsense);
+	if (ret)
+		return ret;
+
+	if (rsense == 0)
+		return -EINVAL;
+
+	/* The maximum output current limit is the one set by the Rsense resistor */
+	tmp = (u64)LTM8054_VOUT_IOUT_MAX_uV * MICRO;
+	do_div(tmp, rsense);
+	priv->max_uA = tmp;
+
+	/*
+	 * Applying a voltage below LTM8054_MAX_CTL_uV on the CTL pin reduces
+	 * the output current limit. If this level drops below
+	 * LTM8054_MIN_CTL_uV the regulator stops switching.
+	 */
+
+	tmp = (u64)priv->max_uA * LTM8054_MIN_CTL_uV;
+	do_div(tmp, LTM8054_MAX_CTL_uV);
+	priv->min_uA = tmp;
+
 	ret = device_property_read_u32_array(dev, "regulator-fb-voltage-divider-ohms",
 					     r, ARRAY_SIZE(r));
 	if (ret)
@@ -60,6 +273,9 @@ static int ltm8054_of_parse(struct device *dev, struct ltm8054_priv *priv,
 	priv->rdesc.min_uV = priv->rdesc.fixed_uV;
 	priv->rdesc.n_voltages = 1;
 
+	dev_dbg(dev, "max_uA: %d min_uA: %d fixed_uV: %d\n",
+		priv->max_uA, priv->min_uA, priv->rdesc.fixed_uV);
+
 	config->of_node = dev_of_node(dev);
 	config->init_data = of_get_regulator_init_data(dev,
 						       config->of_node,
@@ -77,32 +293,76 @@ static int ltm8054_of_parse(struct device *dev, struct ltm8054_priv *priv,
 static int ltm8054_probe(struct platform_device *pdev)
 {
 	struct regulator_config config = { };
+	struct iio_channel *ctl_dac = NULL;
 	struct device *dev = &pdev->dev;
 	struct regulator_dev *rdev;
 	struct ltm8054_priv *priv;
 	int ret;
 
+	/* Do this first, as it might defer. */
+	if (device_property_match_string(dev, "io-channel-names", "ctl") >= 0) {
+		ctl_dac = ltm8054_init_ctl_dac(pdev);
+		if (IS_ERR(ctl_dac))
+			return dev_err_probe(dev, PTR_ERR(ctl_dac),
+					     "failed to initialize CTL DAC\n");
+	}
+
 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 
+	platform_set_drvdata(pdev, priv);
+
+	priv->dev = dev;
 	priv->rdesc.name = "ltm8054-regulator";
-	priv->rdesc.ops = &ltm8054_regulator_ops;
+	priv->rdesc.ops = &ltm8054_no_ctl_ops;
 	priv->rdesc.type = REGULATOR_VOLTAGE;
 	priv->rdesc.owner = THIS_MODULE;
 
+	if (ctl_dac) {
+		priv->ctl_dac = ctl_dac;
+
+		INIT_WORK(&priv->ctl_work.work, ltm8054_do_ctl_work);
+		init_completion(&priv->ctl_rw_done);
+		mutex_init(&priv->ctl_work_lock);
+
+		priv->rdesc.ops = &ltm8054_ctl_ops;
+	}
+
 	config.dev = dev;
 	config.driver_data = priv;
 
 	ret = ltm8054_of_parse(dev, priv, &config);
-	if (ret)
-		return dev_err_probe(dev, ret, "failed to parse device tree\n");
+	if (ret) {
+		ret = dev_err_probe(dev, ret, "failed to parse device tree\n");
+		goto out_err;
+	}
 
 	rdev = devm_regulator_register(dev, &priv->rdesc, &config);
-	if (IS_ERR(rdev))
-		return dev_err_probe(dev, PTR_ERR(rdev), "failed to register regulator\n");
+	if (IS_ERR(rdev)) {
+		ret = dev_err_probe(dev, PTR_ERR(rdev), "failed to register regulator\n");
+		goto out_err;
+	}
 
 	return 0;
+
+out_err:
+	if (ctl_dac) {
+		cancel_work_sync(&priv->ctl_work.work);
+		mutex_destroy(&priv->ctl_work_lock);
+	}
+
+	return ret;
+}
+
+static void ltm8054_remove(struct platform_device *pdev)
+{
+	struct ltm8054_priv *priv = platform_get_drvdata(pdev);
+
+	if (priv->ctl_dac) {
+		cancel_work_sync(&priv->ctl_work.work);
+		mutex_destroy(&priv->ctl_work_lock);
+	}
 }
 
 static const struct of_device_id ltm8054_of_match[] = {
@@ -113,6 +373,7 @@ MODULE_DEVICE_TABLE(of, ltm8054_of_match);
 
 static struct platform_driver ltm8054_driver = {
 	.probe = ltm8054_probe,
+	.remove = ltm8054_remove,
 	.driver = {
 		.name  = "ltm8054",
 		.of_match_table = ltm8054_of_match,

-- 
2.51.2

On Thu, Nov 06, 2025 at 03:11:50PM +0100, Romain Gantois wrote:
> The LTM8054 supports setting a fixed output current limit using a sense
> resistor connected to a dedicated pin. This limit can then be lowered
> dynamically by varying the voltage level of the CTL pin.
> 
> Support controlling the LTM8054's output current limit.

...

>  #include <linux/array_size.h>
> +#include <linux/completion.h>
>  #include <linux/device.h>
>  #include <linux/device/devres.h>
>  #include <linux/device/driver.h>

>  #include <linux/errno.h>
>  
>  #include <linux/gpio/consumer.h>
> +#include <linux/iio/consumer.h>
> +#include <linux/jiffies.h>
> +#include <linux/lockdep.h>
>  #include <linux/math64.h>
> +#include <linux/minmax.h>
>  #include <linux/module.h>
>  #include <linux/of.h>
>  #include <linux/platform_device.h>

>  #include <linux/regulator/of_regulator.h>
>  #include <linux/types.h>
>  
> +#include <linux/units.h>
> +#include <linux/workqueue.h>

This will be updated accordingly.

...

> +struct ltm8054_ctl_pin_work {
> +	struct work_struct work;
> +	unsigned int ctl_val;
> +	bool write;
> +	int ret;
> +};

Have you ran `pahole`? It might suggest a better layout to save a few bytes.

...

> +static void ltm8054_do_ctl_work(struct work_struct *work)
> +{
> +	struct ltm8054_ctl_pin_work *ctl_work = container_of_const(work,
> +								   struct ltm8054_ctl_pin_work,
> +								   work);
> +	struct ltm8054_priv *priv = container_of_const(ctl_work,
> +						       struct ltm8054_priv,
> +						       ctl_work);

These read better in slightly different split:

	struct ltm8054_ctl_pin_work *ctl_work =
		container_of_const(work, struct ltm8054_ctl_pin_work, work);
	struct ltm8054_priv *priv =
		container_of_const(ctl_work, struct ltm8054_priv, ctl_work);

...

> +	mutex_lock(&priv->ctl_work_lock);
> +	val = ctl_work->ctl_val;
> +	write = ctl_work->write;
> +	mutex_unlock(&priv->ctl_work_lock);

Why not scoped_guard() from cleanup,h?

...

> +	/* Standard IIO voltage unit is mV, scale accordingly. */
> +	if (write)
> +		ret = iio_write_channel_processed_scale(priv->ctl_dac,
> +							val, 1000);

One line. It just 82 characters.

> +	else
> +		ret = iio_read_channel_processed_scale(priv->ctl_dac,
> +						       &val, 1000);

Ditto.

And perhaps use MILLI/KILO?

...

> +	pr_debug("LTM8054: %s CTL IO channel, val: %duV\n", write ? "wrote" : "reading", val);

Besides str_write_read() from string_choices.h this should be dev_dbg().

> +	mutex_lock(&priv->ctl_work_lock);
> +	ctl_work->ret = ret;
> +	ctl_work->ctl_val = val;
> +	mutex_unlock(&priv->ctl_work_lock);

scoped_guard()

> +	complete(&priv->ctl_rw_done);
> +}

...

> +static int ltm8054_ctl_pin_rw(struct ltm8054_priv *priv, bool write, unsigned int *ctl_val)
> +{
> +	struct ltm8054_ctl_pin_work *ctl_work = &priv->ctl_work;

> +	int ret = 0;

Redundant assignment.

> +	lockdep_assert_not_held(&priv->ctl_work_lock);
> +
> +	/* The get/set_current_limit() callbacks have an active regulator core

/*
 * The proper style of multi-line comment
 * is depicted in this example. Use it.
 */

> +	 * reservation ID (obtained with ww_acquire_init()).
> +	 *
> +	 * Or, the IO channel driver may call something like
> +	 * regulator_enable(), meaning this thread would acquire a new
> +	 * regulator core reservation ID before the current one is dropped
> +	 * (using ww_acquire_fini()). This is forbidden.
> +	 *
> +	 * Thus, perform the IO channel read/write in a different thread, and
> +	 * wait for it to complete, with a timeout to avoid deadlocking.
> +	 */
> +
> +	scoped_guard(mutex, &priv->ctl_work_lock) {
> +		if (work_busy(&ctl_work->work))
> +			return -EBUSY;
> +
> +		if (write) {
> +			ctl_work->ctl_val = *ctl_val;
> +			ctl_work->write = 1;
> +		} else {
> +			ctl_work->write = 0;
> +		}
> +
> +		schedule_work(&ctl_work->work);
> +	}
> +
> +	ret = wait_for_completion_timeout(&priv->ctl_rw_done, LTM8054_CTL_RW_TIMEOUT);
> +	reinit_completion(&priv->ctl_rw_done);
> +
> +	if (unlikely(!ret))
> +		return -ETIMEDOUT;
> +
> +	scoped_guard(mutex, &priv->ctl_work_lock) {
> +		ret = ctl_work->ret;

> +		if (!ret && !write)
> +			*ctl_val = ctl_work->ctl_val;

Return directly.

		if (ret)
			return ret;

		if (!write)
			...

> +	}

> +	return ret;

	return 0;

> +}

...

> +static struct iio_channel *ltm8054_init_ctl_dac(struct platform_device *pdev)
> +{
> +	struct iio_channel *ctl_dac;
> +	enum iio_chan_type type;
> +	int ret;
> +
> +	ctl_dac = devm_iio_channel_get(&pdev->dev, "ctl");
> +	if (IS_ERR(ctl_dac)) {

> +		if (PTR_ERR(ctl_dac) == -ENODEV)
> +			return ERR_PTR(-EPROBE_DEFER);

Hmm... Are you sure about this?

> +
> +		return ctl_dac;
> +	}
> +
> +	ret = iio_get_channel_type(ctl_dac, &type);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	if (type != IIO_VOLTAGE)
> +		return ERR_PTR(-EINVAL);
> +
> +	return ctl_dac;
> +}

...

>  static int ltm8054_probe(struct platform_device *pdev)
>  {
>  	struct regulator_config config = { };
> +	struct iio_channel *ctl_dac = NULL;
>  	struct device *dev = &pdev->dev;
>  	struct regulator_dev *rdev;
>  	struct ltm8054_priv *priv;
>  	int ret;
>  
> +	/* Do this first, as it might defer. */
> +	if (device_property_match_string(dev, "io-channel-names", "ctl") >= 0) {
> +		ctl_dac = ltm8054_init_ctl_dac(pdev);
> +		if (IS_ERR(ctl_dac))
> +			return dev_err_probe(dev, PTR_ERR(ctl_dac),
> +					     "failed to initialize CTL DAC\n");
> +	}
> +
>  	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
>  	if (!priv)
>  		return -ENOMEM;

> +	platform_set_drvdata(pdev, priv);

Do we need this? I think "no". See below how.

> +	priv->dev = dev;
>  	priv->rdesc.name = "ltm8054-regulator";
> -	priv->rdesc.ops = &ltm8054_regulator_ops;
> +	priv->rdesc.ops = &ltm8054_no_ctl_ops;
>  	priv->rdesc.type = REGULATOR_VOLTAGE;
>  	priv->rdesc.owner = THIS_MODULE;
>  
> +	if (ctl_dac) {
> +		priv->ctl_dac = ctl_dac;

> +		INIT_WORK(&priv->ctl_work.work, ltm8054_do_ctl_work);
> +		init_completion(&priv->ctl_rw_done);

Do devm-helpers.h APIs help with something here? Does
devm_add_action_or_reset() help with not covered cases?

> +		mutex_init(&priv->ctl_work_lock);

Use devm_mutex_init() and don't forget the error check.

> +		priv->rdesc.ops = &ltm8054_ctl_ops;
> +	}
> +
>  	config.dev = dev;
>  	config.driver_data = priv;


From this...

>  	ret = ltm8054_of_parse(dev, priv, &config);
> -	if (ret)
> -		return dev_err_probe(dev, ret, "failed to parse device tree\n");
> +	if (ret) {
> +		ret = dev_err_probe(dev, ret, "failed to parse device tree\n");
> +		goto out_err;
> +	}
>  
>  	rdev = devm_regulator_register(dev, &priv->rdesc, &config);
> -	if (IS_ERR(rdev))
> -		return dev_err_probe(dev, PTR_ERR(rdev), "failed to register regulator\n");
> +	if (IS_ERR(rdev)) {
> +		ret = dev_err_probe(dev, PTR_ERR(rdev), "failed to register regulator\n");
> +		goto out_err;
> +	}
>  
>  	return 0;
> +
> +out_err:
> +	if (ctl_dac) {
> +		cancel_work_sync(&priv->ctl_work.work);
> +		mutex_destroy(&priv->ctl_work_lock);
> +	}
> +
> +	return ret;
> +}
> +
> +static void ltm8054_remove(struct platform_device *pdev)
> +{
> +	struct ltm8054_priv *priv = platform_get_drvdata(pdev);
> +
> +	if (priv->ctl_dac) {
> +		cancel_work_sync(&priv->ctl_work.work);
> +		mutex_destroy(&priv->ctl_work_lock);
> +	}
>  }

...to this no changes are needed.

...

>  	.probe = ltm8054_probe,
> +	.remove = ltm8054_remove,

Neither is this.

-- 
With Best Regards,
Andy Shevchenko

Hello Andy,

On Thursday, 6 November 2025 19:32:29 CET Andy Shevchenko wrote:
> On Thu, Nov 06, 2025 at 03:11:50PM +0100, Romain Gantois wrote:
> > The LTM8054 supports setting a fixed output current limit using a sense
> > resistor connected to a dedicated pin. This limit can then be lowered
> > dynamically by varying the voltage level of the CTL pin.
...
> > +	ctl_dac = devm_iio_channel_get(&pdev->dev, "ctl");
> > +	if (IS_ERR(ctl_dac)) {
> > 
> > +		if (PTR_ERR(ctl_dac) == -ENODEV)
> > +			return ERR_PTR(-EPROBE_DEFER);
> 
> Hmm... Are you sure about this?

The only case where I want to defer is if the IO channel hasn't been created 
yet. From what I've read in iio_channel_get(), -ENODEV is returned specifically 
in this case. For example in fwnode_iio_channel_get_by_name() you have:

```
if (!IS_ERR(chan) || PTR_ERR(chan) != -ENODEV)
		return chan;
```

> > 
> >  	priv->rdesc.type = REGULATOR_VOLTAGE;
> >  	priv->rdesc.owner = THIS_MODULE;
> > 
> > +	if (ctl_dac) {
> > +		priv->ctl_dac = ctl_dac;
> > 
> > +		INIT_WORK(&priv->ctl_work.work, ltm8054_do_ctl_work);
> > +		init_completion(&priv->ctl_rw_done);
> 
> Do devm-helpers.h APIs help with something here? Does
> devm_add_action_or_reset() help with not covered cases?

I could definitely use a cleanup action to flush the ctl pin work item instead 
of doing it in a remove() function. It would also remove the gotos below.

Thanks,

-- 
Romain Gantois, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com

On Fri, Nov 7, 2025 at 4:54 PM Romain Gantois
<romain.gantois@bootlin.com> wrote:
> On Thursday, 6 November 2025 19:32:29 CET Andy Shevchenko wrote:
> > On Thu, Nov 06, 2025 at 03:11:50PM +0100, Romain Gantois wrote:

...

> > > +   ctl_dac = devm_iio_channel_get(&pdev->dev, "ctl");
> > > +   if (IS_ERR(ctl_dac)) {
> > >
> > > +           if (PTR_ERR(ctl_dac) == -ENODEV)
> > > +                   return ERR_PTR(-EPROBE_DEFER);
> >
> > Hmm... Are you sure about this?
>
> The only case where I want to defer is if the IO channel hasn't been created
> yet. From what I've read in iio_channel_get(), -ENODEV is returned specifically
> in this case. For example in fwnode_iio_channel_get_by_name() you have:
>
> ```
> if (!IS_ERR(chan) || PTR_ERR(chan) != -ENODEV)
>                 return chan;


Yes, but my point is that -ENODEV != -EPROBE_DEFER.
The latter may create an unbound driver in some cases. This needs a
very good justification explaining the metamorphoses.

-- 
With Best Regards,
Andy Shevchenko