diff for duplicates of <20180707182117.7a56985d@archlinux> diff --git a/a/1.txt b/N1/1.txt index 73a3a37..2ebaf05 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> Very nice! @@ -51,7 +50,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. @@ -77,15 +76,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 | 897 +++++++++++++++++++++++++++++++++++++++++= -++++++ +> drivers/iio/dac/ad5758.c | 897 +++++++++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 915 insertions(+) > create mode 100644 drivers/iio/dac/ad5758.c ->=20 +> > diff --git a/MAINTAINERS b/MAINTAINERS > index 00e9670..12d102d 100644 > --- a/MAINTAINERS @@ -93,7 +91,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 @@ -111,7 +109,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 @@ -129,14 +127,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..bd36333 @@ -238,11 +236,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 > + */ > + @@ -267,13 +263,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 { @@ -281,7 +277,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, @@ -296,14 +292,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 }, @@ -312,41 +308,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; > + @@ -357,7 +352,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])); @@ -370,12 +365,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); > +} @@ -390,8 +385,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; > + } > + @@ -405,9 +400,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; > + @@ -427,7 +422,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, @@ -444,11 +439,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 at least 100us */ > + usleep_range(100, 1000); @@ -461,7 +456,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) @@ -471,22 +466,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) @@ -507,14 +501,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; > + @@ -530,34 +524,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]); > + /* @@ -565,11 +559,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; > + } > + } > + @@ -580,7 +574,7 @@ 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) @@ -591,12 +585,11 @@ lim) > + AD5758_CAL_MEM_UNREFRESHED_MSK); > +} > + -> +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) @@ -609,12 +602,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) @@ -630,21 +622,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); > + @@ -655,29 +647,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; @@ -688,13 +680,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: @@ -707,7 +699,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); > +} @@ -717,48 +709,48 @@ 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 | > + 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); @@ -766,37 +758,37 @@ le) > + 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, > + }, > + { } > +}; > + > +#define AD5758_DAC_CHAN(_chan_type) { \ -> + .type =3D (_chan_type), \ -> + .info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_RAW) | \ +> + .type = (_chan_type), \ +> + .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, \ > +} > + -> +static const struct iio_chan_spec ad5758_voltage_ch[] =3D { +> +static const struct iio_chan_spec ad5758_voltage_ch[] = { > + AD5758_DAC_CHAN(IIO_VOLTAGE) > +}; > + -> +static const struct iio_chan_spec ad5758_current_ch[] =3D { +> +static const struct iio_chan_spec ad5758_current_ch[] = { > + AD5758_DAC_CHAN(IIO_CURRENT) > +}; > + @@ -816,9 +808,8 @@ le) > +{ > + 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); > +} @@ -830,11 +821,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; > + } @@ -849,23 +840,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 bsearch(&tmp, ad5758_dc_dc_ilim, +> + index = 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"); @@ -875,8 +866,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) { @@ -884,10 +875,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) { @@ -895,24 +886,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; @@ -923,63 +912,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; > + @@ -995,33 +984,33 @@ p); > + struct iio_dev *indio_dev; > + 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 1; +> + 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 = 1; > + -> + 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) -> + indio_dev->channels =3D ad5758_voltage_ch; +> + if (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE) +> + indio_dev->channels = ad5758_voltage_ch; > + else -> + indio_dev->channels =3D ad5758_current_ch; +> + indio_dev->channels = ad5758_current_ch; > + -> + ret =3D ad5758_init(st); +> + ret = ad5758_init(st); > + if (ret < 0) { > + dev_err(&spi->dev, "AD5758 init failed\n"); > + return ret; @@ -1030,18 +1019,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 ff87512..aa94523 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" "Very nice!\n" @@ -75,7 +74,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" @@ -101,15 +100,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 | 897 +++++++++++++++++++++++++++++++++++++++++=\n" - "++++++\n" + "> drivers/iio/dac/ad5758.c | 897 +++++++++++++++++++++++++++++++++++++++++++++++\n" "> 4 files changed, 915 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" @@ -117,7 +115,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" @@ -135,7 +133,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" @@ -153,14 +151,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..bd36333\n" @@ -262,11 +260,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" @@ -291,13 +287,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" @@ -305,7 +301,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" @@ -320,14 +316,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" @@ -336,41 +332,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" @@ -381,7 +376,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" @@ -394,12 +389,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" @@ -414,8 +409,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" @@ -429,9 +424,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" @@ -451,7 +446,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" @@ -468,11 +463,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 at least 100us */\n" "> +\tusleep_range(100, 1000);\n" @@ -485,7 +480,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" @@ -495,22 +490,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" @@ -531,14 +525,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 AD5758_DAC_CONFIG_SR_STEP_MODE(sr_step_idx) |\n" "> +\t AD5758_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" @@ -554,34 +548,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" @@ -589,11 +583,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" @@ -604,7 +598,7 @@ "> +{\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" @@ -615,12 +609,11 @@ "> +\t\t\t\t\t AD5758_CAL_MEM_UNREFRESHED_MSK);\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" @@ -633,12 +626,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" @@ -654,21 +646,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" @@ -679,29 +671,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" @@ -712,13 +704,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" @@ -731,7 +723,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" @@ -741,48 +733,48 @@ "> +\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" "> +\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" @@ -790,37 +782,37 @@ "> +\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" "> +#define AD5758_DAC_CHAN(_chan_type) {\t\t\t\t\\\n" - "> +\t.type =3D (_chan_type),\t\t\t\t\t\\\n" - "> +\t.info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_RAW) |\t\\\n" + "> +\t.type = (_chan_type),\t\t\t\t\t\\\n" + "> +\t.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_RAW) |\t\\\n" "> +\t\tBIT(IIO_CHAN_INFO_SCALE) |\t\t\t\\\n" "> +\t\tBIT(IIO_CHAN_INFO_OFFSET),\t\t\t\\\n" - "> +\t.indexed =3D 1,\t\t\t\t\t\t\\\n" - "> +\t.output =3D 1,\t\t\t\t\t\t\\\n" - "> +\t.ext_info =3D ad5758_ext_info,\t\t\t\t\\\n" + "> +\t.indexed = 1,\t\t\t\t\t\t\\\n" + "> +\t.output = 1,\t\t\t\t\t\t\\\n" + "> +\t.ext_info = ad5758_ext_info,\t\t\t\t\\\n" "> +}\n" "> +\n" - "> +static const struct iio_chan_spec ad5758_voltage_ch[] =3D {\n" + "> +static const struct iio_chan_spec ad5758_voltage_ch[] = {\n" "> +\tAD5758_DAC_CHAN(IIO_VOLTAGE)\n" "> +};\n" "> +\n" - "> +static const struct iio_chan_spec ad5758_current_ch[] =3D {\n" + "> +static const struct iio_chan_spec ad5758_current_ch[] = {\n" "> +\tAD5758_DAC_CHAN(IIO_CURRENT)\n" "> +};\n" "> +\n" @@ -840,9 +832,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" @@ -854,11 +845,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" @@ -873,23 +864,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 bsearch(&tmp, ad5758_dc_dc_ilim,\n" + "> +\t\tindex = bsearch(&tmp, ad5758_dc_dc_ilim,\n" "> +\t\t\t\tARRAY_SIZE(ad5758_dc_dc_ilim),\n" "> +\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" @@ -899,8 +890,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" @@ -908,10 +899,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" @@ -919,24 +910,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" @@ -947,63 +936,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" @@ -1019,33 +1008,33 @@ "> +\tstruct iio_dev *indio_dev;\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 1;\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 = 1;\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\tindio_dev->channels =3D ad5758_voltage_ch;\n" + "> +\tif (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE)\n" + "> +\t\tindio_dev->channels = ad5758_voltage_ch;\n" "> +\telse\n" - "> +\t\tindio_dev->channels =3D ad5758_current_ch;\n" + "> +\t\tindio_dev->channels = ad5758_current_ch;\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" @@ -1054,18 +1043,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" @@ -1074,4 +1063,4 @@ "> +MODULE_DESCRIPTION(\"Analog Devices AD5758 DAC\");\n" "> +MODULE_LICENSE(\"GPL v2\");" -cc98c74bb74c45448ce3c1c0fe8af0b188cc212aa0dfbc8e64907a7a31e82539 +2934268a86c16f73672dd8f89f434e7c1510aaf4c558f8d615dda26627dd7ccb
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.