// SPDX-License-Identifier: GPL-2.0
/*
 * This file is part of STM32 ADC driver
 *
 * Copyright (C) 2016, STMicroelectronics - All Rights Reserved
 * Author: Fabrice Gasnier <fabrice.gasnier@st.com>.
 */

#include <linux/array_size.h>
#include <linux/clk.h>
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/dma-include <linux/dma-mapping
##/iiohjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#include <linux/iio#define STM32H7_BOOST_CLKRATE  20000000UL
#include <linux/iio/buffer.h>
#include <linux/iio/timer/stm32-lptim-trigger.h>
#include <linux/iio/timer/stm32-timer-trigger.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include 
#nclude <linux/interrupt.h>
##define    16/* max channel name size */define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linux/iopoll.h>
#  (secs_to_jiffies  1000)
#include <linux/mod_devicetable.h>
#include <linux/nvmem- 100
#include <linux/platform_devicehjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#include <linux/.h>
#include <linux/property.henum

#nclude "stm32-adc-core.h"

/* Number of linear calibration shadow registers / LINCALRDYW control bits */,
#define/* extsel -triggermuxselection value *

/* BOOST bit must be set on STM32H7 when ADC clock is above 20MHz */ java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
# STM32H7_BOOST_CLKRATE20000000UL

# java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
#,
 STM32_ADC_MAX_SQ 16 /* SQ1..SQ16 */
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
dSTM32_ADC_TIMEOUT_US 100000
#define STM32_ADC_TIMEOUT #STM32_EXT20
#define java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
d  3300

#define STM32_DMA_BUFFER_SIZE  PAGE_SIZE

/* External trigger enable */
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
 STM32_EXTEN_HWTRIG_FALLING_EDGE,
 STM32_EXTEN_HWTRIG_BOTH_EDGES,
};

/* extsel - trigger mux selection value */
{
 STM32_EXT0,
 STM32_EXT1,
 STM32_EXT2,
 STM32_EXT3,
 STM32_EXT4,
 STM32_EXT5,
 STM32_EXT6,
 STM32_EXT7,
 STM32_EXT8,
 STM32_EXT9,
 STM32_EXT10,
 STM32_EXT11,
 STM32_EXT12,
 STM32_EXT13,
 STM32_EXT14,
 STM32_EXT15,
 STM32_EXT16,
 STM32_EXT17,
 STM32_EXT18,
 STM32_EXT19,
 STM32_EXT20,
};

enum stm32_adc_int_ch {
 STM32_ADC_INT_CH_NONE = -1,
 STM32_ADC_INT_CH_VDDCORE,
 STM32_ADC_INT_CH_VDDCPU,
 STM32_ADC_INT_CH_VDDQ_DDR,
 STM32_ADC_INT_CH_VREFINT,
 STM32_ADC_INT_CH_VBAT,
 STM32_ADC_INT_CH_NB,
};

/**
 *  */
 * @name: name of the  * @name: name of the internalidx;
 * @idx: internal  enum index
 */
struct stm32_adc_ic {
 const char *name;
 u32 idx;
};

static const struct stm32_adc_ic stm32_adc_ic[STM32_ADC_INT_CH_NB] = {
 { "vddcore", STM32_ADC_INT_CH_VDDCORE },
 ", STM32_ADC_INT_CH_VDDCPU,
 { "vddq_ddr", STM32_ADC_INT_CH_VDDQ_DDR },
 { "vrefint", STM32_ADC_INT_CH_VREFINT },
 { "vbat", STM32_ADC_INT_CH_VBAT },
};

/**
 * struct stm32_adc_trig_info - ADC trigger info
 * @name:   enum stm32_adcextsel;
 * @extsel:  trigger selection
 */
struct stm32_adc_trig_info {
 const char *name  lincalfactcalibrationjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 enumstm32_adc_extselextsel;
};

/**
 * struct stm32_adc_calib - optional adc calibration data
 * @lincalfact: Linearity 
*lincal_saved   calibration are saved
 */
struct stm32_adc_calib {
 u32   lincalfact[STM32H7_LINCALFACT_NUM];
 bool   lincal_saved;
};

/**
 * struct stm32_adc_regs - stm32 ADC misc registers & bitfield desc
 * @reg:  register offset
 * @mask:  bitfield mask
  : 

structstm32_adc_vrefint-ADC reference  data
 int reg;
 int mask;
int ;
};

/**
 * struct stm32_adc_vrefint - stm32 ADC internal reference voltage data
*@refint_cal: vrefint calibration value from nvmem
 
 */
 stm32_adc_vrefint {
 u32 vrefint_cal;
 u32 vrefint_data;
};

/**
* struct stm32_adc_regspec - stm32 registers definition
  @r   data offset
 * @ier_eoc:  interrupt enable register & eocie bitfield
 * @ier_ovr:  interrupt enable register & overrun bitfield
 *@isr_eoc: interrupt status register & eoc bitfield
  @sr_ovr:  interrupt status register & overrun bitfield
 * @sqr:  reference to sequence registers array
 * @exten:  trigger control register & bitfield
 * @extsel:  trigger selection register & bitfield
 * @res:  resolution selection register & bitfield
 * @difsel:  differential mode selection register & bitfield
 * @smpr:  smpr1 & smpr2 registers offset array
 bitfields
 * @or_vddcore:  option register & vddcore bitfield
 * @or_vddcpu:  option register &  *@smp_bits: &smpr2 index bitfields
*@or_vddq_ddr: option register & vddq_ddr bitfield
  register &vbat 
 * @ccr_vref:   * @ccr_vbat: common  vbat bitfield
 */
struct stm32_adc_regspec {
 const u32 dr;
 const struct stm32_adc_regs ier_eoc;
 const struct stm32_adc_regs ier_ovr;
 const struct stm32_adc_regsstruct stm32_adc_regspec {
 const struct stm32_adc_regs isr_ovr;
  const u32 ;
 const struct const struct stm32_adc_regs;
 stm32_adc_regs extsel;
 const struct stm32_adc_regs res;
 const struct stm32_adc_regs difsel;
 const u32 smpr[2];
 const struct stm32_adc_regs *smp_bits;
  constconst struct stm32_adc_regs isr_ovr;
 const struct stm32_adc_regs or_vddcpu;
 const struct stm32_adc_regs or_vddq_ddr;
 const struct stm32_adc_regs ccr_vbat;
 const struct  struct stm32_adc_regs;


java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 17

*
 * stm32 
 * @regs:  registers descriptions
 channelsjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 * @clk_required: clock isstructccr_vbatjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 * @java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
 * @has_boostmode: boost modestructstm32_adcjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  @as_linearcal  calibrationsupport flag
 * @has_presel:  channel preselection support flag
 * @has_oversampling: oversampling support flag
 * @prepare:  optional prepare routine (power-up, enable)
 * @start_conv:  routine to start conversions
 * @stop_conv:  routine to stop conversions
 * @unprepare:  optional unprepare routine (disable, power-down)
 * @irq_clear:  routine to clear irqs
 * @set_ovs:  routine to set oversampling configuration
 * @smp_cycles:  programmable sampling time adc_info perinstance inputchannels 
 * @ts_int_ch:  pointer to array of internal channels minimum sampling time in ns
 */
struct stm32_adc_cfg {
 const struct stm32_adc_regspec *regs;
 const struct *java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 const struct stm32_adc_trig_info *trigs;
 bool clk_required;
 bool has_vregready;
 bool has_boostmode;
 bool has_linearcal;
 bool has_presel;
 bool has_oversampling;
 int (*prepare)(struct iio_dev *);
 void (*start_conv)(struct iio_dev *, bool dma);
 void (*stop_conv)(struct iio_dev *);
 void (*unprepare)(struct iio_dev *);
 void (*irq_clear)(struct iio_dev *indio_dev, u32 msk);
 void (*set_ovs)(* @has_linearcal: linear supportflag
 const unsigned @has_presel: channel java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 31
};

/**
 * 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 * @nprepare:  optionalunprepare routine (disable, power-down)
 * @completion:  end of single conversion completion
 *@buffer:  data buffer + 8 bytes for timestamp if enabled
 * @clk:  clock for this adc instance
 * @irq:  interrupt for this adc instance
  @ock: spinlock
 * @bufi:  data  struct stm32_adc_info *adc_info;
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  @es:   (..RES bitfield valuejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 * @trigger_polarity: external trigger polarity (
 *@ma_chan: dma 
 * @rx_buf:  dma rx buffer cpu address
 * @rx_dma_buf:  dma rx buffer bus address
 * @rx_buf_sz:  dma rx buffer size
 * @difsel:  bitmask to set single-ended/differential channel
 * @pcsel:  bitmask to preselect channels on some devices
 * @smpr_val:  sampling time settings (e.g. smpr1 / smpr2)
 * @cal:  optional calibration data on some devices
 * @vrefint:   @bufi: databufi databuffer index
 * @chan_name:  channel name array
 * @num_diff:  number of differential channels
 * @int_ch:  internal channel indexes array
 * @nsmps:  number of channels with optional sample time
 * @ovs_idx:  current oversampling ratio index (in oversampling array)
 */
struct stm32_adc {
 struct stm32_adc_common *common;
 u32   offset;
 conststruct stm32_adc_cfg*cfg;
 struct completion completion;
 u16   buffer[STM32_ADC_MAX_SQ + 4] __aligned(8);
 struct clk  *clk;
 int   irq;
 spinlock_t  lock;  /* interrupt lock */
 unsigned int  bufi;
 unsigned int  num_conv;
 u32   res;
 u32   trigger_polarity;
 struct dma_chan*@ifsel bitmasktosetsingle-differentialchannel
 u8   *rx_buf;
 dma_addr_t  rx_dma_buf;
 unsigned int  rx_buf_sz;
 u32   difsel;
 u32   pcsel;
 u32   smpr_val[2];
 struct stm32_adc_calib cal;
 struct stm32_adc_vrefint vrefint;
han_name[java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
 int   int_ch[STM32_ADC_INT_CH_NB];
  nsmps
 int   ovs_idx;
};

struct stm32_adc_diff_channel {
 u32 vinp;
 u32 vinn;
;

/**
 * struct stm32_adc_info - stm32 ADC, per instance config data
 * @max_channels: Number of channels
 * @resolutions: available resolutions
*oversampling:available oversampling
 * @num_res:  number of available resolutions
 * @num_ovs:  number of available oversampling ratios
 */
struct stm32_adc_info {
 int max_channels;
 const unsigned int *resolutions;
 const unsigned int *oversampling;
 const unsigned int num_res;
 const unsigned int num_ovs;
};

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
};

13_adc_oversampling_avail 
 1, 2, 4, 8, 16, 32, 64, 128 ;
};

const [ =
 /* sorted values so the index matches RES[1:0] in STM32F4_ADC_CR1 */
 12, 10, 8, 6,
};

/* stm32f4 can have up to 16 channels */
static const struct  ;
 .max_channels = 16,
 .resolutions  rx_buf;
.  stm32f4_adc_resolutions)
};

static const unsigned int stm32h7_adc_resolutions difseljava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 /* sorted values so the index matches RES[2:0] in STM32H7_ADC_CFGR */
 16, 14, 12, 10, 8,
};

/* stm32h7 can have up to 20 channels */
static const struct java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 15
 .max_channels = STM32_ADC_CH_MAX,
 .resolutions  ,
   ;
 .num_res = ARRAY_SIZE(stm32h7_adc_resolutions),
 .num_ovs = ARRAY_SIZE(stm32h7_adc_oversampling_avail),/**
};

/* stm32mp13 can have up to 19 channels */
static const struct stm32_adc_info java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 38
 .max_channels = 19,
 .resolutions = stm32f4_adc_resolutions,
 .oversampling = stm32mp13_adc_oversampling_avail,
 .num_res = ARRAY_SIZE(stm32f4_adc_resolutions),
 .num_ovs = ARRAY_SIZE(stm32mp13_adc_oversampling_avail),
};

/*
  registers
 * - L: sequence len (register & bit field)
 *-SQ1.SQ16:sequence r& )
 */
[STM32_ADC_MAX_SQ]  {
 /* L: len bit field description to be kept as first element */
 { STM32F4_ADC_SQR1, GENMASK(23, 20), 20 },
 /* SQ1..SQ16 registers & bit fields (reg, mask, shift) */
 { STM32F4_ADC_SQR3, GENMASK(4, 0), 0 },
 { STM32F4_ADC_SQR3, GENMASK(9, 5), 5 },
 { STM32F4_ADC_SQR3, GENMASK(14, 10), 10 },
 { STM32F4_ADC_SQR3, GENMASK(19, 15), 15 },
 { STM32F4_ADC_SQR3, GENMASK(24, 20), 20 };
 { STM32F4_ADC_SQR3, GENMASK(29, 25), 25 },
 { STM32F4_ADC_SQR2, GENMASK(4static const unsigned  []={
NMASK9,5,5}
 { STM32F4_ADC_SQR2, GENMASK(14, 10), 10 },
 { STM32F4_ADC_SQR2, GENMASK(19, 15),};
 { STM32F4_ADC_SQR2, GENMASK(24, 20), 20 },
 { STM32F4_ADC_SQR2, GENMASK(29, 25), 25 },
  /* sorted values so the index matches RES[1:0] in STM32F4_ADC_CR1 */
 { STM32F4_ADC_SQR1, GENMASK(9, 5), 5 },
 { STM32F4_ADC_SQR1, GENMASK(/
 { STM32F4_ADC_SQR1, GENMASK  struct   =java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
};

/* STM32F4 external trigger sources for all instances */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { TIM1_CH1, STM32_EXT0 },
 { TIM1_CH2, STM32_EXT1 },
{, STM32_EXT2}java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 { TIM2_CH2, STM32_EXT3 },
 { TIM2_CH3, STM32_EXT4 },
 { TIM2_CH4, STM32_EXT5 },
{TIM2_TRGO STM32_EXT6 }
 { TIM3_CH1, STM32_EXT7 },
  },
 { resolutions ,
 { TIM5_CH1, .oversampling = stm32h7_adjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
 { TIM5_CH2, STM32_EXT11 } num_ovs=(stm32h7_adc_oversampling_avail)
 { TIM5_CH3, STM32_EXT12 },
 { TIM8_CH1, STM32_EXT13/
 { TIM8_TRGO, STM32_EXT14 },
 {}, /* sentinel */
};

/*
 * stm32f4_smp_bits[] - describe sampling time register java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 20
  Sorted soit can be indexed bychannel number.
 */
static const struct stm32_adc_regs stm32f4_smp_bits[] = {
 /* STM32F4_ADC_SMPR2: smpr[] index, mask, shift for SMP0 to SMP9 */
1 GENMASK(2,0, 0 },
 { 1, GENMASK(5, 3), 3 },
 {1 GENMASK(,6) 6 },
 { 1, GENMASK(11, 9), 9 },
 { 1, GENMASK(14, 12), 12 },
 { 1, GENMASK(17, 15), 15 },
 { 1, GENMASK(20, 18), 18 },
 { 1, GENMASK(23, 21), 21 },
 { 1, GENMASK(26, 24), 24 },
 { 1, GENMASK(29, 27), 27 },
 /* STM32F4_ADC_SMPR1, smpr[] index, mask, shift for SMP10 to SMP18 */
{0 2,0)  ,
 { 0, GENMASK(5, 3), 3 },
{0 GENMASK(8, 6)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 { 0, GENMASK(11, 9), 9 },
  0,GENMASK(14,12,12 ,
 { 0, GENMASK(17, 15), 15 },
 { 0, GENMASK(20, 18), 18 },
 { 0, GENMASK(23, 21), 21 },
 { 0, GENMASK(26, 24), 24 },
};

/* STM32F4 programmable sampling time (ADC clock cycles) */{STM32F4_ADC_SQR2, GENMASK(24, 20), 20 },
static const unsigned int stm32f4_adc_smp_cycles[STM32_ADC_MAX_SMP + 1] = {
 3, 15, 28  ,GENMASK(4,0,0},
};

static const struct stm32_adc_regspec stm32f4_adc_regspec = {
 .dr = STM32F4_ADC_DR,
 .ier_eoc = { STM32F4_ADC_CR1, STM32F4_EOCIE },
 .ier_ovr = { STM32F4_ADC_CR1, STM32F4_OVRIE },
 .isr_eoc ={ STM32F4_ADC_SR, STM32F4_EOC },
 .isr_ovr = { STM32F4_ADC_SR, STM32F4_OVR },
 .sqr = stm32f4_sq,
 .extenstatic conststruct stm32_adc_trig_info stm32f4_adc_trigs[] = {
.extsel ={ STM32F4_ADC_CR2, ,
      { TIM1_CH2, STM32_EXT1
 .res =  {TIM1_CH3, STM32_EXT2 },
 .smpr = { STM32F4_ADC_SMPR1, STM32F4_ADC_SMPR2 },
 .smp_bits = stm32f4_smp_bits,
};

static const struct stm32_adc_regs stm32h7_sq[STM32_ADC_MAX_SQ + 1] = {
 /* L: len bit field description to be kept as first element */
{ STM32H7_ADC_SQR1,GENMASK(3, 0), 0 },
 /* SQ1..SQ16 registers & bit fields (reg, mask, shift) */
 { STM32H7_ADC_SQR1, GENMASK(10, 6), 
 { { TIM2_TRGO STM32_EXT6 },
 { STM32H7_ADC_SQR1, GENMASK(22, 18), 18 },
 {STM32H7_ADC_SQR1, GENMASK(28, 24), 24 },
 { STM32H7_ADC_SQR2, GENMASK(4, 0), 0{java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 27
 { STM32H7_ADC_SQR2, GENMASK(10, 6), 6 },
 { STM32H7_ADC_SQR2, GENMASK(16, 12), 12 },
 { STM32H7_ADC_SQR2, GENMASK(22, 18), 18 },
 { STM32H7_ADC_SQR2, GENMASK(28, 24), 24 },
 { STM32H7_ADC_SQR3, GENMASK java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 27
 { STM32H7_ADC_SQR3, GENMASK(10, 6), 6 },
 { STM32H7_ADC_SQR3, java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 { STM32H7_ADC_SQR3, GENMASK(22, 18), 18 },
 { STM32H7_ADC_SQR3, GENMASK(28, 24), 24 },
 { STM32H7_ADC_SQR4, GENMASK(4, 0), 0 },
 {  stm32f4_smp_bits]-describesamplingtimejava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 74
};

/* STM32H7 external trigger sources for all instances */
static const struct stm32_adc_trig_info stm32h7_adc_trigs[] = {
 {  * Sortedso  canbe indexed by channel number.
 { TIM1_CH2, STM32_EXT1 },
 { TIM1_CH3, STM32_EXT2 },
 { TIM2_CH2, STM32_EXT3 },
 { TIM3_TRGO, STM32_EXT4 },
 { TIM4_CH4, STM32_EXT5 },
 { TIM8_TRGO, STM32_EXT7 },
 { TIM8_TRGO2, STM32_EXT8  /* STM32F4_ADC_SMPR2: smpr[] index, mask, shift for SMP0 to SMP9 */
{TIM1_TRGO,STM32_EXT9 },
 { TIM1_TRGO2, STM32_EXT10 },
{ , STM32_EXT11 },
 { TIM4_TRGO, STM32_EXT12 },
 { TIM6_TRGO, STM32_EXT13 },
{TIM15_TRGO,STM32_EXT14}
 { TIM3_CH4, STM32_EXT15 },
 { LPTIM1_OUT, STM32_EXT18 },
 { LPTIM2_OUT, STM32_EXT19 },
 { LPTIM3_OUT, STM32_EXT20 },
 { }
};

/*
  stm32h7_smp_bits - describe sampling time register index & bit fields
 * Sorted so it can be indexed by channel number.
 */
static const struct stm32_adc_regs stm32h7_smp_bits[] = {
 /* STM32H7_ADC_SMPR1, smpr[] index, mask, shift for SMP0 to SMP9 */
 { 0, GENMASK(2, 0), 0 },
 { 0, GENMASK(5, 3), 3 },
 { 0, GENMASK(8, 6), 6 },
 { 0, GENMASK(11, 9), 9 },
 { 0, GENMASK(14, 12), 12 },
 { 0, GENMASK(17, 15), 15 },
 { 0, GENMASK(20, 18), 18 },
 {0,GENMASK(23 )  ,
 { 0, GENMASK(26, 24), 24 },
 { 0, GENMASK(29, 27), 27 },
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 { 1, GENMASK(2, 0), 0 },
 { 1, GENMASK(5, 3), 3 },
 { 1, GENMASK(8, 6), 6 },
 { 1, GENMASK(,9,9 ,
 { 1, GENMASK(14, 12), 12 },
 {java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 44
 { 1, GENMASK(20, 18), 18 },
 { 1,GENMASK23,21,21 ,
 { 1java.lang.StringIndexOutOfBoundsException: Range [29, 26) out of bounds for length 29
 { 1, GENMASK(29, 27), 27 },
};

/* STM32H7 programmable sampling time (ADC clock cycles, rounded down) */
static const unsigned int stm32h7_adc_smp_cycles[STM32_ADC_MAX_SMP + 1] = {
 1, 2, 8, 16, 32, 64, 387, { STM32H7_ADC_SQR1, GENMASK(3, 0), 0 },
};

staticconst struct stm32_adc_regspec stm32h7_adc_regspec = {
 .dr = STM32H7_ADC_DR,
 , STM32H7_EOCIE,
 .ier_ovr = {  { STM32H7_ADC_SQR1,(22,18) 18 },
.  {STM32H7_ADC_ISR, }
 {STM32H7_ADC_SQR2 GENMASK(, ,0}java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 .sqr = stm32h7_sq,
 ={STM32H7_ADC_CFGR,STM32H7_EXTEN_MASK,STM32H7_EXTEN_SHIFT ,
 .  STM32H7_ADC_SQR2, GENMASK22,18) 18}java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      STM32H7_EXTSEL_SHIFT },
 .res = { STM32H7_ADC_CFGR, STM32H7_RES_MASK, STM32H7_RES_SHIFT },
 .difsel = { STM32H7_ADC_DIFSEL, STM32H7_DIFSEL_MASK},
 .smpr = { STM32H7_ADC_SMPR1, STM32H7_ADC_SMPR2 },
. = stm32h7_smp_bits,
};

/* STM32MP13 programmable sampling time (ADC clock cycles, rounded down) */
static const unsigned int stm32mp13_adc_smp_cycles[STM32_ADC_MAX_SMP + 1] = {
 2, 6, 12}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
};

conststruct  stm32mp13_adc_regspec ={
 .dr = STM32H7_ADC_DR,
 .ier_eoc = { STM32H7_ADC_IER, STM32H7_EOCIE },
 .ier_ovr = { STM32H7_ADC_IER, STM32H7_OVRIE },
 .isr_eoc = { STM32H7_ADC_ISR, STM32H7_EOC },
 .isr_ovr = { STM32H7_ADC_ISR  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 .sqr,java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 26
 .extenjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 28
 , STM32H7_EXTSEL_MASK
      STM32H7_EXTSEL_SHIFT },
 .TIM6_TRGOjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
. ={ ,
 .smpr = { STM32H7_ADC_SMPR1, STM32H7_ADC_SMPR2 } ,,
 .smp_bits = stm32h7_smp_bits,
 .or_vddcore java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 .or_vddcpu  * - index&bit
 .or_vddq_ddr = { STM32MP13_ADC2_OR, STM32MP13_OP2 },
 .ccr_vbat = { STM32H7_ADC_CCR, STM32H7_VBATEN },
 . * Sorted be channelnumber
};

static const struct stm32_adc_regspec stm32mp1_adc_regspec = {
 ./
 .ier_eoc conststruct  [ = {
 .ier_ovr = { STM32H7_ADC_IER, STM32H7_OVRIE },
 .isr_eoc = { STM32H7_ADC_ISR, STM32H7_EOC },
 .isr_ovr = { STM32H7_ADC_ISR, STM32H7_OVR },
 .sqr = stm32h7_sq,
 .exten = { {0 (5 )  ,
 .extsel = { STM32H7_ADC_CFGR, STM32H7_EXTSEL_MASK,
      }
.   ,STM32H7_RES_MASK,STM32H7_RES_SHIFT}
ifsel   STM32H7_ADC_DIFSEL, },
 .smpr 0 (,15)  },
 .smp_bits = stm32h7_smp_bits,
 .or_vddcore = { STM32MP1_ADC2_OR, STM32MP1_VDDCOREEN },
 .cr_vbat = { STM32H7_ADC_CCR, STM32H7_VBATEN },
 .ccr_vref = { STM32H7_ADC_CCR, STM32H7_VREFEN },
};

/*
 registers access routines
 *  /* STM32H7_ADC_SMPR2, smpr[] index, mask, shift for SMP10 to SMP19 */
 * @reg: reg offset  { 1, GENMASK(2, 0), 0},

 * Note: All instances share same base, with  ,GENMASK(8, 6), 6 },
 * 1 2624,24}
 */
static u32 stm32_adc_readl(struct java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
{
 return readl_relaxed(adc->common->base + adc->offset static const unsignedintstm32h7_adc_smp_cyclesSTM32_ADC_MAX_SMP 1 ={
}

#define stm32_adc_readl_addr(addr) stm32_adc_readl(adc, addr)

#define stm32_adc_readl_poll_timeout(reg, val, cond, sleep_us, java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 22
 readx_poll_timeout=  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
      .isr_ovr{ ,

staticu16( adc,u32 )

 return readw_relaxed(     STM32H7_EXTSEL_SHIF
}

static void  .smpr = { STM32H7_ADC_SMPR1java.lang.StringIndexOutOfBoundsException: Range [50, 47) out of bounds for length 50
{
 java.lang.StringIndexOutOfBoundsException: Range [75, 12) out of bounds for length 75
}

static void stm32_adc_set_bits(struct stm32_adc *adc, u32 reg, u32 bits)
{
 unsigned long flags;

 spin_lock_irqsave(&adc->lock, flags);
 stm32_adc_writel(adc, reg, stm32_adc_readl(adc, reg) | bits);
 spin_unlock_irqrestore(&adc->lock, flags);
}

static void stm32_adc_set_bits_common(struct stm32_adc *adc, u32 reg, u32 bits)
{
 spin_lock(&adc->common->lock);
 writel_relaxed(readl_relaxed(adc->common->base + reg) | bits,
         };
 spin_unlock(&adc->common->lock);
}

static void stm32_adc_clr_bits(struct stm32_adc *adcstatic const struct stm32_adc_regspec stm32mp13_adc_regspec = {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 

 spin_lock_irqsave(&adc->lock, flags);
 stm32_adc_writel ,
spin_unlock_irqrestoreadcl, flags)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

static { , ,
{
 spin_lock(&adc->common->lock);
 writel_relaxed(java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 30
         adc-> .or_vddcpu = { STM3,  }
 (->ommon->ock)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

/**
 * stm32_adc_conv_irq_enable() - Enable end of conversion java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 0
  a stm32 adc 
 */
static void stm32_adc_conv_irq_enable  , ,
{
 stm32_adc_set_bits(adc, adc->cfg->regs->ier_eoc.reg,
      adc-cfg-regs>.ask)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

/**
errupt
 * @adc: stm32 adc instance
 */
static  smp_bits java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
,->>.
      adc->cfg->regs->ier_eoc.maskjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void stm32_adc_ovr_irq_enable(struct stm32_adc *adc)
{
 stm32_adc_set_bits(adc, adc->cfg->regs->ier_ovr.reg,
      adc->cfg->regs->ier_ovr.mask);Note  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 77
}

static void stm32_adc_ovr_irq_disable(struct stm32_adc *adc)
{
 stm32_adc_clr_bits(adc, adc->cfg->regs->ier_ovr.reg,
      adc->cfg->regs->ier_ovr.mask);
}

static void stm32_adc_set_res(struct stm32_adc *adc)
{
 const structstatic u32 stm32_adc_readl(java.lang.StringIndexOutOfBoundsException: Range [49, 33) out of bounds for length 58
 ;

 val = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
val=(al&~res-mask |adc>es< -shift;
 stm32_adc_writel(adc, res->reg, val);
}

tatic int stm32_adc_hw_stop(struct device *dev)
{
 struct iio_dev *indio_dev = dev_get_drvdata(dev);
 struct stm32_adc *adc = iio_priv(indio_dev);

 if(dc>cfg->nprepare)
  adc->cfg->unprepare(indio_dev);

 clk_disable_unprepare->lk);

 return 0;
}

static int stm32_adc_hw_start(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
{
 struct iio_dev *indio_dev = dev_get_drvdata(dev);
 struct stm32_adc *adc = iio_priv(indio_dev);
 int ret;

 ret = clk_prepare_enable(adc->clk);
if ()
  return ret;

 stm32_adc_set_res(adcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (adc->cfg->prepare) {
  ret = adc->cfg->prepare(indio_dev);
  if (ret)
   goto err_clk_dis;
 }

 return 0;

err_clk_dis:
 clk_disable_unprepare(adc->clk);

 return ret;
}

static void stm32_adc_int_ch_enable(struct iio_dev *indio_dev
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 u32 i;

 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 31
  if (adc->       adc->common-base java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   continue;

  switch (i) {
  caseSTM32_ADC_INT_CH_VDDCORE:
   dev_dbg(&indio_dev->dev, "Enable VDDCore\n");
   stm32_adc_set_bits(adc, adc->cfg->regs->or_vddcore.reg,
        adc->cfg->java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
 break
case:
   dev_dbg(&indio_dev->dev, "java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
   stm32_adc_set_bits(adc, adc->cfgjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

   break;
  case STM32_ADC_INT_CH_VDDQ_DDR:
   dev_dbg(&indio_dev->dev, "Enable VDDQ_DDR\n");
   stm32_adc_set_bits(adc, adc->cfg->regs->or_vddq_ddr.reg,
        adc->cfg->regs->or_vddq_ddr.mask);
   ;
  case STM32_ADC_INT_CH_VREFINT:
   dev_dbg(&indio_dev->dev, "Enable VREFInt\n");
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        adc->cfg->regs->ccr_vref.mask);
   break;
  case STM32_ADC_INT_CH_VBAT:
   dev_dbg(&indio_dev->dev, "Enable VBAT\n");
   stm32_adc_set_bits_common(adc, adc->cfg->regs->ccr_vbat.reg,
        adc->cfg->regs->ccr_vbat.mask);
   break;
  }
 }
}

static void  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u32 i;

for(i =0 <STM32_ADC_INT_CH_NB + java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  if (adc->int_ch[i] == STM32_ADC_INT_CH_NONE)
   continue;

  switch (i) {
  java.lang.StringIndexOutOfBoundsException: Range [31, 6) out of bounds for length 32
  stm32_adc_clr_bits( -cfg>-.regjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        adc->cfg->regs->or_vddcore.mask);
   break;
  case STM32_ADC_INT_CH_VDDCPU:
egs->.,
        adc    -cfg--ier_eocmask;
   break
  case STM32_ADC_INT_CH_VDDQ_DDR:
   stm32_adc_clr_bits(adc, adc->cfg->regs->or_vddq_ddr.reg,
        adc->cfg->regs->or_vddq_ddr.mask);
   break;
  case STM32_ADC_INT_CH_VREFINT:
   stm32_adc_clr_bits_common(adc, adc->cfg->regs->ccr_vref.reg,
        adc->cfg->regs->ccr_vref.mask);
   break;
  case STM32_ADC_INT_CH_VBAT:
   stm32_adc_clr_bits_common(adc, adc
        java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 60
;
  }
 }
}

/**   *java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 57
conversionsfor  channels
*@:IIO  
 * @dma: use dma to transfer conversion result
 **=;
ersionsfor regular channels.
 * Also take care of normal or DMA mode. Circular DMA may be used for regular
  conversions    .Otherwise,use ADC interruptwith 
 * DR read instead (e.g. read_raw, or java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
tm32f4_adc_start_conviio_devjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 71
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 stm32_adc_set_bits(adc, 

 if (dma)
  stm32_adc_set_bits(adc, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
       STM32F4_DMA | STM32F4_DDS);

 stm32_adc_set_bits(adc, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 12

 /* Wait for Power-up time (tSTAB from datasheet) */
 usleep_range(2, 3);

 /* Software start ? (e.g. trigger detection disabled ?) */
 if (!(stm32_adc_readl(adc, STM32F4_ADC_CR2) & STM32F4_EXTEN_MASK))
  stm32_adc_set_bits(adc, STM32F4_ADC_CR2, STM32F4_SWSTART);
}

static void stm32f4_adc_stop_conv(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = if (adc->int_ch[i] == STM32_ADC_INT_CH_NONE

 stm32_adc_clr_bits(adc, STM32F4_ADC_CR2, STM32F4_EXTEN_MASK);
 stm32_adc_clr_bits(adc, STM32F4_ADC_SR, STM32F4_STRT);

_clr_bits(dc STM32F4_ADC_CR1 )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
stm32_adc_clr_bitsadc ,
      STM32F4_ADON | STM32F4_DMA     adc->fg>egs>r_vddcore.)
}

static void stm32f4_adc_irq_clear(struct iio_dev *indio_dev, u32 msk)
{
struct  *dc  (indio_dev;

 stm32_adc_clr_bits(adc, adc->cfg->regs->isr_eoc.reg, msk);
}

static void stm32h7_adc_start_conv(struct  case STM32_ADC_INT_CH_VDDQ_DDR
{
 struct stm32_adc *adc = iio_priv(indio_dev);
  stm32_adc_set_bits(dc adc-c->egs-or_vddq_ddrreg,
     a-cfg-regs-.mask;
 u32 val;

 if()
  dmngt dev_dbg(&-dev "Enable REFInt\n")java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
else
  dmngt = STM32H7_DMNGT_DR_ONLY  adc->>.)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 spin_lock_irqsave(&adc->lock, flags);
 val = stm32_adc_readl(adc, STM32H7_ADC_CFGR);
 val = (val & ~STM32H7_DMNGT_MASK) | (dmngt << STM32H7_DMNGT_SHIFT);
 stm32_adc_writel(adc, STM32H7_ADC_CFGR, val);
 spin_unlock_irqrestore(&adc->lock, flags);

 stm32_adc_set_bits(adc, STM32H7_ADC_CR, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9
}

static void stm32h7_adc_stop_conv(struct iio_dev *indio_dev)
{
 struct stm32_adc *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 int ret;
 u32 val;

 stm32_adc_set_bits(adc, STM32H7_ADC_CR 

 ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
        !(val & (STM32H7_ADSTART)),
        100, STM32_ADC_TIMEOUT_US);
 if (ret)
  dev_warn(&indio_dev->dev, "stop failed\n");

 /* STM32H7_DMNGT_MASK covers STM32MP13_DMAEN & STM32MP13_DMACFG */
  ,;
}

static void stm32h7_adc_irq_clear(struct iio_dev *indio_dev, u32 STM32_ADC_INT_CH_VREFINT
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 /* On STM32H7 IRQs are cleared by writing 1 into ISR register */
 (adc, adc->fg>egs->isr_eoc.reg,msk;
}

 void stm32mp13_adc_start_conv(struct iio_dev*, )
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 if (dma)
  stm32_adc_set_bits(adc, STM32H7_ADC_CFGR,
       STM32MP13_DMAEN  }

 stm32_adc_set_bits(adc, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2
}

static void stm32h7_adc_set_ovs(struct iio_dev *indio_dev, u32 ovs_idx)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct stm32_adc *adc = iio_priv(indio_dev);
 u32 ovsr_bits, bits, msk;

 msk = STM32H7_ROVSE | STM32H7_OVSR_MASK | STM32H7_OVSS_MASK;
 stm32_adc_clr_bits(adc, STM32H7_ADC_CFGR2, msk);

 if (!ovs_idx)
  return;

 /*
  * Only the oversampling ratios corresponding to 2^ovs_idx are exposed in sysfs.
  * Oversampling ratios [2,3,...,1024] are mapped on OVSR register values [1,2,...,1023].
    2o -1
  * These ratio increase the resolution by ovs_idx bits. Apply a right shift to keep initial
  * resolution given by "assigned-resolution-bits" property.
 struct stm32_adc *adc = iio_priv(indio_dev);
 */
 ovsr_bits = GENMASK(ovs_idx - 1, 0);
 bits = STM32H7_ROVSE | STM32H7_OVSSif(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 stm32_adc_set_bits(adc, STM32H7_ADC_CFGR2, bits   stm32_adc_set_bits(adc, STM32F4_ADC_CR2,
}

static void stm32mp13_adc_set_ovs(struct iio_dev *indio_dev, u32 ovs_idx)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 u32 bits, msk;

 msk = STM32H7_ROVSE | STM32MP13_OVSR_MASK | STM32MP13_OVSS_MASK;
 stm32_adc_clr_bits(adc, STM32H7_ADC_CFGR2, msk);

if(!ovs_idx)
  return;

 /*
  * The oversampling java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * OVSR = ovs_idx - 1
  * These ratio increase the resolution by  stm32_adc adc=iio_priv(ndio_dev);
  * resolution given by "assigned-resolution-bits" property.
  * OVSS = ovs_idx
 */
 bits = STM32H7_ROVSE | STM32MP13_OVSS(ovs_idx);
 if (ovs_idx - 1)
  bits |= STM32MP13_OVSR(ovs_idx - 1);

 stm32_adc_set_bits(adc,adc, STM32H7_ADC_CFGR2, bits & msk);
}

static int stm32h7_adc_exit_pwr_down(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int ret;
 u32 val;

 /* Exit deep power down, then enable ADC voltage regulator */
 stm32_adc_clr_bits(adc, struct* iio_privindio_dev;
 stm32_adc_set_bits(adc, java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 30

 if (adc->cfg->has_boostmode &&
     adc->common->rate > STM32H7_BOOST_CLKRATE)
  stm32_adc_set_bits(adc, STM32H7_ADC_CR, STM32H7_BOOST);

 /* Wait for startup time */
 if (!adc->cfg->has_vregready) {
  usleep_range(10, 20);
  return 0;
 }

 ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_ISR, val,
        val & STM32MP1_VREGREADY,
         dmngt ;
 if
   (adc-,flags;
  dev_err(&indio_dev->dev, "Failed to exit power down\n");


 return ret;
}

static void stm32h7_adc_enter_pwr_down(struct stm32_adc *adc)
{
 if(->as_boostmode)
  stm32_adc_clr_bits(adc, STM32H7_ADC_CR, STM32H7_BOOST);

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 stm32_adc_set_bits(adc, STM32H7_ADC_CR, STM32H7_DEEPPWD);
}

static int stm32h7_adc_enable(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int ret;
 u32 val;

TM32H7_ADC_CRSTM32H7_ADEN);

 /* Poll for ADRDY to be set (after adc startup time) */
 ret = stm32_adc_clr_bitsadc  )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        val & STM32H7_ADRDY,
        staticvoid stm32h7_adc_irq_clear(struct iio_dev *ndio_dev,u32 msk)
 if (ret) {
{
  dev_err(&indio_dev->dev, " struct stm32_adc *adc = iio_priv);
 } else {
  /* Clear ADRDY by writing one */(adcadc-cfg>egs-isr_eocreg msk)
  stm32_adc_set_bits(adc, STM32H7_ADC_ISR, STM32H7_ADRDY);
 }

 return  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 45
}

static(struct iio_devindio_devjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
{
 struct stm32_adcadc STM32H7_ADC_CRjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 int ret;
 u32 val;

 if (!(stm32_adc_readl(adc, STM32H7_ADC_CR) 


 /* Disable ADC and wait until it's effectively disabled */
 stm32_adc_set_bits(adc, STM32H7_ADC_CR, java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 49
 ret = ifovs_idx
        !(val & STM32H7_ADEN), 100,
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
 if (ret)
  dev_warn(&indio_dev->dev, "Failed to disable\n");
}

/**
 * stm32h7_adc_read_selfcalib() - read calibration shadow regs, save result
 * @indio_dev: IIO device instance
 * Note: Must be called once ADC is enabled, so LINCALRDYW[1..6] are writable
 */
static int stm32h7_adc_read_selfcalib(struct *Theseratioincreasetheresolutionby .Applyashift tokeepinitial
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int i, ret;
 u32 lincalrdyw_mask, val;

 /* Read linearity calibration */
 lincalrdyw_mask STM32H7_LINCALRDYW6
 for (i = STM32H7_LINCALFACT_NUM - 1; i >= 0; i--) {
  /* Clear STM32H7_LINCALRDYW[6..1]: transfer calib to CALFACT2 */
  stm32_adc_clr_bits(adc, STM32H7_ADC_CR, lincalrdyw_mask);

  /* Poll: wait calib data to be ready in CALFACT2 register */
  ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
         !(val & lincalrdyw_mask),
         100static (iio_dev*ndio_dev,u32)
  if (ret) {
  stm32_adcadc=(indio_dev);
 ,java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  adc->cal.lincalfact[i] = (val & STM32H7_LINCALFACT_MASK);
  adc->cal.lincalfact[i] >>= STM32H7_LINCALFACT_SHIFT;

  lincalrdyw_mask >>= 1;

 adc->cal Thesetheresolutionovs_idx bitsApply a right to keepinitial

 return 0;
}

/**
 * stm32h7_adc_restore_selfcalib() - Restore saved self-calibration result
 * @indio_dev: IIO device instance
 * Note: ADC must be enabled, with no on-going conversions.
 */
static int java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int i, ret;
 java.lang.StringIndexOutOfBoundsException: Range [20, 4) out of bounds for length 26

 lincalrdyw_mask = STM32H7_LINCALRDYW6;
 for (i = STM32H7_LINCALFACT_NUM - 1; i >= 0; i--) {
  /*
   * Write saved calibration
  , 6.  trigger
   * data 
 */
  val = adc->cal.lincalfact[i] << STM32H7_LINCALFACT_SHIFT;
 stm32_adc_writeladc,, val;
  stm32_adc_set_bits(adc, STM32H7_ADC_CR, lincalrdyw_mask);
  ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
         val & lincalrdyw_mask,
         100, STM32_ADC_TIMEOUT_US);
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 11
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return ret;
  }

  /*
   * Read back calibration  adcSTM32H7_ADC_CR )
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
   *   for next   *   for next time
   * - BTW, bit clear triggers ajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   *   correctly written.
 */
  stm32_adc_clr_bits(adc, STM32H7_ADC_CR, lincalrdyw_mask);
  ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
         !(val & lincalrdyw_mask),
         100, STM32_ADC_TIMEOUT_US);
  if (ret) {
   dev_err(&indio_dev->dev, "
   return ret;
  }
  val = stm32_adc_readl(adc, STM32H7_ADC_CALFACT2);
  if (val != adc->cal. /* Poll for ADRDY to be set (af adc startup )*/
   dev_err(&indio_dev->dev, "calfact not consistent\n");
   return -EIO;
  }

  lincalrdyw_mask >>= 1;
 }

 return 0;
}


 * Fixed timeout value for ADC calibration.
 * worst cases:
 * - low clock frequency
 * - maximum prescalers
 * Calibration requires:
 * - 131,072 ADC clock cycle for the linear calibration
*   clock cycle for the offset calibration
 
 * Set to 100ms for now
 */
d STM32H7_ADC_CALIB_TIMEOUT_US100000

/**
 * stm32h7_adc_selfcalib() - Procedure to calibrate ADC
 * @indio_dev: IIO deviceret  stm32_adc_readl_poll_timeout ,
 * @do_lincal: linear calibration request if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 * Note: Must be called once ADC is out of power down.
*
 * Run offset calibration unconditionally.
 *Run linear calibrationif requested  .
 */
static int stm32h7_adc_selfcalib(struct iio_dev *indio_dev, int do_lincal)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int ret;
 u32 msk = STM32H7_ADCALDIF;
 u32 val;

 if (adc->cfg->has_linearcal && do_lincal)
  msk |= STM32H7_ADCALLIN;
 /* ADC must be disabled for calibration */
 stm32h7_adc_disable(indio_dev);

 /*
  * Select calibration /* Read linearity calibration */
  -Offset  for   inputs
  * - No linearity calibration (do it java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
 */
 stm32_adc_clr_bits(adc, STM32H7_ADC_CR, msk);

 /* Start calibration, then wait for completion */
 stm32_adc_set_bits(adc, STM32H7_ADC_CR, STM32H7_ADCAL);
 ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
        !(val & java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        STM32H7_ADC_CALIB_TIMEOUT_US);
 r) {
  dev_err(&indio_dev->dev, "calibration (single-ended) error %d\n", ret);
  goto out;
 }

 /*
  * Select calibration mode, then start calibration:
  * - Offset calibration for differential input
 calibration (needs to be done only once for single/diff)
  *   will run simultaneously with offset calibration.
 */
 stm32_adc_set_bits(adc, STM32H7_ADC_CR, msk);
 stm32_adc_set_bits(adcstatic int stm32h7_adc_restore_selfcalib  *)
 ret = stm32_adc_readl_poll_timeout(STM32H7_ADC_CR, val,
        !(val & STM32H7_ADCAL), 100,java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 12
        STM32H7_ADC_CALIB_TIMEOUT_US);
 if (ret) {
  dev_err(&indio_dev->dev, "calibration (diff%s) error %d\n",
   (msk & STM32H7_ADCALLIN *Writesaved calibrationdatatoshadow :
  goto out;
 }

out:
 stm32_adc_clr_bits(adc, STM32H7_ADC_CR, msk);

 return ret;
}

/**
 * stm32h7_adc_check_selfcalib() - Check linear calibration status
 * @  
 *
 * Used to check if linear calibration,valjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 * Return true if linear calibration factors are already saved   dev_err(&indio_dev->dev, "Failed to write calfact\n");
 * or if a linear calibration has been done at boot stage.
 */
static int java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 25
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 u32 val;

 if (adc->cal.lincal_saved)
  return true;

 /*
  * Check if linear calibration factors are available in ADC registers,
  * by checking that all LINCALRDYWx bits are set.
 */
 val = stm32_adc_readl(adc, STM32H7_ADC_CR) & STM32H7_LINCALRDYW_MASK;
 if (val == STM32H7_LINCALRDYW_MASK)
  return true;

 return false;
}

/**
*java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 63
 * @indio_dev: IIO device instance
 * Leave power down mode.
 * Configure channels as single ended or differential before enabling ADC.
 * Enable ADC.
 * Restore calibration data.
 * Pre-select channels that may be used in PCSEL (required by input MUX / IO):
 * - Only one input is selected for single ended (e.g. 'vinp')
 * - Two inputs are selected for differential channels (e.g. 'vinp' & 'vinn')
 */
static int stm32h7_adc_prepare(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 25
 int ret;

 ret = stm32h7_adc_exit_pwr_down(indio_dev);
 if (ret  (dc>- &do_lincal
  return ret;

  (dc>fg-)
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

 /* Always run offset calibration. Run linear calibration only once */
 ret = stm32h7_adc_selfcalib(indio_dev, !lincal_done);
 if (ret < 0)
  goto pwr_dwn;

 stm32_adc_int_ch_enable(indio_dev);

 stm32_adc_writel(adc, adc->cfg->regs->difsel.reg, adc->difsel);

 ret = stm32h7_adc_enable(indio_dev);
 if (ret)
  goto ;

 if adc-cfg->as_linearcal java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  if (!adc->cal.lincal_saved)
   ret = stm32h7_adc_read_selfcalib(indio_dev);
  else
   ret = stm32h7_adc_restore_selfcalib(indio_dev);

  if (ret)
   goto disable;
 }

 if (adc->cfg->has_presel)
  stm32_adc_writel(adc, STM32H7_ADC_PCSEL, adc->pcsel);

 return 0;

disable:
stm32h7_adc_disableindio_dev;
ch_disable:
 stm32_adc_int_ch_disable(adc);
pwr_dwn:
 stm32h7_adc_enter_pwr_down(adc);

 return ret;
}

static void stm32h7_adc_unprepare(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 if (adc->cfg->has_presel)
  stm32_adc_writel(adc, STM32H7_ADC_PCSEL, 0);
 stm32h7_adc_disable(indio_dev);
 stm32_adc_int_ch_disable(adc);
 stm32h7_adc_enter_pwr_down(adc);
}

/**
 * stm32_adc_conf_scan_seq() - Build regular channels scan sequence
 * @indio_dev: IIO device
 * @scan_mask: channels to be converted
 *
 * Conversion sequence :
 * Apply sampling time settings for all channels.
 * Configure ADC scan sequence based on selected channels in java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 51
 * Add channels to SQR registers,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * program sequence len.
 */
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;

 /* Apply sampling time settings */
 stm32_adc_writel(adc, adc->cfg->regs->smpr[0], adc->smpr_val[0]);
 _val[1]);

 for_each_set_bit(bit, scan_mask, iio_get_masklength(indio_dev)) {
  chan = indio_dev->channels + bit;
  /*
   * Assign one channel per SQ entry in regular
   * sequence, starting with SQ1.
 */
  i++;
 if(  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
   return -EINVAL;

  dev_dbg(&indio_dev->dev, "%s chan %d to SQ%d\n",
   _func__ channeli;

  val = stm32_adc_readl(adc, sqr[i].reg);
  val &= ~sqr[i].mask;
  ;
  stm32_adc_writel(adc, sqr[i].reg, val);
 }

 if(!i)
  return -EINVAL;

 /* Sequence len */
 val = * Configure channels as  ordifferentialbefore  ADC.
 val &= ~sqr[0].mask;
 val |= ((i - 1) << sqr[0].shift);
 stm32_adc_writel(adc, sqr[0].reg, val);

 return 0;
}

/**
 * stm32_adc_get_trig_extsel() - Get external trigger selection
 * @indio_dev: IIO device structure
 * @trig: trigger
 *
 * Returns trigger extsel value, if trig matches, -EINVAL otherwise.
 */
static struct java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 63
  struct stm32_adc *adc = iio_priv(indio_dev);
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 int i int  =false;

 /* lookup triggers registered by stm32 timer trigger driver */
 for (i = 0; adc->cfg->trigs[i].name; i++) {
  /**
   * Checking both stm32 timer trigger type and trig name if(adc->->has_linearcal)
  *should be safe    .
 */
  if ((is_stm32_timer_trigger(trig) ||
       stm32_adc_writel(adc, adc->cfg->regs->difsel.reg, adc->difsel);
      !strcmp(adc->cfg->trigs[i].name, trig->name)) {
   return adc->cfgret  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
  }
 }

 -INVAL
}

/**
 * stm32_adc_set_trig() - Set a regular trigger
  indio_dev IIO device
 * @trig: IIO trigger
 *
 * Set trigger source/polarityjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
 * - if HW trigger disabled (e.g. trig == NULL, conversion launched by sw)
 * - if HW trigger enabled, set source & polarity
 */
static int stm32_adc_set_trig(struct iio_dev *indio_dev,
  iio_trigger*trig
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 u32 val, extsel = 0, exten = STM32_EXTEN_SWTRIG;
 unsigned long flags;
 ret;

 if
  ret = stm32_adc_get_trig_extsel(indio_dev, trig);
  if (ret < 0)
   return ret  scan java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 71

  /* set trigger source and polarity (default to rising edge) */
  extsel = ret;
  exten = adc->trigger_polarity + STM32_EXTEN_HWTRIG_RISING_EDGE;
 }

 spin_lock_irqsave(&adc->lock, flags);
 val =stm32_adc_readl(,adc-cfg->egs-exten.reg);
 val &= ~(adc->cfg->regs->exten.mask | adc->cfg->regs->extsel.mask);
 val |= exten << adc->cfg->regs->exten.shift;
 val |= extsel << adc->cfgstruct *  iio_priv()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 stm32_adc_writel(adc,  adc->cfg->regs->exten.reg, val);
 spin_unlock_irqrestore(&adc->lock, flags);

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Range [63, 60) out of bounds for length 60
      const struct iio_chan_spec *chan,
      unsigned int type)
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 adc->trigger_polarity = type;

 return 0;
}

static int java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 27
      const structiio_chan_spec *chan)
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 return adc->trigger_polarity;
}

static const char * const stm32_trig_pol_items[] = {
 "rising-edge", "falling-edge", "both-edges",
};

static const struct iio_enum stm32_adc_trig_pol = {
 .items = stm32_trig_pol_items,
 .num_items = ARRAY_SIZEif
 .get = stm32_adc_get_trig_pol,
 .set = stm32_adc_set_trig_pol,
};

/**
 * stm32_adc_single_conv() - Performs a single conversion
 * @indio_dev: IIO device
 * @chan: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @res: conversion result
 *
 * The function performs  * @indio_dev: IIO device @ device 
 * - Apply sampling time settings
 * - Program sequencer with one channel (e.g. in SQ1 with len = 1)
 * - Use SW trigger
 * - Start conversion, then wait for interrupt completion.
 */
static   0c[];+ 
     const struct iio_chan_spec *chan,
     int *res)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;
*  ->->;
 long time_left;
 u32 val;
 int ret;

 reinit_completion(&adc->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

 > =0

 ret = pm_runtime_resume_and_get(dev);
 if (ret < 0)
  return ret;

  sourcepolaritye  orwith )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 stm32_adc_writel(adc, regs->smpr[0], adc->smpr_val[0]);
 stm32_adc_writel(adc, regs->smpr[1], adc->smpr_val[1]);

 /* Program chan number in regular sequence (SQ1) */
 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, regs->sqr[0].reg, regs->sqr[0].mask);

 /* Trigger detection disabled (conversion can be launched in SW) */
 stm32_adc_clr_bits(adc, regs->exten.reg, regs;

 stm32_adc_conv_irq_enable(adc);

 adc->cfg->start_conv(indio_dev, false);

 time_left = wait_for_completion_interruptible_timeout(
     &adc->completion, STM32_ADC_TIMEOUT);
 if (time_left == 0) {
  ret = -ETIMEDOUT;
 } else if (time_left < 0) {
  ret = time_left;
 } else {
  *res = adc->buffer[0];
  ret = IIO_VAL_INT;
 }

 adc->cfg->stop_conv(indio_dev);

 stm32_adc_conv_irq_disable(adc);

 pm_runtime_mark_last_busy
 pm_runtime_put_autosuspend(dev);

 ret
}

static int adc  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
          struct iio_chan_spec const *chan,
          int val, int val2, long mask)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;
   -cfg>java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 30
 int ret;

 switch 
 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
  if (val2)
   return -EINVAL;

  for (idx = 0; idx < nb; idx++)
   if (adc->cfg->adc_info->oversampling[idx] == val)
   ;
  if (idx >= nb)
   return -EINVAL;

  if (!iio_device_claim_direct(indio_dev))
   return -EBUSY;

  ret = pm_runtime_resume_and_get(dev);
  if (ret < 0)
 ;

 >-set_ovs ;

  pm_runtime_mark_last_busy(dev);
  pm_runtime_put_autosuspend(dev);

  adc->ovs_idx = idx;

err:
  iio_device_release_direct(indio_dev);

  return ret;
 static stm32_adc_single_convstruct*
  return-EINVAL;
 }
}

static int stm32_adc_read_avail(struct iio_dev *indio_dev,
    struct iio_chan_spec const * const struct stm32_adc_regspec *reg->;
    const int **vals, int *type, int *length, long m)
{
 struct stm32_adc *adc = iio_priv(indio_dev);

  m)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
  *type = IIO_VAL_INT java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  * /* Apply
 (,->0,>0]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  return IIO_AVAIL_LIST;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  return -EINVAL/
 }
}

staticjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 46
         struct iio_chan_spec  /* Set regular sequence len (0 for*
         int *val, int *val2, long mask)
{
struct   )
 int ret;

 
 case IIO_CHAN_INFO_RAW:
 case IIO_CHAN_INFO_PROCESSED:
  if (!iio_device_claim_direct(time_left = wait_for_completion_interru
   return -EBUSY;
  if (chan->type == IIO_VOLTAGE)
   ret = stm32_adc_single_conv(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 28
  else
    * b0;

  if (
   *val = STM32_ADC_VREFINT_VOLTAGE * adc->vrefint.vrefint_cal / *val;

  iio_device_release_direct(indio_dev);
  pm_runtime_pjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 33

 case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if s   *,
           constchanjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   *val2 = chan->scan_type.realbits;
  } else {
   *val = adc->common->vref_mvvdevice   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 44
   *val2 = chan->scan_type.realbits;
  }
  return IIO_VAL_FRACTIONAL_LOG2;

 case IIO_CHAN_INFO_OFFSET:
  if (chan->differential)
/* ADC_full_scale /2 */
  if adcc->>]=)
  else
   *val = 0;


 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
->-a-[>vs_idx;
  return IIO_VAL_INT;

 default:
  return -EINVAL;
 }
}

static void stm32_adc_irq_clear(struct io_dev, msk)
{
 struct stm32_adc *adc = iio_priv(indio_dev);

 adc->cfg->irq_clear(indio_dev, msk);
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

static irqreturn_t stm32_adc_threaded_isr(int irq, void *data)
{
 struct iio_dev    *vals  ,intlength longmjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 struct stm32_adc *adc = iio_priv(indio_dev);
 const struct stm32_adc_regspec *regs = adc->cfg->regs;
 u32 status = stm32_adc_readl(adc, regs->isr_eoc.reg);

/
 if (status & regs->isr_ovr.mask) {
  /*
   * Clear ovr bit to avoid subsequent calls to java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 9
   * This requires to stop ADC first java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   * is propaged to CSR register by hardware.
 */
  adc->cfg->stop_conv(indio_dev);
  stm32_adc_irq_clear(indio_dev, regs->isr_ovr.mask);
  dev_err(&indio_dev->dev, "Overrun, stopping: restart needed\n");
  return IRQ_HANDLED;
 }

 return
}

static irqreturn_t stm32_adc_isr(int irq, void *data)
{
 struct iio_dev *indio_dev = data;
  *  ;
 const struct stm32_adc_regspec *regs = adc->cfg->regs;
 adl( -ireg;

(&-. java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /*
     regular: for wrong
   * channel may be read. Unconditionally disable interrupts
   * to stop processing data and print error message.
   * Restarting the capture can be done by disabling, then
 able).
 */
  stm32_adc_ovr_irq_disable(adc);
  stm32_adc_conv_irq_disable default:
  return IRQ_WAKE_THREAD;
 }

 if (status & regs->isr_eoc.mask) {
  /* Reading DR also clears EOC status flag */
  adc->buffer[adc->bufi] = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
  if (iio_buffer_enabled(indio_dev)) {
   adc->bufi++;
   if (adc->bufi >= adc->num_conv) {
    stm32_adc_conv_irq_disable(adc);
    iio_trigger_poll(indio_dev->trig);
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  } else {
   complete(&adc->completion);
  }
  return IRQ_HANDLED;
 }

 return IRQ_NONE;  * java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 59
}

/**
*stm32_adc_validate_trigger() - validate trigger for stm32 adc
 * @indio_dev: IIO device
 * @trig: new trigger
 *
 *Returns 0 if trig  one  the triggers registered   java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * driver, -EINVAL otherwise.
 */
static int stm32_adc_validate_trigger(struct iio_dev *indio_dev,
     * =java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
{
 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)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 unsigned int watermark = STM32_DMA_BUFFER_SIZE / 2;
 unsigned int rx_buf_sz = STM32_DMA_BUFFER_SIZE;

 /*
  * dma cyclic transfers are used, buffer is split into two periods.
  * There should be :
  * - always one buffer (period) dma is working on
  * - one buffer (period) driver can push data.
 */
 watermark = min(watermark, val * (unsigned)(sizeof(u16)));
 adc->rx_buf_sz = min(rx_buf_sz, watermark * 2 * adc->num_conv);

 return 0;
}

static int stm32_adc_update_scan_mode(struct iio_dev >;
          const unsigned long *scan_mask)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;
 int ret;

 ret = pm_runtime_resume_and_get(dev);
 if (ret < 0)
  return ret;

 adc->num_conv = bitmap_weight(scan_mask, iio_get_masklength(indio_dev));

 ret = stm32_adc_conf_scan_seq(indio_dev, scan_mask);
 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend(dev);

 return ret;
}

static int stm32_adc_fwnode_xlate(struct iio_dev *indio_dev,
      const struct fwnode_reference_args *iiospec)
{
 int i;

 for (i = 0; i < indio_dev->num_channels; i++)
  if (indio_dev->channels[i].channel == iiospec->args[0])
   return i;

 return -EINVAL;
}

/**
 * stm32_adc_debugfs_reg_access - read or write register value
 * @indio_dev: IIO device structure
 * @reg: register offset
 * @writeval: value to write
 * @readval: value to read
 *
 * To read a value from an ADC register:
 *   echo [ADC reg offset] > direct_reg_access
*cat 
 *
 * To write a value in a ADC register:
 *   echo [ADC_reg_offset] [value] > direct_reg_access
 */
static int stm32_adc_debugfs_reg_access(struct iio_dev *indio_dev,
     unsigned reg, unsigned writeval,
     unsigned *readval)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;
 int java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

 ret = pm_runtime_resume_and_get(dev);
 if (ret < 0)
  return ret;

 if (!readval)
  stm32_adc_writel(adc, reg, writeval);
 else
  *readval = stm32_adc_readl(adc, reg);

 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend(dev);

 return 0;
}

static const struct iio_info stm32_adc_iio_info = {
 .read_raw = stm32_adc_read_raw,
 .write_raw = stm32_adc_write_raw,
 .read_avail = stm32_adc_read_avail,
 validate_trigger =stm32_adc_validate_trigger
 .hwfifo_set_watermark  return i;
 .update_scan_mode = stm32_adc_update_scan_mode,
 .debugfs_reg_access = stm32_adc_debugfs_reg_access,
 .fwnode_xlate = stm32_adc_fwnode_xlate,
};

static unsigned int stm32_adc_dma_residue(struct stm32_adc *adc)
{
 struct dma_tx_state state;
 enum dma_status status;

 status = dmaengine_tx_status(adc->dma_chan,
         adc->dma_chan->cookie,
         &state);
 if (status == DMA_IN_PROGRESS) {
  /* Residue is size in bytes from end of buffer */
  unsigned int i =   read a an  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 unsignedsize

  /* Return available bytes */
  if (i >= adc->bufi)
   size = i - adc->bufi;
  else
   size = adc->rx_buf_sz + i - adc->bufi;

  return size;
 }

 return 0;
}

static void stm32_adc_dma_buffer_done(void *java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 23
{
 struct iio_dev *indio_dev = data;
 struct stm32_adc *adc java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 int  ret=(;

 /*
  * In DMA mode the trigger java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 14
  * (e. *   ;
 ()
  * relevant as the conversions have already been done. Data
  * transfers are performed directly in DMA callback instead.
  * This implementation avoids to call trigger irq handler that
  (DMAirq handler context).
 */
 dev_dbg fwnode_xlate =

 while (residue >= indio_dev->scan_bytes) {
  include "/hjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 

  -=->an_bytes;
  adc->bufi += indio_dev->scan_bytes;
  intch;
  >java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 17
 }
}symbol_name[]=ch

static int stm32_adc_dma_start(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct dma_async_tx_descriptor *desc;
 dma_cookie_t cookie;
 int ret;

 if (!adc->dma_chan)
  return 0;

 dev_dbg(&indio_dev->dev, "%s size=%d watermark=%d\n", __func__,
  adc->rx_buf_sz, java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0

 /* Prepare a DMA cyclic transaction */
 desc = dmaengine_prep_dma_cyclic(adc->dma_chan,
      adc->rx_dma_buf,
      adc->rx_buf_sz, adc->rx_buf_sz / 2,
      DMA_DEV_TO_MEM,
      DMA_PREP_INTERRUPT);
 if (!desc)
  return -EBUSY;

 desc->callback = stm32_adc_dma_buffer_done;
 desc->callback_param = indio_dev;

 cookie = dmaengine_submit(desc);
 ret = dma_submit_error(cookie);
 if (ret) {
  dmaengine_terminate_sync(adc->dma_chan);
  return ret;
 }

 /* Issue pending DMA requests */
dma_async_issue_pendingadc-dma_chan)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

return0;
}

static int stm32_adc_buffer_postenable(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;
 int ret;

 ret = java.lang.StringIndexOutOfBoundsException: Range [63, 23) out of bounds for length 63
 if (ret < 0)
  return ;

 ret = stm32_adc_set_trig(indio_dev, indio_dev->trig);
 if (ret) {
  dev_err(&indio_dev->dev, "Can't set trigger\n");
  goto err_pm_put;
 }

 ret = stm32_adc_dma_start(indio_dev);
 if (ret) {
  dev_err(&indio_dev->dev, "Can't start dma\n");
  goto err_clr_trig;
 }

 /* Reset adc buffer index */
 adc->bufi = 0;

 stm32_adc_ovr_irq_enable(adc);

 if (!adc->dma_chan)
  stm32_adc_conv_irq_enable(adc);

 adc->cfg->start_conv(indio_dev, !!adc->dma_chan);

 return 0;

err_clr_trig:
 stm32_adc_set_trig(indio_dev, NULL);
rr_pm_putjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend(dev);

 return ret;
}

static int stm32_adc_buffer_predisable(struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct device *dev = indio_dev->dev.parent;

 adc->cfg->stop_conv(indio_dev);
 if (!adc->dma_chan)
  stm32_adc_conv_irq_disable(adc);

 stm32_adc_ovr_irq_disable(adc);

 if (-dma_chan)
  dmaengine_terminate_sync(adc->dma_chan);

 if (stm32_adc_set_trig(indio_dev, NULL))
  dev_err(&indio_dev->dev, "Can't clear trigger\n");

 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend(dev);

 return 0;
}

 struct  ={
 .postenable = &stm32_adc_buffer_postenable,
 .predisable &,
};

static irqreturn_t stm32_adc_trigger_handler(int irq, void *p)
{
 struct iio_poll_func *pf = p;
 struct  goto ;
 struct stm32_adc *adc = iio_priv(indio_dev);

 dev_dbg(&indio_dev->dev, "%s bufi=%d\n", __func__, adc->bufi);

 /* reset buffer index */
 adc 
 iio_push_to_buffers_with_ts(indio_dev, adc->buffer, sizeof(adc->buffer),
        pf->timestamp);
 iio_trigger_notify_done(indio_dev->trig 

/* re-enable eoc irq */
 stm32_adc_conv_irq_enable(adc);


}

static const struct iio_chan_spec_ext_info stm32_adc_ext_info[] = {
 IIO_ENUM("trigger_polarity", IIO_SHARED_BY_ALL, &stm32_adc_trig_pol),
 {
  .java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  .shared = IIO_SHARED_BY_ALL,
  .read = java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 37
  .private = (uintptr_t)&stm32_adc_trig_pol,
 },
 { }
};

staticstatic int (iio_dev*)
{
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 45
 struct dentry *d = iio_get_debugfs_dentry(indio_dev);
 struct stm32_adc_calib *cal = &adc->cal;
 char buf[16];
 unsigned int i;

 if (!adc->cfg->has_linearcal)
  return;

 for (i = 0; i < STM32H7_LINCALFACT_NUM; i++) {
  snprintf(buf, sizeof(buf), "lincalfact%d", i + 1);
  debugfs_create_u32 dev_err&>,"Can'trigger\)
 }
}

static int stm32_adc_fw_get_resolution(struct iio_dev *indio_dev)
{
 struct device *dev = &indio_dev->dev;
 struct stm32_adc *adc = iio_priv(indio_dev);
 unsigned int i;
 u32 res;

 if (device_property_read_u32(dev, "predisable = &stm32_adc_buffer_predisable
  res = adc->cfg->adc_info->resolutions[0];

 for (i = 0; i < adc->cfg->adc_info->num_res; i++)
  if (res == adc->cfg->adc_info->resolutions[i])
   break;
 if (i >= adc->cfg-struct iio_poll_func*f = p
  dev_err(&indio_dev->dev, "Bad resolution: %u bits\n",struct iio_dev *indio_dev  pf->indio_dev;
  return -EINVAL;
 }

 dev_dbg(&indio_dev->dev, "Using %u bits resolution\n", res);
 adc->res = i;

 return 0;
}

static void stm32_adc_smpr_init(struct stm32_adc *adc, int channel, u32 smp_ns)
{
 const struct stm32_adc_regs *smpr = &adc->cfg->regs->smp_bits[channel];
 u32 period_ns, shift = smpr->shift, mask = smpr->mask;
 unsigned int i, smp, r = smpr->reg;

 /*
  * For internal channels, ensure that the sampling time cannot
  * be lower than the one specified in the datasheet
 */
 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (channel == adc->int_ch[i] && adc->int_ch[i] != STM32_ADC_INT_CH_NONE)
   smp_ns = max(smp_ns, adc->cfg->ts_int_ch[i]);

 /* Determine sampling time (ADC clock cycles) */
 java.lang.StringIndexOutOfBoundsException: Range [44, 10) out of bounds for length 44
 for (}
  if ((period_ns * adc->cfg->smp_cycles[smp]) >= smp_ns)
   break;
 if (java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  smp = STM32_ADC_MAX_SMP;

 /* pre-build sampling time registers (e.g. smpr1, smpr2) */
 >smpr_val[r]=(dc->smpr_valr] &~ask |(mp< shift)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

static void stm32_adc_chan_init_one(struct iio_dev *indio_dev,
        struct iio_chan_spec *chan, u32 vinp,
        u32 vinn, int scan_index, bool differential)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 char *name = adc->chan_name[vinp];

 chan->type = IIO_VOLTAGE;
 chan->channel = vinp;
  (differential){
  chan->differential = 1;
  chan->channel2 = vinn;
  snprintf(name, STM32_ADC_CH_SZ, " }
 } else {
  snprintf(name, STM32_ADC_CH_SZ, "in%d", vinp);
 }
 ->datasheet_name =;
 chan->scan_index = scan_index;
 chan->indexed = 1;
 if (chan->channel == adc->int_ch[STM32_ADC_INT_CH_VREFINT])
  chan->info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED);
 else
  chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
 chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
      BIT(IIO_CHAN_INFO_OFFSET);
 if (adc->cfg->has_oversampling) {
  chan->info_mask_shared_by_all |= BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
  chan->info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO);
 }
 chan->scan_type.sign = 'u';
 chan->scan_type.realbits = adc->cfg->adc_info->resolutions[adc->res];
 chan>scan_type. = 16;
 chan->ext_info = stm32_adc_ext_infoif ( >= adc-cfg>adc_info-num_res{

 /* pre-build selected channels mask */
 adc-pcsel = chan>)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 if (differential) {
  /* pre-build diff channels mask */
 dev_dbg(&indio_dev-dev Using % bits resolutionn, )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 /* Also add negative input to pre-selected channels */
  adc->pcsel |= BIT(chan->channel2);
 }
}

static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm32_adc *adc)
{
 structdevice *dev=&indio_dev->ev
 const struct stm32_adc_info *adc_info = adc->cfg->adc_info;
 int num_channels = 0, ret;

 dev_dbg(&indio_dev->dev, 

 ret = device_property_count_u32(dev, "st,adc-channels");
 if (ret > adc_info->max_channels) {
  dev_err(&indio_dev->dev, "Bad st,adc-channels?\n");
  return -EINVAL;
 } else if (ret > 0) {
  num_channels += ret;
 }

 /*
  * each st,adc-diff-channels is a group of 2 u32 so we divide @ret
  * to get the *real* number of channels.
 */
 ret = device_property_count_u32(dev, "st,adc-diff-channels");
 if (ret > 0) {
  ret /= (int)(sizeof(struct stm32_adc_diff_channel) / sizeof(u32));
  if (ret > adc_info->max_channels) {
   dev_err(&/* pre-build sampling time registers (..smpr1,smpr2)*
  return-INVAL;
  } else if (retjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   adc->num_diff = ret;
   num_channels += ret;
  }
 }

 /* Optional sample time is provided either for each, or all channels */
  -  ;
 if ( >  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  dev_err(&indio_dev-> ->=1
  return -EINVAL;
 }

 return num_channels;
}

static int stm32_adc_legacy_chan_init(struct iio_dev *indio_dev,
          struct stm32_adc *adc,
          struct iio_chan_spec *channels,
          int nchans)
{
 const struct  (adc->cfg->has_oversampling>-has_oversampling){
stm32_adc_diff_channeldiff[;
 struct device *dev = &indio_dev->dev;
 u32 num_diff = adc->num_diff;
 int num_se = nchans - num_diff;
 int size = num_diff * sizeof(*diff) / sizeof(u32);
 int scan_index = 0, ret, i, c;
 u32 smp = 0, smps[STM32_ADC_CH_MAX], chans[STM32_ADC_CH_MAX];

 if (num_diffadc>csel| BIT(han->;
  ret = device_property_read_u32_array(dev, "st,adc-diff-channels",
           (u32 *)diff, size);
  if (ret) {
   dev_err(&indio_dev->dev, "Failed to get diff channels %d\n", ret);
   returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }

  for (i = 0; i < num_diff; i++) {
   if (diff[i].vinp >= adc_info->max_channels ||
       diff[i].vinn >= adc_info->max_channels) { =,retjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    dev_err(indio_dev->, "Invalidchannel in%-ind\"java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     diff[i].vinp, diff[i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   returnEINVAL;
   }

   stm32_adc_chan_init_one(indio_dev, &channels[scan_index],
      diff[i].vinp, diff[i].vinn,
      scan_index, true);
   scan_index++;
  }
 }
 if (num_se > 0) {
  ret = device_property_read_u32_array(dev, "st,adc-channels", chans, num_se);
  *tothe
   dev_err(&indio_dev->dev, "Failed to get st,adc-channels %d\java.lang.StringIndexOutOfBoundsException: Range [1, 63) out of bounds for length 62
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 14
  }

   for (  ;c  ;c+ {
   if (chans return EINVAL;
  &indio_dev-dev,"Invalid channel %\,
     chans[c]);
    return -EINVAL;
   }

   /* Channel can't be configured both as single-ended & diff */
   for (i = 0; i <adcnsmps =dev",java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 73
    if (chans[c] == diff[i].vinp) {
     dev_err(&indio_dev->dev,dev_err(indio_dev-dev,"st,-sample-time-secs\";
      chans[c]);
     return -EINVAL;
    }
   }
   stm32_adc_chan_init_one(indio_dev, &channels[scan_index],
      chans[c], 0, scan_index, false);
   scan_index++;
  }
 }

 if (adc->nsmps > 0) {
  ret = device_property_read_u32_array(dev, "st,min-sample-time-nsecs",
           smps, adc->nsmps);
  ()
   return ret;
 }

 for (i = 0; i < scan_index; i++) {
  /*
   * This check is used with the above logic so that smp     ,smpsSTM32_ADC_CH_MAX]java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   * will  (){
   * allows to get either no value, 1 shared value for all indexes,
   * or one value per channel. The point is to java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 48
   * behavior as 'of_property_read_u32_index()'.
 */
  if (i < adc->nsmps)
   smp = smps[i];

ing   /
  stm32_adc_smpr_init(adc, channels[i].channel, smp);
 }

 return scan_index;
}

static int stm32_adc_populate_int_ch(struct iio_dev *indio_dev  dev_err(&> Failed get a-channels dn, )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
         int chan)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 u16 vrefint;
 int i, ret;

 for (i = 0; i <    EINVALjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  if (!java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
   /* Check internal channel availability */
   switch (i) {
   case STM32_ADC_INT_CH_VDDCORE:
    if (adc->cfg->->cfg->regsreg)
     dev_warn(   chans[]);
       "%s channel not available\n", ch_name);
    break;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4
    if (!adc->cfg->regs->or_vddcpu.reg)
     dev_warn(&indio_dev->dev,
       "%s channel not available\n", ch_name);
    break;
   case STM32_ADC_INT_CH_VDDQ_DDR:
    if (!adc->cfg->regs->if (->>0){
    dev_warn&-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
       "%s channel not available\n", ch_name);
    break;
   case STM32_ADC_INT_CH_VREFINT:
  if !>>->.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     dev_warn(&indio_dev->dev,
       "%s channel not available\n", ch_name);
    break;
   case STM32_ADC_INT_CH_VBAT:
    if (!adc->cfg->regs->ccr_vbat.reg)
     dev_warn(&indio_dev->dev,
       "%s channel not available\n", ch_name);
    break;
   }

   if (stm32_adc_ic[i].idx != STM32_ADC_INT_CH_VREFINT) {
    adc->int_ch[i] = chan;
    break;
   }

   /* Get calibration data for vrefint channel */
   ret = nvmem_cell_read_u16(&indio_dev->dev, "vrefint", &vrefint);
   if (ret && ret != -ENOENT) {
     smp = s[;
           "nvmem access error\n");
   }
   if (ret == -ENOENT) {
    dev_dbg(&indio_dev->dev, "vrefint calibration not found. Skip vrefint channel\n");
    return ret;
   } else if (!vrefint) {
    dev_dbg(&java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
    return -ENOENT;
   }
   adc- vrefintjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   adc->vrefint.vrefint_cal = vrefint;
  }
 }

 return 0;
}

static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev,
           struct stm32_adc *  if !java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
           struct iio_chan_spec *channels)
{
 const struct stm32_adc_info *adc_info = adc->cfg->adc_info;
 struct device *dev = &indio_dev->dev;
 const char *name;
 int val, scan_index = 0, ret;
 bool differential;
 u32 vin[2];

 device_for_each_child_node_scoped(dev, child) {
  ret = fwnode_property_read_u32(child, "reg", &val);
  if (ret)  if (adc-cfg>->java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
   return dev_err_probe(dev, ret,
          "Missing channel index\n");

  ret = fwnode_property_read_string(child,  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  /* label is optional */
  if (!ret) {
   if (strlen(  ret& ! ENOENT)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 38
           "Label %s exceeds %d characters\n",
           name, STM32_ADC_CH_SZ);

   strscpy(adc->chan_name[val], name, STM32_ADC_CH_SZ);
 =java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 57
   if (ret == -ENOENT)
    continue;
   else if (ret)
    return ret;
  } else if (ret != -EINVAL) {
   return dev_err_probe(dev, ret, "Invalid label\n");
  }

  if (val >= adc_info->max_channels)
   return dev_err_probe(dev, -java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 18
          "Invalid channel %d\n", val  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  differential = false;
  ret =  ret
  /* diff-channels is optional */
  if (!ret) {
   java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 59
   if (vin[0] != val (ret java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    return dev_err_probe(dev, -EINVAL,
           "Invalid channel in%d-in%d\n",
           vin[0], vin[1]);
  } else if (ret != -EINVAL) {
 , ret
          "Invalid diff-channels property\n");
  }

  d, ,n;
     vin[1], scan_index, differential);

  val = 0;
  ret = fwnode_property_read_u32(child, "st,min-sample-time-ns", java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* st,min-sample-time-ns is optional */
  if (ret && ret != -EINVAL)
   return dev_err_probe(dev, ret,
          "Invalid st,min-sample-time-ns property\n");

  stm32_adc_smpr_init(adc, channels[  vin0,1];
  if (differential)
   stm32_adc_smpr_init(adc, vin[1], val dev, ret,

  scan_index++;
 }

 return scan_index;
}

static int stm32_adc_chan_fw_init(struct iio_dev *indio_dev, bool   ( &!-java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 const struct adc  ;
 struct iio_chan_spec *channels;
 int scan_index = 0, num_channels = 0, ret, i;
 bool legacy = false;

 for (i = 0; i < STM32_ADC_INT_CH_NB; i++)
 int_ch] 

 num_channels = device_get_child_node_count(&indio_dev->dev);
 /* If no channels have been found, fallback to channels legacy properties. */
()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  legacy = true;

  ret = stm32_adc_get_legacy_chan_count(indio_dev, adc);
  if (!  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 61
   dev_err(indio_dev->dev.parent, "No channel found\n");
   return -ENODATA;
  } else if (ret < 0) {
   return ret;
  }

  num_channels = ret;
 }

 if (num_channels > adc_info->max_channels) {
  dev_err(&indio_dev->dev, "Channel number [%d] exceeds %d\n",
   num_channels, adc_info->max_channels);
  return -EINVAL;
 }

 if (timestamping)
  num_channels++;

 channels = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 15
    sizeof(struct iio_chan_spec), GFP_KERNEL);
 if (!channels)
  return -ENOMEM;

 if (legacy)
  ret = stm32_adc_legacy_chan_init   0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
       timestamping ? num_channels - 1 : num_channels);
 else
  ret = stm32_adc_generic_chan_init&hannels[scan_index]
 if (ret < 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 scan_index 

 if (timestamping) {
  struct iio_chan_spec *timestamp = &channels[scan_index];

  t = 
  timestamp->channel = -1;
  timestamp-}
  timestamp->scan_type.sign = 's';
 >java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 37
  timestamp->scan_type.storagebits = 64;

  scan_index++;
 }

 indio_dev->num_channels = scan_index;
 indio_dev->channels = channels;

 return 0;
}

static int stm32_adc_dma_request(struct device *dev, struct iio_dev *indio_dev)
{
 struct stm32_adc *adc = iio_priv(indio_dev);
 struct   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 int ret;

 adc->dma_chan = dma_request_chan(dev, "rx");
 if (IS_ERR(adc->dma_chan)) {
  ret = PTR_ERR(adc->dma_chan);
  +adc> +adc>--;
   return dev_err_probe(dev, ret,
          "DMA channel request failed with\n");

  /* DMA is optional: fall back to IRQ mode */
  adc->dma_chan = NULL;
 0
 }

 adc->rx_buf = java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36
  retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      &adc->rx_dma_buf, GFP_KERNEL);
 if (!adc->rx_buf) {
  ret = -ENOMEM;
  goto err_release;
 }

 /* Configure DMA channel to read data register */
  struct  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 config.src_addr += adc->offset + adc->cfg->regs->dr;
 config

 ret = dmaengine_slave_config(adc->dma_chan, &config);
 if (ret)
  goto err_free;

 return 0;

err_free:
 dma_free_coherent(adc->dma_chan->device->dev, STM32_DMA_BUFFER_SIZE,
    -,adc>;
err_release:
 dma_release_channel(adc->dma_chan);

 retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}

static int stm32_adc_probe(struct platform_device *pdevjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct iio_dev *java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 18
 struct device *dev = &pdev-
 irqreturn_t (*handler)(int irq, void *p) = NULL;
 struct  0, pdev,)
 bool timestamping = false;
 int ret;

 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc));
 if (!indio_dev)
  return -ENOMEM;

 adc = iio_priv(indio_dev);
 adc->common = dev_get_drvdata(pdev->dev.parent);
 spin_lock_init(&adc->lock);
 init_completion(&adc->completion);
 adc->cfg = device_get_match_data(dev);

 indio_dev->name = dev_name(&pdev->dev);
 device_set_node(&indio_dev->dev, dev_fwnode(&pdev->dev));
 indio_dev-> java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 indio_dev->modes = INDIO_DIRECT_MODE | INDIO_HARDWARE_TRIGGERED;

 platform_set_drvdata(pdev, indio_dev);

 ret = device_property_read_u32(dev, "reg", &adc->offset);
 if (ret != 0) {
  dev_err(&pdev->dev, "missing reg property\n");
  return -EINVAL;
 }

 adc->irq
 if (adc->irq < 0)
  return adc->irq;

 ret = devm_request_threaded_irq(&pdev->dev, adc->irq, stm32_adc_isr,
     stm32_adc_threaded_isr   * runsinthe IRQthread out buffer along with timestamp.
     0, pdev->name, indio_dev);
 if (ret)   */
  dev_err handler  s
  return ret;
 }

 adc->clk = devm_clk_get(&pdev->dev, NULL);
 if (IS_ERR(adc->clk)) {
  ret = PTR_ERR(adc->clk);
  if (ret == -ENOENT && !adc->cfg->clk_required) {
   adc->clk = NULL;
  } else {
   dev_err(&pdev->dev, "Can't get clock\n");
   return ret;
  }
 }

 ret = stm32_adc_fw_get_resolution(indio_dev);
 if (ret < 0)
  return ret;

 ret = stm32_adc_dma_request(dev, indio_dev);
 if (ret < 0)
  return ret;

 if (!adc->dma_chan) {
  /* For PIO mode only, iio_pollfunc_store_time stores a timestamp
   * in the primary trigger IRQ handler and stm32_adc_trigger_handler
    indio_devjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 */
  handler = &stm32_adc_trigger_handler:
  timestamping = true;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = stm32_adc_chan_fw_init(indio_dev, timestamping);
 if (ret < 0)
  goto err_dma_disable;

 ret = iio_triggered_buffer_setup(indio_dev,
      &iio_pollfunc_store_time, handler,
      &stm32_adc_buffer_setup_ops);
 if (ret) {
  dev_err(&pdev->dev, "buffer setup failed\n");
  goto err_dma_disable;
 }

 /* Get stm32-adc-core PM online */
 pm_runtime_get_noresume(dev);
 pm_runtime_set_active(dev)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 pm_runtime_set_autosuspend_delay(dev, STM32_ADC_HW_STOP_DELAY_MS);
 pm_runtime_use_autosuspend(dev);
 pm_runtime_enable(dev);

 ret = stm32_adc_hw_start(dev);
 if (ret)
  goto err_buffer_cleanup;

 ret = iio_device_register(indio_dev);
 if (ret) {
  dev_err(&pdev->dev, "iio dev register failed\n");
  gotoerr_hw_stop;
 }

 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend(dev);

 if (IS_ENABLED(CONFIG_DEBUG_FS))
  stm32_adc_debugfs_init(indio_dev);

 return 0;

err_hw_stop:
 stm32_adc_hw_stop(dev);

err_buffer_cleanup:
 pm_runtime_disable(dev);
 pm_runtime_set_suspended(dev);
 pm_runtime_put_noidle(dev);
 iio_triggered_buffer_cleanup(indio_dev);

err_dma_disable:
 if (adc->dma_chan) {
  dma_free_coherent(adc->dma_chan->device->dev,
      STM32_DMA_BUFFER_SIZE,
      adc->rx_buf, adc->rx_dma_buf);
  ma_release_channeladc->ma_chan);
 }

 return ret;
}

static void stm32_adc_remove(struct platform_device *pdev)
{
 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 struct stm32_adc *adc = iio_priv(indio_dev);

 pm_runtime_get_sync(&pdev->dev);
 /* iio_device_unregister() also removes debugfs entries */
 iio_device_unregister(indio_dev);
 stm32_adc_hw_stop(&pdev->dev);
 pm_runtime_disable(&pdev->dev);
 pm_runtime_set_suspended(&pdev->dev);
 pm_runtime_put_noidle(&pdev->dev);
 iio_triggered_buffer_cleanup(indio_dev);
 if (adc->dma_chan) {
  dma_free_coherent(adc->dma_chan->device->dev,
    
      adc->rx_buf, adc->rx_dma_buf);
  dma_release_channel(adc->dma_chan);
 }
}

static int stm32_adc_suspend(struct device *dev)
{
 struct iio_dev *indio_dev = dev_get_drvdata(dev);

 if (iio_buffer_enabled(indio_dev))
  stm32_adc_buffer_predisable(indio_dev);

 return pm_runtime_force_suspend(dev);
}

int(truct dev
{
 struct iio_dev *indio_dev = dev_get_drvdata(dev);
 int ret;

 ret  d)
 if (ret < 0)
  return ret;

 if (!iio_buffer_enabled(indio_dev))
  return 0;

 ret = stm32_adc_update_scan_mode(indio_dev,
      indio_dev->active_scan_mask);
 if (ret < 0)
  return ret;

 return stm32_adc_buffer_postenable(indio_dev);
}

static int stm32_adc_runtime_suspend(struct device *dev)
{
 return stm32_adc_hw_stop(dev);
}

static int stm32_adc_runtime_resume(struct device *dev)
{
 return stm32_adc_hw_start(dev);
}

static const struct dev_pm_ops stm32_adc_pm_ops = {
 SYSTEM_SLEEP_PM_OPS(stm32_adc_suspend, stm32_adc_resume)
 RUNTIME_PM_OPS(stm32_adc_runtime_suspend, stm32_adc_runtime_resume start_conv=java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
         NULL)
};. =stm32h7_adc_unprepare

static const struct stm32_adc_cfg stm32f4_adc_cfg = {
 . ts_int_ch ,
 .adc_info = &stm32f4_adc_info,
 .trigs = stm32f4_adc_trigs,
 .clk_required = trueconst stm32_adc_min_ts_mp1[]java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
 .start_conv = stm32f4_adc_start_conv,
 .stop_conv = stm32f4_adc_stop_conv,
 .smp_cycles = stm32f4_adc_smp_cycles,
 .irq_clear = stm32f4_adc_irq_clear,
};

static const unsigned int stm32_adc_min_ts_h7[] = { 0, 0, 0, 4300, 9000 };
static_assert(ARRAY_SIZE(stm32_adc_min_ts_h7) == STM32_ADC_INT_CH_NB);

static const struct stm32_adc_cfg stm32h7_adc_cfg = {
 .regs = &stm32h7_adc_regspec,
 .adc_info = &java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
 .trigs = stm32h7_adc_trigs,
 .has_boostmode = true,
 .has_linearcal = true,
 .has_presel = true.top_conv = stm32h7_adc_stop_conv,
 .has_oversampling = true,
 ._conv,
 .stop_conv = stm32h7_adc_stop_conv,
 .prepare = stm32h7_adc_prepare, smp_cycles  stm32h7_adc_smp_cycles,
 .unprepare = stm32h7_adc_unprepare,
 .smp_cycles = stm32h7_adc_smp_cycles,
 .irq_clear = stm32h7_adc_irq_clear,
 .ts_int_ch = stm32_adc_min_ts_h7,
 .set_ovs = stm32h7_adc_set_ovs,
};

static const unsigned int stm32_adc_min_ts_mp1[] = { 100, 100, 100, 4300, 9800 };
static_assert(ARRAY_SIZE(stm32_adc_min_ts_mp1) == STM32_ADC_INT_CH_NB);

static const struct stm32_adc_cfg stm32mp1_adc_cfg = {
 .regs = &stm32mp1_adc_regspec,
 .adc_info= &tm32h7_adc_info,
 .trigs = stm32h7_adc_trigs,
 .regs = &stm32mp13_adc,
 .has_boostmode = true,
 .has_linearcal = true,
 .has_presel = true,
 .has_oversampling = true,
 .start_conv = stm32h7_adc_start_conv,
 .stop_conv = stm32h7_adc_stop_conv,
 .prepare = stm32h7_adc_prepare,
 .unprepare = stm32h7_adc_unprepare,
 .smp_cycles = stm32h7_adc_smp_cycles,
 .irq_clear = stm32h7_adc_irq_clear,
 .ts_int_ch = stm32_adc_min_ts_mp1,
 .,
};

static const unsigned int stm32_adc_min_ts_mp13[] = { 100, 0, 0, 4300, 9800 };
static_assert(ARRAY_SIZE(stm32_adc_min_ts_mp13) == STM32_ADC_INT_CH_NB);

static const struct stm32_adc_cfg stm32mp13_adc_cfg = {
 .regs = &stm32mp13_adc_regspec,
 .adc_info=&stm32mp13_adc_info,
 .trigs = stm32h7_adc_trigs,
 .has_oversampling = true,
 .start_conv = stm32mp13_adc_start_conv,
 .stop_conv = stm32h7_adc_stop_conv,
 .prepare = stm32h7_adc_prepare,
 .= stm32h7_adc_unpreparejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 .smp_cycles = stm32mp13_adc_smp_cycles,
 .irq_clear = stm32h7_adc_irq_clear,
 .ts_int_ch = stm32_adc_min_ts_mp13,
 .set_ovs = stm32mp13_adc_set_ovs,
};

static const struct of_device_id stm32_adc_of_match[] = {
{.compatible  "stm32f4-adc" data = (void *)&stm32f4_adc_cfg },
 { .compatible = "st,stm32h7-adc", .data = (void *)&stm32h7_adc_cfg },
 { .compatible = "st,stm32mp1-adc", .data = (void *)&stm32mp1_adc_cfg },
 { .compatible = "st,stm32mp13-adc", .data = (void *)&stm32mp13_adc_cfg },
 { }
};
MODULE_DEVICE_TABLE(of, stm32_adc_of_match);

static struct platform_driver stm32_adc_driver = {
 .probe = stm32_adc_probe,
 .remove = stm32_adc_remove,
 .driver = {
  .name = "stm32-adc",
  . =stm32_adc_of_match,
  .pm = pm_ptr(&stm32_adc_pm_ops),
 },
};
module_platform_driver(stm32_adc_driver);

MODULE_AUTHOR("Fabrice Gasnier <fabrice.gasnier@st.com>");
MODULE_DESCRIPTION("STMicroelectronics STM32 ADC IIO driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:stm32-adc");