Devicetree
 help / color / mirror / Atom feed
* [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support
@ 2026-11-19 11:24 Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep() Nicolae-Daniel Deaconescu
                   ` (5 more replies)
  0 siblings, 6 replies; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

Hi all,

This adds the LTC2387-16, LTC2387-18, ADAQ23875, ADAQ23876 and ADAQ23878
to the ad7625 driver. They are single channel differential 16 and 18 bit
SAR ADCs, up to 15 MSPS, read like the AD762x and AD796x with two PWMs
(CNV and CLK) and an IIO backend that captures the LVDS data. They differ in
four ways: double data rate on one or two lanes, a CLK burst that overlaps
the next conversion at high rates, so the sampling period is raised until it
fits, no EN pins, and on the ADAQ modules an amplifier whose gain divides
the scale.

Patches 1 and 2 let the PWM provider report its clock rate and the clock
cycles per step, so the driver can place the burst in whole steps. Patch 3
fixes sampling frequency problems that the new parts would also hit, and
patch 4 moves code so that patch 6 touches less of the old code. The binding
is a file of its own, as few properties are shared with adi,ad7625.yaml.

Changes in v4:
- Dropped the patch that renamed existing variables and macros to the
  standard unit names.
- Patch 4: pick the bandwidth mode first and check the result of setting it
  once.
- Patch 5: added the Acked-by.
- Patch 6: added chip info members for the gain, EN pins, second PWM name and
  supplies, report the sampling frequency rounded up so that writing it back
  keeps the rate, drop the 0 V reference check, name the AD7625 and similar
  parts in Kconfig, the top comment, MODULE_DESCRIPTION() and the documentation,
  shorten the commit message, and fix comments.

Changes in v3:
- Split the binding into adi,ltc2387.yaml and left adi,ad7625.yaml as it was.
- Moved the EN pin setup into a helper in a patch of its own.
- Made the Kconfig prompt, top comment and MODULE_DESCRIPTION() generic and
  sorted the part lists by part number.
- Used HZ_PER_MHZ for the maximum rate and a default gain of 1 * MILLI.
- Simplified the gain, reference supply and lane count handling.
- PWM step API: put Context before Returns in the kernel-doc and dropped a
  redundant check.

Changes in v2:
- Joined the driver to ad7625 (binding, driver, Kconfig and documentation).
- Dropped the clocks property of the ADC and added the PWM waveform step API.
- Compatibles use the adi, prefix and the datasheet part numbers.
- Dropped the x4 parts.
- Fixed the missing return of dev_err_probe() for the initial sampling
  frequency.
- Added the maintainers of the new parts to the AD7625 entry.

Tested on an ADAQ23875 with a ZedBoard. The other new parts and the existing
parts were not tested on hardware.

AI disclosure: parts of the commit text and the code were checked with an AI
coding assistant (Claude): the first version of the merge into ad7625, the PWM
step API, the timing arithmetic and the test scripts. I reviewed every change,
built it and ran tests on the ADAQ23875 + ZedBoard.

Link to v3: https://lore.kernel.org/all/20261106160529.876251-1-Nicolae-daniel.Deaconescu@analog.com/
Link to v2: https://lore.kernel.org/all/20261104132143.215581-1-Nicolae-daniel.Deaconescu@analog.com/
Link to v1: https://lore.kernel.org/all/20261027134409.76824-1-Nicolae-daniel.Deaconescu@analog.com/

Nicolae-Daniel Deaconescu (4):
  pwm: core: add pwm_get_waveform_step_might_sleep()
  pwm: axi-pwmgen: report the waveform step
  iio: adc: ad7625: fix sampling frequency handling
  iio: adc: ad7625: move initial mode setup

Sergiu Cuciurean (2):
  dt-bindings: iio: adc: add adi,ltc2387
  iio: adc: ad7625: add LTC2387 and ADAQ2387x support

 .../bindings/iio/adc/adi,ltc2387.yaml         | 169 +++++++
 Documentation/iio/ad7625.rst                  |  34 +-
 MAINTAINERS                                   |   3 +
 drivers/iio/adc/Kconfig                       |   7 +-
 drivers/iio/adc/ad7625.c                      | 473 ++++++++++++++++--
 drivers/pwm/core.c                            |  69 +++
 drivers/pwm/pwm-axi-pwmgen.c                  |  13 +
 include/linux/pwm.h                           |  34 ++
 8 files changed, 765 insertions(+), 37 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml


base-commit: 43ffda3c7f8456bbe641ae8249a077a361b97880
-- 
2.56.0


^ permalink raw reply	[flat|nested] 10+ messages in thread

* [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep()
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-21 23:35   ` Jonathan Cameron
  2026-11-19 11:24 ` [PATCH v4 2/6] pwm: axi-pwmgen: report the waveform step Nicolae-Daniel Deaconescu
                   ` (4 subsequent siblings)
  5 siblings, 1 reply; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

A consumer that must meet minimum times, or place an edge relative to the
cycles of a clock a PWM gates, can't do that with the waveform API alone:
rounding goes down, and the margin a minimum needs is the PWM step, known
only to the provider.

Let the provider report the rate of the clock its timing derives from and
the clock cycles per step. A consumer then works in whole steps and rounds
up when converting to nanoseconds, instead of reading the rate from a clock
it gets on its own, which breaks if the PWM divides its clock.

Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
---
 drivers/pwm/core.c  | 69 +++++++++++++++++++++++++++++++++++++++++++++
 include/linux/pwm.h | 34 ++++++++++++++++++++++
 2 files changed, 103 insertions(+)

diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c
index 2a050ff4608b..a63b8f65a43d 100644
--- a/drivers/pwm/core.c
+++ b/drivers/pwm/core.c
@@ -14,6 +14,7 @@
 #include <linux/of.h>
 #include <linux/pwm.h>
 #include <linux/list.h>
+#include <linux/math64.h>
 #include <linux/mutex.h>
 #include <linux/err.h>
 #include <linux/slab.h>
@@ -325,6 +326,68 @@ int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf
 }
 EXPORT_SYMBOL_GPL(pwm_get_waveform_might_sleep);
 
+/**
+ * pwm_get_waveform_step_might_sleep - Query the granularity of the waveforms
+ * Cannot be used in atomic context.
+ * @pwm: PWM device
+ * @step: output parameter
+ *
+ * Stores in @step the clock rate the timing of @pwm is derived from and how
+ * many cycles of that clock one step lasts. Period, duty length and duty
+ * offset are multiples of that step, so a waveform that is asked for in whole
+ * steps, and is within the range of the hardware, is not changed by rounding.
+ * Compute the length of n steps in nanoseconds as
+ * n * @step->clk_cycles_per_step * NSEC_PER_SEC / @step->clk_rate_Hz and round
+ * it up, because pwm_round_waveform_might_sleep() and
+ * pwm_set_waveform_might_sleep() round down. The product can exceed 64 bits, so
+ * compute it with mul_u64_u64_div_u64_roundup().
+ *
+ * The values can change when a clock changes its rate, so they are only valid
+ * as long as the provider's input clocks are not reconfigured.
+ *
+ * Context: May sleep.
+ * Returns: 0 on success, -EOPNOTSUPP if the provider doesn't report it or a
+ * negative errno.
+ */
+int pwm_get_waveform_step_might_sleep(struct pwm_device *pwm,
+				      struct pwm_waveform_step *step)
+{
+	struct pwm_chip *chip = pwm->chip;
+	const struct pwm_ops *ops = chip->ops;
+	int ret;
+
+	might_sleep();
+
+	if (!pwmchip_supports_waveform(chip) || !ops->get_waveform_step)
+		return -EOPNOTSUPP;
+
+	guard(pwmchip)(chip);
+
+	if (!chip->operational)
+		return -ENODEV;
+
+	if (IS_ENABLED(CONFIG_PWM_DEBUG) && chip->atomic) {
+		/*
+		 * Catch any drivers that have been marked as atomic but
+		 * that will sleep anyway.
+		 */
+		non_block_start();
+		ret = ops->get_waveform_step(chip, pwm, step);
+		non_block_end();
+	} else {
+		ret = ops->get_waveform_step(chip, pwm, step);
+	}
+	if (ret)
+		return ret;
+
+	if (!step->clk_rate_Hz ||
+	    step->clk_rate_Hz > mul_u32_u32(step->clk_cycles_per_step, NSEC_PER_SEC))
+		return -EINVAL;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(pwm_get_waveform_step_might_sleep);
+
 /* Called with the pwmchip lock held */
 static int __pwm_set_waveform(struct pwm_device *pwm,
 			      const struct pwm_waveform *wf,
@@ -1710,6 +1773,12 @@ static bool pwm_ops_check(const struct pwm_chip *chip)
 		if (!ops->apply)
 			return false;
 
+		if (ops->get_waveform_step) {
+			dev_warn(pwmchip_parent(chip),
+				 ".get_waveform_step() needs .write_waveform()\n");
+			return false;
+		}
+
 		if (IS_ENABLED(CONFIG_PWM_DEBUG) && !ops->get_state)
 			dev_warn(pwmchip_parent(chip),
 				 "Please implement the .get_state() callback\n");
diff --git a/include/linux/pwm.h b/include/linux/pwm.h
index b11ae91723f8..c52f4c9153c2 100644
--- a/include/linux/pwm.h
+++ b/include/linux/pwm.h
@@ -76,6 +76,34 @@ struct pwm_waveform {
 	u64 duty_offset_ns;
 };
 
+/**
+ * struct pwm_waveform_step - granularity of the waveforms a PWM can generate
+ * @clk_rate_Hz: rate of the clock the PWM's timing is derived from
+ * @clk_cycles_per_step: number of those clock cycles one step lasts
+ *
+ * The period, the duty length and the duty offset of a waveform are multiples
+ * of one step, which lasts @clk_cycles_per_step / @clk_rate_Hz seconds. A PWM
+ * that divides its input clock in hardware has @clk_cycles_per_step > 1. A
+ * waveform that is asked for in whole steps, and is within the range of the
+ * hardware, is not changed by rounding.
+ *
+ * The step is the same for every waveform and for the period, the duty length
+ * and the duty offset, so a provider whose granularity depends on the
+ * requested period (for example through a prescaler) can't describe itself
+ * with it. One step also has to last at least 1 ns, otherwise rounding a
+ * length in nanoseconds up can add a whole step.
+ *
+ * A consumer that needs a minimum time, or that has to place an edge relative
+ * to the cycles of the clock a PWM channel gates, can use this to ask for
+ * the next possible value instead of one that is rounded down, and to compute
+ * the frequency a rounded period results in without the error of the
+ * nanosecond resolution of struct pwm_waveform.
+ */
+struct pwm_waveform_step {
+	unsigned long clk_rate_Hz;
+	unsigned int clk_cycles_per_step;
+};
+
 /*
  * struct pwm_state - state of a PWM channel
  * @period: PWM period (in nanoseconds)
@@ -287,6 +315,9 @@ struct pwm_capture {
  * @round_waveform_fromhw: convert a driver specific waveform presentation to struct pwm_waveform
  * @read_waveform: read driver specific waveform presentation from hardware
  * @write_waveform: write driver specific waveform presentation to hardware
+ * @get_waveform_step: optional, report the granularity of the waveforms. Called
+ *	with the chip locked, so it must not sleep on an atomic chip and should
+ *	report a cached clock rate instead of calling clk_get_rate()
  * @apply: atomically apply a new PWM config
  * @get_state: get the current PWM state.
  */
@@ -305,6 +336,8 @@ struct pwm_ops {
 			    void *wfhw);
 	int (*write_waveform)(struct pwm_chip *chip, struct pwm_device *pwm,
 			      const void *wfhw);
+	int (*get_waveform_step)(struct pwm_chip *chip, struct pwm_device *pwm,
+				 struct pwm_waveform_step *step);
 
 	int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm,
 		     const struct pwm_state *state);
@@ -394,6 +427,7 @@ static inline void pwmchip_set_drvdata(struct pwm_chip *chip, void *data)
 /* PWM consumer APIs */
 int pwm_round_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf);
 int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf);
+int pwm_get_waveform_step_might_sleep(struct pwm_device *pwm, struct pwm_waveform_step *step);
 int pwm_set_waveform_might_sleep(struct pwm_device *pwm, const struct pwm_waveform *wf, bool exact);
 int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state);
 int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state);
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* [PATCH v4 2/6] pwm: axi-pwmgen: report the waveform step
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep() Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 3/6] iio: adc: ad7625: fix sampling frequency handling Nicolae-Daniel Deaconescu
                   ` (3 subsequent siblings)
  5 siblings, 0 replies; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

The period, duty and offset counters of the AXI PWM generator count cycles
of its external clock, without a divider. Report that clock rate and one
cycle per step.

Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
---
 drivers/pwm/pwm-axi-pwmgen.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/drivers/pwm/pwm-axi-pwmgen.c b/drivers/pwm/pwm-axi-pwmgen.c
index b40522f01002..6b15244efabf 100644
--- a/drivers/pwm/pwm-axi-pwmgen.c
+++ b/drivers/pwm/pwm-axi-pwmgen.c
@@ -136,6 +136,18 @@ static int axi_pwmgen_round_waveform_fromhw(struct pwm_chip *chip, struct pwm_de
 	return 0;
 }
 
+static int axi_pwmgen_get_waveform_step(struct pwm_chip *chip,
+					struct pwm_device *pwm,
+					struct pwm_waveform_step *step)
+{
+	struct axi_pwmgen_ddata *ddata = axi_pwmgen_ddata_from_chip(chip);
+
+	step->clk_rate_Hz = ddata->clk_rate_hz;
+	step->clk_cycles_per_step = 1;
+
+	return 0;
+}
+
 static int axi_pwmgen_write_waveform(struct pwm_chip *chip,
 				     struct pwm_device *pwm,
 				     const void *_wfhw)
@@ -201,6 +213,7 @@ static const struct pwm_ops axi_pwmgen_pwm_ops = {
 	.round_waveform_fromhw = axi_pwmgen_round_waveform_fromhw,
 	.read_waveform = axi_pwmgen_read_waveform,
 	.write_waveform = axi_pwmgen_write_waveform,
+	.get_waveform_step = axi_pwmgen_get_waveform_step,
 };
 
 static int axi_pwmgen_setup(struct regmap *regmap, struct device *dev)
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* [PATCH v4 3/6] iio: adc: ad7625: fix sampling frequency handling
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep() Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 2/6] pwm: axi-pwmgen: report the waveform step Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup Nicolae-Daniel Deaconescu
                   ` (2 subsequent siblings)
  5 siblings, 0 replies; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

Fix sampling frequency handling issues:

- Fix issue where writing 0 to sampling_frequency caused a division by
  zero. Return -EINVAL.
- Fix issue where a waveform rounded up by the PWM went unreported:
  pwm_round_waveform_might_sleep() returns 1, which
  ad7625_set_sampling_freq() passed on while dropping the new waveforms.
  Return -EINVAL.
- Fix issue where probe() continued after failing to set the initial
  sampling frequency, leaving the PWMs unconfigured. Return the error.

Fixes: b7ffd0fa65e9 ("iio: adc: ad7625: add driver")
Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
---
 drivers/iio/adc/ad7625.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/drivers/iio/adc/ad7625.c b/drivers/iio/adc/ad7625.c
index e73a5c9e7f0b..ade2f2368bd8 100644
--- a/drivers/iio/adc/ad7625.c
+++ b/drivers/iio/adc/ad7625.c
@@ -178,6 +178,9 @@ static int ad7625_set_sampling_freq(struct ad7625_state *st, u32 freq)
 	unsigned long target;
 	int ret;
 
+	if (!freq)
+		return -EINVAL;
+
 	target = DIV_ROUND_UP(NSEC_PER_SEC, freq);
 	cnv_wf.period_length_ns = clamp(target, 100UL, 10UL * NSEC_PER_USEC);
 
@@ -188,8 +191,10 @@ static int ad7625_set_sampling_freq(struct ad7625_state *st, u32 freq)
 	cnv_wf.duty_length_ns = st->info->timing_spec->conv_high_ns;
 
 	ret = pwm_round_waveform_might_sleep(st->cnv_pwm, &cnv_wf);
-	if (ret)
+	if (ret < 0)
 		return ret;
+	if (ret)
+		return -EINVAL;
 
 	/*
 	 * Set up the burst signal for transferring data. period and
@@ -205,8 +210,10 @@ static int ad7625_set_sampling_freq(struct ad7625_state *st, u32 freq)
 	clk_gate_wf.duty_offset_ns = st->info->timing_spec->conv_msb_ns;
 
 	ret = pwm_round_waveform_might_sleep(st->clk_gate_pwm, &clk_gate_wf);
-	if (ret)
+	if (ret < 0)
 		return ret;
+	if (ret)
+		return -EINVAL;
 
 	st->cnv_wf = cnv_wf;
 	st->clk_gate_wf = clk_gate_wf;
@@ -646,8 +653,8 @@ static int ad7625_probe(struct platform_device *pdev)
 
 	ret = ad7625_set_sampling_freq(st, default_sample_freq);
 	if (ret)
-		dev_err_probe(dev, ret,
-			      "failed to set valid sampling frequency\n");
+		return dev_err_probe(dev, ret,
+				     "failed to set valid sampling frequency\n");
 
 	return devm_iio_device_register(dev, indio_dev);
 }
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
                   ` (2 preceding siblings ...)
  2026-11-19 11:24 ` [PATCH v4 3/6] iio: adc: ad7625: fix sampling frequency handling Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-21 23:40   ` Jonathan Cameron
  2026-11-19 11:24 ` [PATCH v4 5/6] dt-bindings: iio: adc: add adi,ltc2387 Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
  5 siblings, 1 reply; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

Move the EN pin mode setup from ad7625_probe() into
ad7625_set_initial_mode(). Pick the mode first and check the result of
setting it once, returning its error instead of -EINVAL. A following patch
adds parts without EN pins that skip it.

Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
---
 drivers/iio/adc/ad7625.c | 52 ++++++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/drivers/iio/adc/ad7625.c b/drivers/iio/adc/ad7625.c
index ade2f2368bd8..127441050687 100644
--- a/drivers/iio/adc/ad7625.c
+++ b/drivers/iio/adc/ad7625.c
@@ -561,6 +561,32 @@ static int devm_ad7625_regulator_setup(struct device *dev,
 	return 0;
 }
 
+static int ad7625_set_initial_mode(struct device *dev, struct ad7625_state *st)
+{
+	enum ad7960_mode mode;
+	int ret;
+
+	/* Set the device mode based on detected EN configuration. */
+	if (!st->info->has_bandwidth_control) {
+		ad7625_set_en_gpios_for_vref(st, st->have_refin, st->vref_mv);
+		return 0;
+	}
+
+	if (st->can_wide_bandwidth)
+		mode = AD7960_MODE_WIDE_BANDWIDTH;
+	else if (st->can_narrow_bandwidth)
+		mode = AD7960_MODE_NARROW_BANDWIDTH;
+	else
+		return dev_err_probe(dev, -EINVAL,
+			"couldn't set device to wide or narrow bandwidth modes\n");
+
+	ret = ad7960_set_mode(st, mode, st->have_refin, st->vref_mv);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to set EN pins\n");
+
+	return 0;
+}
+
 static int ad7625_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -595,29 +621,9 @@ static int ad7625_probe(struct platform_device *pdev)
 	if (ret)
 		return ret;
 
-	/* Set the device mode based on detected EN configuration. */
-	if (!st->info->has_bandwidth_control) {
-		ad7625_set_en_gpios_for_vref(st, st->have_refin, st->vref_mv);
-	} else {
-		/*
-		 * If neither sampling mode is available, then report an error,
-		 * since the other modes are not useful defaults.
-		 */
-		if (st->can_wide_bandwidth) {
-			ret = ad7960_set_mode(st, AD7960_MODE_WIDE_BANDWIDTH,
-					      st->have_refin, st->vref_mv);
-		} else if (st->can_narrow_bandwidth) {
-			ret = ad7960_set_mode(st, AD7960_MODE_NARROW_BANDWIDTH,
-					      st->have_refin, st->vref_mv);
-		} else {
-			return dev_err_probe(dev, -EINVAL,
-				"couldn't set device to wide or narrow bandwidth modes\n");
-		}
-
-		if (ret)
-			return dev_err_probe(dev, -EINVAL,
-					     "failed to set EN pins\n");
-	}
+	ret = ad7625_set_initial_mode(dev, st);
+	if (ret)
+		return ret;
 
 	ret = devm_ad7625_pwm_get(dev, st);
 	if (ret)
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* [PATCH v4 5/6] dt-bindings: iio: adc: add adi,ltc2387
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
                   ` (3 preceding siblings ...)
  2026-11-19 11:24 ` [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-19 11:24 ` [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
  5 siblings, 0 replies; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu, Conor Dooley

From: Sergiu Cuciurean <sergiu.cuciurean@analog.com>

Add a binding for the LTC2387-16, LTC2387-18, ADAQ23875, ADAQ23876 and
ADAQ23878, single channel differential ADCs that are read like the AD762x
and AD796x: two PWMs drive CNV and CLK and an AXI ADC captures the LVDS
data.

They get their own binding because few properties carry over. Output is
double data rate on one or two lanes, there are no EN pins, and the PWM
provider reports the clock rate. The ADAQ modules add an amplifier ahead
of the ADC, whose gain the devicetree has to describe as strapping can't be
read from the part. There is no fallback compatible, as a driver for an
AD762x or AD796x part would read these wrongly.

Add the binding to the maintainers entry of the AD7625 driver.

Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com>
Co-developed-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
Acked-by: Conor Dooley <conor.dooley@microchip.com>
---
 .../bindings/iio/adc/adi,ltc2387.yaml         | 169 ++++++++++++++++++
 MAINTAINERS                                   |   1 +
 2 files changed, 170 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml

diff --git a/Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml b/Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml
new file mode 100644
index 000000000000..2441446c10a0
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/iio/adc/adi,ltc2387.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Analog Devices LTC2387 and ADAQ2387x Analog to Digital Converters
+
+maintainers:
+  - Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
+  - Sergiu Cuciurean <sergiu.cuciurean@analog.com>
+
+description: |
+  Single channel differential 15 MSPS SAR analog to digital converters with an
+  LVDS interface, and the ADAQ uModule data acquisition systems that put a
+  fully differential amplifier in front of the LTC2387 die.
+
+  * https://www.analog.com/en/products/adaq23875.html
+  * https://www.analog.com/en/products/adaq23876.html
+  * https://www.analog.com/en/products/adaq23878.html
+  * https://www.analog.com/en/products/ltc2387-16.html
+  * https://www.analog.com/en/products/ltc2387-18.html
+
+properties:
+  compatible:
+    enum:
+      - adi,adaq23875
+      - adi,adaq23876
+      - adi,adaq23878
+      - adi,ltc2387-16
+      - adi,ltc2387-18
+
+  vdd-supply:
+    description: 5V analog power supply (VDD).
+
+  vddl-supply:
+    description: 2.5V analog power supply (VDDL), LTC2387 parts only.
+
+  ovdd-supply:
+    description: 2.5V output power supply (OVDD), LTC2387 parts only.
+
+  vio-supply:
+    description: 2.5V digital supply (VIO), ADAQ parts only.
+
+  vs-p-supply:
+    description: Amplifier positive supply (VS+), ADAQ parts only.
+
+  vs-n-supply:
+    description:
+      Amplifier negative supply (VS-), ADAQ parts only. Leave it out if VS-
+      is tied to ground.
+
+  ref-supply:
+    description:
+      Voltage regulator for the external reference voltage on REFBUF. If it
+      is not present, the internal reference is used.
+
+  pwms:
+    items:
+      - description: PWM connected to the CNV input on the ADC.
+      - description:
+          PWM that gates the clock connected to the ADC's CLK input, so that
+          it sees the burst of pulses for each conversion.
+
+  pwm-names:
+    items:
+      - const: cnv
+      - const: clk
+
+  io-backends:
+    description:
+      The AXI ADC IP block connected to the DA+/- and DB+/- data lines and
+      the DCO+/- lines of the ADC.
+    maxItems: 1
+
+  adi,use-two-lanes:
+    $ref: /schemas/types.yaml#/definitions/flag
+    description:
+      Describes whether the TWOLANES pin is set high, selecting two-lane LVDS
+      output, or low, selecting one-lane output (the default).
+
+  adi,gain-milli:
+    $ref: /schemas/types.yaml#/definitions/uint16
+    description:
+      Gain of the fully-differential amplifier that the ADAQ modules
+      integrate ahead of the LTC2387 die, expressed as gain * 1000. It is
+      set by pin strapping on the ADAQ23876 and ADAQ23878, so it must match
+      the board. Not allowed on the ADAQ23875, whose gain is fixed at 2, or
+      on the LTC2387.
+    enum: [370, 730, 870, 1380, 2250]
+
+required:
+  - compatible
+  - pwms
+  - pwm-names
+  - io-backends
+  - vdd-supply
+
+allOf:
+  - if:
+      properties:
+        compatible:
+          contains:
+            enum:
+              - adi,ltc2387-16
+              - adi,ltc2387-18
+    then:
+      properties:
+        vio-supply: false
+        vs-p-supply: false
+        vs-n-supply: false
+        adi,gain-milli: false
+      required:
+        - vddl-supply
+        - ovdd-supply
+    else:
+      properties:
+        vddl-supply: false
+        ovdd-supply: false
+      required:
+        - vio-supply
+        - vs-p-supply
+
+  - if:
+      properties:
+        compatible:
+          contains:
+            const: adi,adaq23875
+    then:
+      properties:
+        adi,gain-milli: false
+
+  - if:
+      properties:
+        compatible:
+          contains:
+            enum:
+              - adi,adaq23876
+              - adi,adaq23878
+    then:
+      required:
+        - adi,gain-milli
+
+additionalProperties: false
+
+examples:
+  - |
+    adc {
+        compatible = "adi,ltc2387-16";
+        io-backends = <&axi_adc>;
+        ovdd-supply = <&supply_2_5V>;
+        pwms = <&axi_pwm_gen 0 0 0>, <&axi_pwm_gen 1 0 0>;
+        pwm-names = "cnv", "clk";
+        ref-supply = <&supply_4_096V>;
+        vdd-supply = <&supply_5V>;
+        vddl-supply = <&supply_2_5V>;
+    };
+  - |
+    adc {
+        compatible = "adi,adaq23878";
+        io-backends = <&axi_adc>;
+        pwms = <&axi_pwm_gen 0 0 0>, <&axi_pwm_gen 1 0 0>;
+        pwm-names = "cnv", "clk";
+        vdd-supply = <&supply_5V>;
+        vio-supply = <&supply_2_5V>;
+        vs-p-supply = <&supply_5V>;
+        adi,gain-milli = /bits/ 16 <870>;
+        adi,use-two-lanes;
+    };
diff --git a/MAINTAINERS b/MAINTAINERS
index 52024397dc78..9d07f1f47c6f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1658,6 +1658,7 @@ S:	Supported
 W:	https://ez.analog.com/linux-software-drivers
 W:	http://analogdevicesinc.github.io/hdl/projects/pulsar_lvds/index.html
 F:	Documentation/devicetree/bindings/iio/adc/adi,ad7625.yaml
+F:	Documentation/devicetree/bindings/iio/adc/adi,ltc2387.yaml
 F:	Documentation/iio/ad7625.rst
 F:	drivers/iio/adc/ad7625.c
 
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support
  2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
                   ` (4 preceding siblings ...)
  2026-11-19 11:24 ` [PATCH v4 5/6] dt-bindings: iio: adc: add adi,ltc2387 Nicolae-Daniel Deaconescu
@ 2026-11-19 11:24 ` Nicolae-Daniel Deaconescu
  2026-11-21 23:48   ` Jonathan Cameron
  5 siblings, 1 reply; 10+ messages in thread
From: Nicolae-Daniel Deaconescu @ 2026-11-19 11:24 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel, Nicolae-Daniel Deaconescu

From: Sergiu Cuciurean <sergiu.cuciurean@analog.com>

Add the LTC2387-16, LTC2387-18, ADAQ23875, ADAQ23876 and ADAQ23878 as chip
data of this driver. The same two PWMs and IIO backend are used to read
from them. See the binding patch for how they differ from the existing
parts.

The CLK burst of a conversion starts at least t_FIRSTCLK after its CNV and
ends at most t_LASTCLK after the next CNV, so the sampling period is raised
until the burst fits, instead of being clamped to 10 MSPS. Waveforms are
built in whole PWM steps, read with pwm_get_waveform_step_might_sleep().

The scale is divided by the gain of the ADAQ front end.

Add new maintainer entries.

Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com>
Co-developed-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
---
 Documentation/iio/ad7625.rst |  34 ++-
 MAINTAINERS                  |   2 +
 drivers/iio/adc/Kconfig      |   7 +-
 drivers/iio/adc/ad7625.c     | 406 ++++++++++++++++++++++++++++++++++-
 4 files changed, 439 insertions(+), 10 deletions(-)

diff --git a/Documentation/iio/ad7625.rst b/Documentation/iio/ad7625.rst
index 61761e3b75c3..c9dbd5c631ba 100644
--- a/Documentation/iio/ad7625.rst
+++ b/Documentation/iio/ad7625.rst
@@ -4,8 +4,8 @@
 AD7625 driver
 ====================
 
-ADC driver for Analog Devices Inc. AD7625, AD7626, AD7960, and AD7961
-devices. The module name is ``ad7625``.
+ADC driver for Analog Devices Inc. AD7625 and fairly similar devices. The module
+name is ``ad7625``.
 
 Supported devices
 =================
@@ -16,8 +16,14 @@ The following chips are supported by this driver:
 * `AD7626 <https://www.analog.com/AD7626>`_
 * `AD7960 <https://www.analog.com/AD7960>`_
 * `AD7961 <https://www.analog.com/AD7961>`_
+* `ADAQ23875 <https://www.analog.com/ADAQ23875>`_
+* `ADAQ23876 <https://www.analog.com/ADAQ23876>`_
+* `ADAQ23878 <https://www.analog.com/ADAQ23878>`_
+* `LTC2387-16 <https://www.analog.com/LTC2387-16>`_
+* `LTC2387-18 <https://www.analog.com/LTC2387-18>`_
 
-The driver requires use of the Pulsar LVDS HDL project:
+The driver requires use of the Pulsar LVDS HDL project for the AD7625, AD7626,
+AD7960 and AD7961:
 
 * `Pulsar LVDS HDL <http://analogdevicesinc.github.io/hdl/projects/pulsar_lvds/index.html>`_
 
@@ -65,6 +71,28 @@ The source is determined by the device tree. If ``ref-supply`` is present, then
 the external reference is used. If ``refin-supply`` is present, then the internal
 buffer is used. If neither is present, then the internal reference is used.
 
+LTC2387 and ADAQ2387x
+---------------------
+
+These parts output data on one or two lanes at double data rate, selected by
+the TWOLANES pin, which the ``adi,use-two-lanes`` property describes. They have no
+EN pins and no ``clocks`` property. The driver asks the two PWMs for their
+step with ``pwm_get_waveform_step_might_sleep()`` and builds the CNV and CLK
+waveforms in whole steps, so that the burst of CLK pulses starts at least
+t\ :sub:`FIRSTCLK` after CNV and ends at most t\ :sub:`LASTCLK` after the
+next CNV. The burst can run into the next conversion period, which limits the
+sampling frequency in one-lane mode. The ADAQ parts divide the scale by the
+gain of their front end. It is fixed on the ADAQ23875 and given by
+``adi,gain-milli`` on the ADAQ23876 and ADAQ23878.
+
+The driver counts every cycle of the clock that the PWM reports as one pulse
+of the CLK input, so the clock gated onto CLK has to be the one the PWM
+counts. They need an AXI ADC design of their own, not the Pulsar LVDS one: the
+DDR capture and the lane count have to match it, as the AXI ADC backend has no
+DDR operation to select it, and for two lanes it has to implement
+``num_lanes_set``. The first sample after the buffer is enabled can be stale,
+as the CLK burst of a conversion may fall into the next conversion period.
+
 Unimplemented features
 ----------------------
 
diff --git a/MAINTAINERS b/MAINTAINERS
index 9d07f1f47c6f..7c419c285e0a 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1653,6 +1653,8 @@ F:	include/dt-bindings/iio/addac/adi,ad74413r.h
 ANALOG DEVICES INC AD7625 DRIVER
 M:	Michael Hennerich <Michael.Hennerich@analog.com>
 M:	Nuno Sá <nuno.sa@analog.com>
+M:	Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
+M:	Sergiu Cuciurean <sergiu.cuciurean@analog.com>
 R:	Trevor Gamblin <tgamblin@baylibre.com>
 S:	Supported
 W:	https://ez.analog.com/linux-software-drivers
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 02de4809ae31..3a79e5ff84f5 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -404,7 +404,7 @@ config AD7606_IFACE_SPI
 	  module will be called ad7606_spi.
 
 config AD7625
-	tristate "Analog Devices AD7625/AD7626 High Speed ADC driver"
+	tristate "Analog Devices high speed LVDS ADCs similar to the AD7625"
 	depends on PWM
 	select IIO_BACKEND
 	help
@@ -413,6 +413,11 @@ config AD7625
 	  * AD7626 16-Bit, 10 MSPS PulSAR Analog-to-Digital Converter
 	  * AD7960 18-Bit, 5 MSPS PulSAR Analog-to-Digital Converter
 	  * AD7961 16-Bit, 5 MSPS PulSAR Analog-to-Digital Converter
+	  * ADAQ23875 and ADAQ23876 16-Bit, 15 MSPS uModule Data Acquisition
+	    Systems
+	  * ADAQ23878 18-Bit, 15 MSPS uModule Data Acquisition System
+	  * LTC2387-16 16-Bit, 15 MSPS SAR Analog-to-Digital Converter
+	  * LTC2387-18 18-Bit, 15 MSPS SAR Analog-to-Digital Converter
 
 	  The driver requires the assistance of the AXI ADC IP core to operate.
 
diff --git a/drivers/iio/adc/ad7625.c b/drivers/iio/adc/ad7625.c
index 127441050687..8ddd18e45c8a 100644
--- a/drivers/iio/adc/ad7625.c
+++ b/drivers/iio/adc/ad7625.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: (GPL-2.0-only)
 /*
- * Analog Devices Inc. AD7625 ADC driver
+ * Analog Devices Inc. high speed LVDS ADCs similar to the AD7625
  *
  * Copyright 2024 Analog Devices Inc.
  * Copyright 2024 BayLibre, SAS
@@ -17,10 +17,14 @@
 #include <linux/iio/backend.h>
 #include <linux/iio/iio.h>
 #include <linux/kernel.h>
+#include <linux/math64.h>
+#include <linux/minmax.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/property.h>
 #include <linux/pwm.h>
 #include <linux/regulator/consumer.h>
+#include <linux/types.h>
 #include <linux/units.h>
 
 #define AD7625_INTERNAL_REF_MV 4096
@@ -33,6 +37,15 @@ struct ad7625_timing_spec {
 	unsigned int conv_msb_ns;
 };
 
+struct ad7625_ddr_timing {
+	/* Minimum conversion high time (t_{CNVH}). */
+	unsigned int cnv_high_min_ns;
+	/* Minimum CNV to first CLK edge of the same conversion (t_{FIRSTCLK}). */
+	unsigned int first_clk_min_ns;
+	/* Maximum next CNV to last CLK edge of the previous one (t_{LASTCLK}). */
+	unsigned int last_clk_max_ns;
+};
+
 struct ad7625_chip_info {
 	const char *name;
 	const unsigned int max_sample_freq_hz;
@@ -41,6 +54,18 @@ struct ad7625_chip_info {
 	const bool has_power_down_state;
 	const bool has_bandwidth_control;
 	const bool has_internal_vref;
+	/* Parts with DDR output on one or two lanes, timed by the PWMs. */
+	const struct ad7625_ddr_timing *ddr_timing;
+	const bool no_en_pins;
+	/* Name of the second PWM, "clk_gate" if NULL. */
+	const char *clk_pwm_name;
+	/* Supplies to enable, if the part isn't supplied by VIO, VDD1, VDD2. */
+	const char * const *supplies;
+	const unsigned int num_supplies;
+	/* Whether the scale is divided by a gain. */
+	const bool has_gain;
+	/* The gain * MILLI, 0 if it is pin strapped on the board and set in the DT. */
+	const u16 default_gain;
 };
 
 /* AD7625_CHAN_SPEC - Define a chan spec structure for a specific chip */
@@ -78,6 +103,12 @@ struct ad7625_state {
 	struct pwm_waveform cnv_wf;
 	unsigned int vref_mv;
 	u32 sampling_freq_hz;
+	/* Step of the PWMs, for the parts with DDR output */
+	struct pwm_waveform_step step;
+	/* Gain of the front end * MILLI */
+	u16 gain;
+	/* Whether the TWOLANES pin is high, for the parts with DDR output */
+	bool two_lanes;
 	/*
 	 * Optional GPIOs for controlling device state. EN0 and EN1
 	 * determine voltage reference configuration and on/off state.
@@ -164,6 +195,78 @@ static const struct ad7625_chip_info ad7961_chip_info = {
 	.has_internal_vref = false,
 };
 
+static const struct ad7625_ddr_timing ltc2387_ddr_timing = {
+	.cnv_high_min_ns = 5,
+	.first_clk_min_ns = 65,
+	.last_clk_max_ns = 49,
+};
+
+static const char * const ltc2387_supplies[] = { "vdd", "vddl", "ovdd" };
+static const char * const adaq2387x_supplies[] = { "vdd", "vio", "vs-p" };
+
+static const struct ad7625_chip_info ltc2387_16_chip_info = {
+	.name = "ltc2387-16",
+	.max_sample_freq_hz = 15 * HZ_PER_MHZ,
+	.chan_spec = AD7625_CHAN_SPEC(16),
+	.ddr_timing = &ltc2387_ddr_timing,
+	.no_en_pins = true,
+	.clk_pwm_name = "clk",
+	.has_gain = true,
+	.supplies = ltc2387_supplies,
+	.num_supplies = ARRAY_SIZE(ltc2387_supplies),
+	.default_gain = 1 * MILLI,
+};
+
+static const struct ad7625_chip_info ltc2387_18_chip_info = {
+	.name = "ltc2387-18",
+	.max_sample_freq_hz = 15 * HZ_PER_MHZ,
+	.chan_spec = AD7625_CHAN_SPEC(18),
+	.ddr_timing = &ltc2387_ddr_timing,
+	.no_en_pins = true,
+	.clk_pwm_name = "clk",
+	.has_gain = true,
+	.supplies = ltc2387_supplies,
+	.num_supplies = ARRAY_SIZE(ltc2387_supplies),
+	.default_gain = 1 * MILLI,
+};
+
+static const struct ad7625_chip_info adaq23875_chip_info = {
+	.name = "adaq23875",
+	.max_sample_freq_hz = 15 * HZ_PER_MHZ,
+	.chan_spec = AD7625_CHAN_SPEC(16),
+	.ddr_timing = &ltc2387_ddr_timing,
+	.no_en_pins = true,
+	.clk_pwm_name = "clk",
+	.has_gain = true,
+	.supplies = adaq2387x_supplies,
+	.num_supplies = ARRAY_SIZE(adaq2387x_supplies),
+	.default_gain = 2 * MILLI,
+};
+
+static const struct ad7625_chip_info adaq23876_chip_info = {
+	.name = "adaq23876",
+	.max_sample_freq_hz = 15 * HZ_PER_MHZ,
+	.chan_spec = AD7625_CHAN_SPEC(16),
+	.ddr_timing = &ltc2387_ddr_timing,
+	.no_en_pins = true,
+	.clk_pwm_name = "clk",
+	.has_gain = true,
+	.supplies = adaq2387x_supplies,
+	.num_supplies = ARRAY_SIZE(adaq2387x_supplies),
+};
+
+static const struct ad7625_chip_info adaq23878_chip_info = {
+	.name = "adaq23878",
+	.max_sample_freq_hz = 15 * HZ_PER_MHZ,
+	.chan_spec = AD7625_CHAN_SPEC(18),
+	.ddr_timing = &ltc2387_ddr_timing,
+	.no_en_pins = true,
+	.clk_pwm_name = "clk",
+	.has_gain = true,
+	.supplies = adaq2387x_supplies,
+	.num_supplies = ARRAY_SIZE(adaq2387x_supplies),
+};
+
 enum ad7960_mode {
 	AD7960_MODE_POWER_DOWN,
 	AD7960_MODE_SNOOZE,
@@ -172,12 +275,178 @@ enum ad7960_mode {
 	AD7960_MODE_TEST_PATTERN,
 };
 
+/* Cycles of the gated clock needed to cover @ns, rounded up. */
+static u32 ad7625_ddr_ns_to_cycles(struct ad7625_state *st, u32 ns)
+{
+	return mul_u64_u64_div_u64_roundup(ns, st->step.clk_rate_Hz,
+					   NSEC_PER_SEC);
+}
+
+/* PWM steps needed to cover @cycles clock cycles, rounded up. */
+static u32 ad7625_ddr_cycles_to_steps(struct ad7625_state *st, u32 cycles)
+{
+	return DIV_ROUND_UP(cycles, st->step.clk_cycles_per_step);
+}
+
+/*
+ * The PWMs round a requested length down to whole steps, so asking for
+ * round_up(n * step) ns results in exactly n steps.
+ */
+static u64 ad7625_ddr_steps_to_ns(struct ad7625_state *st, u32 steps)
+{
+	u64 cycles = mul_u32_u32(steps, st->step.clk_cycles_per_step);
+
+	return mul_u64_u64_div_u64_roundup(cycles, NSEC_PER_SEC,
+					   st->step.clk_rate_Hz);
+}
+
+/* CLK pulses per conversion. Each pulse carries 2 bits per lane (DDR). */
+static u32 ad7625_ddr_burst_pulses(struct ad7625_state *st)
+{
+	return DIV_ROUND_UP(st->info->chan_spec.scan_type.realbits,
+			    st->two_lanes ? 4 : 2);
+}
+
+/*
+ * Read the step of the PWMs. They have to agree, as CNV and CLK are one
+ * burst, and the burst has to be a whole number of steps long, so a PWM that
+ * takes several clock cycles per step can only make a matching number of
+ * pulses.
+ */
+static int ad7625_ddr_read_step(struct ad7625_state *st,
+				struct pwm_waveform_step *step)
+{
+	struct pwm_waveform_step cnv_step;
+	int ret;
+
+	ret = pwm_get_waveform_step_might_sleep(st->clk_gate_pwm, step);
+	if (ret)
+		return ret;
+
+	ret = pwm_get_waveform_step_might_sleep(st->cnv_pwm, &cnv_step);
+	if (ret)
+		return ret;
+
+	if (cnv_step.clk_rate_Hz != step->clk_rate_Hz ||
+	    cnv_step.clk_cycles_per_step != step->clk_cycles_per_step)
+		return -EINVAL;
+
+	if (ad7625_ddr_burst_pulses(st) % step->clk_cycles_per_step)
+		return -EINVAL;
+
+	return 0;
+}
+
+static int ad7625_ddr_apply_freq(struct ad7625_state *st, u32 freq)
+{
+	u32 period, period_cycles, min_period, gate, burst_end, lastclk;
+	const struct ad7625_ddr_timing *t = st->info->ddr_timing;
+	u32 offset, offset_cycles, cnvh, cnvh_cycles;
+	struct pwm_waveform clk_gate_wf, cnv_wf;
+	struct pwm_waveform_step step;
+	u32 cycles_per_step;
+	int ret;
+
+	/* The step changes if the clock of the PWMs was reconfigured since probe. */
+	ret = ad7625_ddr_read_step(st, &step);
+	if (ret)
+		return ret;
+
+	st->step = step;
+
+	if (!freq || freq > st->info->max_sample_freq_hz ||
+	    freq > st->step.clk_rate_Hz)
+		return -EINVAL;
+
+	cycles_per_step = st->step.clk_cycles_per_step;
+
+	/*
+	 * Lengths are in steps of the PWMs, except lastclk, burst_end and the
+	 * ones named *_cycles, which are in clock cycles.
+	 */
+	gate = ad7625_ddr_burst_pulses(st) / cycles_per_step;
+	cnvh_cycles = ad7625_ddr_ns_to_cycles(st, t->cnv_high_min_ns);
+	cnvh = max(ad7625_ddr_cycles_to_steps(st, cnvh_cycles), 1U);
+	offset_cycles = ad7625_ddr_ns_to_cycles(st, t->first_clk_min_ns);
+	offset = ad7625_ddr_cycles_to_steps(st, offset_cycles);
+	lastclk = mul_u64_u64_div_u64(t->last_clk_max_ns, st->step.clk_rate_Hz,
+				      NSEC_PER_SEC);
+
+	/*
+	 * The gated clock burst for one conversion starts t_FIRSTCLK after its
+	 * CNV and may run into the next period, but has to end within
+	 * t_LASTCLK of the next CNV. It must also leave the gate low for at
+	 * least one step per period.
+	 */
+	burst_end = (offset + gate) * cycles_per_step;
+	min_period = burst_end > lastclk ?
+		     DIV_ROUND_UP(burst_end - lastclk, cycles_per_step) : 0;
+	period_cycles = DIV_ROUND_UP(st->step.clk_rate_Hz, freq);
+	period = max3(DIV_ROUND_UP(period_cycles, cycles_per_step), gate + 1,
+		      min_period);
+
+	cnv_wf = (struct pwm_waveform) {
+		.period_length_ns = ad7625_ddr_steps_to_ns(st, period),
+		.duty_length_ns = ad7625_ddr_steps_to_ns(st, cnvh),
+		.duty_offset_ns = 0,
+	};
+	clk_gate_wf = (struct pwm_waveform) {
+		.period_length_ns = cnv_wf.period_length_ns,
+		.duty_length_ns = ad7625_ddr_steps_to_ns(st, gate),
+		.duty_offset_ns = ad7625_ddr_steps_to_ns(st, offset % period),
+	};
+
+	/*
+	 * The waveforms are whole steps, so nothing should have to grow. If it
+	 * did, a minimum time of the part is no longer met.
+	 */
+	ret = pwm_round_waveform_might_sleep(st->cnv_pwm, &cnv_wf);
+	if (ret < 0)
+		return ret;
+	if (ret)
+		return -EINVAL;
+
+	ret = pwm_round_waveform_might_sleep(st->clk_gate_pwm, &clk_gate_wf);
+	if (ret < 0)
+		return ret;
+	if (ret)
+		return -EINVAL;
+
+	st->cnv_wf = cnv_wf;
+	st->clk_gate_wf = clk_gate_wf;
+	/*
+	 * The period was rounded up from the requested frequency, so round the
+	 * frequency up too, or writing the reported value back could add a step.
+	 */
+	st->sampling_freq_hz =
+		DIV64_U64_ROUND_UP(st->step.clk_rate_Hz,
+				   mul_u32_u32(period, cycles_per_step));
+
+	return 0;
+}
+
+static int ad7625_set_sampling_freq_ddr(struct ad7625_state *st, u32 freq)
+{
+	struct pwm_waveform_step old_step = st->step;
+	int ret;
+
+	ret = ad7625_ddr_apply_freq(st, freq);
+	/* Keep the step that the stored waveforms were computed with. */
+	if (ret)
+		st->step = old_step;
+
+	return ret;
+}
+
 static int ad7625_set_sampling_freq(struct ad7625_state *st, u32 freq)
 {
 	struct pwm_waveform clk_gate_wf = { }, cnv_wf = { };
 	unsigned long target;
 	int ret;
 
+	if (st->info->ddr_timing)
+		return ad7625_set_sampling_freq_ddr(st, freq);
+
 	if (!freq)
 		return -EINVAL;
 
@@ -239,6 +508,14 @@ static int ad7625_read_raw(struct iio_dev *indio_dev,
 		return IIO_VAL_INT;
 
 	case IIO_CHAN_INFO_SCALE:
+		if (st->info->has_gain) {
+			/* Divided by the gain of the front end, 1 if the part has none. */
+			*val = st->vref_mv * MILLI;
+			*val2 = st->gain << (chan->scan_type.realbits - 1);
+
+			return IIO_VAL_FRACTIONAL;
+		}
+
 		*val = st->vref_mv;
 		*val2 = chan->scan_type.realbits - 1;
 
@@ -421,6 +698,37 @@ static int ad7960_set_mode(struct ad7625_state *st, enum ad7960_mode mode,
 	}
 }
 
+/* The gains the ADAQ23876 and ADAQ23878 can be strapped to, times MILLI. */
+static const u16 ad7625_gains[] = { 370, 730, 870, 1380, 2250 };
+
+static int ad7625_parse_ddr(struct device *dev, struct ad7625_state *st)
+{
+	int ret;
+
+	st->two_lanes = device_property_read_bool(dev, "adi,use-two-lanes");
+
+	/* A fixed gain part has no adi,gain-milli, the others are pin strapped. */
+	st->gain = st->info->default_gain;
+	if (st->gain)
+		return 0;
+
+	ret = device_property_read_u16(dev, "adi,gain-milli", &st->gain);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "failed to read adi,gain-milli\n");
+
+	/*
+	 * The scale is gain << (realbits - 1), up to 17 bits for the 18-bit
+	 * parts, and has to fit in an int, so only these gains are accepted.
+	 */
+	for (unsigned int i = 0; i < ARRAY_SIZE(ad7625_gains); i++)
+		if (st->gain == ad7625_gains[i])
+			return 0;
+
+	return dev_err_probe(dev, -EINVAL, "unsupported adi,gain-milli %u\n",
+			     st->gain);
+}
+
 static int ad7625_buffer_preenable(struct iio_dev *indio_dev)
 {
 	struct ad7625_state *st = iio_priv(indio_dev);
@@ -464,8 +772,10 @@ static const struct iio_buffer_setup_ops ad7625_buffer_setup_ops = {
 static int devm_ad7625_pwm_get(struct device *dev,
 			       struct ad7625_state *st)
 {
+	const char *clk_name;
 	struct clk *ref_clk;
 	u32 ref_clk_rate_hz;
+	int ret;
 
 	st->cnv_pwm = devm_pwm_get(dev, "cnv");
 	if (IS_ERR(st->cnv_pwm))
@@ -475,14 +785,28 @@ static int devm_ad7625_pwm_get(struct device *dev,
 	/* Preemptively disable the PWM in case it was enabled at boot */
 	pwm_disable(st->cnv_pwm);
 
-	st->clk_gate_pwm = devm_pwm_get(dev, "clk_gate");
+	clk_name = st->info->clk_pwm_name ?: "clk_gate";
+	st->clk_gate_pwm = devm_pwm_get(dev, clk_name);
 	if (IS_ERR(st->clk_gate_pwm))
 		return dev_err_probe(dev, PTR_ERR(st->clk_gate_pwm),
-				     "failed to get clk_gate pwm\n");
+				     "failed to get %s pwm\n", clk_name);
 
 	/* Preemptively disable the PWM in case it was enabled at boot */
 	pwm_disable(st->clk_gate_pwm);
 
+	/*
+	 * The PWMs tell the step of their waveforms, so the parts with DDR
+	 * output need no clock of their own to know the length of a CLK pulse.
+	 */
+	if (st->info->ddr_timing) {
+		ret = ad7625_ddr_read_step(st, &st->step);
+		if (ret)
+			return dev_err_probe(dev, ret,
+					     "failed to get usable steps of the pwms\n");
+
+		return 0;
+	}
+
 	ref_clk = devm_clk_get_enabled(dev, NULL);
 	if (IS_ERR(ref_clk))
 		return dev_err_probe(dev, PTR_ERR(ref_clk),
@@ -498,8 +822,40 @@ static int devm_ad7625_pwm_get(struct device *dev,
 	return 0;
 }
 
+static int devm_ad7625_listed_regulator_setup(struct device *dev,
+					      struct ad7625_state *st)
+{
+	int ret;
+
+	ret = devm_regulator_bulk_get_enable(dev, st->info->num_supplies,
+					     st->info->supplies);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to enable supplies\n");
+
+	/* VS- of the ADAQ modules is left out if it is tied to ground. */
+	ret = devm_regulator_get_enable_optional(dev, "vs-n");
+	if (ret && ret != -ENODEV)
+		return dev_err_probe(dev, ret, "failed to enable VS-\n");
+
+	ret = devm_regulator_get_enable_read_voltage(dev, "ref");
+	if (ret == -ENODEV) {
+		/* Without ref-supply the internal reference is used. */
+		st->vref_mv = AD7625_INTERNAL_REF_MV;
+		return 0;
+	}
+	if (ret < 0)
+		return dev_err_probe(dev, ret, "failed to get REF voltage\n");
+
+	st->vref_mv = ret / (MICRO / MILLI);
+
+	return 0;
+}
+
 /*
- * There are three required input voltages for each device, plus two
+ * Parts with a supply list in their chip info (LTC2387, ADAQ2387x) get their
+ * supplies and the optional REF from devm_ad7625_listed_regulator_setup().
+ *
+ * The other parts have three required input voltages each, plus two
  * conditionally-optional (depending on part) REF and REFIN voltages
  * where their validity depends upon the EN pin configuration.
  *
@@ -519,6 +875,9 @@ static int devm_ad7625_regulator_setup(struct device *dev,
 	static const char * const regulator_names[] = { "vio", "vdd2", "vdd1" };
 	int ret, ref_mv;
 
+	if (st->info->supplies)
+		return devm_ad7625_listed_regulator_setup(dev, st);
+
 	ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulator_names),
 					     regulator_names);
 	if (ret)
@@ -566,6 +925,10 @@ static int ad7625_set_initial_mode(struct device *dev, struct ad7625_state *st)
 	enum ad7960_mode mode;
 	int ret;
 
+	/* The new parts have no EN pins. */
+	if (st->info->no_en_pins)
+		return 0;
+
 	/* Set the device mode based on detected EN configuration. */
 	if (!st->info->has_bandwidth_control) {
 		ad7625_set_en_gpios_for_vref(st, st->have_refin, st->vref_mv);
@@ -609,7 +972,9 @@ static int ad7625_probe(struct platform_device *pdev)
 		return dev_err_probe(dev, -EINVAL,
 				     "self-clocked mode not supported\n");
 
-	if (st->info->has_bandwidth_control)
+	if (st->info->ddr_timing)
+		ret = ad7625_parse_ddr(dev, st);
+	else if (st->info->has_bandwidth_control)
 		ret = ad7625_parse_mode(dev, st, 4);
 	else
 		ret = ad7625_parse_mode(dev, st, 2);
@@ -644,6 +1009,20 @@ static int ad7625_probe(struct platform_device *pdev)
 	if (ret)
 		return ret;
 
+	if (st->info->ddr_timing) {
+		if (st->two_lanes) {
+			ret = iio_backend_num_lanes_set(st->back, 2);
+		} else {
+			ret = iio_backend_num_lanes_set(st->back, 1);
+			/* Without the op, a backend can only be left on one lane. */
+			if (ret == -EOPNOTSUPP)
+				ret = 0;
+		}
+		if (ret)
+			return dev_err_probe(dev, ret,
+					     "failed to set the number of lanes\n");
+	}
+
 	ret = devm_iio_backend_enable(dev, st->back);
 	if (ret)
 		return ret;
@@ -657,6 +1036,11 @@ static int ad7625_probe(struct platform_device *pdev)
 	if (st->info->has_bandwidth_control && !st->can_wide_bandwidth)
 		default_sample_freq = AD7960_MAX_NBW_FREQ;
 
+	/* The DDR parts reject rates above the clock of the PWMs. */
+	if (st->info->ddr_timing)
+		default_sample_freq = min(default_sample_freq,
+					  st->step.clk_rate_Hz);
+
 	ret = ad7625_set_sampling_freq(st, default_sample_freq);
 	if (ret)
 		return dev_err_probe(dev, ret,
@@ -670,6 +1054,11 @@ static const struct of_device_id ad7625_of_match[] = {
 	{ .compatible = "adi,ad7626", .data = &ad7626_chip_info },
 	{ .compatible = "adi,ad7960", .data = &ad7960_chip_info },
 	{ .compatible = "adi,ad7961", .data = &ad7961_chip_info },
+	{ .compatible = "adi,adaq23875", .data = &adaq23875_chip_info },
+	{ .compatible = "adi,adaq23876", .data = &adaq23876_chip_info },
+	{ .compatible = "adi,adaq23878", .data = &adaq23878_chip_info },
+	{ .compatible = "adi,ltc2387-16", .data = &ltc2387_16_chip_info },
+	{ .compatible = "adi,ltc2387-18", .data = &ltc2387_18_chip_info },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, ad7625_of_match);
@@ -679,6 +1068,11 @@ static const struct platform_device_id ad7625_device_ids[] = {
 	{ .name = "ad7626", .driver_data = (kernel_ulong_t)&ad7626_chip_info },
 	{ .name = "ad7960", .driver_data = (kernel_ulong_t)&ad7960_chip_info },
 	{ .name = "ad7961", .driver_data = (kernel_ulong_t)&ad7961_chip_info },
+	{ .name = "adaq23875", .driver_data = (kernel_ulong_t)&adaq23875_chip_info },
+	{ .name = "adaq23876", .driver_data = (kernel_ulong_t)&adaq23876_chip_info },
+	{ .name = "adaq23878", .driver_data = (kernel_ulong_t)&adaq23878_chip_info },
+	{ .name = "ltc2387-16", .driver_data = (kernel_ulong_t)&ltc2387_16_chip_info },
+	{ .name = "ltc2387-18", .driver_data = (kernel_ulong_t)&ltc2387_18_chip_info },
 	{ }
 };
 MODULE_DEVICE_TABLE(platform, ad7625_device_ids);
@@ -694,6 +1088,6 @@ static struct platform_driver ad7625_driver = {
 module_platform_driver(ad7625_driver);
 
 MODULE_AUTHOR("Trevor Gamblin <tgamblin@baylibre.com>");
-MODULE_DESCRIPTION("Analog Devices AD7625 ADC");
+MODULE_DESCRIPTION("Analog Devices high speed LVDS ADCs similar to the AD7625");
 MODULE_LICENSE("GPL");
 MODULE_IMPORT_NS("IIO_BACKEND");
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 10+ messages in thread

* Re: [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep()
  2026-11-19 11:24 ` [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep() Nicolae-Daniel Deaconescu
@ 2026-11-21 23:35   ` Jonathan Cameron
  0 siblings, 0 replies; 10+ messages in thread
From: Jonathan Cameron @ 2026-11-21 23:35 UTC (permalink / raw)
  To: Nicolae-Daniel Deaconescu
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel

On Thu, 19 Nov 2026 13:24:15 +0200
Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com> wrote:

> A consumer that must meet minimum times, or place an edge relative to the
> cycles of a clock a PWM gates, can't do that with the waveform API alone:
> rounding goes down, and the margin a minimum needs is the PWM step, known
> only to the provider.
> 
> Let the provider report the rate of the clock its timing derives from and
> the clock cycles per step. A consumer then works in whole steps and rounds
> up when converting to nanoseconds, instead of reading the rate from a clock
> it gets on its own, which breaks if the PWM divides its clock.
> 
> Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
> ---
>  drivers/pwm/core.c  | 69 +++++++++++++++++++++++++++++++++++++++++++++
>  include/linux/pwm.h | 34 ++++++++++++++++++++++
>  2 files changed, 103 insertions(+)
> 
> diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c
> index 2a050ff4608b..a63b8f65a43d 100644
> --- a/drivers/pwm/core.c
> +++ b/drivers/pwm/core.c
> @@ -14,6 +14,7 @@
>  #include <linux/of.h>
>  #include <linux/pwm.h>
>  #include <linux/list.h>
> +#include <linux/math64.h>
>  #include <linux/mutex.h>
>  #include <linux/err.h>
>  #include <linux/slab.h>
> @@ -325,6 +326,68 @@ int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf
>  }
>  EXPORT_SYMBOL_GPL(pwm_get_waveform_might_sleep);
>  
> +/**
> + * pwm_get_waveform_step_might_sleep - Query the granularity of the waveforms
> + * Cannot be used in atomic context.

Odd to have that second bit here in the kernel-doc. Particularly as you have
a Context entry below saying the same thing below and a name of _might_sleep.

> + * @pwm: PWM device
> + * @step: output parameter
> + *
> + * Stores in @step the clock rate the timing of @pwm is derived from and how
> + * many cycles of that clock one step lasts. Period, duty length and duty

Can this be a cross reference to the docs in for the structure?
Nice to not duplicate stuff where possible.

> + * offset are multiples of that step, so a waveform that is asked for in whole
> + * steps, and is within the range of the hardware, is not changed by rounding.
> + * Compute the length of n steps in nanoseconds as
> + * n * @step->clk_cycles_per_step * NSEC_PER_SEC / @step->clk_rate_Hz and round

I'd tweak the wrap to just have the formula on a line on its own.

> + * it up, because pwm_round_waveform_might_sleep() and
> + * pwm_set_waveform_might_sleep() round down. The product can exceed 64 bits, so
> + * compute it with mul_u64_u64_div_u64_roundup().

I don't understand this. I was thinking it was an implementation detail that
should not be in these docs anyway, but I can't immediately spot it at all.
So rewrite or drop.


> + *
> + * The values can change when a clock changes its rate, so they are only valid
> + * as long as the provider's input clocks are not reconfigured.
> + *
> + * Context: May sleep.
> + * Returns: 0 on success, -EOPNOTSUPP if the provider doesn't report it or a
> + * negative errno.
> + */
> +int pwm_get_waveform_step_might_sleep(struct pwm_device *pwm,
> +				      struct pwm_waveform_step *step)
> +{
> +	struct pwm_chip *chip = pwm->chip;
> +	const struct pwm_ops *ops = chip->ops;
> +	int ret;
> +
> +	might_sleep();
> +
> +	if (!pwmchip_supports_waveform(chip) || !ops->get_waveform_step)
> +		return -EOPNOTSUPP;
> +
> +	guard(pwmchip)(chip);
> +
> +	if (!chip->operational)
> +		return -ENODEV;
> +
> +	if (IS_ENABLED(CONFIG_PWM_DEBUG) && chip->atomic) {
> +		/*
> +		 * Catch any drivers that have been marked as atomic but
> +		 * that will sleep anyway.

Wrap comments to 80 chars unless it helps readability to not do so.

> +		 */
> +		non_block_start();
> +		ret = ops->get_waveform_step(chip, pwm, step);
> +		non_block_end();
> +	} else {
> +		ret = ops->get_waveform_step(chip, pwm, step);
> +	}
> +	if (ret)
> +		return ret;
> +
> +	if (!step->clk_rate_Hz ||
> +	    step->clk_rate_Hz > mul_u32_u32(step->clk_cycles_per_step, NSEC_PER_SEC))
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +EXPORT_SYMBOL_GPL(pwm_get_waveform_step_might_sleep);
> +
>  /* Called with the pwmchip lock held */
>  static int __pwm_set_waveform(struct pwm_device *pwm,
>  			      const struct pwm_waveform *wf,
> @@ -1710,6 +1773,12 @@ static bool pwm_ops_check(const struct pwm_chip *chip)
>  		if (!ops->apply)
>  			return false;
>  
> +		if (ops->get_waveform_step) {
> +			dev_warn(pwmchip_parent(chip),
> +				 ".get_waveform_step() needs .write_waveform()\n");
> +			return false;
> +		}
> +
>  		if (IS_ENABLED(CONFIG_PWM_DEBUG) && !ops->get_state)
>  			dev_warn(pwmchip_parent(chip),
>  				 "Please implement the .get_state() callback\n");
> diff --git a/include/linux/pwm.h b/include/linux/pwm.h
> index b11ae91723f8..c52f4c9153c2 100644
> --- a/include/linux/pwm.h
> +++ b/include/linux/pwm.h
> @@ -76,6 +76,34 @@ struct pwm_waveform {
>  	u64 duty_offset_ns;
>  };
>  
> +/**
> + * struct pwm_waveform_step - granularity of the waveforms a PWM can generate
> + * @clk_rate_Hz: rate of the clock the PWM's timing is derived from
> + * @clk_cycles_per_step: number of those clock cycles one step lasts
> + *
> + * The period, the duty length and the duty offset of a waveform are multiples
> + * of one step, which lasts @clk_cycles_per_step / @clk_rate_Hz seconds. A PWM
> + * that divides its input clock in hardware has @clk_cycles_per_step > 1. A
> + * waveform that is asked for in whole steps, and is within the range of the
> + * hardware, is not changed by rounding.
> + *
> + * The step is the same for every waveform and for the period, the duty length
> + * and the duty offset, so a provider whose granularity depends on the
> + * requested period (for example through a prescaler) can't describe itself
> + * with it. One step also has to last at least 1 ns, otherwise rounding a
> + * length in nanoseconds up can add a whole step.
> + *
> + * A consumer that needs a minimum time, or that has to place an edge relative
> + * to the cycles of the clock a PWM channel gates, can use this to ask for
> + * the next possible value instead of one that is rounded down, and to compute
> + * the frequency a rounded period results in without the error of the
> + * nanosecond resolution of struct pwm_waveform.
> + */
> +struct pwm_waveform_step {
> +	unsigned long clk_rate_Hz;
> +	unsigned int clk_cycles_per_step;
> +};

For this to go through IIO (or an immutable branch if needed) I'll obviously
need PWM tags.

Thanks,

Jonathan


^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup
  2026-11-19 11:24 ` [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup Nicolae-Daniel Deaconescu
@ 2026-11-21 23:40   ` Jonathan Cameron
  0 siblings, 0 replies; 10+ messages in thread
From: Jonathan Cameron @ 2026-11-21 23:40 UTC (permalink / raw)
  To: Nicolae-Daniel Deaconescu
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel

On Thu, 19 Nov 2026 13:24:18 +0200
Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com> wrote:

Rather than move, I'd say 'factor out' for the title and in this text.

> Move the EN pin mode setup from ad7625_probe() into
> ad7625_set_initial_mode(). Pick the mode first and check the result of
> setting it once, returning its error instead of -EINVAL. A following patch

It was only ever set once.  Anyhow the only bit of this paragraph I'd
keep is.  "Return error if reported by ad7960_set_mode() rather than
replacing it with -EINVAL"

> adds parts without EN pins that skip it.
This last bit is fine but I'd put it first as the 'why' answer for the
whole patch.


> 
> Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
> ---
>  drivers/iio/adc/ad7625.c | 52 ++++++++++++++++++++++------------------
>  1 file changed, 29 insertions(+), 23 deletions(-)
> 
> diff --git a/drivers/iio/adc/ad7625.c b/drivers/iio/adc/ad7625.c
> index ade2f2368bd8..127441050687 100644
> --- a/drivers/iio/adc/ad7625.c
> +++ b/drivers/iio/adc/ad7625.c
> @@ -561,6 +561,32 @@ static int devm_ad7625_regulator_setup(struct device *dev,
>  	return 0;
>  }
>  
> +static int ad7625_set_initial_mode(struct device *dev, struct ad7625_state *st)
> +{
> +	enum ad7960_mode mode;
> +	int ret;
> +
> +	/* Set the device mode based on detected EN configuration. */
> +	if (!st->info->has_bandwidth_control) {
> +		ad7625_set_en_gpios_for_vref(st, st->have_refin, st->vref_mv);
> +		return 0;
> +	}
> +
> +	if (st->can_wide_bandwidth)
> +		mode = AD7960_MODE_WIDE_BANDWIDTH;
> +	else if (st->can_narrow_bandwidth)
> +		mode = AD7960_MODE_NARROW_BANDWIDTH;
> +	else
> +		return dev_err_probe(dev, -EINVAL,
> +			"couldn't set device to wide or narrow bandwidth modes\n");
> +
> +	ret = ad7960_set_mode(st, mode, st->have_refin, st->vref_mv);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "failed to set EN pins\n");
> +
> +	return 0;
> +}
> +
>  static int ad7625_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
> @@ -595,29 +621,9 @@ static int ad7625_probe(struct platform_device *pdev)
>  	if (ret)
>  		return ret;
>  
> -	/* Set the device mode based on detected EN configuration. */
> -	if (!st->info->has_bandwidth_control) {
> -		ad7625_set_en_gpios_for_vref(st, st->have_refin, st->vref_mv);
> -	} else {
> -		/*
> -		 * If neither sampling mode is available, then report an error,
> -		 * since the other modes are not useful defaults.
> -		 */
> -		if (st->can_wide_bandwidth) {
> -			ret = ad7960_set_mode(st, AD7960_MODE_WIDE_BANDWIDTH,
> -					      st->have_refin, st->vref_mv);
> -		} else if (st->can_narrow_bandwidth) {
> -			ret = ad7960_set_mode(st, AD7960_MODE_NARROW_BANDWIDTH,
> -					      st->have_refin, st->vref_mv);
> -		} else {
> -			return dev_err_probe(dev, -EINVAL,
> -				"couldn't set device to wide or narrow bandwidth modes\n");
> -		}
> -
> -		if (ret)
> -			return dev_err_probe(dev, -EINVAL,
> -					     "failed to set EN pins\n");
> -	}
> +	ret = ad7625_set_initial_mode(dev, st);
> +	if (ret)
> +		return ret;
>  
>  	ret = devm_ad7625_pwm_get(dev, st);
>  	if (ret)


^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support
  2026-11-19 11:24 ` [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
@ 2026-11-21 23:48   ` Jonathan Cameron
  0 siblings, 0 replies; 10+ messages in thread
From: Jonathan Cameron @ 2026-11-21 23:48 UTC (permalink / raw)
  To: Nicolae-Daniel Deaconescu
  Cc: Uwe Kleine-König, Conor Dooley, Krzysztof Kozlowski,
	Rob Herring, David Lechner, Nuno Sá, Andy Shevchenko,
	Michael Hennerich, Trevor Gamblin, Joshua Crofts,
	Sergiu Cuciurean, linux-iio, devicetree, linux-pwm, linux-doc,
	linux-kernel

On Thu, 19 Nov 2026 13:24:20 +0200
Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com> wrote:

> From: Sergiu Cuciurean <sergiu.cuciurean@analog.com>
> 
> Add the LTC2387-16, LTC2387-18, ADAQ23875, ADAQ23876 and ADAQ23878 as chip
> data of this driver. The same two PWMs and IIO backend are used to read
> from them. See the binding patch for how they differ from the existing
> parts.
> 
> The CLK burst of a conversion starts at least t_FIRSTCLK after its CNV and
> ends at most t_LASTCLK after the next CNV, so the sampling period is raised
> until the burst fits, instead of being clamped to 10 MSPS. Waveforms are
> built in whole PWM steps, read with pwm_get_waveform_step_might_sleep().
> 
> The scale is divided by the gain of the ADAQ front end.
> 
> Add new maintainer entries.
> 
> Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com>
> Co-developed-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>
> Signed-off-by: Nicolae-Daniel Deaconescu <Nicolae-daniel.Deaconescu@analog.com>


> diff --git a/drivers/iio/adc/ad7625.c b/drivers/iio/adc/ad7625.c
> index 127441050687..8ddd18e45c8a 100644
> --- a/drivers/iio/adc/ad7625.c
> +++ b/drivers/iio/adc/ad7625.c
One minor thing inline. Looks to be a good shape. Thanks

Jonathan


> @@ -498,8 +822,40 @@ static int devm_ad7625_pwm_get(struct device *dev,
>  	return 0;
>  }
>  
> +static int devm_ad7625_listed_regulator_setup(struct device *dev,
> +					      struct ad7625_state *st)
> +{
> +	int ret;
> +
> +	ret = devm_regulator_bulk_get_enable(dev, st->info->num_supplies,
> +					     st->info->supplies);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "failed to enable supplies\n");
> +
> +	/* VS- of the ADAQ modules is left out if it is tied to ground. */
> +	ret = devm_regulator_get_enable_optional(dev, "vs-n");
Does it hurt to just a non optional call here?
You'll get a stub regulator that will do nothing. That seems to make
little difference vs carefully handling the not present case.

The optional stuff only really comes into its own when we want
to do something else instead. It doesn't matter if we are ignoring
the lack of presence.

> +	if (ret && ret != -ENODEV)
> +		return dev_err_probe(dev, ret, "failed to enable VS-\n");
> +
> +	ret = devm_regulator_get_enable_read_voltage(dev, "ref");
> +	if (ret == -ENODEV) {
> +		/* Without ref-supply the internal reference is used. */
> +		st->vref_mv = AD7625_INTERNAL_REF_MV;
> +		return 0;
> +	}
> +	if (ret < 0)
> +		return dev_err_probe(dev, ret, "failed to get REF voltage\n");
> +
> +	st->vref_mv = ret / (MICRO / MILLI);
> +
> +	return 0;
> +}



^ permalink raw reply	[flat|nested] 10+ messages in thread

end of thread, other threads:[~2026-11-21 23:48 UTC | newest]

Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 11:24 [PATCH v4 0/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
2026-11-19 11:24 ` [PATCH v4 1/6] pwm: core: add pwm_get_waveform_step_might_sleep() Nicolae-Daniel Deaconescu
2026-11-21 23:35   ` Jonathan Cameron
2026-11-19 11:24 ` [PATCH v4 2/6] pwm: axi-pwmgen: report the waveform step Nicolae-Daniel Deaconescu
2026-11-19 11:24 ` [PATCH v4 3/6] iio: adc: ad7625: fix sampling frequency handling Nicolae-Daniel Deaconescu
2026-11-19 11:24 ` [PATCH v4 4/6] iio: adc: ad7625: move initial mode setup Nicolae-Daniel Deaconescu
2026-11-21 23:40   ` Jonathan Cameron
2026-11-19 11:24 ` [PATCH v4 5/6] dt-bindings: iio: adc: add adi,ltc2387 Nicolae-Daniel Deaconescu
2026-11-19 11:24 ` [PATCH v4 6/6] iio: adc: ad7625: add LTC2387 and ADAQ2387x support Nicolae-Daniel Deaconescu
2026-11-21 23:48   ` Jonathan Cameron

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox