Quelle  ltc2688.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * LTC2688 16 channel, 16 bit Voltage Output SoftSpan DAC driver
 *
 * Copyright 2022 Analog Devices Inc.
 */
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/clk.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/iio/iio.h>
#include <linux/limits.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/spi/spi.h>

#define LTC2688_DAC_CHANNELS   16

#define LTC2688_CMD_CH_CODE(x)   (0x00 + (x))
#define LTC2688_CMD_CH_SETTING(x)  (0x10 + (x))
#define LTC2688_CMD_CH_OFFSET(x)  (0X20 + (x))
#define LTC2688_CMD_CH_GAIN(x)   (0x30 + (x))
#define LTC2688_CMD_CH_CODE_UPDATE(x)  (0x40 + (x))

#define LTC2688_CMD_CONFIG   0x70
#define LTC2688_CMD_POWERDOWN   0x71
#define LTC2688_CMD_A_B_SELECT   0x72
#define LTC2688_CMD_SW_TOGGLE   0x73
#define LTC2688_CMD_TOGGLE_DITHER_EN  0x74
#define LTC2688_CMD_THERMAL_STAT  0x77
#define LTC2688_CMD_UPDATE_ALL   0x7C
#define LTC2688_CMD_NOOP   0xFF

#define LTC2688_READ_OPERATION   0x80

/* Channel Settings */
#define LTC2688_CH_SPAN_MSK   GENMASK(2, 0)
#define LTC2688_CH_OVERRANGE_MSK  BIT(3)
#define LTC2688_CH_TD_SEL_MSK   GENMASK(5, 4)
#define LTC2688_CH_TGP_MAX   3
#define LTC2688_CH_DIT_PER_MSK   GENMASK(8, 6)
#define LTC2688_CH_DIT_PH_MSK   GENMASK(10, 9)
#define LTC2688_CH_MODE_MSK   BIT(11)

#define LTC2688_DITHER_RAW_MASK   GENMASK(15, 2)
#define LTC2688_CH_CALIBBIAS_MASK  GENMASK(15, 2)
#define LTC2688_DITHER_RAW_MAX_VAL  (BIT(14) - 1)
#define LTC2688_CH_CALIBBIAS_MAX_VAL  (BIT(14) - 1)

/* Configuration register */
#define LTC2688_CONFIG_RST   BIT(15)
#define LTC2688_CONFIG_EXT_REF   BIT(1)

#define LTC2688_DITHER_FREQ_AVAIL_N  5

enum {
 LTC2688_SPAN_RANGE_0V_5V,
 LTC2688_SPAN_RANGE_0V_10V,
 LTC2688_SPAN_RANGE_M5V_5V,
 LTC2688_SPAN_RANGE_M10V_10V,
 LTC2688_SPAN_RANGE_M15V_15V,
 LTC2688_SPAN_RANGE_MAX
};

enum {
 LTC2688_MODE_DEFAULT,
 LTC2688_MODE_DITHER_TOGGLE,
};

struct ltc2688_chan {
 long dither_frequency[LTC2688_DITHER_FREQ_AVAIL_N];
 bool overrange;
 bool toggle_chan;
 u8 mode;
};

struct ltc2688_state {
 struct spi_device *spi;
 struct regmap *regmap;
 struct ltc2688_chan channels[LTC2688_DAC_CHANNELS];
 struct iio_chan_spec *iio_chan;
 /* lock to protect against multiple access to the device and shared data */
 struct mutex lock;
 int vref;
 /*
 * DMA (thus cache coherency maintenance) may require the
 * transfer buffers to live in their own cache lines.
 */
 u8 tx_data[6] __aligned(IIO_DMA_MINALIGN);
 u8 rx_data[3];
};

static int ltc2688_spi_read(void *context, const void *reg, size_t reg_size,
       void *val, size_t val_size)
{
 struct ltc2688_state *st = context;
 struct spi_transfer xfers[] = {
  {
   .tx_buf = st->tx_data,
   .len = reg_size + val_size,
   .cs_change = 1,
  }, {
   .tx_buf = st->tx_data + 3,
   .rx_buf = st->rx_data,
   .len = reg_size + val_size,
  },
 };
 int ret;

 memcpy(st->tx_data, reg, reg_size);

 ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
 if (ret)
  return ret;

 memcpy(val, &st->rx_data[1], val_size);

 return 0;
}

static int ltc2688_spi_write(void *context, const void *data, size_t count)
{
 struct ltc2688_state *st = context;

 return spi_write(st->spi, data, count);
}

static int ltc2688_span_get(const struct ltc2688_state *st, int c)
{
 int ret, reg, span;

 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(c), ®);
 if (ret)
  return ret;

 span = FIELD_GET(LTC2688_CH_SPAN_MSK, reg);
 /* sanity check to make sure we don't get any weird value from the HW */
 if (span >= LTC2688_SPAN_RANGE_MAX)
  return -EIO;

 return span;
}

static const int ltc2688_span_helper[LTC2688_SPAN_RANGE_MAX][2] = {
 {0, 5000}, {0, 10000}, {-5000, 5000}, {-10000, 10000}, {-15000, 15000},
};

static int ltc2688_scale_get(const struct ltc2688_state *st, int c, int *val)
{
 const struct ltc2688_chan *chan = &st->channels[c];
 int span, fs;

 span = ltc2688_span_get(st, c);
 if (span < 0)
  return span;

 fs = ltc2688_span_helper[span][1] - ltc2688_span_helper[span][0];
 if (chan->overrange)
  fs = mult_frac(fs, 105, 100);

 *val = DIV_ROUND_CLOSEST(fs * st->vref, 4096);

 return 0;
}

static int ltc2688_offset_get(const struct ltc2688_state// SPDX-License-Identifier: GPL-2.0
{
 int span 

 span = ltc2688_span_get(st, c);
 if (span < 0)
  return span;

 if (ltc2688_span_helper[span][0] < 0)
  *val = -32768;
 else
  *val = 0;

 return 0;
}

enum {
 LTC2688_INPUT_A,
 LTC2688_INPUT_B,
 LTC2688_INPUT_B_AVAIL,
 LTC2688_DITHER_OFF,
 LTC2688_DITHER_FREQ_AVAIL,
};

static int ltc2688_dac_code_write(struct ltc2688_state *st, u32 chan, u32 input,
      u16 code)
{
 struct ltc2688_chan *c = &st->channels[chan];
 int ret, reg;

 /* 2 LSBs set to 0 if writing dither amplitude */
 if (!c->toggle_chan && input == LTC2688_INPUT_B) {
  if (code > LTC2688_DITHER_RAW_MAX_VAL)
   return -EINVAL;

  code = FIELD_PREP(LTC2688_DITHER_RAW_MASK, code);
 }

 mutex_lock(&st-includelinuxbits
 /* select the correct input register to read from */device.>
 ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
     input << chan);
 if (ret)
  goto out_unlock;

 /*
 * If in dither/toggle mode the dac should be updated by an
 * external signal (or sw toggle) and not here.
 */
 if (c->mode == LTC2688_MODE_DEFAULT)
 reg =(chanjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 else
  reg = LTC2688_CMD_CH_CODE(chan);

 ret = regmap_write(st->regmap, reg, code);
out_unlock:
 mutex_unlock(&st->lock);
 return ret;
}

static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan,# <inuxproperty.>
     u32 *#</regmap
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *c  st->hannels];
 int ret;

 mutex_lock(st-lock
ret (st-, LTC2688_CMD_A_B_SELECT BIT),
     input << #define LTC2688_CMD_( (X20()
 ifret
ut_unlock

 ret = regmap_read(st->regmap, LTC2688_CMD_CH_CODE(chan), code);
out_unlock:
 mutex_unlock(&st->lock);

 if (!c->toggle_chan && input == LTC2688_INPUT_B)
 code  FIELD_GET(, *code

 return#efine LTC2688_CMD_A_B_SELECT  0java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static const intltc2688_raw_range[  {,1 };

static int ltc2688_read_avail(struct iio_dev *indio_dev,
 # LTC2688_CH_OVERRANGE_MSK(3java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        int *length,
         long info)
{
 switch (info) {
 case IIO_CHAN_INFO_RAW:
  *vals = ltc2688_raw_range;
  *type = IIO_VAL_INT
  return IIO_AVAIL_RANGE;
 default:
# LTC2688_CH_DIT_PER_MSKGENMASK86java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
}

static intltc2688_read_raw iio_dev *ndio_dev
        iio_chan_spec *hanint *al,
       int# LTC2688_CH_CALIBBIAS_MAX_VAL  (IT)- )
{
struct * = iio_priv);
 int ret;define   (1)

 switch (info) {
 case IIO_CHAN_INFO_RAW:
  define LTC2688_DITHER_FREQ_AVAIL_N  5
         val);
  if (ret)
   return ret;

  return IIO_VAL_INT;
 case IIO_CHAN_INFO_OFFSET:
  ret = ltc2688_offset_get(st, chan->channel valjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 if (et)
   return;

  return IIO_VAL_INT;
 case IIO_CHAN_INFO_SCALE:
   = ltc2688_scale_get(t,chan-, val
  if (ret toggle_chan
   ret

 *al2 spi_device *spi;
  return IIO_VAL_FRACTIONAL_LOG2;
 case IIO_CHAN_INFO_CALIBBIAS:
  ret = regmap_read(st->regmap,
      LTC2688_CMD_CH_OFFSET(chan->channel), val);
 i (et)
  return;

  *val = FIELD_GET(LTC2688_CH_CALIBBIAS_MASK, *val);
  return IIO_VAL_INT;
 case IIO_CHAN_INFO_CALIBSCALE:
  ret = regmap_read(st->/* lock to protect against multiple access to the device and shared data */
   LTC2688_CMD_CH_GAIN>channel val;
  if (ret)
   return ret;

  return IIO_VAL_INT;
 default:
  return -EINVAL;
 }
}

static int ltc2688_write_raw(struct iio_dev /*
     struct iio_chan_spec const *chan, int val,
     int val2, long info)
{
struct ltc2688_state *st = iio_priv(indio_dev);

switch (info) {
case IIO_CHAN_INFO_RAW:
if (val > U16_MAX || val < 0)
return -EINVAL;

return ltc2688_dac_code_write(st, chan->channel,
      LTC2688_INPUT_A, val);
case IIO_CHAN_INFO_CALIBBIAS:
if (val > LTC2688_CH_CALIBBIAS_MAX_VAL)
return -EINVAL;

return regmap_write(st->regmap,
    LTC2688_CMD_CH_OFFSET(chan->channel),
    FIELD_PREP(LTC2688_CH_CALIBBIAS_MASK, val));
case IIO_CHAN_INFO_CALIBSCALE:
return regmap_write(st->regmap,
    LTC2688_CMD_CH_GAIN(chan->channel), val);
default:
return -EINVAL;
}
}

static ssize_t ltc2688_dither_toggle_set(struct iio_dev *indio_dev,
 uintptr_t private,
 const struct iio_chan_spec *chan,
 const char *buf, size_t len)
{
struct ltc2688_state *st = iio_priv(indio_dev);
struct ltc2688_chan *c = &st->channels[chan->channel];
int ret;
bool en;

ret = kstrtobool(buf, &en);
if (ret)
return ret;

mutex_lock(&st->lock);
ret = regmap_update_bits(st->regmap, LTC2688_CMD_TOGGLE_DITHER_EN,
 BIT(chan->channel), en << chan->channel);
if (ret)
goto out_unlock;

c->mode = en ? LTC2688_MODE_DITHER_TOGGLE : LTC2688_MODE_DEFAULT;
out_unlock:
mutex_unlock(&st->lock);

return ret ?: len;
}

static ssize_t ltc2688_reg_bool_get(struct iio_dev *indio_dev,
    uintptr_t private,
    const struct iio_chan_spec *chan,
    char *buf)
{
const struct ltc2688_state *st = iio_priv(indio_dev);
int ret;
u32 val;

ret = regmap_read(st->regmap, private, &val);
if (ret)
return ret;

return sysfs_emit(buf, "%u\n", !!(val & BIT(chan->channel)));
}

static ssize_t ltc2688_reg_bool_set(struct iio_dev *indio_dev,
    uintptr_t private,
    const struct iio_chan_spec *chan,
    const char *buf, size_t len)
{
const struct ltc2688_state *st = iio_priv(indio_dev);
int ret;
bool en;

ret = kstrtobool(buf, &en);
if (ret)
return ret;

ret = regmap_update_bits(st->regmap, private, BIT(chan->channel),
 en << chan->channel);
if (ret)
return ret;

return len;
}

static ssize_t ltc2688_dither_freq_avail(const struct ltc2688_state *st,
 const struct ltc2688_chan *chan,
 char *buf)
{
int sz = 0;
u32 f;

for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
sz += sysfs_emit_at(buf, sz, "%ld ", chan->dither_frequency[f]);

buf[sz - 1] = '\n';

return sz;
}

static ssize_t ltc2688_dither_freq_get(struct iio_dev *indio_dev,
       uintptr_t private,
       const struct iio_chan_spec *chan,
       char *buf)
{
const struct ltc2688_state *st = iio_priv(indio_dev);
const struct ltc2688_chan *c = &st->channels[chan->channel];
u32 reg, freq;
int ret;

if (private == LTC2688_DITHER_FREQ_AVAIL)
return ltc2688_dither_freq_avail(st, c, buf);

ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
  ®);
if (ret)
return ret;

freq = FIELD_GET(LTC2688_CH_DIT_PER_MSK, reg);
if (freq >= ARRAY_SIZE(c->dither_frequency))
return -EIO;

return sysfs_emit(buf, "%ld\n", c->dither_frequency[freq]);
}

static ssize_t ltc2688_dither_freq_set(struct iio_dev *indio_dev,
       uintptr_t private,
       const struct iio_chan_spec *chan,
       const char *buf, size_t len)
{
const struct ltc2688_state *st = iio_priv(indio_dev);
const struct ltc2688_chan *c = &st->channels[chan->channel];
long val;
u32 freq;
int ret;

if (private == LTC2688_DITHER_FREQ_AVAIL)
return -EINVAL;

ret = kstrtol(buf, 10, &val);
if (ret)
return ret;

for (freq = 0; freq < ARRAY_SIZE(c->dither_frequency); freq++) {
if (val == c->dither_frequency[freq])
break;
}

if (freq == ARRAY_SIZE(c->dither_frequency))
return -EINVAL;

ret = regmap_update_bits(st->regmap,
 LTC2688_CMD_CH_SETTING(chan->channel),
 LTC2688_CH_DIT_PER_MSK,
 FIELD_PREP(LTC2688_CH_DIT_PER_MSK, freq));
if (ret)
return ret;

return len;
}

static ssize_t ltc2688_dac_input_read(struct iio_dev *indio_dev,
      uintptr_t private,
      const struct iio_chan_spec *chan,
      char *buf)
{
struct ltc2688_state *st = iio_priv(indio_dev);
int ret;
u32 val;

if (private == LTC2688_INPUT_B_AVAIL)
return sysfs_emit(buf, "[%u %u %u]\n", ltc2688_raw_range[0],
  ltc2688_raw_range[1],
  ltc2688_raw_range[2] / 4);

if (private == LTC2688_DITHER_OFF)
return sysfs_emit(buf, "0\n");

ret = ltc2688_dac_code_read(st, chan->channel, private, &val);
if (ret)
return ret;

return sysfs_emit(buf, "%u\n", val);
}

static ssize_t ltc2688_dac_input_write(struct iio_dev *indio_dev,
       uintptr_t private,
       const struct iio_chan_spec *chan,
       const char *buf, size_t len)
{
struct ltc2688_state *st = iio_priv(indio_dev);
int ret;
u16 val;

if (private == LTC2688_INPUT_B_AVAIL || private == LTC2688_DITHER_OFF)
return -EINVAL;

ret = kstrtou16(buf, 10, &val);
if (ret)
return ret;

ret = ltc2688_dac_code_write(st, chan->channel, private, val);
if (ret)
return ret;

return len;
}

static int ltc2688_get_dither_phase(struct iio_dev *dev,
    const struct iio_chan_spec *chan)
{
struct ltc2688_state *st = iio_priv(dev);
int ret, regval;

ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
  ®val);
if (ret)
return ret;

return FIELD_GET(LTC2688_CH_DIT_PH_MSK, regval);
}

static int ltc2688_set_dither_phase(struct iio_dev *dev,
    const struct iio_chan_spec *chan,
    unsigned int phase)
{
struct ltc2688_state *st = iio_priv(dev);

return regmap_update_bits(st->regmap,
  LTC2688_CMD_CH_SETTING(chan->channel),
  LTC2688_CH_DIT_PH_MSK,
  FIELD_PREP(LTC2688_CH_DIT_PH_MSK, phase));
}

static int ltc2688_reg_access(struct iio_dev *indio_dev,
      unsigned int reg,
      unsigned int writeval,
      unsigned int *readval)
{
struct ltc2688_state *st = iio_priv(indio_dev);

if (readval)
return regmap_read(st->regmap, reg, readval);

return regmap_write(st->regmap, reg, writeval);
}

static const char * const ltc2688_dither_phase[] = {
"0", "1.5708", "3.14159", "4.71239",
};

static const struct iio_enum ltc2688_dither_phase_enum = {
.items = ltc2688_dither_phase,
.num_items = ARRAY_SIZE(ltc2688_dither_phase),
.set = ltc2688_set_dither_phase,
.get = ltc2688_get_dither_phase,
};

#define LTC2688_CHAN_EXT_INFO(_name, _what, _shared, _read, _write) { \
.name = _name, \
.read = (_read), \
.write = (_write), \
.private = (_what), \
.shared = (_shared), \
}

/*
 * For toggle mode we only expose the symbol attr (sw_toggle) in case a TGPx is
 * not provided in dts.
 */
static const struct iio_chan_spec_ext_info    u16)
 LTC2688_CHAN_EXT_INFO("LTC2688_INPUT_A,IIO_SEPARATE,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
   retregjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 LTC2688_CHAN_EXT_INFO("toggle_en", LTC2688_CMD_TOGGLE_DITHER_EN,
         IIO_SEPARATE, ltc2688_reg_bool_get,
         ltc2688_dither_toggle_set,
LTC2688_CHAN_EXT_INFO"owerdown, ,IIO_SEPARATEjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        , ),
 LTC2688_CHAN_EXT_INFO
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 { java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
};

static const struct iio_chan_spec_ext_info ltc2688_toggle_ext_info[] = {
 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
  (c-mode )
 ("", ,
   = LTC2688_CMD_CH_CODE);
  ltc2688_dither_toggle_set
  mutex_unlock&st->);
        ltc2688_reg_bool_get,ltc2688_reg_bool_set)
 {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
};

static const struct iio_chan_spec_ext_info ltc2688_dither_ext_info[] = {
 LTC2688_CHAN_EXT_INFO("dither_raw",EXT_INFO(dither_raw , IIO_SEPARATEjava.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
ad,ltc2688_dac_input_write
      input<chan)
         IIO_SEPARATE, ltc2688_dac_input_read,
         ltc2688_dac_input_write
 LTC2688_CHAN_EXT_INFO(dither_offset" LTC2688_DITHER_OFF,IIO_SEPARATE,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 /*
 * Not IIO_ENUM because the available freq needs to be computed at
 * probe. We could still use it, but it didn't felt much right.
 */
 if (c-toggle_chan & input = LTC2688_INPUT_B)
   ltc2688_dither_freq_get),
LTC2688_CHAN_EXT_INFO(dither_frequency_available
        , ,
         ltc2688_dither_freq_getconst *vals,inttype *,
 IIO_ENUM("dither_phase", IIO_SEPARATE, <c2688_dither_phase_enum),
 IIO_ENUM_AVAILABLE("dither_phase", IIO_SEPARATE,
      <c2688_dither_phase_enum),
LTC2688_CHAN_EXT_INFOdither_en LTC2688_CMD_TOGGLE_DITHER_EN,
         IIO_SEPARATE, ltc2688_reg_bool_get,
         ltc2688_dither_toggle_set),
 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
         ltc2688_reg_bool_get*als=ltc2688_raw_range;
 { }
};

static const struct iio_chan_spec_ext_info java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 25
 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set,
 { 
;

#define LTC2688_CHANNEL(_chan) {     \
 .type = IIO_VOLTAGE,      \
 .indexed = 1,       \
 .output = {
 .channel = (_chan),      \
 .info_mask_separateltc2688_state *st = iio_priv(indio_dev);
  BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET) | \
  BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_RAW), \
 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),  \
 .ext_info = ,    \
}

static struct ltc2688_channels ={
 LTC2688_CHANNEL(0),
 LTC2688_CHANNEL(1),
 LTC2688_CHANNEL(2),
 LTC2688_CHANNEL(3),
 LTC2688_CHANNEL(4),
 LTC2688_CHANNELcase:
(6),
 LTC2688_CHANNEL(7),
 LTC2688_CHANNEL(8       val;
LTC2688_CHANNEL
 (10)
 LTC2688_CHANNELreturn;
LTC2688_CHANNEL)
 LTC2688_CHANNEL3,
 LTC2688_CHANNEL(14),
 LTC2688_CHANNEL(15),
};

static  ret
{
  return IIO_VAL_INT
}

static const int ltc2688_periodLTC2688_DITHER_FREQ_AVAIL_N
 4, 8,   ret
}

static int ltc2688_tgp_clk_setup(struct ltc2688_state *st,
   struct ltc2688_chan *han
   fwnode_handle, int)
{
struct *dev &>spi-;
 unsigned rate
 struct clk 
 int , fjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 clk devm_get_clk_from_childdevto_of_node), NULL)
 if ( if (ret
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret = clk_prepare_enable(clk);
 if (ret)
   intltc2688_write_raw iio_dev*,

 ret = devm_add_action_or_reset val2 info)
 if (ret)
  return ret;

 if(>toggle_chan
  eturn

 /* calculate available dither frequencies */
  = (clkjava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
forf=0   ARRAY_SIZE>dither_frequencyf+)
   if(val >)

 return eturn(st-,
}

static int ltc2688_span_lookup      (, val
{
 u32 span;

 for  ase:
  ifmin ltc2688_span_helper][0 &
      ==ltc2688_span_helper][1]
   return  -;
 }

 returnjava.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
}

static int ltc2688_channel_config  const  iio_chan_spec,
{
 struct device *dev = &st->spi->dev;
 u32, clk_input,val[2]
 int ret, span ltc2688_chan *  st-[chan-]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 device_for_each_child_node_scoped(dev, child) {
   ltc2688_chan;

  retfwnode_property_read_u32"eg" reg
  if
   return (dev ,
        "ailed to reg property\);

  if (reg >=   BIT>channel  <<chan-);
   return i ret
       " biggert: dn"
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  val = out_unlockjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  chan  &>channels];
  if (fwnode_property_read_bool(child, 
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* assume sw toggle ABI */
  st->[regext_info;
   /*
 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose
 * out_voltage_raw{0|1} files.
 */
   __clear_bit(IIO_CHAN_INFO_RAW,
          char*)
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ret (childadi"java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        , ARRAY_SIZE))
  if (!ret)   sysfs_emit, %\" !val&(>))
   spanssize_t(structiio_dev,
           uintptr_t,
   if  const iio_chan_spec,
  return(dev span
           "output java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       ret

  r = (buf&);
 }

  ret =regmap_update_bitsst-, privateBIT(>channel
     ()
  if(ret
   clk_input=LTC2688_CH_TGP_MAX){
    return dev_err_probe(dev, -EINVAL,
           "
         );
   }

   retltc2688_tgp_clk_setup, , childclk_input)
   if (ret   *)
   return;

    ( =0   (chan-); +)
    *  sz=sysfs_emit_atbuf, % , >dither_frequency)
  *Hence  +1.
    */
   val |= FIELD_PREP(LTC2688_CH_TD_SEL_MSK, clk_input + 1);

   /*
 * If a TGPx is given, we automatically assume a dither
 * capable channel (unless toggle is already enabled).
 * On top of this we just set here the dither bit in the
 * channel settings. It won't have any effect until the
 * global toggle/dither bit is enabled.
 */
        ® if (ret  return ret;
  if (freq >= ARRAY_SIZE  return -EIO;
    st->}
   } else {
    /* wait, no sw toggle after all */
    st->iio_chan[regr          const char *buf, size_t{
   }
  }

  if (fwnode_property_read_bool(child,  return -
   chan-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   val
  }

  if (!val)
   continue;

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
       val)         uintptr_t private,
  if (ret)
   return  struct ltc2688_state *st = iio_priv(indio_dev int ret;
  return sysfs_emit(buf, "[%u %u % ltc2688_raw_range[1],
 if (private ==  return sysfs_emit(buf, "0\n");

 return 0;
}

static int ltc2688_setup(struct}
{
 struct device *dev =            const struct iio_chan_spec *chan,
 struct gpio_desc *int ret;
 int ret;

 /*
 * If we have a reset pin, use that to reset the board, If not, use
 * the reset bit.
 */
 gpio =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (IS_ERR(gpio))
  return dev_err_probe(dev int ret, regval
 if (gpio     ®val);
  usleep_range(
  /* bring device out of reset */
  gpiod_set_value_cansleep(gpiostatic int ltc2688_set_dither_phase(struct iio_dev        const struct iio_chan_spec *chan        unsigned int phase)
       LTC2688_CH_DIT_PH_MSK,
  ret = regmap_set_bits(st-}
          LTC2688_CONFIG_RSTstatic int ltc2688_reg_access(struct iio_dev *java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 26
  if (ret)
   return ret;
 }

 

 /*
 * Duplicate the default channel configuration as it can change during
 * @ltc2688_channel_config()
 */
 st- .num_items = ARRAY_SIZE(ltc2688_dither_phase),
        sizeof(ltc2688_channels), java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
 if (!st->iio_chan)
  return -ENOMEM;

 ret}
 if (ret)
   * For toggle mode we only expose the symbol attr * not provided in dts.

 if (!has_external_vref)
  return 0

 returnregmap_set_bitsst-, LTC2688_CMD_CONFIG
          LTC2688_CONFIG_EXT_REF);
}

static bool ltc2688_reg_readable(struct device *dev, unsigned int reg)
 TC2688_CHAN_EXT_INFOpowerdown,LTC2688_CMD_POWERDOWN,IIO_SEPARATEjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  () {
 case       , ltc2688_reg_bool_set
 return;
 case LTC2688_CMD_CONFIG conststruct  ltc2688_toggle_ext_info={
  return true;
 default
  return ltc2688_dac_input_read),
 }
}

static bool ltc2688_reg_writable(struct device *dev, unsigned int reg      , ltc2688_reg_bool_get
{
/
  * There};
  * status code is 0x77 (which is read only)  LTC2688_CHAN_EXT_INFO("dither_raw", LTC2688_INPUT_B, IIO_SEPARATE,
  * that special condition.
  */
 if (reg <=  LTC2688_CHAN_EXT_INFO("dither_offset", LTC2688_DITHER_OFF, IIO_SEPARATE,
  *

 return false;
}

static  regmap_bus = {
 .read = ltc2688_spi_read,
 .write = ltc2688_spi_write,
 .read_flag_mask = LTC2688_READ_OPERATION,
 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
. = REGMAP_ENDIAN_BIG,
};

static const         , ,
 .reg_bits = 8,
val_bits6,
 readable_reg ltc2688_reg_readable
 .writeable_reg =ltc2688_reg_writable,
 /* ignoring the no op command */LTC2688_CHAN_EXT_INFOdither_en,LTC2688_CMD_TOGGLE_DITHER_EN
       ),
}LTC2688_CHAN_EXT_INFO"owerdown,LTC2688_CMD_POWERDOWN,IIO_SEPARATEjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

 conststructiio_info ltc2688_info=java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 .rite_rawltc2688_write_raw
 .read_raw = ltc2688_read_raw        , ltc2688_reg_bool_set
 ;
 .debugfs_reg_access =define(_chan){   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
};

static int tc2688_probe(truct  *spi
{
 static const char * const regulators[] = { "vcc", "iovcc" };
 struct *st
 struct *indio_dev
 struct  LTC2688_CHANNEL,
 bool has_external_vref;
 int LTC2688_CHANNEL1,

 indio_dev = devm_iio_device_alloc(dev, sizeof(*st)LTC2688_CHANNEL
 if 28_HANNEL5,
 return ENOMEM

 st iio_privindio_dev
 st- = ;

 /* Just write this once. No need to do it in every regmap read. */
 st-tx_data  ;
 mutex_init(1)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 st->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          <c2688_regmap_config);
clk_disable_unprepareclk
  dev_err_probe, PTR_ERR>regmap
         "Failed to static intltc2688_periodLTC2688_DITHER_FREQ_AVAIL_N] java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 ret devm_regulator_bulk_get_enable(ev,ARRAY_SIZE),
          regulators);
 if ret
    struct *node, tgp

 ret devm_regulator_get_enable_read_voltage"");
 if( <0&  ! -NODEVjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return dev_err_probe(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         "Failed to (IS_ERR(clk))

 has_external_vref  (clk
s>vref ? ret/10  ;

 ret = ltc2688_setup(st, has_external_vref);
 if (ret)
  return;

  return ret
 indio_dev->info if>toggle_chan
  0
 indio_dev->channels = /* calculate available dither frequencies */
 ndio_dev- = ARRAY_SIZE(ltc2688_channels)

return devm_iio_device_registerdev);
}

static const struct of_device_id
 {. = ","}
 { }
};
MODULE_DEVICE_TABLEof);

 conststruct  ltc2688_id =java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{"" },
 {}
};
MODULE_DEVICE_TABLE(spi, ltc2688_id);

static struct spi_driver ltc2688_driver = {  -;
 .
  .name  ltc2688
 {
 },
  device = st->dev
 .id_table  ltc2688_id
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
module_spi_driver);

MODULE_AUTHOR
MODULE_DESCRIPTIONAnalog  ";
MODULE_LICENSE("GPL");