All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Olivier Moysan" <olivier.moysan@foss.st.com>
Cc: devicetree@vger.kernel.org, dri-devel@lists.freedesktop.org,
	linux-sound@vger.kernel.org, robh@kernel.org,
	conor+dt@kernel.org, media-ci@linuxtv.org
Subject: Re: [PATCH v2 07/11] iio: adc: stm32-mdf: add direct iio conversion support
Date: Wed, 18 Nov 2026 15:51:39 +0000	[thread overview]
Message-ID: <sashiko-outbox-221382@kernel.org> (raw)
In-Reply-To: <20261118-upstream_mdf_v2-v2-7-7939d3c3720a@foss.st.com>

Thank you for your contribution! Sashiko AI review found 15 potential
issues to consider:
- [High] iio: adc: stm32-mdf: divide by zero in stm32_mdf_adc_read_raw()
  on scale read
- [High] iio: adc: stm32-mdf: unshifted raw sample in
  stm32_mdf_adc_single_conv()
- [High] iio: adc: stm32-mdf: divide by zero in
  stm32_mdf_adc_check_clock_config()
- [High] iio: adc: stm32-mdf: wrong regmap and filter order in
  stm32_mdf_irq()
- [High] iio: adc: stm32-mdf: wrong consumer device in
  stm32_mdf_channel_parse_of()
- [Medium] iio: adc: stm32-mdf: W1C status bits not cleared in
  stm32_mdf_irq()
- [Medium] iio: adc: stm32-mdf: divide by zero in
  mdf_adc_set_samp_freq() on bad rate
- [Medium] iio: adc: stm32-mdf: out-of-bounds buffer read in
  stm32_mdf_adc_single_conv()
- [Medium] iio: adc: stm32-mdf: premature IRQ registration in
  stm32_mdf_adc_probe()
- [Medium] iio: adc: stm32-mdf: missing error handling in
  stm32_mdf_adc_start_filter()
- [Medium] iio: adc: stm32-mdf: channel count mismatch in
  stm32_mdf_adc_init()
- [Medium] iio: adc: stm32-mdf: unlocked requested_sample_freq reset in
  write_raw()
- [Medium] iio: adc: stm32-mdf: kclk exclusivity and n_active_ch race
  across filters
- [Medium] iio: adc: stm32-mdf: unsynchronized mdf->filter_list access
  and removal
- [Medium] iio: adc: stm32-mdf: wrong bitmask for datsrc in
  apply_filters_config()
--

commit 2d5ac177e0b4a7ad327bdcde3015713c0361e50e
Author: Olivier Moysan <olivier.moysan@foss.st.com>

iio: adc: stm32-mdf: add direct iio conversion support

This commit adds single-shot IIO direct conversion support, channel and
backend initialization, interrupt handling, and raw/scale/offset/frequency
sysfs accessors to the STM32 MDF ADC driver.

> diff --git a/drivers/iio/adc/stm32-mdf-adc.c b/drivers/iio/adc/stm32-mdf-adc.c
> index eae7a4fa14851..7361ce6182bec 100644
> --- a/drivers/iio/adc/stm32-mdf-adc.c
> +++ b/drivers/iio/adc/stm32-mdf-adc.c
> @@ -329,6 +329,79 @@ static struct stm32_mdf_adc *stm32_mdf_get_filter_by_handle(struct stm32_mdf *md
>  	return NULL;
>  }
>  
> +static int stm32_mdf_adc_start_filter(struct stm32_mdf_adc *adc)
> +{
> +	struct stm32_mdf_adc *adc_inter;
> +	struct stm32_mdf *mdf = adc->mdf;
> +	u32 val;
> +
> +	if (MDF_IS_FILTER0(adc))
> +		list_for_each_entry(adc_inter, &mdf->filter_list, entry)
> +			if (MDF_IS_INTERLEAVED_FILT_NOT_0(adc_inter))
> +				stm32_mdf_adc_start_filter(adc_inter);
> +
> +	/* Check filter status. Bypass cache to access volatile MDF_DFLTCR_ACTIVE bit */
> +	regcache_cache_bypass(adc->regmap, true);
> +	regmap_read(adc->regmap, MDF_DFLTCR_REG, &val);
> +	regcache_cache_bypass(adc->regmap, false);
> +	if (val & MDF_DFLTCR_ACTIVE) {
> +		dev_err(adc->dev, "Filter [%d] is already running\n", adc->fl_id);
> +		return -EBUSY;
> +	}
> +
> +	return regmap_set_bits(adc->regmap, MDF_DFLTCR_REG, MDF_DFLTCR_DFLTEN);
> +}

[Severity: Medium]
Does stm32_mdf_adc_start_filter() ignore errors from starting interleaved
filters and leave already-started sibling filters enabled if filter 0 is
busy?

When stm32_mdf_adc_start_conv() sees an error from
stm32_mdf_adc_start_filter(), it jumps to stop_sitf without stopping any
secondary interleaved filters that were just enabled.
stm32_mdf_adc_filter_set_mode() and its caller stm32_mdf_adc_single_conv()
similarly ignore errors when configuring the filter acquisition mode.

> @@ -606,7 +679,7 @@ static int stm32_mdf_adc_check_clock_config(struct stm32_mdf_adc *adc, unsigned
>  	return ret;
>  }
>  
> -static int __maybe_unused mdf_adc_set_samp_freq(struct iio_dev *indio_dev)
> +static int mdf_adc_set_samp_freq(struct iio_dev *indio_dev)
>  {
>  	struct stm32_mdf_adc *adc = iio_priv(indio_dev);
>  	struct device *dev = &indio_dev->dev;
> @@ -675,6 +748,483 @@ static int __maybe_unused mdf_adc_set_samp_freq(struct iio_dev *indio_dev)
>  	return ret;
>  }
>  
> +static int stm32_mdf_adc_start_mdf(struct iio_dev *indio_dev)
> +{
> +	struct stm32_mdf_adc *adc = iio_priv(indio_dev);
> +	int ret;
> +
> +	ret = clk_prepare_enable(adc->sitf->sck);
> +	if (ret < 0) {
> +		dev_err(&indio_dev->dev, "Failed to enable clock %s\n",
> +			__clk_get_name(adc->sitf->sck));
> +		return ret;
> +	}
> +
> +	ret = mdf_adc_set_samp_freq(indio_dev);

[Severity: High]
Does calling mdf_adc_set_samp_freq() divide by zero in
stm32_mdf_adc_check_clock_config() on the first conversion or sampling
frequency write?

mdf_adc_set_samp_freq() calls stm32_mdf_adc_check_clock_config() before
stm32_mdf_adc_set_filters_config() initializes adc->decim_cic:

drivers/iio/adc/stm32-mdf-adc.c:stm32_mdf_adc_check_clock_config() {
    ...
	/* RSFLT enabled: check Fproc > 24 * Fsck / (MCICD+1) */
	cic_ratio = DIV_ROUND_CLOSEST(24, adc->decim_cic);
    ...
}

On the first call after probe, adc->decim_cic is still 0, triggering a
divide by zero; on later rate changes, stm32_mdf_adc_check_clock_config()
checks against the previous stale adc->decim_cic value.

In addition, stm32_mdf_adc_apply_filters_config() (called via
mdf_adc_set_samp_freq() -> stm32_mdf_adc_set_filters_config()) uses
MDF_SITFCR_SCKSRC_MASK (GENMASK(2, 1)) instead of MDF_DFLTCICR_DATSRC_MASK
(GENMASK(1, 0)) when programming adc->datsrc into MDF_DFLTCICR_REG:

drivers/iio/adc/stm32-mdf-adc.c:stm32_mdf_adc_apply_filters_config() {
    ...
	/* Configure CICR */
	msk = MDF_SITFCR_SCKSRC_MASK | MDF_DFLTCICR_CICMOD_MASK |
	      MDF_DFLTCICR_MCICD_MASK | MDF_DFLTCICR_SCALE_MASK;
	val = FIELD_PREP(MDF_SITFCR_SCKSRC_MASK, adc->datsrc) |
    ...
}

This shifts datsrc into bits [2:1] and leaves bit 0 unmasked.

[ ... ]

> +static int stm32_mdf_channel_parse_of(struct iio_dev *indio_dev, struct fwnode_handle *node,
> +				      struct iio_chan_spec *ch)
> +{
> +	struct stm32_mdf_adc *adc = iio_priv(indio_dev);
> +	struct iio_backend *backend;
> +	const char *label = fwnode_get_name(node);
> +	int ret;
> +	u32 stu = 0;
> +
> +	ret = fwnode_property_read_u32(node, "reg", &ch->channel);
> +	if (ret < 0) {
> +		dev_err(&indio_dev->dev, "Failed to read channel index: [%d]\n", ret);
> +		return ret;
> +	}

[ ... ]

> +	if (adc->dev_data->type == STM32_MDF_IIO) {
> +		backend = devm_iio_backend_fwnode_get(&indio_dev->dev, NULL, node);
> +		if (IS_ERR(backend))
> +			return dev_err_probe(&indio_dev->dev, PTR_ERR(backend),
> +					     "Failed to get backend\n");
> +		adc->channels[ch->scan_index].backend = backend;
> +	}
> +
> +	return ret;
> +}

[Severity: High]
Should devm_iio_backend_fwnode_get() (and dev_err_probe(), as well as
devm_kcalloc() in stm32_mdf_adc_init()) use adc->dev (&pdev->dev) instead
of &indio_dev->dev?

Passing &indio_dev->dev attaches the DL_FLAG_AUTOREMOVE_CONSUMER
device_link and the devres release action to the unregistered, driverless
IIO struct device rather than the platform device.  If a later channel's
backend defers or probe fails before iio_device_register(),
device_links_purge(&indio_dev->dev) never runs, so the reference taken by
device_link_add() pins &indio_dev->dev at refcount 1 and leaks the IIO
device, its devres allocations, the device_link, and the backend module
reference.  Even when probe succeeds, &indio_dev->dev has no bound
device_driver, so the device link stays in DL_STATE_AVAILABLE and
unbinding the backend supplier driver fails to unbind stm32-mdf-adc and
triggers a WARN_ON in device_links_driver_cleanup().

[ ... ]

> +static int stm32_mdf_adc_single_conv(struct iio_dev *indio_dev,
> +				     const struct iio_chan_spec *chan, int *res)
> +{

[ ... ]

> +	if (MDF_IS_INTERLEAVED_FILT(adc))
> +		*res = adc->buffer[chan->channel];
> +	else
> +		*res = adc->buffer[0];

[Severity: High]
Does stm32_mdf_adc_single_conv() return an unshifted 32-bit MDF_DFLTDR_REG
value instead of the 24-bit signed sample?

The 24-bit sample sits in bits [31:8] of MDF_DFLTDR_REG
(MDF_DFLTDR_DR_MASK), and IIO_CHAN_INFO_SCALE and IIO_CHAN_INFO_OFFSET in
stm32_mdf_adc_read_raw() are computed for a 24-bit sample (realbits = 24,
dflt_max).  In the IIO ABI, scan_type.shift (8) is only applied to
buffered scan elements, never to IIO_CHAN_INFO_RAW, so *res is 256 times
too large (and retains bits [7:0]) unless it is arithmetic right-shifted
by 8.

[Severity: Medium]
Can adc->buffer[chan->channel] also read out of bounds in interleaved
mode?

adc->buffer is allocated with adc->mdf->nb_interleave elements (which can
be 2), whereas chan->channel comes directly from the unvalidated DT "reg"
property (0..7) rather than chan->scan_index.  Also, passing &ch->channel
(int *) to fwnode_property_read_u32() in stm32_mdf_channel_parse_of()
passes a signed pointer where u32 * is expected.

> +
> +stop_conv:
> +	stm32_mdf_adc_stop_conv(indio_dev);
> +
> +err_conv:
> +	adc->trgo = save_trgo;
> +
> +	stm32_mdf_adc_stop_mdf(indio_dev);
> +
> +	return ret;
> +}
> +
> +static int stm32_mdf_adc_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
> +				   int val, int val2, long mask)
> +{
> +	struct stm32_mdf_adc *adc = iio_priv(indio_dev);
> +	int ret = 0;
> +
> +	if (mask != IIO_CHAN_INFO_SAMP_FREQ || !val)
> +		return -EINVAL;

[Severity: Medium]
Can writing a negative value or a frequency greater than 2 * sck_freq to
in_voltage_sampling_frequency trigger a divide by zero in
mdf_adc_set_samp_freq()?

Checking !val allows negative signed int values through, which sign-extend
when assigned to unsigned long adc->requested_sample_freq.  Whenever
sample_freq > 2 * sck_freq, DIV_ROUND_CLOSEST(sck_freq, sample_freq) in
mdf_adc_set_samp_freq() evaluates to 0, and the immediately following
dev_warn() divides by decim_ratio:

drivers/iio/adc/stm32-mdf-adc.c:mdf_adc_set_samp_freq() {
    ...
	decim_ratio = DIV_ROUND_CLOSEST(sck_freq, sample_freq);

	delta = abs(sck_freq - (decim_ratio * sample_freq));
	delta_ppm = (1000000 * delta) / sck_freq;
	if (delta_ppm > 1000)
		dev_warn(dev, "Sample rate deviation [%lu] ppm: [%lu] vs [%lu] Hz\n",
			 delta_ppm, sck_freq / decim_ratio, sample_freq);
    ...
}

> +
> +	{
> +		IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
> +		if (IIO_DEV_ACQUIRE_FAILED(claim))
> +			return -EBUSY;
> +
> +		/* Set requested_sample_freq right now, as used by mdf_adc_set_samp_freq() */
> +		adc->requested_sample_freq = val;
> +
> +		if (adc->dev_data->type == STM32_MDF_IIO) {
> +			ret = stm32_mdf_core_lock_kclk_rate(adc->mdf);
> +			if (!ret) {
> +				ret = mdf_adc_set_samp_freq(indio_dev);
> +
> +				stm32_mdf_core_unlock_kclk_rate(adc->mdf);
> +			}
> +		}
> +	}
> +
> +	if (ret)
> +		adc->requested_sample_freq = 0;

[Severity: Medium]
Does resetting adc->requested_sample_freq = 0 outside the
IIO_DEV_ACQUIRE_DIRECT_MODE scope race with concurrent direct-mode callers
and discard any previously configured sampling frequency on error?

The inner block releases the direct-mode claim before if (ret) runs, so a
concurrent reader or writer can observe the failed rate or have its new
rate overwritten with 0, and any prior valid requested_sample_freq is not
restored.

[Severity: Medium]
Can concurrent operations across two filter IIO devices sharing adc->mdf
cause an unbalanced clk_rate_exclusive_put() on priv->kclk?

Each filter has its own IIO direct-mode lock, while
stm32_mdf_core_lock_kclk_rate(), stm32_mdf_core_unlock_kclk_rate(),
stm32_mdf_core_start_mdf(), and stm32_mdf_core_stop_mdf() share
priv->n_active_ch and priv->exclusive_flg without locking:

CPU0 (Filter A write_raw)         CPU1 (Filter B raw conversion)
stm32_mdf_core_lock_kclk_rate()
  /* n_active_ch == 1: skips get */
                                  stm32_mdf_core_stop_mdf()
                                    atomic_dec_and_test(&n_active_ch)
                                    clk_rate_exclusive_put(kclk)
                                    exclusive_flg = false
stm32_mdf_core_unlock_kclk_rate()
  /* !atomic_read(&n_active_ch) */
  clk_rate_exclusive_put(kclk)  <-- unbalanced put

Similarly, if two filters call stm32_mdf_core_start_mdf() concurrently from
0, the second filter sees atomic_inc_return(&priv->n_active_ch) == 2 and
returns 0 before the first filter finishes pm_runtime_resume_and_get() and
sets MDF_CKG_CKGDEN.

> +
> +	return ret;
> +}
> +
> +static int stm32_mdf_adc_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
> +				  int *val, int *val2, long mask)
> +{

[ ... ]

> +	case IIO_CHAN_INFO_SAMP_FREQ:
> +		*val = adc->sample_freq;
> +
> +		return IIO_VAL_INT;
> +
> +	case IIO_CHAN_INFO_SCALE:
> +		/*
> +		 * Vconv = (raw>>shift + offset) * scale.
> +		 * scale = Vref * k / 2^res (denominator is managed through FRACTIONAL_LOG2 type)
> +		 * k correspond to the ratio between max resolution and actual filter maximum
> +		 * k = max / dflt_max
> +		 * max = 2^(res - 1) - 1
> +		 * max_dflt = D^N * gain_lin * gain_rsflt
> +		 * scale = Vref * max / dflt_max
> +		 */
> +		if (adc->channels[idx].backend) {
> +			ret = iio_backend_read_scale(adc->channels[idx].backend, chan,
> +						     &scale, NULL);
> +			if (ret < 0)
> +				return ret;
> +
> +			*val = div_u64((u64)scale * max, adc->dflt_max);
> +
> +			*val2 = chan->scan_type.realbits;
> +			if (chan->differential)
> +				*val *= 2;
> +		} else {
> +			return -EPERM;
> +		}
> +
> +		return IIO_VAL_FRACTIONAL_LOG2;
> +
> +	case IIO_CHAN_INFO_OFFSET:
> +		if (adc->channels[idx].backend) {
> +			ret = iio_backend_read_offset(adc->channels[idx].backend, chan,
> +						      &offset, NULL);
> +			if (ret < 0)
> +				return ret;
> +
> +			*val = offset;
> +			if (!chan->differential)
> +				*val += adc->dflt_max;

[Severity: High]
Does reading IIO_CHAN_INFO_SCALE before the first raw conversion or
sampling_frequency write divide by zero because adc->dflt_max is still 0?

Neither stm32_mdf_adc_probe() nor stm32_mdf_adc_init() calls
mdf_adc_set_samp_freq() to compute the initial filter parameters, so
adc->dflt_max and adc->sample_freq remain 0 until a conversion is started
or IIO_CHAN_INFO_SAMP_FREQ is written.  Reading in_voltageX_scale right
after probe divides by adc->dflt_max == 0, while reading
in_voltageX_offset or in_voltage_sampling_frequency uses uninitialized 0
values.

[ ... ]

> +static irqreturn_t stm32_mdf_irq(int irq, void *arg)
> +{
> +	struct iio_dev *indio_dev = arg;
> +	struct stm32_mdf_adc *adc = iio_priv(indio_dev), *adc_inter;
> +	struct regmap *regmap = adc->regmap;
> +	u32 *ptr = adc->buffer;
> +	u32 isr, ier, flags;
> +
> +	regmap_read(regmap, MDF_DFLTISR_REG, &isr);
> +	regmap_read(regmap, MDF_DFLTIER_REG, &ier);
> +
> +	flags = isr & ier;
> +	if (!flags)
> +		return IRQ_NONE;
> +
> +	if (flags & MDF_DFLTISR_FTHF_MASK) {
> +		/* Reading the data register clear the IRQ status */
> +		regmap_read(regmap, MDF_DFLTDR_REG, ptr++);
> +
> +		if (MDF_IS_FILTER0(adc))
> +			list_for_each_entry(adc_inter, &adc->mdf->filter_list, entry)
> +				if (MDF_IS_INTERLEAVED_FILT_NOT_0(adc_inter))
> +					regmap_read(regmap, MDF_DFLTDR_REG, ptr++);
> +
> +		complete(&adc->completion);
> +	}

[Severity: High]
In the interleaved filter loop, shouldn't regmap_read() read from
adc_inter->regmap instead of Filter 0's regmap?

Passing regmap reads Filter 0's MDF_DFLTDR_REG repeatedly and leaves the
interleaved filters' data registers unread.  Also, because
stm32_mdf_adc_parse_of() inserts filters at the head of mdf->filter_list
with list_add(), iterating mdf->filter_list with ptr++ stores the
interleaved samples into adc->buffer in reverse probe order.

> +
> +	if (flags & MDF_DFLTISR_DOVRF_MASK) {
> +		dev_warn(&indio_dev->dev, "Data overflow detected\n");
> +		regmap_set_bits(regmap, MDF_DFLTISR_REG, MDF_DFLTISR_DOVRF_MASK);
> +	}
> +
> +	if (flags & MDF_DFLTISR_RFOVRF_MASK) {
> +		dev_warn(&indio_dev->dev, "Reshape filter overrun detected\n");
> +		regmap_set_bits(regmap, MDF_DFLTISR_REG, MDF_DFLTISR_RFOVRF_MASK);
> +	}
> +
> +	if (flags & MDF_DFLTISR_SATF_MASK) {
> +		dev_warn(&indio_dev->dev, "Saturation detected\n");
> +		regmap_set_bits(regmap, MDF_DFLTISR_REG, MDF_DFLTISR_SATF_MASK);
> +
> +		/* Notify only once */
> +		regmap_clear_bits(adc->regmap, MDF_DFLTIER_REG, MDF_DFLTIER_SATIE_MASK);
> +	}

[Severity: Medium]
Does regmap_set_bits() fail to clear the write-1-to-clear status flags in
MDF_DFLTISR_REG?

MDF_DFLTISR_REG is marked volatile in stm32_mdf_adc_volatile_reg(), and
regmap_set_bits() calls _regmap_update_bits() with force = false.  When an
interrupt status bit is already 1 in hardware, regmap reads MDF_DFLTISR_REG,
sees that the bit is already set, and skips the register write, leaving the
interrupt asserted.  Using regmap_write() with the flag mask will clear the
W1C bit without accidentally clearing other pending W1C bits via a
read-modify-write.

> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int stm32_mdf_adc_init(struct device *dev, struct iio_dev *indio_dev)
> +{
> +	struct stm32_mdf_adc *adc = iio_priv(indio_dev);
> +	struct iio_chan_spec *ch = NULL;
> +	unsigned int num_ch;
> +	int ret;
> +
> +	num_ch = device_get_child_node_count(indio_dev->dev.parent);
> +	if (num_ch) {
> +		/* Filter0 may have several channels in interleaved mode */
> +		if (num_ch > 1) {
> +			if (!MDF_IS_FILTER0(adc)) {
> +				dev_err(dev, "Too many channels for filter [%d]\n", adc->fl_id);
> +				return -EINVAL;
> +			} else if (num_ch != adc->mdf->nb_interleave) {
> +				dev_err(dev, "Unexpected channels number for filter0: [%d]\n",
> +					num_ch);
> +				return -EINVAL;
> +			}
> +		}
> +
> +		ch = devm_kcalloc(&indio_dev->dev, num_ch, sizeof(*ch), GFP_KERNEL);
> +		if (!ch)
> +			return -ENOMEM;
> +
> +		adc->channels = devm_kcalloc(&indio_dev->dev, num_ch, sizeof(*adc->channels),
> +					     GFP_KERNEL);
> +		if (!adc->channels)
> +			return -ENOMEM;
> +
> +		ret = stm32_mdf_adc_chan_init(indio_dev, ch);
> +		if (ret < 0)
> +			return dev_err_probe(dev, ret, "Channels init failed\n");
> +	}
> +
> +	indio_dev->num_channels = num_ch;

[Severity: Medium]
If any child node has a "compatible" property (which
stm32_mdf_adc_chan_init() skips), does assigning indio_dev->num_channels =
num_ch instead of the initialized channel count returned in ret leave
uninitialized trailing entries in indio_dev->channels and adc->channels?

Also, because num_ch != adc->mdf->nb_interleave is only checked when
num_ch > 1, a Filter 0 configured for interleaved mode
(adc->mdf->nb_interleave >= 2) with only 1 channel node is not rejected.

[ ... ]

> @@ -883,13 +1435,41 @@ static int stm32_mdf_adc_probe(struct platform_device *pdev)
>  	if (IS_ERR(adc->regmap))
>  		return dev_err_probe(dev, PTR_ERR(adc->regmap), "Failed to init regmap\n");
>  
> +	irq = platform_get_irq(pdev, 0);
> +	if (irq < 0)
> +		return dev_err_probe(dev, irq, "Failed to get IRQ\n");
> +
> +	ret = devm_request_irq(dev, irq, stm32_mdf_irq, 0, pdev->name, iio);
> +	if (ret < 0)
> +		return dev_err_probe(dev, ret, "Failed to request IRQ\n");
> +
>  	ret = stm32_mdf_adc_parse_of(pdev, adc);
>  	if (ret < 0)
>  		return ret;
>  
> +	iio->info = &stm32_mdf_info_adc;
> +	iio->name = dev_name(&pdev->dev);
> +
>  	adc->dev = dev;
> +	adc->dev_data = dev_data;
> +	ret = dev_data->init(dev, iio);

[Severity: Medium]
Can an interrupt firing right after devm_request_irq() dereference a NULL
adc->buffer or an uninitialized adc->completion in stm32_mdf_irq()?

adc->buffer is only allocated later in stm32_mdf_adc_parse_of(), and
init_completion(&adc->completion) is only called in dev_data->init().
Because devres releases resources in reverse order of registration,
adc->buffer is also freed before the IRQ is freed on teardown.

> +	if (ret < 0)
> +		goto err_clean_list;
> +
> +	if (!MDF_IS_INTERLEAVED_FILT_NOT_0(adc)) {
> +		ret = iio_device_register(iio);
> +		if (ret < 0) {
> +			dev_err_probe(dev, ret, "Failed to register IIO device: %d\n", ret);
> +			goto err_clean_list;
> +		}
> +	}
>  
>  	return 0;
> +
> +err_clean_list:
> +	list_del(&adc->entry);
> +
> +	return ret;
>  }

[Severity: Medium]
What serializes mdf->filter_list modifications in probe/remove against
Filter 0 traversing mdf->filter_list in process and hardirq contexts?

Filter 0 registers its IIO device as soon as it probes, so conversions and
stm32_mdf_irq() on Filter 0 can traverse mdf->filter_list while a sibling
filter device is still probing (calling list_add() in
stm32_mdf_adc_parse_of() or list_del() on error) or being unbound in
stm32_mdf_adc_remove(), where the sibling's struct stm32_mdf_adc is also
freed while Filter 0 remains registered.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118-upstream_mdf_v2-v2-0-7939d3c3720a@foss.st.com?part=7

  reply	other threads:[~2026-11-18 15:51 UTC|newest]

Thread overview: 24+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18 15:17 [PATCH v2 00/11] iio: adc: stm32: add mdf support for stm32mp2 Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 01/11] dt-bindings: iio: adc: add stm32mp2 mdf filter Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 02/11] iio: adc: stm32-mdf: add core registration Olivier Moysan
2026-11-18 15:45   ` sashiko-bot
2026-11-19  9:44   ` Andy Shevchenko
2026-11-18 15:17 ` [PATCH v2 03/11] iio: adc: stm32-mdf: add cck clocks provider Olivier Moysan
2026-11-18 15:50   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 04/11] iio: adc: stm32-mdf: add serial interfaces support Olivier Moysan
2026-11-18 15:42   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 05/11] iio: adc: stm32-mdf: add digital filter device support Olivier Moysan
2026-11-18 15:40   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 06/11] iio: adc: stm32-mdf: configure cic filters and sample rates Olivier Moysan
2026-11-18 15:34   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 07/11] iio: adc: stm32-mdf: add direct iio conversion support Olivier Moysan
2026-11-18 15:51   ` sashiko-bot [this message]
2026-11-18 15:17 ` [PATCH v2 08/11] iio: adc: stm32-mdf: add dma buffered acquisition support Olivier Moysan
2026-11-18 15:55   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 09/11] iio: adc: stm32-mdf: add external timer trigger support Olivier Moysan
2026-11-18 15:37   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 10/11] iio: adc: stm32-mdf: add dmic audio filter support Olivier Moysan
2026-11-18 16:06   ` sashiko-bot
2026-11-18 15:17 ` [PATCH v2 11/11] ASoC: stm32: add mdf dai support Olivier Moysan
2026-11-18 16:08   ` sashiko-bot
2026-11-19 18:37 ` [PATCH v2 00/11] iio: adc: stm32: add mdf support for stm32mp2 Conor Dooley

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=sashiko-outbox-221382@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=linux-sound@vger.kernel.org \
    --cc=media-ci@linuxtv.org \
    --cc=olivier.moysan@foss.st.com \
    --cc=robh@kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.