diff for duplicates of <20180630164914.0c1470f3@archlinux> diff --git a/a/1.txt b/N1/1.txt index 7cd4347..5f2acff 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -3,14 +3,13 @@ Stefan Popa <stefan.popa@analog.com> wrote: > The AD5758 is a single channel DAC with 16-bit precision which uses the > SPI interface that operates at clock rates up to 50MHz. ->=20 +> > The output can be configured as voltage or current and is available on a > single terminal. ->=20 +> > Datasheet: -> http://www.analog.com/media/en/technical-documentation/data-sheets/ad5758= -.pdf ->=20 +> http://www.analog.com/media/en/technical-documentation/data-sheets/ad5758.pdf +> > Signed-off-by: Stefan Popa <stefan.popa@analog.com> Hi Stefan, @@ -45,7 +44,7 @@ Jonathan > - Used bsearch() instead of ad5758_get_array_index(). > - Reduced the delays. > - strtobool() -> kstrtobool(). ->=20 +> > Changes in v2: > - removed unnecessary parenthesis in AD5758_REG_WRITE macro. > - added missing documentation fields of ad5758_state struct. @@ -71,15 +70,14 @@ Jonathan > - returned directly at the end of ad5758_init(). > - in ad5758_probe() used device managed for registering the device > and returned directly without the error message. ->=20 +> > MAINTAINERS | 7 + > drivers/iio/dac/Kconfig | 10 + > drivers/iio/dac/Makefile | 1 + -> drivers/iio/dac/ad5758.c | 899 +++++++++++++++++++++++++++++++++++++++++= -++++++ +> drivers/iio/dac/ad5758.c | 899 +++++++++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 917 insertions(+) > create mode 100644 drivers/iio/dac/ad5758.c ->=20 +> > diff --git a/MAINTAINERS b/MAINTAINERS > index 00e9670..12d102d 100644 > --- a/MAINTAINERS @@ -87,7 +85,7 @@ Jonathan > @@ -796,6 +796,13 @@ M: Michael Hanselmann <linux-kernel@hansmi.ch> > S: Supported > F: drivers/macintosh/ams/ -> =20 +> > +ANALOG DEVICES INC AD5758 DRIVER > +M: Stefan Popa <stefan.popa@analog.com> > +L: linux-iio@vger.kernel.org @@ -105,7 +103,7 @@ Jonathan > @@ -167,6 +167,16 @@ config AD5755 > To compile this driver as a module, choose M here: the > module will be called ad5755. -> =20 +> > +config AD5758 > + tristate "Analog Devices AD5758 DAC driver" > + depends on SPI_MASTER @@ -123,14 +121,14 @@ Jonathan > index 57aa230..a1b37cf 100644 > --- a/drivers/iio/dac/Makefile > +++ b/drivers/iio/dac/Makefile -> @@ -16,6 +16,7 @@ obj-$(CONFIG_AD5592R_BASE) +=3D ad5592r-base.o -> obj-$(CONFIG_AD5592R) +=3D ad5592r.o -> obj-$(CONFIG_AD5593R) +=3D ad5593r.o -> obj-$(CONFIG_AD5755) +=3D ad5755.o -> +obj-$(CONFIG_AD5755) +=3D ad5758.o -> obj-$(CONFIG_AD5761) +=3D ad5761.o -> obj-$(CONFIG_AD5764) +=3D ad5764.o -> obj-$(CONFIG_AD5791) +=3D ad5791.o +> @@ -16,6 +16,7 @@ obj-$(CONFIG_AD5592R_BASE) += ad5592r-base.o +> obj-$(CONFIG_AD5592R) += ad5592r.o +> obj-$(CONFIG_AD5593R) += ad5593r.o +> obj-$(CONFIG_AD5755) += ad5755.o +> +obj-$(CONFIG_AD5755) += ad5758.o +> obj-$(CONFIG_AD5761) += ad5761.o +> obj-$(CONFIG_AD5764) += ad5764.o +> obj-$(CONFIG_AD5791) += ad5791.o > diff --git a/drivers/iio/dac/ad5758.c b/drivers/iio/dac/ad5758.c > new file mode 100644 > index 0000000..bd1bed7 @@ -234,11 +232,9 @@ Jonathan > + * @lock: mutex lock > + * @out_range: struct which stores the output range > + * @dc_dc_mode: variable which stores the mode of operation -> + * @dc_dc_ilim: variable which stores the dc-to-dc converter current lim= -it +> + * @dc_dc_ilim: variable which stores the dc-to-dc converter current limit > + * @slew_time: variable which stores the target slew time -> + * @pwr_down: variable which contains whether a channel is powered down = -or not +> + * @pwr_down: variable which contains whether a channel is powered down or not > + * @data: spi transfer buffers > + */ > + @@ -263,13 +259,13 @@ or not > + * Output ranges corresponding to bits [3:0] from DAC_CONFIG register > + * 0000: 0 V to 5 V voltage range > + * 0001: 0 V to 10 V voltage range -> + * 0010: =C2=B15 V voltage range -> + * 0011: =C2=B110 V voltage range +> + * 0010: ±5 V voltage range +> + * 0011: ±10 V voltage range > + * 1000: 0 mA to 20 mA current range > + * 1001: 0 mA to 24 mA current range > + * 1010: 4 mA to 20 mA current range -> + * 1011: =C2=B120 mA current range -> + * 1100: =C2=B124 mA current range +> + * 1011: ±20 mA current range +> + * 1100: ±24 mA current range > + * 1101: -1 mA to +22 mA current range > + */ > +enum ad5758_output_range { @@ -277,7 +273,7 @@ or not > + AD5758_RANGE_0V_10V, > + AD5758_RANGE_PLUSMINUS_5V, > + AD5758_RANGE_PLUSMINUS_10V, -> + AD5758_RANGE_0mA_20mA =3D 8, +> + AD5758_RANGE_0mA_20mA = 8, > + AD5758_RANGE_0mA_24mA, > + AD5758_RANGE_4mA_24mA, > + AD5758_RANGE_PLUSMINUS_20mA, @@ -292,14 +288,14 @@ or not > + AD5758_DCDC_MODE_PPC_CURRENT, > +}; > + -> +static const struct ad5758_range ad5758_voltage_range[] =3D { +> +static const struct ad5758_range ad5758_voltage_range[] = { > + { AD5758_RANGE_0V_5V, 0, 5000000 }, > + { AD5758_RANGE_0V_10V, 0, 10000000 }, > + { AD5758_RANGE_PLUSMINUS_5V, -5000000, 5000000 }, > + { AD5758_RANGE_PLUSMINUS_10V, -10000000, 10000000 } > +}; > + -> +static const struct ad5758_range ad5758_current_range[] =3D { +> +static const struct ad5758_range ad5758_current_range[] = { > + { AD5758_RANGE_0mA_20mA, 0, 20000}, > + { AD5758_RANGE_0mA_24mA, 0, 24000 }, > + { AD5758_RANGE_4mA_24mA, 4, 24000 }, @@ -308,41 +304,40 @@ or not > + { AD5758_RANGE_MINUS_1mA_PLUS_22mA, -1000, 22000 }, > +}; > + -> +static const int ad5758_sr_clk[16] =3D { +> +static const int ad5758_sr_clk[16] = { > + 240000, 200000, 150000, 128000, 64000, 32000, 16000, 8000, 4000, 2000, > + 1000, 512, 256, 128, 64, 16 > +}; > + -> +static const int ad5758_sr_step[8] =3D { +> +static const int ad5758_sr_step[8] = { > + 4, 12, 64, 120, 256, 500, 1820, 2048 > +}; > + -> +static const int ad5758_dc_dc_ilim[6] =3D { +> +static const int ad5758_dc_dc_ilim[6] = { > + 150000, 200000, 250000, 300000, 350000, 400000 > +}; > + -> +static int ad5758_spi_reg_read(struct ad5758_state *st, unsigned int add= -r) +> +static int ad5758_spi_reg_read(struct ad5758_state *st, unsigned int addr) > +{ -> + struct spi_transfer t[] =3D { +> + struct spi_transfer t[] = { > + { -> + .tx_buf =3D &st->d32[0], -> + .len =3D 4, -> + .cs_change =3D 1, +> + .tx_buf = &st->d32[0], +> + .len = 4, +> + .cs_change = 1, > + }, { -> + .tx_buf =3D &st->d32[1], -> + .rx_buf =3D &st->d32[2], -> + .len =3D 4, +> + .tx_buf = &st->d32[1], +> + .rx_buf = &st->d32[2], +> + .len = 4, > + }, > + }; > + int ret; > + -> + st->d32[0] =3D cpu_to_be32( +> + st->d32[0] = cpu_to_be32( > + (AD5758_WR_FLAG_MSK(AD5758_TWO_STAGE_READBACK_SELECT) << 24) | > + (addr << 8)); -> + st->d32[1] =3D cpu_to_be32(AD5758_WR_FLAG_MSK(AD5758_NOP) << 24); +> + st->d32[1] = cpu_to_be32(AD5758_WR_FLAG_MSK(AD5758_NOP) << 24); > + -> + ret =3D spi_sync_transfer(st->spi, t, ARRAY_SIZE(t)); +> + ret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t)); > + if (ret < 0) > + return ret; > + @@ -353,7 +348,7 @@ r) > + unsigned int addr, > + unsigned int val) > +{ -> + st->d32[0] =3D cpu_to_be32((AD5758_WR_FLAG_MSK(addr) << 24) | +> + st->d32[0] = cpu_to_be32((AD5758_WR_FLAG_MSK(addr) << 24) | > + ((val & 0xFFFF) << 8)); > + > + return spi_write(st->spi, &st->d32[0], sizeof(st->d32[0])); @@ -366,12 +361,12 @@ r) > +{ > + int regval; > + -> + regval =3D ad5758_spi_reg_read(st, addr); +> + regval = ad5758_spi_reg_read(st, addr); > + if (regval < 0) > + return regval; > + -> + regval &=3D ~mask; -> + regval |=3D val; +> + regval &= ~mask; +> + regval |= val; > + > + return ad5758_spi_reg_write(st, addr, regval); > +} @@ -386,8 +381,8 @@ r) > +{ > + int i; > + -> + for (i =3D 0; i < size; i++) { -> + if (val <=3D array[i]) +> + for (i = 0; i < size; i++) { +> + if (val <= array[i]) > + return i; > + } > + @@ -401,9 +396,9 @@ r) > + unsigned int timeout; > + int ret; > + -> + timeout =3D 10; +> + timeout = 10; > + do { -> + ret =3D ad5758_spi_reg_read(st, reg); +> + ret = ad5758_spi_reg_read(st, reg); > + if (ret < 0) > + return ret; > + @@ -423,7 +418,7 @@ r) > +{ > + int ret; > + -> + ret =3D ad5758_spi_reg_write(st, AD5758_KEY, +> + ret = ad5758_spi_reg_write(st, AD5758_KEY, > + AD5758_KEY_CODE_CALIB_MEM_REFRESH); > + if (ret < 0) { > + dev_err(&st->spi->dev, @@ -440,11 +435,11 @@ r) > +{ > + int ret; > + -> + ret =3D ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_1); +> + ret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_1); > + if (ret < 0) > + return ret; > + -> + ret =3D ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_2); +> + ret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_2); > + > + /* Perform a software reset and wait 100us */ > + udelay(100); @@ -457,7 +452,7 @@ r) > +{ > + int ret; > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, +> + ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, > + AD5758_DCDC_CONFIG1_DCDC_MODE_MSK, > + AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(mode)); > + if (ret < 0) @@ -467,22 +462,21 @@ r) > + * Poll the BUSY_3WI bit in the DCDC_CONFIG2 register until it is 0. > + * This allows the 3-wire interface communication to complete. > + */ -> + ret =3D ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2, +> + ret = ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2, > + AD5758_DCDC_CONFIG2_BUSY_3WI_MSK); > + if (ret < 0) > + return ret; > + -> + st->dc_dc_mode =3D mode; +> + st->dc_dc_mode = mode; > + > + return ret; > +} > + -> +static int ad5758_set_dc_dc_ilim(struct ad5758_state *st, unsigned int i= -lim) +> +static int ad5758_set_dc_dc_ilim(struct ad5758_state *st, unsigned int ilim) > +{ > + int ret; > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG2, +> + ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG2, > + AD5758_DCDC_CONFIG2_ILIMIT_MSK, > + AD5758_DCDC_CONFIG2_ILIMIT_MODE(ilim)); > + if (ret < 0) @@ -503,14 +497,14 @@ lim) > + unsigned long int mask; > + int ret; > + -> + mask =3D AD5758_DAC_CONFIG_SR_EN_MSK | +> + mask = AD5758_DAC_CONFIG_SR_EN_MSK | > + AD5758_DAC_CONFIG_SR_CLOCK_MSK | > + AD5758_DAC_CONFIG_SR_STEP_MSK; -> + mode =3D AD5758_DAC_CONFIG_SR_EN_MODE(1) | +> + mode = AD5758_DAC_CONFIG_SR_EN_MODE(1) | > + AD5758_DAC_CONFIG_SR_STEP_MODE(sr_step_idx) | > + AD5758_DAC_CONFIG_SR_CLOCK_MODE(sr_clk_idx); > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, mask, mode); +> + ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, mask, mode); > + if (ret < 0) > + return ret; > + @@ -526,34 +520,34 @@ lim) > + s64 diff_new, diff_old; > + u64 sr_step, calc_slew_time; > + -> + sr_clk_idx =3D 0; -> + sr_step_idx =3D 0; -> + diff_old =3D S64_MAX; +> + sr_clk_idx = 0; +> + sr_step_idx = 0; +> + diff_old = S64_MAX; > + /* > + * The slew time can be determined by using the formula: -> + * Slew Time =3D (Full Scale Out / (Step Size x Update Clk Freq)) +> + * Slew Time = (Full Scale Out / (Step Size x Update Clk Freq)) > + * where Slew time is expressed in microseconds > + * Given the desired slew time, the following algorithm determines the > + * best match for the step size and the update clock frequency. > + */ -> + for (i =3D 0; i < ARRAY_SIZE(ad5758_sr_clk); i++) { +> + for (i = 0; i < ARRAY_SIZE(ad5758_sr_clk); i++) { > + /* > + * Go through each valid update clock freq and determine a raw > + * value for the step size by using the formula: -> + * Step Size =3D Full Scale Out / (Update Clk Freq * Slew Time) +> + * Step Size = Full Scale Out / (Update Clk Freq * Slew Time) > + */ -> + sr_step =3D AD5758_FULL_SCALE_MICRO; +> + sr_step = AD5758_FULL_SCALE_MICRO; > + do_div(sr_step, ad5758_sr_clk[i]); > + do_div(sr_step, st->slew_time); > + /* > + * After a raw value for step size was determined, find the > + * closest valid match > + */ -> + res =3D ad5758_find_closest_match(ad5758_sr_step, +> + res = ad5758_find_closest_match(ad5758_sr_step, > + ARRAY_SIZE(ad5758_sr_step), > + sr_step); > + /* Calculate the slew time */ -> + calc_slew_time =3D AD5758_FULL_SCALE_MICRO; +> + calc_slew_time = AD5758_FULL_SCALE_MICRO; > + do_div(calc_slew_time, ad5758_sr_step[res]); > + do_div(calc_slew_time, ad5758_sr_clk[i]); > + /* @@ -561,11 +555,11 @@ lim) > + * is different from the desired slew time and store the diff > + * for the next iteration > + */ -> + diff_new =3D abs(st->slew_time - calc_slew_time); +> + diff_new = abs(st->slew_time - calc_slew_time); > + if (diff_new < diff_old) { -> + diff_old =3D diff_new; -> + sr_clk_idx =3D i; -> + sr_step_idx =3D res; +> + diff_old = diff_new; +> + sr_clk_idx = i; +> + sr_step_idx = res; > + } > + } > + @@ -576,34 +570,32 @@ lim) > +{ > + int ret; > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, +> + ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, > + AD5758_DAC_CONFIG_RANGE_MSK, > + AD5758_DAC_CONFIG_RANGE_MODE(range)); > + if (ret < 0) > + return ret; > + > + /* Wait to allow time for the internal calibrations to complete */ -> + ret =3D ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS, +> + ret = ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS, > + AD5758_CAL_MEM_UNREFRESHED_MSK); > + if (ret < 0) > + return ret; same as -ret =3D ad5758_wait_for_task_complete? You've done that everywhere else so= - I -assume it is safe (I haven't checked). Also odd spacing after the =3D above +ret = ad5758_wait_for_task_complete? You've done that everywhere else so I +assume it is safe (I haven't checked). Also odd spacing after the = above so please check that throughout. > + > + return ret; > +} > + -> +static int ad5758_fault_prot_switch_en(struct ad5758_state *st, bool ena= -ble) +> +static int ad5758_fault_prot_switch_en(struct ad5758_state *st, bool enable) > +{ > + int ret; > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, +> + ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, > + AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK, > + AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(enable)); > + if (ret < 0) @@ -616,12 +608,11 @@ ble) > + AD5758_DCDC_CONFIG2_BUSY_3WI_MSK); > +} > + -> +static int ad5758_internal_buffers_en(struct ad5758_state *st, bool enab= -le) +> +static int ad5758_internal_buffers_en(struct ad5758_state *st, bool enable) > +{ > + int ret; > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, +> + ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, > + AD5758_DAC_CONFIG_INT_EN_MSK, > + AD5758_DAC_CONFIG_INT_EN_MODE(enable)); > + if (ret < 0) @@ -637,21 +628,21 @@ le) > + unsigned int writeval, > + unsigned int *readval) > +{ -> + struct ad5758_state *st =3D iio_priv(indio_dev); +> + struct ad5758_state *st = iio_priv(indio_dev); > + int ret; > + > + mutex_lock(&st->lock); > + if (readval) { -> + ret =3D ad5758_spi_reg_read(st, reg); +> + ret = ad5758_spi_reg_read(st, reg); > + if (ret < 0) { > + mutex_unlock(&st->lock); > + return ret; > + } > + -> + *readval =3D ret; -> + ret =3D 0; +> + *readval = ret; +> + ret = 0; > + } else { -> + ret =3D ad5758_spi_reg_write(st, reg, writeval); +> + ret = ad5758_spi_reg_write(st, reg, writeval); > + } > + mutex_unlock(&st->lock); > + @@ -662,29 +653,29 @@ le) > + struct iio_chan_spec const *chan, > + int *val, int *val2, long info) > +{ -> + struct ad5758_state *st =3D iio_priv(indio_dev); +> + struct ad5758_state *st = iio_priv(indio_dev); > + int max, min, ret; > + > + switch (info) { > + case IIO_CHAN_INFO_RAW: > + mutex_lock(&st->lock); -> + ret =3D ad5758_spi_reg_read(st, AD5758_DAC_INPUT); +> + ret = ad5758_spi_reg_read(st, AD5758_DAC_INPUT); > + mutex_unlock(&st->lock); > + if (ret < 0) > + return ret; > + -> + *val =3D ret; +> + *val = ret; > + return IIO_VAL_INT; > + case IIO_CHAN_INFO_SCALE: -> + min =3D st->out_range.min; -> + max =3D st->out_range.max; -> + *val =3D (max - min) / 1000; -> + *val2 =3D 16; +> + min = st->out_range.min; +> + max = st->out_range.max; +> + *val = (max - min) / 1000; +> + *val2 = 16; > + return IIO_VAL_FRACTIONAL_LOG2; > + case IIO_CHAN_INFO_OFFSET: -> + min =3D st->out_range.min; -> + max =3D st->out_range.max; -> + *val =3D ((min * (1 << 16)) / (max - min)) / 1000; +> + min = st->out_range.min; +> + max = st->out_range.max; +> + *val = ((min * (1 << 16)) / (max - min)) / 1000; > + return IIO_VAL_INT; > + default: > + return -EINVAL; @@ -695,13 +686,13 @@ le) > + struct iio_chan_spec const *chan, > + int val, int val2, long info) > +{ -> + struct ad5758_state *st =3D iio_priv(indio_dev); +> + struct ad5758_state *st = iio_priv(indio_dev); > + int ret; > + > + switch (info) { > + case IIO_CHAN_INFO_RAW: > + mutex_lock(&st->lock); -> + ret =3D ad5758_spi_reg_write(st, AD5758_DAC_INPUT, val); +> + ret = ad5758_spi_reg_write(st, AD5758_DAC_INPUT, val); > + mutex_unlock(&st->lock); > + return ret; > + default: @@ -714,7 +705,7 @@ le) > + const struct iio_chan_spec *chan, > + char *buf) > +{ -> + struct ad5758_state *st =3D iio_priv(indio_dev); +> + struct ad5758_state *st = iio_priv(indio_dev); > + > + return sprintf(buf, "%d\n", st->pwr_down); > +} @@ -724,56 +715,55 @@ le) > + struct iio_chan_spec const *chan, > + const char *buf, size_t len) > +{ -> + struct ad5758_state *st =3D iio_priv(indio_dev); +> + struct ad5758_state *st = iio_priv(indio_dev); > + bool pwr_down; > + unsigned int dcdc_config1_mode, dc_dc_mode, dac_config_mode, val; > + unsigned long int dcdc_config1_msk, dac_config_msk; > + int ret; > + -> + ret =3D kstrtobool(buf, &pwr_down); +> + ret = kstrtobool(buf, &pwr_down); > + if (ret) > + return ret; > + > + mutex_lock(&st->lock); > + if (pwr_down) { -> + dc_dc_mode =3D AD5758_DCDC_MODE_POWER_OFF; -> + val =3D 0; +> + dc_dc_mode = AD5758_DCDC_MODE_POWER_OFF; +> + val = 0; > + } else { -> + dc_dc_mode =3D st->dc_dc_mode; -> + val =3D 1; +> + dc_dc_mode = st->dc_dc_mode; +> + val = 1; > + } > + -> + dcdc_config1_mode =3D (AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(dc_dc_mode) | +> + dcdc_config1_mode = (AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(dc_dc_mode) | > + AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(val)); -> + dcdc_config1_msk =3D (AD5758_DCDC_CONFIG1_DCDC_MODE_MSK | +> + dcdc_config1_msk = (AD5758_DCDC_CONFIG1_DCDC_MODE_MSK | > + AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK); > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, +> + ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1, > + dcdc_config1_msk, > + dcdc_config1_mode); > + if (ret < 0) > + goto err_unlock; > + -> + dac_config_mode =3D (AD5758_DAC_CONFIG_OUT_EN_MODE(val) | +> + dac_config_mode = (AD5758_DAC_CONFIG_OUT_EN_MODE(val) | > + AD5758_DAC_CONFIG_INT_EN_MODE(val)); -> + dac_config_msk =3D (AD5758_DAC_CONFIG_OUT_EN_MSK | +> + dac_config_msk = (AD5758_DAC_CONFIG_OUT_EN_MSK | -I wouldn't have the double space after the =3D=20 -That sort things is fragile to later changes in the driver and doesn't real= -ly +I wouldn't have the double space after the = +That sort things is fragile to later changes in the driver and doesn't really make much different to readability. There are some excess brackets in here which will get 'fixed' by someone following the static checkers if we don't do it now. > + AD5758_DAC_CONFIG_INT_EN_MSK); > + -> + ret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, +> + ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, > + dac_config_msk, > + dac_config_mode); > + if (ret < 0) > + goto err_unlock; > + -> + st->pwr_down =3D pwr_down; +> + st->pwr_down = pwr_down; > + > +err_unlock: > + mutex_unlock(&st->lock); @@ -781,23 +771,23 @@ by someone following the static checkers if we don't do it now. > + return ret ? ret : len; > +} > + -> +static const struct iio_info ad5758_info =3D { -> + .read_raw =3D ad5758_read_raw, -> + .write_raw =3D ad5758_write_raw, -> + .debugfs_reg_access =3D &ad5758_reg_access, +> +static const struct iio_info ad5758_info = { +> + .read_raw = ad5758_read_raw, +> + .write_raw = ad5758_write_raw, +> + .debugfs_reg_access = &ad5758_reg_access, > +}; > + -> +static const struct iio_chan_spec_ext_info ad5758_ext_info[] =3D { +> +static const struct iio_chan_spec_ext_info ad5758_ext_info[] = { > + { -> + .name =3D "powerdown", -> + .read =3D ad5758_read_powerdown, -> + .write =3D ad5758_write_powerdown, -> + .shared =3D IIO_SHARED_BY_TYPE, +> + .name = "powerdown", +> + .read = ad5758_read_powerdown, +> + .write = ad5758_write_powerdown, +> + .shared = IIO_SHARED_BY_TYPE, > + }, > + { } > +}; > + -> +static struct iio_chan_spec ad5758_channels[] =3D { +> +static struct iio_chan_spec ad5758_channels[] = { Hmm. So this is a template that is then updated. @@ -806,12 +796,12 @@ modes? I.e. one voltage, one current? You need be using a copy of this, not the actual template here, which should be constant. > + { -> + .info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_RAW) | +> + .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_RAW) | > + BIT(IIO_CHAN_INFO_SCALE) | > + BIT(IIO_CHAN_INFO_OFFSET), -> + .indexed =3D 1, -> + .output =3D 1, -> + .ext_info =3D ad5758_ext_info, +> + .indexed = 1, +> + .output = 1, +> + .ext_info = ad5758_ext_info, > + }, > +}; > + @@ -831,9 +821,8 @@ of this, not the actual template here, which should be constant. > +{ > + unsigned int mask; > + -> + mask =3D (AD5758_WR_FLAG_MSK(AD5758_DIGITAL_DIAG_CONFIG) << 24) | 0x5C3= -A; -> + st->d32[0] =3D cpu_to_be32(mask); +> + mask = (AD5758_WR_FLAG_MSK(AD5758_DIGITAL_DIAG_CONFIG) << 24) | 0x5C3A; +> + st->d32[0] = cpu_to_be32(mask); > + > + return spi_write(st->spi, &st->d32[0], 4); > +} @@ -845,11 +834,11 @@ A; > +{ > + int i; > + -> + for (i =3D 0; i < size; i++) { -> + if ((min =3D=3D range[i].min) && (max =3D=3D range[i].max)) { -> + st->out_range.reg =3D range[i].reg; -> + st->out_range.min =3D range[i].min; -> + st->out_range.max =3D range[i].max; +> + for (i = 0; i < size; i++) { +> + if ((min == range[i].min) && (max == range[i].max)) { +> + st->out_range.reg = range[i].reg; +> + st->out_range.min = range[i].min; +> + st->out_range.max = range[i].max; > + > + return 0; > + } @@ -864,23 +853,23 @@ A; > + const struct ad5758_range *range; > + int *index, ret; > + -> + st->dc_dc_ilim =3D 0; -> + ret =3D device_property_read_u32(&st->spi->dev, +> + st->dc_dc_ilim = 0; +> + ret = device_property_read_u32(&st->spi->dev, > + "adi,dc-dc-ilim-microamp", &tmp); > + if (ret) { > + dev_dbg(&st->spi->dev, > + "Missing \"dc-dc-ilim-microamp\" property\n"); > + } else { -> + index =3D (int *) bsearch(&tmp, ad5758_dc_dc_ilim, +> + index = (int *) bsearch(&tmp, ad5758_dc_dc_ilim, > + ARRAY_SIZE(ad5758_dc_dc_ilim), > + sizeof(int), cmpfunc); > + if (!index) > + dev_dbg(&st->spi->dev, "dc-dc-ilim out of range\n"); > + else -> + st->dc_dc_ilim =3D index - ad5758_dc_dc_ilim; +> + st->dc_dc_ilim = index - ad5758_dc_dc_ilim; > + } > + -> + ret =3D device_property_read_u32(&st->spi->dev, "adi,dc-dc-mode", +> + ret = device_property_read_u32(&st->spi->dev, "adi,dc-dc-mode", > + &st->dc_dc_mode); > + if (ret) { > + dev_err(&st->spi->dev, "Missing \"dc-dc-mode\" property\n"); @@ -890,8 +879,8 @@ A; > + if (!ad5758_is_valid_mode(st->dc_dc_mode)) > + return -EINVAL; > + -> + if (st->dc_dc_mode =3D=3D AD5758_DCDC_MODE_DPC_VOLTAGE) { -> + ret =3D device_property_read_u32_array(&st->spi->dev, +> + if (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE) { +> + ret = device_property_read_u32_array(&st->spi->dev, > + "adi,range-microvolt", > + tmparray, 2); > + if (ret) { @@ -899,10 +888,10 @@ A; > + "Missing \"range-microvolt\" property\n"); > + return ret; > + } -> + range =3D ad5758_voltage_range; -> + size =3D ARRAY_SIZE(ad5758_voltage_range); +> + range = ad5758_voltage_range; +> + size = ARRAY_SIZE(ad5758_voltage_range); > + } else { -> + ret =3D device_property_read_u32_array(&st->spi->dev, +> + ret = device_property_read_u32_array(&st->spi->dev, > + "adi,range-microamp", > + tmparray, 2); > + if (ret) { @@ -910,24 +899,22 @@ A; > + "Missing \"range-microamp\" property\n"); > + return ret; > + } -> + range =3D ad5758_current_range; -> + size =3D ARRAY_SIZE(ad5758_current_range); +> + range = ad5758_current_range; +> + size = ARRAY_SIZE(ad5758_current_range); > + } > + -> + ret =3D ad5758_find_out_range(st, range, size, tmparray[0], tmparray[1]= -); +> + ret = ad5758_find_out_range(st, range, size, tmparray[0], tmparray[1]); > + if (ret) { > + dev_err(&st->spi->dev, "range invalid\n"); > + return ret; > + } > + -> + ret =3D device_property_read_u32(&st->spi->dev, "adi,slew-time-us", &tm= -p); +> + ret = device_property_read_u32(&st->spi->dev, "adi,slew-time-us", &tmp); > + if (ret) { > + dev_dbg(&st->spi->dev, "Missing \"slew-time-us\" property\n"); -> + st->slew_time =3D 0; +> + st->slew_time = 0; > + } else { -> + st->slew_time =3D tmp; +> + st->slew_time = tmp; > + } > + > + return 0; @@ -938,63 +925,63 @@ p); > + int regval, ret; > + > + /* Disable CRC checks */ -> + ret =3D ad5758_crc_disable(st); +> + ret = ad5758_crc_disable(st); > + if (ret < 0) > + return ret; > + > + /* Perform a software reset */ -> + ret =3D ad5758_soft_reset(st); +> + ret = ad5758_soft_reset(st); > + if (ret < 0) > + return ret; > + > + /* Disable CRC checks */ -> + ret =3D ad5758_crc_disable(st); +> + ret = ad5758_crc_disable(st); > + if (ret < 0) > + return ret; > + > + /* Perform a calibration memory refresh */ -> + ret =3D ad5758_calib_mem_refresh(st); +> + ret = ad5758_calib_mem_refresh(st); > + if (ret < 0) > + return ret; > + -> + regval =3D ad5758_spi_reg_read(st, AD5758_DIGITAL_DIAG_RESULTS); +> + regval = ad5758_spi_reg_read(st, AD5758_DIGITAL_DIAG_RESULTS); > + if (regval < 0) > + return regval; > + > + /* Clear all the error flags */ -> + ret =3D ad5758_spi_reg_write(st, AD5758_DIGITAL_DIAG_RESULTS, regval); +> + ret = ad5758_spi_reg_write(st, AD5758_DIGITAL_DIAG_RESULTS, regval); > + if (ret < 0) > + return ret; > + > + /* Set the dc-to-dc current limit */ -> + ret =3D ad5758_set_dc_dc_ilim(st, st->dc_dc_ilim); +> + ret = ad5758_set_dc_dc_ilim(st, st->dc_dc_ilim); > + if (ret < 0) > + return ret; > + > + /* Configure the dc-to-dc controller mode */ -> + ret =3D ad5758_set_dc_dc_conv_mode(st, st->dc_dc_mode); +> + ret = ad5758_set_dc_dc_conv_mode(st, st->dc_dc_mode); > + if (ret < 0) > + return ret; > + > + /* Configure the output range */ -> + ret =3D ad5758_set_out_range(st, st->out_range.reg); +> + ret = ad5758_set_out_range(st, st->out_range.reg); > + if (ret < 0) > + return ret; > + > + /* Enable Slew Rate Control, set the slew rate clock and step */ > + if (st->slew_time) { -> + ret =3D ad5758_slew_rate_config(st); +> + ret = ad5758_slew_rate_config(st); > + if (ret < 0) > + return ret; > + } > + > + /* Enable the VIOUT fault protection switch (FPS is closed) */ -> + ret =3D ad5758_fault_prot_switch_en(st, 1); +> + ret = ad5758_fault_prot_switch_en(st, 1); > + if (ret < 0) > + return ret; > + > + /* Power up the DAC and internal (INT) amplifiers */ -> + ret =3D ad5758_internal_buffers_en(st, 1); +> + ret = ad5758_internal_buffers_en(st, 1); > + if (ret < 0) > + return ret; > + @@ -1008,38 +995,38 @@ p); > +{ > + struct ad5758_state *st; > + struct iio_dev *indio_dev; -> + struct iio_chan_spec *channels =3D ad5758_channels; +> + struct iio_chan_spec *channels = ad5758_channels; > + int ret; > + -> + indio_dev =3D devm_iio_device_alloc(&spi->dev, sizeof(*st)); +> + indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); > + if (!indio_dev) > + return -ENOMEM; > + -> + st =3D iio_priv(indio_dev); +> + st = iio_priv(indio_dev); > + spi_set_drvdata(spi, indio_dev); > + -> + st->spi =3D spi; +> + st->spi = spi; > + > + mutex_init(&st->lock); > + -> + indio_dev->dev.parent =3D &spi->dev; -> + indio_dev->name =3D spi_get_device_id(spi)->name; -> + indio_dev->info =3D &ad5758_info; -> + indio_dev->modes =3D INDIO_DIRECT_MODE; -> + indio_dev->num_channels =3D ARRAY_SIZE(ad5758_channels); +> + indio_dev->dev.parent = &spi->dev; +> + indio_dev->name = spi_get_device_id(spi)->name; +> + indio_dev->info = &ad5758_info; +> + indio_dev->modes = INDIO_DIRECT_MODE; +> + indio_dev->num_channels = ARRAY_SIZE(ad5758_channels); > + -> + ret =3D ad5758_parse_dt(st); +> + ret = ad5758_parse_dt(st); > + if (ret < 0) > + return ret; > + -> + if (st->dc_dc_mode =3D=3D AD5758_DCDC_MODE_DPC_VOLTAGE) -> + channels->type =3D IIO_VOLTAGE; +> + if (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE) +> + channels->type = IIO_VOLTAGE; > + else -> + channels->type =3D IIO_CURRENT; +> + channels->type = IIO_CURRENT; > + -> + indio_dev->channels =3D channels; +> + indio_dev->channels = channels; > + -> + ret =3D ad5758_init(st); +> + ret = ad5758_init(st); > + if (ret < 0) { > + dev_err(&spi->dev, "AD5758 init failed\n"); > + return ret; @@ -1048,18 +1035,18 @@ p); > + return devm_iio_device_register(&st->spi->dev, indio_dev); > +} > + -> +static const struct spi_device_id ad5758_id[] =3D { +> +static const struct spi_device_id ad5758_id[] = { > + { "ad5758", 0 }, > + {} > +}; > +MODULE_DEVICE_TABLE(spi, ad5758_id); > + -> +static struct spi_driver ad5758_driver =3D { -> + .driver =3D { -> + .name =3D KBUILD_MODNAME, +> +static struct spi_driver ad5758_driver = { +> + .driver = { +> + .name = KBUILD_MODNAME, > + }, -> + .probe =3D ad5758_probe, -> + .id_table =3D ad5758_id, +> + .probe = ad5758_probe, +> + .id_table = ad5758_id, > +}; > + > +module_spi_driver(ad5758_driver); diff --git a/a/content_digest b/N1/content_digest index 169db7c..7807d0e 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -27,14 +27,13 @@ "\n" "> The AD5758 is a single channel DAC with 16-bit precision which uses the\n" "> SPI interface that operates at clock rates up to 50MHz.\n" - ">=20\n" + "> \n" "> The output can be configured as voltage or current and is available on a\n" "> single terminal.\n" - ">=20\n" + "> \n" "> Datasheet:\n" - "> http://www.analog.com/media/en/technical-documentation/data-sheets/ad5758=\n" - ".pdf\n" - ">=20\n" + "> http://www.analog.com/media/en/technical-documentation/data-sheets/ad5758.pdf\n" + "> \n" "> Signed-off-by: Stefan Popa <stefan.popa@analog.com>\n" "\n" "Hi Stefan,\n" @@ -69,7 +68,7 @@ "> \t- Used bsearch() instead of ad5758_get_array_index().\n" "> \t- Reduced the delays.\n" "> \t- strtobool() -> kstrtobool().\n" - ">=20\n" + "> \n" "> Changes in v2:\n" "> \t- removed unnecessary parenthesis in AD5758_REG_WRITE macro.\n" "> \t- added missing documentation fields of ad5758_state struct.\n" @@ -95,15 +94,14 @@ "> \t- returned directly at the end of ad5758_init().\n" "> \t- in ad5758_probe() used device managed for registering the device\n" "> \t and returned directly without the error message.\n" - ">=20\n" + "> \n" "> MAINTAINERS | 7 +\n" "> drivers/iio/dac/Kconfig | 10 +\n" "> drivers/iio/dac/Makefile | 1 +\n" - "> drivers/iio/dac/ad5758.c | 899 +++++++++++++++++++++++++++++++++++++++++=\n" - "++++++\n" + "> drivers/iio/dac/ad5758.c | 899 +++++++++++++++++++++++++++++++++++++++++++++++\n" "> 4 files changed, 917 insertions(+)\n" "> create mode 100644 drivers/iio/dac/ad5758.c\n" - ">=20\n" + "> \n" "> diff --git a/MAINTAINERS b/MAINTAINERS\n" "> index 00e9670..12d102d 100644\n" "> --- a/MAINTAINERS\n" @@ -111,7 +109,7 @@ "> @@ -796,6 +796,13 @@ M:\tMichael Hanselmann <linux-kernel@hansmi.ch>\n" "> S:\tSupported\n" "> F:\tdrivers/macintosh/ams/\n" - "> =20\n" + "> \n" "> +ANALOG DEVICES INC AD5758 DRIVER\n" "> +M:\tStefan Popa <stefan.popa@analog.com>\n" "> +L:\tlinux-iio@vger.kernel.org\n" @@ -129,7 +127,7 @@ "> @@ -167,6 +167,16 @@ config AD5755\n" "> \t To compile this driver as a module, choose M here: the\n" "> \t module will be called ad5755.\n" - "> =20\n" + "> \n" "> +config AD5758\n" "> +\ttristate \"Analog Devices AD5758 DAC driver\"\n" "> +\tdepends on SPI_MASTER\n" @@ -147,14 +145,14 @@ "> index 57aa230..a1b37cf 100644\n" "> --- a/drivers/iio/dac/Makefile\n" "> +++ b/drivers/iio/dac/Makefile\n" - "> @@ -16,6 +16,7 @@ obj-$(CONFIG_AD5592R_BASE) +=3D ad5592r-base.o\n" - "> obj-$(CONFIG_AD5592R) +=3D ad5592r.o\n" - "> obj-$(CONFIG_AD5593R) +=3D ad5593r.o\n" - "> obj-$(CONFIG_AD5755) +=3D ad5755.o\n" - "> +obj-$(CONFIG_AD5755) +=3D ad5758.o\n" - "> obj-$(CONFIG_AD5761) +=3D ad5761.o\n" - "> obj-$(CONFIG_AD5764) +=3D ad5764.o\n" - "> obj-$(CONFIG_AD5791) +=3D ad5791.o\n" + "> @@ -16,6 +16,7 @@ obj-$(CONFIG_AD5592R_BASE) += ad5592r-base.o\n" + "> obj-$(CONFIG_AD5592R) += ad5592r.o\n" + "> obj-$(CONFIG_AD5593R) += ad5593r.o\n" + "> obj-$(CONFIG_AD5755) += ad5755.o\n" + "> +obj-$(CONFIG_AD5755) += ad5758.o\n" + "> obj-$(CONFIG_AD5761) += ad5761.o\n" + "> obj-$(CONFIG_AD5764) += ad5764.o\n" + "> obj-$(CONFIG_AD5791) += ad5791.o\n" "> diff --git a/drivers/iio/dac/ad5758.c b/drivers/iio/dac/ad5758.c\n" "> new file mode 100644\n" "> index 0000000..bd1bed7\n" @@ -258,11 +256,9 @@ "> + * @lock:\tmutex lock\n" "> + * @out_range:\tstruct which stores the output range\n" "> + * @dc_dc_mode:\tvariable which stores the mode of operation\n" - "> + * @dc_dc_ilim:\tvariable which stores the dc-to-dc converter current lim=\n" - "it\n" + "> + * @dc_dc_ilim:\tvariable which stores the dc-to-dc converter current limit\n" "> + * @slew_time:\tvariable which stores the target slew time\n" - "> + * @pwr_down:\tvariable which contains whether a channel is powered down =\n" - "or not\n" + "> + * @pwr_down:\tvariable which contains whether a channel is powered down or not\n" "> + * @data:\tspi transfer buffers\n" "> + */\n" "> +\n" @@ -287,13 +283,13 @@ "> + * Output ranges corresponding to bits [3:0] from DAC_CONFIG register\n" "> + * 0000: 0 V to 5 V voltage range\n" "> + * 0001: 0 V to 10 V voltage range\n" - "> + * 0010: =C2=B15 V voltage range\n" - "> + * 0011: =C2=B110 V voltage range\n" + "> + * 0010: \302\2615 V voltage range\n" + "> + * 0011: \302\26110 V voltage range\n" "> + * 1000: 0 mA to 20 mA current range\n" "> + * 1001: 0 mA to 24 mA current range\n" "> + * 1010: 4 mA to 20 mA current range\n" - "> + * 1011: =C2=B120 mA current range\n" - "> + * 1100: =C2=B124 mA current range\n" + "> + * 1011: \302\26120 mA current range\n" + "> + * 1100: \302\26124 mA current range\n" "> + * 1101: -1 mA to +22 mA current range\n" "> + */\n" "> +enum ad5758_output_range {\n" @@ -301,7 +297,7 @@ "> +\tAD5758_RANGE_0V_10V,\n" "> +\tAD5758_RANGE_PLUSMINUS_5V,\n" "> +\tAD5758_RANGE_PLUSMINUS_10V,\n" - "> +\tAD5758_RANGE_0mA_20mA =3D 8,\n" + "> +\tAD5758_RANGE_0mA_20mA = 8,\n" "> +\tAD5758_RANGE_0mA_24mA,\n" "> +\tAD5758_RANGE_4mA_24mA,\n" "> +\tAD5758_RANGE_PLUSMINUS_20mA,\n" @@ -316,14 +312,14 @@ "> +\tAD5758_DCDC_MODE_PPC_CURRENT,\n" "> +};\n" "> +\n" - "> +static const struct ad5758_range ad5758_voltage_range[] =3D {\n" + "> +static const struct ad5758_range ad5758_voltage_range[] = {\n" "> +\t{ AD5758_RANGE_0V_5V, 0, 5000000 },\n" "> +\t{ AD5758_RANGE_0V_10V, 0, 10000000 },\n" "> +\t{ AD5758_RANGE_PLUSMINUS_5V, -5000000, 5000000 },\n" "> +\t{ AD5758_RANGE_PLUSMINUS_10V, -10000000, 10000000 }\n" "> +};\n" "> +\n" - "> +static const struct ad5758_range ad5758_current_range[] =3D {\n" + "> +static const struct ad5758_range ad5758_current_range[] = {\n" "> +\t{ AD5758_RANGE_0mA_20mA, 0, 20000},\n" "> +\t{ AD5758_RANGE_0mA_24mA, 0, 24000 },\n" "> +\t{ AD5758_RANGE_4mA_24mA, 4, 24000 },\n" @@ -332,41 +328,40 @@ "> +\t{ AD5758_RANGE_MINUS_1mA_PLUS_22mA, -1000, 22000 },\n" "> +};\n" "> +\n" - "> +static const int ad5758_sr_clk[16] =3D {\n" + "> +static const int ad5758_sr_clk[16] = {\n" "> +\t240000, 200000, 150000, 128000, 64000, 32000, 16000, 8000, 4000, 2000,\n" "> +\t1000, 512, 256, 128, 64, 16\n" "> +};\n" "> +\n" - "> +static const int ad5758_sr_step[8] =3D {\n" + "> +static const int ad5758_sr_step[8] = {\n" "> +\t4, 12, 64, 120, 256, 500, 1820, 2048\n" "> +};\n" "> +\n" - "> +static const int ad5758_dc_dc_ilim[6] =3D {\n" + "> +static const int ad5758_dc_dc_ilim[6] = {\n" "> +\t150000, 200000, 250000, 300000, 350000, 400000\n" "> +};\n" "> +\n" - "> +static int ad5758_spi_reg_read(struct ad5758_state *st, unsigned int add=\n" - "r)\n" + "> +static int ad5758_spi_reg_read(struct ad5758_state *st, unsigned int addr)\n" "> +{\n" - "> +\tstruct spi_transfer t[] =3D {\n" + "> +\tstruct spi_transfer t[] = {\n" "> +\t\t{\n" - "> +\t\t\t.tx_buf =3D &st->d32[0],\n" - "> +\t\t\t.len =3D 4,\n" - "> +\t\t\t.cs_change =3D 1,\n" + "> +\t\t\t.tx_buf = &st->d32[0],\n" + "> +\t\t\t.len = 4,\n" + "> +\t\t\t.cs_change = 1,\n" "> +\t\t}, {\n" - "> +\t\t\t.tx_buf =3D &st->d32[1],\n" - "> +\t\t\t.rx_buf =3D &st->d32[2],\n" - "> +\t\t\t.len =3D 4,\n" + "> +\t\t\t.tx_buf = &st->d32[1],\n" + "> +\t\t\t.rx_buf = &st->d32[2],\n" + "> +\t\t\t.len = 4,\n" "> +\t\t},\n" "> +\t};\n" "> +\tint ret;\n" "> +\n" - "> +\tst->d32[0] =3D cpu_to_be32(\n" + "> +\tst->d32[0] = cpu_to_be32(\n" "> +\t\t(AD5758_WR_FLAG_MSK(AD5758_TWO_STAGE_READBACK_SELECT) << 24) |\n" "> +\t\t(addr << 8));\n" - "> +\tst->d32[1] =3D cpu_to_be32(AD5758_WR_FLAG_MSK(AD5758_NOP) << 24);\n" + "> +\tst->d32[1] = cpu_to_be32(AD5758_WR_FLAG_MSK(AD5758_NOP) << 24);\n" "> +\n" - "> +\tret =3D spi_sync_transfer(st->spi, t, ARRAY_SIZE(t));\n" + "> +\tret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t));\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" @@ -377,7 +372,7 @@ "> +\t\t\t\tunsigned int addr,\n" "> +\t\t\t\tunsigned int val)\n" "> +{\n" - "> +\tst->d32[0] =3D cpu_to_be32((AD5758_WR_FLAG_MSK(addr) << 24) |\n" + "> +\tst->d32[0] = cpu_to_be32((AD5758_WR_FLAG_MSK(addr) << 24) |\n" "> +\t\t\t\t ((val & 0xFFFF) << 8));\n" "> +\n" "> +\treturn spi_write(st->spi, &st->d32[0], sizeof(st->d32[0]));\n" @@ -390,12 +385,12 @@ "> +{\n" "> +\tint regval;\n" "> +\n" - "> +\tregval =3D ad5758_spi_reg_read(st, addr);\n" + "> +\tregval = ad5758_spi_reg_read(st, addr);\n" "> +\tif (regval < 0)\n" "> +\t\treturn regval;\n" "> +\n" - "> +\tregval &=3D ~mask;\n" - "> +\tregval |=3D val;\n" + "> +\tregval &= ~mask;\n" + "> +\tregval |= val;\n" "> +\n" "> +\treturn ad5758_spi_reg_write(st, addr, regval);\n" "> +}\n" @@ -410,8 +405,8 @@ "> +{\n" "> +\tint i;\n" "> +\n" - "> +\tfor (i =3D 0; i < size; i++) {\n" - "> +\t\tif (val <=3D array[i])\n" + "> +\tfor (i = 0; i < size; i++) {\n" + "> +\t\tif (val <= array[i])\n" "> +\t\t\treturn i;\n" "> +\t}\n" "> +\n" @@ -425,9 +420,9 @@ "> +\tunsigned int timeout;\n" "> +\tint ret;\n" "> +\n" - "> +\ttimeout =3D 10;\n" + "> +\ttimeout = 10;\n" "> +\tdo {\n" - "> +\t\tret =3D ad5758_spi_reg_read(st, reg);\n" + "> +\t\tret = ad5758_spi_reg_read(st, reg);\n" "> +\t\tif (ret < 0)\n" "> +\t\t\treturn ret;\n" "> +\n" @@ -447,7 +442,7 @@ "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_reg_write(st, AD5758_KEY,\n" + "> +\tret = ad5758_spi_reg_write(st, AD5758_KEY,\n" "> +\t\t\t\t AD5758_KEY_CODE_CALIB_MEM_REFRESH);\n" "> +\tif (ret < 0) {\n" "> +\t\tdev_err(&st->spi->dev,\n" @@ -464,11 +459,11 @@ "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_1);\n" + "> +\tret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_1);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_2);\n" + "> +\tret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_2);\n" "> +\n" "> +\t/* Perform a software reset and wait 100us */\n" "> +\tudelay(100);\n" @@ -481,7 +476,7 @@ "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" "> +\t\t\t\t AD5758_DCDC_CONFIG1_DCDC_MODE_MSK,\n" "> +\t\t\t\t AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(mode));\n" "> +\tif (ret < 0)\n" @@ -491,22 +486,21 @@ "> +\t * Poll the BUSY_3WI bit in the DCDC_CONFIG2 register until it is 0.\n" "> +\t * This allows the 3-wire interface communication to complete.\n" "> +\t */\n" - "> +\tret =3D ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2,\n" + "> +\tret = ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2,\n" "> +\t\t\t\t\t AD5758_DCDC_CONFIG2_BUSY_3WI_MSK);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" - "> +\tst->dc_dc_mode =3D mode;\n" + "> +\tst->dc_dc_mode = mode;\n" "> +\n" "> +\treturn ret;\n" "> +}\n" "> +\n" - "> +static int ad5758_set_dc_dc_ilim(struct ad5758_state *st, unsigned int i=\n" - "lim)\n" + "> +static int ad5758_set_dc_dc_ilim(struct ad5758_state *st, unsigned int ilim)\n" "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG2,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG2,\n" "> +\t\t\t\t AD5758_DCDC_CONFIG2_ILIMIT_MSK,\n" "> +\t\t\t\t AD5758_DCDC_CONFIG2_ILIMIT_MODE(ilim));\n" "> +\tif (ret < 0)\n" @@ -527,14 +521,14 @@ "> +\tunsigned long int mask;\n" "> +\tint ret;\n" "> +\n" - "> +\tmask =3D AD5758_DAC_CONFIG_SR_EN_MSK |\n" + "> +\tmask = AD5758_DAC_CONFIG_SR_EN_MSK |\n" "> +\t AD5758_DAC_CONFIG_SR_CLOCK_MSK |\n" "> +\t AD5758_DAC_CONFIG_SR_STEP_MSK;\n" - "> +\tmode =3D AD5758_DAC_CONFIG_SR_EN_MODE(1) |\n" + "> +\tmode = AD5758_DAC_CONFIG_SR_EN_MODE(1) |\n" "> +\t\tAD5758_DAC_CONFIG_SR_STEP_MODE(sr_step_idx) |\n" "> +\t\tAD5758_DAC_CONFIG_SR_CLOCK_MODE(sr_clk_idx);\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, mask, mode);\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, mask, mode);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" @@ -550,34 +544,34 @@ "> +\ts64 diff_new, diff_old;\n" "> +\tu64 sr_step, calc_slew_time;\n" "> +\n" - "> +\tsr_clk_idx =3D 0;\n" - "> +\tsr_step_idx =3D 0;\n" - "> +\tdiff_old =3D S64_MAX;\n" + "> +\tsr_clk_idx = 0;\n" + "> +\tsr_step_idx = 0;\n" + "> +\tdiff_old = S64_MAX;\n" "> +\t/*\n" "> +\t * The slew time can be determined by using the formula:\n" - "> +\t * Slew Time =3D (Full Scale Out / (Step Size x Update Clk Freq))\n" + "> +\t * Slew Time = (Full Scale Out / (Step Size x Update Clk Freq))\n" "> +\t * where Slew time is expressed in microseconds\n" "> +\t * Given the desired slew time, the following algorithm determines the\n" "> +\t * best match for the step size and the update clock frequency.\n" "> +\t */\n" - "> +\tfor (i =3D 0; i < ARRAY_SIZE(ad5758_sr_clk); i++) {\n" + "> +\tfor (i = 0; i < ARRAY_SIZE(ad5758_sr_clk); i++) {\n" "> +\t\t/*\n" "> +\t\t * Go through each valid update clock freq and determine a raw\n" "> +\t\t * value for the step size by using the formula:\n" - "> +\t\t * Step Size =3D Full Scale Out / (Update Clk Freq * Slew Time)\n" + "> +\t\t * Step Size = Full Scale Out / (Update Clk Freq * Slew Time)\n" "> +\t\t */\n" - "> +\t\tsr_step =3D AD5758_FULL_SCALE_MICRO;\n" + "> +\t\tsr_step = AD5758_FULL_SCALE_MICRO;\n" "> +\t\tdo_div(sr_step, ad5758_sr_clk[i]);\n" "> +\t\tdo_div(sr_step, st->slew_time);\n" "> +\t\t/*\n" "> +\t\t * After a raw value for step size was determined, find the\n" "> +\t\t * closest valid match\n" "> +\t\t */\n" - "> +\t\tres =3D ad5758_find_closest_match(ad5758_sr_step,\n" + "> +\t\tres = ad5758_find_closest_match(ad5758_sr_step,\n" "> +\t\t\t\t\t\tARRAY_SIZE(ad5758_sr_step),\n" "> +\t\t\t\t\t\tsr_step);\n" "> +\t\t/* Calculate the slew time */\n" - "> +\t\tcalc_slew_time =3D AD5758_FULL_SCALE_MICRO;\n" + "> +\t\tcalc_slew_time = AD5758_FULL_SCALE_MICRO;\n" "> +\t\tdo_div(calc_slew_time, ad5758_sr_step[res]);\n" "> +\t\tdo_div(calc_slew_time, ad5758_sr_clk[i]);\n" "> +\t\t/*\n" @@ -585,11 +579,11 @@ "> +\t\t * is different from the desired slew time and store the diff\n" "> +\t\t * for the next iteration\n" "> +\t\t */\n" - "> +\t\tdiff_new =3D abs(st->slew_time - calc_slew_time);\n" + "> +\t\tdiff_new = abs(st->slew_time - calc_slew_time);\n" "> +\t\tif (diff_new < diff_old) {\n" - "> +\t\t\tdiff_old =3D diff_new;\n" - "> +\t\t\tsr_clk_idx =3D i;\n" - "> +\t\t\tsr_step_idx =3D res;\n" + "> +\t\t\tdiff_old = diff_new;\n" + "> +\t\t\tsr_clk_idx = i;\n" + "> +\t\t\tsr_step_idx = res;\n" "> +\t\t}\n" "> +\t}\n" "> +\n" @@ -600,34 +594,32 @@ "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" "> +\t\t\t\t AD5758_DAC_CONFIG_RANGE_MSK,\n" "> +\t\t\t\t AD5758_DAC_CONFIG_RANGE_MODE(range));\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Wait to allow time for the internal calibrations to complete */\n" - "> +\tret =3D ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,\n" + "> +\tret = ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,\n" "> +\t\t\t\t\t AD5758_CAL_MEM_UNREFRESHED_MSK);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "\n" "same as\n" - "ret =3D ad5758_wait_for_task_complete? You've done that everywhere else so=\n" - " I\n" - "assume it is safe (I haven't checked). Also odd spacing after the =3D above\n" + "ret = ad5758_wait_for_task_complete? You've done that everywhere else so I\n" + "assume it is safe (I haven't checked). Also odd spacing after the = above\n" "so please check that throughout.\n" "\n" "> +\n" "> +\treturn ret;\n" "> +}\n" "> +\n" - "> +static int ad5758_fault_prot_switch_en(struct ad5758_state *st, bool ena=\n" - "ble)\n" + "> +static int ad5758_fault_prot_switch_en(struct ad5758_state *st, bool enable)\n" "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" "> +\t\t\tAD5758_DCDC_CONFIG1_PROT_SW_EN_MSK,\n" "> +\t\t\tAD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(enable));\n" "> +\tif (ret < 0)\n" @@ -640,12 +632,11 @@ "> +\t\t\t\t\t AD5758_DCDC_CONFIG2_BUSY_3WI_MSK);\n" "> +}\n" "> +\n" - "> +static int ad5758_internal_buffers_en(struct ad5758_state *st, bool enab=\n" - "le)\n" + "> +static int ad5758_internal_buffers_en(struct ad5758_state *st, bool enable)\n" "> +{\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" "> +\t\t\t\t AD5758_DAC_CONFIG_INT_EN_MSK,\n" "> +\t\t\t\t AD5758_DAC_CONFIG_INT_EN_MODE(enable));\n" "> +\tif (ret < 0)\n" @@ -661,21 +652,21 @@ "> +\t\t\t unsigned int writeval,\n" "> +\t\t\t unsigned int *readval)\n" "> +{\n" - "> +\tstruct ad5758_state *st =3D iio_priv(indio_dev);\n" + "> +\tstruct ad5758_state *st = iio_priv(indio_dev);\n" "> +\tint ret;\n" "> +\n" "> +\tmutex_lock(&st->lock);\n" "> +\tif (readval) {\n" - "> +\t\tret =3D ad5758_spi_reg_read(st, reg);\n" + "> +\t\tret = ad5758_spi_reg_read(st, reg);\n" "> +\t\tif (ret < 0) {\n" "> +\t\t\tmutex_unlock(&st->lock);\n" "> +\t\t\treturn ret;\n" "> +\t\t}\n" "> +\n" - "> +\t\t*readval =3D ret;\n" - "> +\t\tret =3D 0;\n" + "> +\t\t*readval = ret;\n" + "> +\t\tret = 0;\n" "> +\t} else {\n" - "> +\t\tret =3D ad5758_spi_reg_write(st, reg, writeval);\n" + "> +\t\tret = ad5758_spi_reg_write(st, reg, writeval);\n" "> +\t}\n" "> +\tmutex_unlock(&st->lock);\n" "> +\n" @@ -686,29 +677,29 @@ "> +\t\t\t struct iio_chan_spec const *chan,\n" "> +\t\t\t int *val, int *val2, long info)\n" "> +{\n" - "> +\tstruct ad5758_state *st =3D iio_priv(indio_dev);\n" + "> +\tstruct ad5758_state *st = iio_priv(indio_dev);\n" "> +\tint max, min, ret;\n" "> +\n" "> +\tswitch (info) {\n" "> +\tcase IIO_CHAN_INFO_RAW:\n" "> +\t\tmutex_lock(&st->lock);\n" - "> +\t\tret =3D ad5758_spi_reg_read(st, AD5758_DAC_INPUT);\n" + "> +\t\tret = ad5758_spi_reg_read(st, AD5758_DAC_INPUT);\n" "> +\t\tmutex_unlock(&st->lock);\n" "> +\t\tif (ret < 0)\n" "> +\t\t\treturn ret;\n" "> +\n" - "> +\t\t*val =3D ret;\n" + "> +\t\t*val = ret;\n" "> +\t\treturn IIO_VAL_INT;\n" "> +\tcase IIO_CHAN_INFO_SCALE:\n" - "> +\t\tmin =3D st->out_range.min;\n" - "> +\t\tmax =3D st->out_range.max;\n" - "> +\t\t*val =3D (max - min) / 1000;\n" - "> +\t\t*val2 =3D 16;\n" + "> +\t\tmin = st->out_range.min;\n" + "> +\t\tmax = st->out_range.max;\n" + "> +\t\t*val = (max - min) / 1000;\n" + "> +\t\t*val2 = 16;\n" "> +\t\treturn IIO_VAL_FRACTIONAL_LOG2;\n" "> +\tcase IIO_CHAN_INFO_OFFSET:\n" - "> +\t\tmin =3D st->out_range.min;\n" - "> +\t\tmax =3D st->out_range.max;\n" - "> +\t\t*val =3D ((min * (1 << 16)) / (max - min)) / 1000;\n" + "> +\t\tmin = st->out_range.min;\n" + "> +\t\tmax = st->out_range.max;\n" + "> +\t\t*val = ((min * (1 << 16)) / (max - min)) / 1000;\n" "> +\t\treturn IIO_VAL_INT;\n" "> +\tdefault:\n" "> +\t\treturn -EINVAL;\n" @@ -719,13 +710,13 @@ "> +\t\t\t struct iio_chan_spec const *chan,\n" "> +\t\t\t int val, int val2, long info)\n" "> +{\n" - "> +\tstruct ad5758_state *st =3D iio_priv(indio_dev);\n" + "> +\tstruct ad5758_state *st = iio_priv(indio_dev);\n" "> +\tint ret;\n" "> +\n" "> +\tswitch (info) {\n" "> +\tcase IIO_CHAN_INFO_RAW:\n" "> +\t\tmutex_lock(&st->lock);\n" - "> +\t\tret =3D ad5758_spi_reg_write(st, AD5758_DAC_INPUT, val);\n" + "> +\t\tret = ad5758_spi_reg_write(st, AD5758_DAC_INPUT, val);\n" "> +\t\tmutex_unlock(&st->lock);\n" "> +\t\treturn ret;\n" "> +\tdefault:\n" @@ -738,7 +729,7 @@ "> +\t\t\t\t const struct iio_chan_spec *chan,\n" "> +\t\t\t\t char *buf)\n" "> +{\n" - "> +\tstruct ad5758_state *st =3D iio_priv(indio_dev);\n" + "> +\tstruct ad5758_state *st = iio_priv(indio_dev);\n" "> +\n" "> +\treturn sprintf(buf, \"%d\\n\", st->pwr_down);\n" "> +}\n" @@ -748,56 +739,55 @@ "> +\t\t\t\t struct iio_chan_spec const *chan,\n" "> +\t\t\t\t const char *buf, size_t len)\n" "> +{\n" - "> +\tstruct ad5758_state *st =3D iio_priv(indio_dev);\n" + "> +\tstruct ad5758_state *st = iio_priv(indio_dev);\n" "> +\tbool pwr_down;\n" "> +\tunsigned int dcdc_config1_mode, dc_dc_mode, dac_config_mode, val;\n" "> +\tunsigned long int dcdc_config1_msk, dac_config_msk;\n" "> +\tint ret;\n" "> +\n" - "> +\tret =3D kstrtobool(buf, &pwr_down);\n" + "> +\tret = kstrtobool(buf, &pwr_down);\n" "> +\tif (ret)\n" "> +\t\treturn ret;\n" "> +\n" "> +\tmutex_lock(&st->lock);\n" "> +\tif (pwr_down) {\n" - "> +\t\tdc_dc_mode =3D AD5758_DCDC_MODE_POWER_OFF;\n" - "> +\t\tval =3D 0;\n" + "> +\t\tdc_dc_mode = AD5758_DCDC_MODE_POWER_OFF;\n" + "> +\t\tval = 0;\n" "> +\t} else {\n" - "> +\t\tdc_dc_mode =3D st->dc_dc_mode;\n" - "> +\t\tval =3D 1;\n" + "> +\t\tdc_dc_mode = st->dc_dc_mode;\n" + "> +\t\tval = 1;\n" "> +\t}\n" "> +\n" - "> +\tdcdc_config1_mode =3D (AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(dc_dc_mode) |\n" + "> +\tdcdc_config1_mode = (AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(dc_dc_mode) |\n" "> +\t\t\t AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(val));\n" - "> +\tdcdc_config1_msk =3D (AD5758_DCDC_CONFIG1_DCDC_MODE_MSK |\n" + "> +\tdcdc_config1_msk = (AD5758_DCDC_CONFIG1_DCDC_MODE_MSK |\n" "> +\t\t\t AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK);\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,\n" "> +\t\t\t\t dcdc_config1_msk,\n" "> +\t\t\t\t dcdc_config1_mode);\n" "> +\tif (ret < 0)\n" "> +\t\tgoto err_unlock;\n" "> +\n" - "> +\tdac_config_mode =3D (AD5758_DAC_CONFIG_OUT_EN_MODE(val) |\n" + "> +\tdac_config_mode = (AD5758_DAC_CONFIG_OUT_EN_MODE(val) |\n" "> +\t\t\t AD5758_DAC_CONFIG_INT_EN_MODE(val));\n" - "> +\tdac_config_msk =3D (AD5758_DAC_CONFIG_OUT_EN_MSK |\n" + "> +\tdac_config_msk = (AD5758_DAC_CONFIG_OUT_EN_MSK |\n" "\n" - "I wouldn't have the double space after the =3D=20\n" - "That sort things is fragile to later changes in the driver and doesn't real=\n" - "ly\n" + "I wouldn't have the double space after the = \n" + "That sort things is fragile to later changes in the driver and doesn't really\n" "make much different to readability.\n" "There are some excess brackets in here which will get 'fixed'\n" "by someone following the static checkers if we don't do it now.\n" "\n" "> +\t\t\t AD5758_DAC_CONFIG_INT_EN_MSK);\n" "> +\n" - "> +\tret =3D ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" + "> +\tret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,\n" "> +\t\t\t\t dac_config_msk,\n" "> +\t\t\t\t dac_config_mode);\n" "> +\tif (ret < 0)\n" "> +\t\tgoto err_unlock;\n" "> +\n" - "> +\tst->pwr_down =3D pwr_down;\n" + "> +\tst->pwr_down = pwr_down;\n" "> +\n" "> +err_unlock:\n" "> +\tmutex_unlock(&st->lock);\n" @@ -805,23 +795,23 @@ "> +\treturn ret ? ret : len;\n" "> +}\n" "> +\n" - "> +static const struct iio_info ad5758_info =3D {\n" - "> +\t.read_raw =3D ad5758_read_raw,\n" - "> +\t.write_raw =3D ad5758_write_raw,\n" - "> +\t.debugfs_reg_access =3D &ad5758_reg_access,\n" + "> +static const struct iio_info ad5758_info = {\n" + "> +\t.read_raw = ad5758_read_raw,\n" + "> +\t.write_raw = ad5758_write_raw,\n" + "> +\t.debugfs_reg_access = &ad5758_reg_access,\n" "> +};\n" "> +\n" - "> +static const struct iio_chan_spec_ext_info ad5758_ext_info[] =3D {\n" + "> +static const struct iio_chan_spec_ext_info ad5758_ext_info[] = {\n" "> +\t{\n" - "> +\t\t.name =3D \"powerdown\",\n" - "> +\t\t.read =3D ad5758_read_powerdown,\n" - "> +\t\t.write =3D ad5758_write_powerdown,\n" - "> +\t\t.shared =3D IIO_SHARED_BY_TYPE,\n" + "> +\t\t.name = \"powerdown\",\n" + "> +\t\t.read = ad5758_read_powerdown,\n" + "> +\t\t.write = ad5758_write_powerdown,\n" + "> +\t\t.shared = IIO_SHARED_BY_TYPE,\n" "> +\t},\n" "> +\t{ }\n" "> +};\n" "> +\n" - "> +static struct iio_chan_spec ad5758_channels[] =3D {\n" + "> +static struct iio_chan_spec ad5758_channels[] = {\n" "\n" "Hmm. So this is a template that is then updated.\n" "\n" @@ -830,12 +820,12 @@ "of this, not the actual template here, which should be constant.\n" "\n" "> +\t{\n" - "> +\t\t.info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_RAW) |\n" + "> +\t\t.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_RAW) |\n" "> +\t\t\tBIT(IIO_CHAN_INFO_SCALE) |\n" "> +\t\t\tBIT(IIO_CHAN_INFO_OFFSET),\n" - "> +\t\t.indexed =3D 1,\n" - "> +\t\t.output =3D 1,\n" - "> +\t\t.ext_info =3D ad5758_ext_info,\n" + "> +\t\t.indexed = 1,\n" + "> +\t\t.output = 1,\n" + "> +\t\t.ext_info = ad5758_ext_info,\n" "> +\t},\n" "> +};\n" "> +\n" @@ -855,9 +845,8 @@ "> +{\n" "> +\tunsigned int mask;\n" "> +\n" - "> +\tmask =3D (AD5758_WR_FLAG_MSK(AD5758_DIGITAL_DIAG_CONFIG) << 24) | 0x5C3=\n" - "A;\n" - "> +\tst->d32[0] =3D cpu_to_be32(mask);\n" + "> +\tmask = (AD5758_WR_FLAG_MSK(AD5758_DIGITAL_DIAG_CONFIG) << 24) | 0x5C3A;\n" + "> +\tst->d32[0] = cpu_to_be32(mask);\n" "> +\n" "> +\treturn spi_write(st->spi, &st->d32[0], 4);\n" "> +}\n" @@ -869,11 +858,11 @@ "> +{\n" "> +\tint i;\n" "> +\n" - "> +\tfor (i =3D 0; i < size; i++) {\n" - "> +\t\tif ((min =3D=3D range[i].min) && (max =3D=3D range[i].max)) {\n" - "> +\t\t\tst->out_range.reg =3D range[i].reg;\n" - "> +\t\t\tst->out_range.min =3D range[i].min;\n" - "> +\t\t\tst->out_range.max =3D range[i].max;\n" + "> +\tfor (i = 0; i < size; i++) {\n" + "> +\t\tif ((min == range[i].min) && (max == range[i].max)) {\n" + "> +\t\t\tst->out_range.reg = range[i].reg;\n" + "> +\t\t\tst->out_range.min = range[i].min;\n" + "> +\t\t\tst->out_range.max = range[i].max;\n" "> +\n" "> +\t\t\treturn 0;\n" "> +\t\t}\n" @@ -888,23 +877,23 @@ "> +\tconst struct ad5758_range *range;\n" "> +\tint *index, ret;\n" "> +\n" - "> +\tst->dc_dc_ilim =3D 0;\n" - "> +\tret =3D device_property_read_u32(&st->spi->dev,\n" + "> +\tst->dc_dc_ilim = 0;\n" + "> +\tret = device_property_read_u32(&st->spi->dev,\n" "> +\t\t\t\t \"adi,dc-dc-ilim-microamp\", &tmp);\n" "> +\tif (ret) {\n" "> +\t\tdev_dbg(&st->spi->dev,\n" "> +\t\t\t\"Missing \\\"dc-dc-ilim-microamp\\\" property\\n\");\n" "> +\t} else {\n" - "> +\t\tindex =3D (int *) bsearch(&tmp, ad5758_dc_dc_ilim,\n" + "> +\t\tindex = (int *) bsearch(&tmp, ad5758_dc_dc_ilim,\n" "> +\t\t\t\t\tARRAY_SIZE(ad5758_dc_dc_ilim),\n" "> +\t\t\t\t\tsizeof(int), cmpfunc);\n" "> +\t\tif (!index)\n" "> +\t\t\tdev_dbg(&st->spi->dev, \"dc-dc-ilim out of range\\n\");\n" "> +\t\telse\n" - "> +\t\t\tst->dc_dc_ilim =3D index - ad5758_dc_dc_ilim;\n" + "> +\t\t\tst->dc_dc_ilim = index - ad5758_dc_dc_ilim;\n" "> +\t}\n" "> +\n" - "> +\tret =3D device_property_read_u32(&st->spi->dev, \"adi,dc-dc-mode\",\n" + "> +\tret = device_property_read_u32(&st->spi->dev, \"adi,dc-dc-mode\",\n" "> +\t\t\t\t &st->dc_dc_mode);\n" "> +\tif (ret) {\n" "> +\t\tdev_err(&st->spi->dev, \"Missing \\\"dc-dc-mode\\\" property\\n\");\n" @@ -914,8 +903,8 @@ "> +\tif (!ad5758_is_valid_mode(st->dc_dc_mode))\n" "> +\t\treturn -EINVAL;\n" "> +\n" - "> +\tif (st->dc_dc_mode =3D=3D AD5758_DCDC_MODE_DPC_VOLTAGE) {\n" - "> +\t\tret =3D device_property_read_u32_array(&st->spi->dev,\n" + "> +\tif (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE) {\n" + "> +\t\tret = device_property_read_u32_array(&st->spi->dev,\n" "> +\t\t\t\t\t\t \"adi,range-microvolt\",\n" "> +\t\t\t\t\t\t tmparray, 2);\n" "> +\t\tif (ret) {\n" @@ -923,10 +912,10 @@ "> +\t\t\t\t\"Missing \\\"range-microvolt\\\" property\\n\");\n" "> +\t\t\treturn ret;\n" "> +\t\t}\n" - "> +\t\trange =3D ad5758_voltage_range;\n" - "> +\t\tsize =3D ARRAY_SIZE(ad5758_voltage_range);\n" + "> +\t\trange = ad5758_voltage_range;\n" + "> +\t\tsize = ARRAY_SIZE(ad5758_voltage_range);\n" "> +\t} else {\n" - "> +\t\tret =3D device_property_read_u32_array(&st->spi->dev,\n" + "> +\t\tret = device_property_read_u32_array(&st->spi->dev,\n" "> +\t\t\t\t\t\t \"adi,range-microamp\",\n" "> +\t\t\t\t\t\t tmparray, 2);\n" "> +\t\tif (ret) {\n" @@ -934,24 +923,22 @@ "> +\t\t\t\t\"Missing \\\"range-microamp\\\" property\\n\");\n" "> +\t\t\treturn ret;\n" "> +\t\t}\n" - "> +\t\trange =3D ad5758_current_range;\n" - "> +\t\tsize =3D ARRAY_SIZE(ad5758_current_range);\n" + "> +\t\trange = ad5758_current_range;\n" + "> +\t\tsize = ARRAY_SIZE(ad5758_current_range);\n" "> +\t}\n" "> +\n" - "> +\tret =3D ad5758_find_out_range(st, range, size, tmparray[0], tmparray[1]=\n" - ");\n" + "> +\tret = ad5758_find_out_range(st, range, size, tmparray[0], tmparray[1]);\n" "> +\tif (ret) {\n" "> +\t\tdev_err(&st->spi->dev, \"range invalid\\n\");\n" "> +\t\treturn ret;\n" "> +\t}\n" "> +\n" - "> +\tret =3D device_property_read_u32(&st->spi->dev, \"adi,slew-time-us\", &tm=\n" - "p);\n" + "> +\tret = device_property_read_u32(&st->spi->dev, \"adi,slew-time-us\", &tmp);\n" "> +\tif (ret) {\n" "> +\t\tdev_dbg(&st->spi->dev, \"Missing \\\"slew-time-us\\\" property\\n\");\n" - "> +\t\tst->slew_time =3D 0;\n" + "> +\t\tst->slew_time = 0;\n" "> +\t} else {\n" - "> +\t\tst->slew_time =3D tmp;\n" + "> +\t\tst->slew_time = tmp;\n" "> +\t}\n" "> +\n" "> +\treturn 0;\n" @@ -962,63 +949,63 @@ "> +\tint regval, ret;\n" "> +\n" "> +\t/* Disable CRC checks */\n" - "> +\tret =3D ad5758_crc_disable(st);\n" + "> +\tret = ad5758_crc_disable(st);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Perform a software reset */\n" - "> +\tret =3D ad5758_soft_reset(st);\n" + "> +\tret = ad5758_soft_reset(st);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Disable CRC checks */\n" - "> +\tret =3D ad5758_crc_disable(st);\n" + "> +\tret = ad5758_crc_disable(st);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Perform a calibration memory refresh */\n" - "> +\tret =3D ad5758_calib_mem_refresh(st);\n" + "> +\tret = ad5758_calib_mem_refresh(st);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" - "> +\tregval =3D ad5758_spi_reg_read(st, AD5758_DIGITAL_DIAG_RESULTS);\n" + "> +\tregval = ad5758_spi_reg_read(st, AD5758_DIGITAL_DIAG_RESULTS);\n" "> +\tif (regval < 0)\n" "> +\t\treturn regval;\n" "> +\n" "> +\t/* Clear all the error flags */\n" - "> +\tret =3D ad5758_spi_reg_write(st, AD5758_DIGITAL_DIAG_RESULTS, regval);\n" + "> +\tret = ad5758_spi_reg_write(st, AD5758_DIGITAL_DIAG_RESULTS, regval);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Set the dc-to-dc current limit */\n" - "> +\tret =3D ad5758_set_dc_dc_ilim(st, st->dc_dc_ilim);\n" + "> +\tret = ad5758_set_dc_dc_ilim(st, st->dc_dc_ilim);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Configure the dc-to-dc controller mode */\n" - "> +\tret =3D ad5758_set_dc_dc_conv_mode(st, st->dc_dc_mode);\n" + "> +\tret = ad5758_set_dc_dc_conv_mode(st, st->dc_dc_mode);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Configure the output range */\n" - "> +\tret =3D ad5758_set_out_range(st, st->out_range.reg);\n" + "> +\tret = ad5758_set_out_range(st, st->out_range.reg);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Enable Slew Rate Control, set the slew rate clock and step */\n" "> +\tif (st->slew_time) {\n" - "> +\t\tret =3D ad5758_slew_rate_config(st);\n" + "> +\t\tret = ad5758_slew_rate_config(st);\n" "> +\t\tif (ret < 0)\n" "> +\t\t\treturn ret;\n" "> +\t}\n" "> +\n" "> +\t/* Enable the VIOUT fault protection switch (FPS is closed) */\n" - "> +\tret =3D ad5758_fault_prot_switch_en(st, 1);\n" + "> +\tret = ad5758_fault_prot_switch_en(st, 1);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" "> +\t/* Power up the DAC and internal (INT) amplifiers */\n" - "> +\tret =3D ad5758_internal_buffers_en(st, 1);\n" + "> +\tret = ad5758_internal_buffers_en(st, 1);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" @@ -1032,38 +1019,38 @@ "> +{\n" "> +\tstruct ad5758_state *st;\n" "> +\tstruct iio_dev *indio_dev;\n" - "> +\tstruct iio_chan_spec *channels =3D ad5758_channels;\n" + "> +\tstruct iio_chan_spec *channels = ad5758_channels;\n" "> +\tint ret;\n" "> +\n" - "> +\tindio_dev =3D devm_iio_device_alloc(&spi->dev, sizeof(*st));\n" + "> +\tindio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));\n" "> +\tif (!indio_dev)\n" "> +\t\treturn -ENOMEM;\n" "> +\n" - "> +\tst =3D iio_priv(indio_dev);\n" + "> +\tst = iio_priv(indio_dev);\n" "> +\tspi_set_drvdata(spi, indio_dev);\n" "> +\n" - "> +\tst->spi =3D spi;\n" + "> +\tst->spi = spi;\n" "> +\n" "> +\tmutex_init(&st->lock);\n" "> +\n" - "> +\tindio_dev->dev.parent =3D &spi->dev;\n" - "> +\tindio_dev->name =3D spi_get_device_id(spi)->name;\n" - "> +\tindio_dev->info =3D &ad5758_info;\n" - "> +\tindio_dev->modes =3D INDIO_DIRECT_MODE;\n" - "> +\tindio_dev->num_channels =3D ARRAY_SIZE(ad5758_channels);\n" + "> +\tindio_dev->dev.parent = &spi->dev;\n" + "> +\tindio_dev->name = spi_get_device_id(spi)->name;\n" + "> +\tindio_dev->info = &ad5758_info;\n" + "> +\tindio_dev->modes = INDIO_DIRECT_MODE;\n" + "> +\tindio_dev->num_channels = ARRAY_SIZE(ad5758_channels);\n" "> +\n" - "> +\tret =3D ad5758_parse_dt(st);\n" + "> +\tret = ad5758_parse_dt(st);\n" "> +\tif (ret < 0)\n" "> +\t\treturn ret;\n" "> +\n" - "> +\tif (st->dc_dc_mode =3D=3D AD5758_DCDC_MODE_DPC_VOLTAGE)\n" - "> +\t\tchannels->type =3D IIO_VOLTAGE;\n" + "> +\tif (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE)\n" + "> +\t\tchannels->type = IIO_VOLTAGE;\n" "> +\telse\n" - "> +\t\tchannels->type =3D IIO_CURRENT;\n" + "> +\t\tchannels->type = IIO_CURRENT;\n" "> +\n" - "> +\tindio_dev->channels =3D channels;\n" + "> +\tindio_dev->channels = channels;\n" "> +\n" - "> +\tret =3D ad5758_init(st);\n" + "> +\tret = ad5758_init(st);\n" "> +\tif (ret < 0) {\n" "> +\t\tdev_err(&spi->dev, \"AD5758 init failed\\n\");\n" "> +\t\treturn ret;\n" @@ -1072,18 +1059,18 @@ "> +\treturn devm_iio_device_register(&st->spi->dev, indio_dev);\n" "> +}\n" "> +\n" - "> +static const struct spi_device_id ad5758_id[] =3D {\n" + "> +static const struct spi_device_id ad5758_id[] = {\n" "> +\t{ \"ad5758\", 0 },\n" "> +\t{}\n" "> +};\n" "> +MODULE_DEVICE_TABLE(spi, ad5758_id);\n" "> +\n" - "> +static struct spi_driver ad5758_driver =3D {\n" - "> +\t.driver =3D {\n" - "> +\t\t.name =3D KBUILD_MODNAME,\n" + "> +static struct spi_driver ad5758_driver = {\n" + "> +\t.driver = {\n" + "> +\t\t.name = KBUILD_MODNAME,\n" "> +\t},\n" - "> +\t.probe =3D ad5758_probe,\n" - "> +\t.id_table =3D ad5758_id,\n" + "> +\t.probe = ad5758_probe,\n" + "> +\t.id_table = ad5758_id,\n" "> +};\n" "> +\n" "> +module_spi_driver(ad5758_driver);\n" @@ -1092,4 +1079,4 @@ "> +MODULE_DESCRIPTION(\"Analog Devices AD5758 DAC\");\n" "> +MODULE_LICENSE(\"GPL v2\");" -175992504cd355bccd1df1c28b113b5a58b41ba1f7fb4a89d876748a044d4a07 +907a637d932336367d97f7e31122ea3ded49de2acda1cb32804086436e3d489a
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.