Re: [PATCH v2 3/5] iio: adc: stm32: introduce compatible data cfg

[Jonathan Cameron]

On Mon, 29 May 2017 11:28:18 +0200
Fabrice Gasnier <fabrice.gasnier@xxxxxx> wrote:

> Prepare support for stm32h7 adc variant by introducing compatible
> configuration data.
> Move STM32F4 specific stuff to compatible data structure:
> - registers & bit fields
> - input channels data
> - start/stop procedures
> - trigger definitions
> 
> Signed-off-by: Fabrice Gasnier <fabrice.gasnier@xxxxxx>
Applied.
> ---
> Changes in v2:
> - rename stm32f4_adc123_channels to stm32_adc_channels
> ---
>  drivers/iio/adc/stm32-adc-core.c |  62 ++++++++++--
>  drivers/iio/adc/stm32-adc.c      | 202 +++++++++++++++++++++++++++++----------
>  2 files changed, 205 insertions(+), 59 deletions(-)
> 
> diff --git a/drivers/iio/adc/stm32-adc-core.c b/drivers/iio/adc/stm32-adc-core.c
> index 597ab7a..c5d292c 100644
> --- a/drivers/iio/adc/stm32-adc-core.c
> +++ b/drivers/iio/adc/stm32-adc-core.c
> @@ -50,11 +50,38 @@
>  #define STM32F4_ADC_MAX_CLK_RATE	36000000
>  
>  /**
> + * stm32_adc_common_regs - stm32 common registers, compatible dependent data
> + * @csr:	common status register offset
> + * @eoc1:	adc1 end of conversion flag in @csr
> + * @eoc2:	adc2 end of conversion flag in @csr
> + * @eoc3:	adc3 end of conversion flag in @csr
> + */
> +struct stm32_adc_common_regs {
> +	u32 csr;
> +	u32 eoc1_msk;
> +	u32 eoc2_msk;
> +	u32 eoc3_msk;
> +};
> +
> +struct stm32_adc_priv;
> +
> +/**
> + * stm32_adc_priv_cfg - stm32 core compatible configuration data
> + * @regs:	common registers for all instances
> + * @clk_sel:	clock selection routine
> + */
> +struct stm32_adc_priv_cfg {
> +	const struct stm32_adc_common_regs *regs;
> +	int (*clk_sel)(struct platform_device *, struct stm32_adc_priv *);
> +};
> +
> +/**
>   * struct stm32_adc_priv - stm32 ADC core private data
>   * @irq:		irq for ADC block
>   * @domain:		irq domain reference
>   * @aclk:		clock reference for the analog circuitry
>   * @vref:		regulator reference
> + * @cfg:		compatible configuration data
>   * @common:		common data for all ADC instances
>   */
>  struct stm32_adc_priv {
> @@ -62,6 +89,7 @@ struct stm32_adc_priv {
>  	struct irq_domain		*domain;
>  	struct clk			*aclk;
>  	struct regulator		*vref;
> +	const struct stm32_adc_priv_cfg	*cfg;
>  	struct stm32_adc_common		common;
>  };
>  
> @@ -112,6 +140,14 @@ static int stm32f4_adc_clk_sel(struct platform_device *pdev,
>  	return 0;
>  }
>  
> +/* STM32F4 common registers definitions */
> +static const struct stm32_adc_common_regs stm32f4_adc_common_regs = {
> +	.csr = STM32F4_ADC_CSR,
> +	.eoc1_msk = STM32F4_EOC1,
> +	.eoc2_msk = STM32F4_EOC2,
> +	.eoc3_msk = STM32F4_EOC3,
> +};
> +
>  /* ADC common interrupt for all instances */
>  static void stm32_adc_irq_handler(struct irq_desc *desc)
>  {
> @@ -120,15 +156,15 @@ static void stm32_adc_irq_handler(struct irq_desc *desc)
>  	u32 status;
>  
>  	chained_irq_enter(chip, desc);
> -	status = readl_relaxed(priv->common.base + STM32F4_ADC_CSR);
> +	status = readl_relaxed(priv->common.base + priv->cfg->regs->csr);
>  
> -	if (status & STM32F4_EOC1)
> +	if (status & priv->cfg->regs->eoc1_msk)
>  		generic_handle_irq(irq_find_mapping(priv->domain, 0));
>  
> -	if (status & STM32F4_EOC2)
> +	if (status & priv->cfg->regs->eoc2_msk)
>  		generic_handle_irq(irq_find_mapping(priv->domain, 1));
>  
> -	if (status & STM32F4_EOC3)
> +	if (status & priv->cfg->regs->eoc3_msk)
>  		generic_handle_irq(irq_find_mapping(priv->domain, 2));
>  
>  	chained_irq_exit(chip, desc);
> @@ -194,6 +230,7 @@ static void stm32_adc_irq_remove(struct platform_device *pdev,
>  static int stm32_adc_probe(struct platform_device *pdev)
>  {
>  	struct stm32_adc_priv *priv;
> +	struct device *dev = &pdev->dev;
>  	struct device_node *np = pdev->dev.of_node;
>  	struct resource *res;
>  	int ret;
> @@ -205,6 +242,9 @@ static int stm32_adc_probe(struct platform_device *pdev)
>  	if (!priv)
>  		return -ENOMEM;
>  
> +	priv->cfg = (const struct stm32_adc_priv_cfg *)
> +		of_match_device(dev->driver->of_match_table, dev)->data;
> +
>  	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>  	priv->common.base = devm_ioremap_resource(&pdev->dev, res);
>  	if (IS_ERR(priv->common.base))
> @@ -251,7 +291,7 @@ static int stm32_adc_probe(struct platform_device *pdev)
>  		}
>  	}
>  
> -	ret = stm32f4_adc_clk_sel(pdev, priv);
> +	ret = priv->cfg->clk_sel(pdev, priv);
>  	if (ret < 0)
>  		goto err_clk_disable;
>  
> @@ -296,9 +336,17 @@ static int stm32_adc_remove(struct platform_device *pdev)
>  	return 0;
>  }
>  
> +static const struct stm32_adc_priv_cfg stm32f4_adc_priv_cfg = {
> +	.regs = &stm32f4_adc_common_regs,
> +	.clk_sel = stm32f4_adc_clk_sel,
> +};
> +
>  static const struct of_device_id stm32_adc_of_match[] = {
> -	{ .compatible = "st,stm32f4-adc-core" },
> -	{},
> +	{
> +		.compatible = "st,stm32f4-adc-core",
> +		.data = (void *)&stm32f4_adc_priv_cfg
> +	}, {
> +	},
>  };
>  MODULE_DEVICE_TABLE(of, stm32_adc_of_match);
>  
> diff --git a/drivers/iio/adc/stm32-adc.c b/drivers/iio/adc/stm32-adc.c
> index c28e7ff..50b2538 100644
> --- a/drivers/iio/adc/stm32-adc.c
> +++ b/drivers/iio/adc/stm32-adc.c
> @@ -34,6 +34,7 @@
>  #include <linux/module.h>
>  #include <linux/platform_device.h>
>  #include <linux/of.h>
> +#include <linux/of_device.h>
>  
>  #include "stm32-adc-core.h"
>  
> @@ -133,9 +134,48 @@ struct stm32_adc_regs {
>  };
>  
>  /**
> + * stm32_adc_regspec - stm32 registers definition, compatible dependent data
> + * @dr:			data register offset
> + * @ier_eoc:		interrupt enable register & eocie bitfield
> + * @isr_eoc:		interrupt status register & eoc bitfield
> + * @sqr:		reference to sequence registers array
> + * @exten:		trigger control register & bitfield
> + * @extsel:		trigger selection register & bitfield
> + * @res:		resolution selection register & bitfield
> + */
> +struct stm32_adc_regspec {
> +	const u32 dr;
> +	const struct stm32_adc_regs ier_eoc;
> +	const struct stm32_adc_regs isr_eoc;
> +	const struct stm32_adc_regs *sqr;
> +	const struct stm32_adc_regs exten;
> +	const struct stm32_adc_regs extsel;
> +	const struct stm32_adc_regs res;
> +};
> +
> +struct stm32_adc;
> +
> +/**
> + * stm32_adc_cfg - stm32 compatible configuration data
> + * @regs:		registers descriptions
> + * @adc_info:		per instance input channels definitions
> + * @trigs:		external trigger sources
> + * @start_conv:		routine to start conversions
> + * @stop_conv:		routine to stop conversions
> + */
> +struct stm32_adc_cfg {
> +	const struct stm32_adc_regspec	*regs;
> +	const struct stm32_adc_info	*adc_info;
> +	struct stm32_adc_trig_info	*trigs;
> +	void (*start_conv)(struct stm32_adc *, bool dma);
> +	void (*stop_conv)(struct stm32_adc *);
> +};
> +
> +/**
>   * struct stm32_adc - private data of each ADC IIO instance
>   * @common:		reference to ADC block common data
>   * @offset:		ADC instance register offset in ADC block
> + * @cfg:		compatible configuration data
>   * @completion:		end of single conversion completion
>   * @buffer:		data buffer
>   * @clk:		clock for this adc instance
> @@ -153,6 +193,7 @@ struct stm32_adc_regs {
>  struct stm32_adc {
>  	struct stm32_adc_common	*common;
>  	u32			offset;
> +	const struct stm32_adc_cfg	*cfg;
>  	struct completion	completion;
>  	u16			buffer[STM32_ADC_MAX_SQ];
>  	struct clk		*clk;
> @@ -180,8 +221,25 @@ struct stm32_adc_chan_spec {
>  	const char		*name;
>  };
>  
> -/* Input definitions common for all STM32F4 instances */
> -static const struct stm32_adc_chan_spec stm32f4_adc123_channels[] = {
> +/**
> + * struct stm32_adc_info - stm32 ADC, per instance config data
> + * @channels:		Reference to stm32 channels spec
> + * @max_channels:	Number of channels
> + * @resolutions:	available resolutions
> + * @num_res:		number of available resolutions
> + */
> +struct stm32_adc_info {
> +	const struct stm32_adc_chan_spec *channels;
> +	int max_channels;
> +	const unsigned int *resolutions;
> +	const unsigned int num_res;
> +};
> +
> +/*
> + * Input definitions common for all instances:
> + * stm32f4 can have up to 16 channels
> + */
> +static const struct stm32_adc_chan_spec stm32_adc_channels[] = {
>  	{ IIO_VOLTAGE, 0, "in0" },
>  	{ IIO_VOLTAGE, 1, "in1" },
>  	{ IIO_VOLTAGE, 2, "in2" },
> @@ -205,6 +263,13 @@ struct stm32_adc_chan_spec {
>  	12, 10, 8, 6,
>  };
>  
> +static const struct stm32_adc_info stm32f4_adc_info = {
> +	.channels = stm32_adc_channels,
> +	.max_channels = 16,
> +	.resolutions = stm32f4_adc_resolutions,
> +	.num_res = ARRAY_SIZE(stm32f4_adc_resolutions),
> +};
> +
>  /**
>   * stm32f4_sq - describe regular sequence registers
>   * - L: sequence len (register & bit field)
> @@ -252,6 +317,17 @@ struct stm32_adc_chan_spec {
>  	{}, /* sentinel */
>  };
>  
> +static const struct stm32_adc_regspec stm32f4_adc_regspec = {
> +	.dr = STM32F4_ADC_DR,
> +	.ier_eoc = { STM32F4_ADC_CR1, STM32F4_EOCIE },
> +	.isr_eoc = { STM32F4_ADC_SR, STM32F4_EOC },
> +	.sqr = stm32f4_sq,
> +	.exten = { STM32F4_ADC_CR2, STM32F4_EXTEN_MASK, STM32F4_EXTEN_SHIFT },
> +	.extsel = { STM32F4_ADC_CR2, STM32F4_EXTSEL_MASK,
> +		    STM32F4_EXTSEL_SHIFT },
> +	.res = { STM32F4_ADC_CR1, STM32F4_RES_MASK, STM32F4_RES_SHIFT },
> +};
> +
>  /**
>   * STM32 ADC registers access routines
>   * @adc: stm32 adc instance
> @@ -299,7 +375,8 @@ static void stm32_adc_clr_bits(struct stm32_adc *adc, u32 reg, u32 bits)
>   */
>  static void stm32_adc_conv_irq_enable(struct stm32_adc *adc)
>  {
> -	stm32_adc_set_bits(adc, STM32F4_ADC_CR1, STM32F4_EOCIE);
> +	stm32_adc_set_bits(adc, adc->cfg->regs->ier_eoc.reg,
> +			   adc->cfg->regs->ier_eoc.mask);
>  };
>  
>  /**
> @@ -308,19 +385,22 @@ static void stm32_adc_conv_irq_enable(struct stm32_adc *adc)
>   */
>  static void stm32_adc_conv_irq_disable(struct stm32_adc *adc)
>  {
> -	stm32_adc_clr_bits(adc, STM32F4_ADC_CR1, STM32F4_EOCIE);
> +	stm32_adc_clr_bits(adc, adc->cfg->regs->ier_eoc.reg,
> +			   adc->cfg->regs->ier_eoc.mask);
>  }
>  
>  static void stm32_adc_set_res(struct stm32_adc *adc)
>  {
> -	u32 val = stm32_adc_readl(adc, STM32F4_ADC_CR1);
> +	const struct stm32_adc_regs *res = &adc->cfg->regs->res;
> +	u32 val;
>  
> -	val = (val & ~STM32F4_RES_MASK) | (adc->res << STM32F4_RES_SHIFT);
> -	stm32_adc_writel(adc, STM32F4_ADC_CR1, val);
> +	val = stm32_adc_readl(adc, res->reg);
> +	val = (val & ~res->mask) | (adc->res << res->shift);
> +	stm32_adc_writel(adc, res->reg, val);
>  }
>  
>  /**
> - * stm32_adc_start_conv() - Start conversions for regular channels.
> + * stm32f4_adc_start_conv() - Start conversions for regular channels.
>   * @adc: stm32 adc instance
>   * @dma: use dma to transfer conversion result
>   *
> @@ -329,7 +409,7 @@ static void stm32_adc_set_res(struct stm32_adc *adc)
>   * conversions, in IIO buffer modes. Otherwise, use ADC interrupt with direct
>   * DR read instead (e.g. read_raw, or triggered buffer mode without DMA).
>   */
> -static void stm32_adc_start_conv(struct stm32_adc *adc, bool dma)
> +static void stm32f4_adc_start_conv(struct stm32_adc *adc, bool dma)
>  {
>  	stm32_adc_set_bits(adc, STM32F4_ADC_CR1, STM32F4_SCAN);
>  
> @@ -347,7 +427,7 @@ static void stm32_adc_start_conv(struct stm32_adc *adc, bool dma)
>  		stm32_adc_set_bits(adc, STM32F4_ADC_CR2, STM32F4_SWSTART);
>  }
>  
> -static void stm32_adc_stop_conv(struct stm32_adc *adc)
> +static void stm32f4_adc_stop_conv(struct stm32_adc *adc)
>  {
>  	stm32_adc_clr_bits(adc, STM32F4_ADC_CR2, STM32F4_EXTEN_MASK);
>  	stm32_adc_clr_bits(adc, STM32F4_ADC_SR, STM32F4_STRT);
> @@ -371,6 +451,7 @@ static int stm32_adc_conf_scan_seq(struct iio_dev *indio_dev,
>  				   const unsigned long *scan_mask)
>  {
>  	struct stm32_adc *adc = iio_priv(indio_dev);
> +	const struct stm32_adc_regs *sqr = adc->cfg->regs->sqr;
>  	const struct iio_chan_spec *chan;
>  	u32 val, bit;
>  	int i = 0;
> @@ -388,20 +469,20 @@ static int stm32_adc_conf_scan_seq(struct iio_dev *indio_dev,
>  		dev_dbg(&indio_dev->dev, "%s chan %d to SQ%d\n",
>  			__func__, chan->channel, i);
>  
> -		val = stm32_adc_readl(adc, stm32f4_sq[i].reg);
> -		val &= ~stm32f4_sq[i].mask;
> -		val |= chan->channel << stm32f4_sq[i].shift;
> -		stm32_adc_writel(adc, stm32f4_sq[i].reg, val);
> +		val = stm32_adc_readl(adc, sqr[i].reg);
> +		val &= ~sqr[i].mask;
> +		val |= chan->channel << sqr[i].shift;
> +		stm32_adc_writel(adc, sqr[i].reg, val);
>  	}
>  
>  	if (!i)
>  		return -EINVAL;
>  
>  	/* Sequence len */
> -	val = stm32_adc_readl(adc, stm32f4_sq[0].reg);
> -	val &= ~stm32f4_sq[0].mask;
> -	val |= ((i - 1) << stm32f4_sq[0].shift);
> -	stm32_adc_writel(adc, stm32f4_sq[0].reg, val);
> +	val = stm32_adc_readl(adc, sqr[0].reg);
> +	val &= ~sqr[0].mask;
> +	val |= ((i - 1) << sqr[0].shift);
> +	stm32_adc_writel(adc, sqr[0].reg, val);
>  
>  	return 0;
>  }
> @@ -412,19 +493,21 @@ static int stm32_adc_conf_scan_seq(struct iio_dev *indio_dev,
>   *
>   * Returns trigger extsel value, if trig matches, -EINVAL otherwise.
>   */
> -static int stm32_adc_get_trig_extsel(struct iio_trigger *trig)
> +static int stm32_adc_get_trig_extsel(struct iio_dev *indio_dev,
> +				     struct iio_trigger *trig)
>  {
> +	struct stm32_adc *adc = iio_priv(indio_dev);
>  	int i;
>  
>  	/* lookup triggers registered by stm32 timer trigger driver */
> -	for (i = 0; stm32f4_adc_trigs[i].name; i++) {
> +	for (i = 0; adc->cfg->trigs[i].name; i++) {
>  		/**
>  		 * Checking both stm32 timer trigger type and trig name
>  		 * should be safe against arbitrary trigger names.
>  		 */
>  		if (is_stm32_timer_trigger(trig) &&
> -		    !strcmp(stm32f4_adc_trigs[i].name, trig->name)) {
> -			return stm32f4_adc_trigs[i].extsel;
> +		    !strcmp(adc->cfg->trigs[i].name, trig->name)) {
> +			return adc->cfg->trigs[i].extsel;
>  		}
>  	}
>  
> @@ -449,7 +532,7 @@ static int stm32_adc_set_trig(struct iio_dev *indio_dev,
>  	int ret;
>  
>  	if (trig) {
> -		ret = stm32_adc_get_trig_extsel(trig);
> +		ret = stm32_adc_get_trig_extsel(indio_dev, trig);
>  		if (ret < 0)
>  			return ret;
>  
> @@ -459,11 +542,11 @@ static int stm32_adc_set_trig(struct iio_dev *indio_dev,
>  	}
>  
>  	spin_lock_irqsave(&adc->lock, flags);
> -	val = stm32_adc_readl(adc, STM32F4_ADC_CR2);
> -	val &= ~(STM32F4_EXTEN_MASK | STM32F4_EXTSEL_MASK);
> -	val |= exten << STM32F4_EXTEN_SHIFT;
> -	val |= extsel << STM32F4_EXTSEL_SHIFT;
> -	stm32_adc_writel(adc, STM32F4_ADC_CR2, val);
> +	val = stm32_adc_readl(adc, adc->cfg->regs->exten.reg);
> +	val &= ~(adc->cfg->regs->exten.mask | adc->cfg->regs->extsel.mask);
> +	val |= exten << adc->cfg->regs->exten.shift;
> +	val |= extsel << adc->cfg->regs->extsel.shift;
> +	stm32_adc_writel(adc,  adc->cfg->regs->exten.reg, val);
>  	spin_unlock_irqrestore(&adc->lock, flags);
>  
>  	return 0;
> @@ -515,6 +598,7 @@ static int stm32_adc_single_conv(struct iio_dev *indio_dev,
>  				 int *res)
>  {
>  	struct stm32_adc *adc = iio_priv(indio_dev);
> +	const struct stm32_adc_regspec *regs = adc->cfg->regs;
>  	long timeout;
>  	u32 val;
>  	int ret;
> @@ -524,20 +608,20 @@ static int stm32_adc_single_conv(struct iio_dev *indio_dev,
>  	adc->bufi = 0;
>  
>  	/* Program chan number in regular sequence (SQ1) */
> -	val = stm32_adc_readl(adc, stm32f4_sq[1].reg);
> -	val &= ~stm32f4_sq[1].mask;
> -	val |= chan->channel << stm32f4_sq[1].shift;
> -	stm32_adc_writel(adc, stm32f4_sq[1].reg, val);
> +	val = stm32_adc_readl(adc, regs->sqr[1].reg);
> +	val &= ~regs->sqr[1].mask;
> +	val |= chan->channel << regs->sqr[1].shift;
> +	stm32_adc_writel(adc, regs->sqr[1].reg, val);
>  
>  	/* Set regular sequence len (0 for 1 conversion) */
> -	stm32_adc_clr_bits(adc, stm32f4_sq[0].reg, stm32f4_sq[0].mask);
> +	stm32_adc_clr_bits(adc, regs->sqr[0].reg, regs->sqr[0].mask);
>  
>  	/* Trigger detection disabled (conversion can be launched in SW) */
> -	stm32_adc_clr_bits(adc, STM32F4_ADC_CR2, STM32F4_EXTEN_MASK);
> +	stm32_adc_clr_bits(adc, regs->exten.reg, regs->exten.mask);
>  
>  	stm32_adc_conv_irq_enable(adc);
>  
> -	stm32_adc_start_conv(adc, false);
> +	adc->cfg->start_conv(adc, false);
>  
>  	timeout = wait_for_completion_interruptible_timeout(
>  					&adc->completion, STM32_ADC_TIMEOUT);
> @@ -550,7 +634,7 @@ static int stm32_adc_single_conv(struct iio_dev *indio_dev,
>  		ret = IIO_VAL_INT;
>  	}
>  
> -	stm32_adc_stop_conv(adc);
> +	adc->cfg->stop_conv(adc);
>  
>  	stm32_adc_conv_irq_disable(adc);
>  
> @@ -590,11 +674,12 @@ static irqreturn_t stm32_adc_isr(int irq, void *data)
>  {
>  	struct stm32_adc *adc = data;
>  	struct iio_dev *indio_dev = iio_priv_to_dev(adc);
> -	u32 status = stm32_adc_readl(adc, STM32F4_ADC_SR);
> +	const struct stm32_adc_regspec *regs = adc->cfg->regs;
> +	u32 status = stm32_adc_readl(adc, regs->isr_eoc.reg);
>  
> -	if (status & STM32F4_EOC) {
> +	if (status & regs->isr_eoc.mask) {
>  		/* Reading DR also clears EOC status flag */
> -		adc->buffer[adc->bufi] = stm32_adc_readw(adc, STM32F4_ADC_DR);
> +		adc->buffer[adc->bufi] = stm32_adc_readw(adc, regs->dr);
>  		if (iio_buffer_enabled(indio_dev)) {
>  			adc->bufi++;
>  			if (adc->bufi >= adc->num_conv) {
> @@ -621,7 +706,7 @@ static irqreturn_t stm32_adc_isr(int irq, void *data)
>  static int stm32_adc_validate_trigger(struct iio_dev *indio_dev,
>  				      struct iio_trigger *trig)
>  {
> -	return stm32_adc_get_trig_extsel(trig) < 0 ? -EINVAL : 0;
> +	return stm32_adc_get_trig_extsel(indio_dev, trig) < 0 ? -EINVAL : 0;
>  }
>  
>  static int stm32_adc_set_watermark(struct iio_dev *indio_dev, unsigned int val)
> @@ -799,7 +884,7 @@ static int stm32_adc_buffer_postenable(struct iio_dev *indio_dev)
>  	if (!adc->dma_chan)
>  		stm32_adc_conv_irq_enable(adc);
>  
> -	stm32_adc_start_conv(adc, !!adc->dma_chan);
> +	adc->cfg->start_conv(adc, !!adc->dma_chan);
>  
>  	return 0;
>  
> @@ -817,7 +902,7 @@ static int stm32_adc_buffer_predisable(struct iio_dev *indio_dev)
>  	struct stm32_adc *adc = iio_priv(indio_dev);
>  	int ret;
>  
> -	stm32_adc_stop_conv(adc);
> +	adc->cfg->stop_conv(adc);
>  	if (!adc->dma_chan)
>  		stm32_adc_conv_irq_disable(adc);
>  
> @@ -895,12 +980,12 @@ static int stm32_adc_of_get_resolution(struct iio_dev *indio_dev)
>  	u32 res;
>  
>  	if (of_property_read_u32(node, "assigned-resolution-bits", &res))
> -		res = stm32f4_adc_resolutions[0];
> +		res = adc->cfg->adc_info->resolutions[0];
>  
> -	for (i = 0; i < ARRAY_SIZE(stm32f4_adc_resolutions); i++)
> -		if (res == stm32f4_adc_resolutions[i])
> +	for (i = 0; i < adc->cfg->adc_info->num_res; i++)
> +		if (res == adc->cfg->adc_info->resolutions[i])
>  			break;
> -	if (i >= ARRAY_SIZE(stm32f4_adc_resolutions)) {
> +	if (i >= adc->cfg->adc_info->num_res) {
>  		dev_err(&indio_dev->dev, "Bad resolution: %u bits\n", res);
>  		return -EINVAL;
>  	}
> @@ -926,7 +1011,7 @@ static void stm32_adc_chan_init_one(struct iio_dev *indio_dev,
>  	chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
>  	chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE);
>  	chan->scan_type.sign = 'u';
> -	chan->scan_type.realbits = stm32f4_adc_resolutions[adc->res];
> +	chan->scan_type.realbits = adc->cfg->adc_info->resolutions[adc->res];
>  	chan->scan_type.storagebits = 16;
>  	chan->ext_info = stm32_adc_ext_info;
>  }
> @@ -934,6 +1019,8 @@ static void stm32_adc_chan_init_one(struct iio_dev *indio_dev,
>  static int stm32_adc_chan_of_init(struct iio_dev *indio_dev)
>  {
>  	struct device_node *node = indio_dev->dev.of_node;
> +	struct stm32_adc *adc = iio_priv(indio_dev);
> +	const struct stm32_adc_info *adc_info = adc->cfg->adc_info;
>  	struct property *prop;
>  	const __be32 *cur;
>  	struct iio_chan_spec *channels;
> @@ -942,7 +1029,7 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev)
>  
>  	num_channels = of_property_count_u32_elems(node, "st,adc-channels");
>  	if (num_channels < 0 ||
> -	    num_channels >= ARRAY_SIZE(stm32f4_adc123_channels)) {
> +	    num_channels >= adc_info->max_channels) {
>  		dev_err(&indio_dev->dev, "Bad st,adc-channels?\n");
>  		return num_channels < 0 ? num_channels : -EINVAL;
>  	}
> @@ -953,12 +1040,12 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev)
>  		return -ENOMEM;
>  
>  	of_property_for_each_u32(node, "st,adc-channels", prop, cur, val) {
> -		if (val >= ARRAY_SIZE(stm32f4_adc123_channels)) {
> +		if (val >= adc_info->max_channels) {
>  			dev_err(&indio_dev->dev, "Invalid channel %d\n", val);
>  			return -EINVAL;
>  		}
>  		stm32_adc_chan_init_one(indio_dev, &channels[scan_index],
> -					&stm32f4_adc123_channels[val],
> +					&adc_info->channels[val],
>  					scan_index);
>  		scan_index++;
>  	}
> @@ -990,7 +1077,7 @@ static int stm32_adc_dma_request(struct iio_dev *indio_dev)
>  	/* Configure DMA channel to read data register */
>  	memset(&config, 0, sizeof(config));
>  	config.src_addr = (dma_addr_t)adc->common->phys_base;
> -	config.src_addr += adc->offset + STM32F4_ADC_DR;
> +	config.src_addr += adc->offset + adc->cfg->regs->dr;
>  	config.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
>  
>  	ret = dmaengine_slave_config(adc->dma_chan, &config);
> @@ -1011,6 +1098,7 @@ static int stm32_adc_dma_request(struct iio_dev *indio_dev)
>  static int stm32_adc_probe(struct platform_device *pdev)
>  {
>  	struct iio_dev *indio_dev;
> +	struct device *dev = &pdev->dev;
>  	struct stm32_adc *adc;
>  	int ret;
>  
> @@ -1025,6 +1113,8 @@ static int stm32_adc_probe(struct platform_device *pdev)
>  	adc->common = dev_get_drvdata(pdev->dev.parent);
>  	spin_lock_init(&adc->lock);
>  	init_completion(&adc->completion);
> +	adc->cfg = (const struct stm32_adc_cfg *)
> +		of_match_device(dev->driver->of_match_table, dev)->data;
>  
>  	indio_dev->name = dev_name(&pdev->dev);
>  	indio_dev->dev.parent = &pdev->dev;
> @@ -1129,8 +1219,16 @@ static int stm32_adc_remove(struct platform_device *pdev)
>  	return 0;
>  }
>  
> +static const struct stm32_adc_cfg stm32f4_adc_cfg = {
> +	.regs = &stm32f4_adc_regspec,
> +	.adc_info = &stm32f4_adc_info,
> +	.trigs = stm32f4_adc_trigs,
> +	.start_conv = stm32f4_adc_start_conv,
> +	.stop_conv = stm32f4_adc_stop_conv,
> +};
> +
>  static const struct of_device_id stm32_adc_of_match[] = {
> -	{ .compatible = "st,stm32f4-adc" },
> +	{ .compatible = "st,stm32f4-adc", .data = (void *)&stm32f4_adc_cfg },
>  	{},
>  };
>  MODULE_DEVICE_TABLE(of, stm32_adc_of_match);