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.
 */
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# </.h>
#include </
#include <linux/device.java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
#include <linux/  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
#include < reg =LTC2688_CMD_CH_CODE_UPDATE);
#include <linux/limits.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/mutex.h>
#include <linux/of.hjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#nclude</propertyhjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#nclude linux.h>
#include <linux/regulator/consumer.{
#include <linux/spi/spi.h>

#define LTC2688_DAC_CHANNELS   1  ltc2688_chan =&t->[chan

 mutex_lock(st->);
#define   = regmap_update_bits>regmapLTC2688_CMD_A_B_SELECT,(chan
CH_OFFSET() 0 + ()
#define LTC2688_CMD_CH_GAIN(x) ()
#define goto o;

#define LTC2688_CMD_CONFIG   0x70
#define LTC2688_CMD_POWERDOWN   *code =FIELD_GETLTC2688_DITHER_RAW_MASK);
# LTC2688_CMD_A_B_SELECT   x72
#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

#definestatic const ltc2688_raw_range[ =0,1 U16_MAX

/* Channel Settings */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define  BIT)
#define LTC2688_CH_TD_SEL_MSK   GENMASK(5, 4)
#define LTC2688_CH_TGP_MAX   3 const **vals, int *type, int 
define   (8 )
#define LTC2688_CH_DIT_PH_MSK   GENMASK(10, 9)
#define LTC2688_CH_MODE_MSK   BIT(11)

#define LTC2688_DITHER_RAW_MASK   GENMASK( }
#define static int ltc2688_read_raw (structiio_dev i,
       struct const*, int *al,
#efine LTC2688_CH_CALIBBIAS_MAX_VAL  ((14  1

/* Configuration register */
#define   ltc2688_statest (indio_dev
# LTC2688_CONFIG_EXT_REFBITjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

#,);

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,
 if (et)

struct  ret
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 boolret ltc2688_scale_get(t >channel);
 bool;
 u8   return;
};

struct  *al2 = 16;
 struct spi_device
 struct regmap  f(et)
 struct  ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/* lock to protect against multiple access to the device and shared data */
 struct mutex lock;    (chan-),val)
 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);
 {
};

static int ltc2688_spi_read(void
       void *val  if (val > U16_MAX || val   return
{
 struct   if (val > LTC2688_CH_CALIBBIAS_MAX_VAL   return -
       FIELD_PREP(LTC2688_CH_CALIBBIAS_MASK, val));
  {
   .tx_buf = st->tx_data,
   .len = reg_size + val_size,
   .cs_change case IIO_CHAN_INFO_CALIBSCALE  return regmap_write        LTC2688_CMD_CH_GAIN(chan- default:
  }, {  int  bool
   .  return ret
   mutex_lock(&st- ret = regmap_update_bits(st->regmap     BIT(chan->channel) if (ret  goto out_unlockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   .len        char{
  },
 };
 int ret;

 memcpy

 ret = spi_sync_transfer( if (ret)
 if (ret)
  return ret;

 memcpy}

 return 0;
}

static int ltc2688_spi_write(void *context  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
{
 struct ltc2688_state *      const struct ltc2688_chan *chan,

 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
{
 int ret, reg, span;

 ret  u32 reg int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 freq = FIELD_GET(LTC2688_CH_DIT_PER_MSK if (freq >= ARRAY_SIZE(c->dither_frequency  return -EIOjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return   uintptr_t private,

 span = FIELD_GET           const char *buf, size_t{
 /* sanity check to make sure we don't get any weird value from the HW */ long  u32 freq;
 if (span  ret = kstrtol(buf, 10 if (ret)
  return -EIO;

 return span;      LTC2688_CH_DIT_PER_MSK     FIELD_PREP( if (ret  return ret;
}

static const int ltc2688_span_helper[LTC2688_SPAN_RANGE_MAX          uintptr_t private,
 {0          char *buf)
};

static int ret;
{
 const  if (private == LTC2688_INPUT_B_AVAIL)
 int span, fs;

       ltc2688_raw_range[2] / 4);
 if (span if (private == LTC2688_DITHER_OFF  return sysfs_emit(
  return span;

 fs = ltc2688_span_helper[span    {
 struct ltc2688_state *st = iio_priv int ret;
   if (private == LTC2688_INPUT_B_AVAIL || private  return -EINVAL

 *val

 return 0;
}

static int ltc2688_offset_get(const struct if (ret)
{
 int span

 span = ltc2688_span_get(st, c);
 if (span <
  return return FIELD_GET(LTC2688_CH_DIT_PH_MSK, regval}

 if (ltc2688_span_helper[span        const struct iio_chan_spec *chan,
  *val = -3276java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  *val = 0;

 return 0;
}

enum {
 LTC2688_INPUT_A,
 LTC2688_INPUT_B,
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 LTC2688_DITHER_OFF, .items = ltc2688_dither_phase .num_items = ARRAY_SIZE(ltc2688_dither_phase .set = ltc2688_set_dither_phase .get = ltc2688_get_dither_phase,
 LTC2688_DITHER_FREQ_AVAIL,
};

static int ltc2688_dac_code_write(struct  * not
    code
{
 struct ltc2688_chan *c = & LTC2688_CHAN_EXT_INFO(raw0, LTC2688_INPUT_A java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
int, reg;

 /* 2 LSBs set to 0 if writing dither amplitude */
 if (!c->toggle_chan),
   ("owerdown" LTC2688_CMD_POWERDOWN ,
   return -EINVAL;

  code = FIELD_PREP(LTC2688_DITHER_RAW_MASK, code);
 }

          ltc2688_reg_bool_getltc2688_reg_bool_set
 /* select the correct input register to read from */
 ret = regmap_update_bits}
     input << chan);
 if (ret)
  gotojava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 * If in dither/toggle mode the dac should be updated by an
 * external signal (or sw toggle) and not here.
 */
if> ==LTC2688_MODE_DEFAULT
  regLTC2688_CHAN_EXT_INFOtoggle_en, LTC2688_CMD_TOGGLE_DITHER_EN
 else
 reg (chan

       ),
out_unlock:
 mutex_unlock(st->ock
 return ret        ltc2688_reg_bool_get,ltc2688_reg_bool_set,
}

static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan, u32 input,
     u32 *code"dither_raw",LTC2688_INPUT_BIIO_SEPARATE,
{
 struct ltc2688_chan *c = &st->channels[chan];
 int ret;

 mutex_lock(&st->lock);
 ret = regmap_update_bits( ret = regmap_update_bits(st- ),
     <<chan)
 if (ret)
  goto out_unlock;

 ret = regmap_readLTC2688_CHAN_EXT_INFO(dither_offset" ,IIO_SEPARATE,
out_unlock:
 mutex_unlock(  *

if (c->oggle_chan & input= LTC2688_INPUT_B)
  *code = FIELD_GET(LTC2688_DITHER_RAW_MASK, *code);

 return ret;
}

static         , ltc2688_dither_freq_set

 LTC2688_CHAN_EXT_INFO"",
         struct LTC2688_DITHER_FREQ_AVAILIIO_SEPARATE
          int*vals, *, intlength
         long info)
{
 ("",LTC2688_CMD_TOGGLE_DITHER_ENjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 case IIO_CHAN_INFO_RAW:
  *als  ltc2688_raw_rangejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  *type = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  return IIO_AVAIL_RANGE;
 default:
  return -EINVAL;
 }
),

static}
       struct}
       int java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct ltc2688_ext_info 
 int ret

 switch (info const iio_chan_spec[] = java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  IIO_CHAN_INFO_RAW
   LTC2688_CHANNELjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
       val)
   (9),
   returnLTC2688_CHANNEL)

   IIO_VAL_INT
 case IIO_CHAN_INFO_OFFSET (12)
  ret(13java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
  if()
   return ret;

;
 case IIO_CHAN_INFO_SCALE:
  ret
  if (ret)static const intltc2688_period[] = {
  return;

 }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 case IIO_CHAN_INFO_CALIBBIAS:
    struct ltc2688_chan *,
         struct *node tgp
  if  device =st->dev
   return ret long;

  *intret;
  return IIO_VAL_INT;
 case IIO_CHAN_INFO_CALIBSCALE:
  ret = regmap_read(st->regmap,
      LTC2688_CMD_CH_GAIN =devm_get_clk_from_child(, (node NULL)
)
   return ret;

  return IIO_VAL_INT;
 default:
  return -java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 }
}

atic (structiio_dev indio_dev
        struct iio_chan_spec const
        int, longinfojava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 struct ltc2688_state chan-)

  r 0;
 case IIO_CHAN_INFO_RAW
  /* calculate available dither frequencies */
   returnrateclk_get_rate);

  return ltc2688_dac_code_write(st, chan->channel,
      (  ;f <(chan-); f+)
 case IIO_CHAN_INFO_CALIBBIAS:
  (val >LTC2688_CH_CALIBBIAS_MAX_VAL
   return

 r regmap_write>regmap
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      FIELD_PREPLTC2688_CH_CALIBBIAS_MASK));
c IIO_CHAN_INFO_CALIBSCALE
  return regmap_write ( ==[span0&
          max [span]
 default:
 returnEINVAL
 }
}

static ssize_t ltc2688_dither_toggle_set(struct iio_dev *indio_dev,
     java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    const struct *chan
      const char *bufjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct ltc2688_state *st = iio_priv regclk_input,, tmp;
 structltc2688_chan * =&>channels>channel;
 int ret;
 bool en;

 ret = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 if (retstruct *chan
  return ret   = (child, "eg" &);

 mutex_lock(&st-returndev_err_probe,ret
 ret       Failedgetpropertyn"java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    (chan-),en >channeljava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 f()
  goto out_unlock        reg han%\"

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

 returnchan=st-[regjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1

static ssize_t ltc2688_reg_bool_get(struct iio_dev *indio_dev,
        uintptr_t  st->io_chan]. = ltc2688_toggle_sym_ext_info
        const struct    * Clear IIO_CHAN_INFO_RAW bit as toggle    * out_voltage_raw{0|1} files.
      char buf
{
 const struct   }
 int ret;
 u32 val;

 ret = regmap_read(st->regmap =fwnode_property_read_u32_array, ",output-range-microvolt,
 if (ret)
  return ret    tmp(tmp;

return(buf"un,!( &BITchan-channel);
}

static  ltc2688_reg_bool_setstruct  *indio_dev
        private
       struct *chan
        const char     dev_err_probe,,
{
 const struct ltc2688_state *st = iio_priv(indio_dev);
int;
 bool en;

 et kstrtobool, en
 if (ret 
  return ret;

 ret regmap_update_bits(>regmap, BITchan-),
     en << chan->channel);
ifret
  return ret !) {

 return if( > LTC2688_CH_TGP_MAX java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

static ssize_t ltc2688_dither_freq_avail(const struct   clk_input
      const   = (stchan, clk_input)
     charbuf
{
 int sz  ret
 u32 f;

 for(  0f<ARRAY_SIZE>dither_frequencyf+
  + sysfs_emit_at(, sz"ld"chan-[f];

   *Hencethejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 return
}

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 ltc2688_toggle_sym_ext_info
 LTC2688_CHAN_EXT_INFO(return 0
  
 LTC2688_CHAN_EXT_INFO (>regmap,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 LTC2688_CHAN_EXT_INFO("toggle_en"
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         ltc2688_dither_toggle_set),
L("",LTC2688_CMD_POWERDOWN,IIO_SEPARATE,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 LTC2688_CHAN_EXT_INFO("symbol", LTC2688_CMD_SW_TOGGLE,switchreg
  ltc2688_reg_bool_get),
 { }
};  true

static struct iio_chan_spec_ext_info[]  java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,:
        , ltc2688_dac_input_write
 LTC2688_CHAN_EXT_INFO
         ltc2688_dac_input_read
 LTC2688_CHAN_EXT_INFO("toggle_en",java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   IIO_SEPARATE,
         ltc2688_dither_toggle_set),
 LTC2688_CHAN_EXT_INFO("powerdown",{
    /*
{ }
};

static const struct iio_chan_spec_ext_info ltc2688_dither_ext_info[] = {
LTC2688_CHAN_EXT_INFO("dither_raw", LTC2688_INPUT_B, IIO_SEPARATE,
      ltc2688_dac_input_read, ltc2688_dac_input_write),
LTC2688_CHAN_EXT_INFO("dither_raw_available", LTC2688_INPUT_B_AVAIL,
      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.
 */
 conststruct ltc2688_regmap_busjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
          val_format_endian_defaultREGMAP_ENDIAN_BIG,
 LTC2688_CHAN_EXT_INFO("dither_frequency_available",
  LTC2688_DITHER_FREQ_AVAILIIO_SEPARATE
         ltc2688_dither_freq_get, ltc2688_dither_freq_set),
  . = 1,
 . =,
      <c2688_dither_phase_enumwriteable_reg =ltc2688_reg_writable,
 ("",,
         IIO_SEPARATE, ltc2688_reg_bool_get,
  ltc2688_dither_toggle_set
 ("owerdown"  ,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 { }
};

static const struct iio_chan_spec_ext_infostatic  iio_infoltc2688_info  {
 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE. = ,
        ltc2688_reg_bool_get),
 { }
}

# LTC2688_CHANNELchan     \
 .type = IIO_VOLTAGE,      \
 .indexed = 1,       \
 .output intltc2688_probe(tructspi_device)
 .channel = (_chan),  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 .info_mask_separate = BIT(IIO_CHAN_INFO_CALIBSCALE) |  \
  BIT ltc2688_state;
  BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_RAW), \
 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),  \
 .ext_info = ltc2688_ext_info,     \
}

static iio_dev;
(0)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 LTC2688_CHANNEL()
 LTC2688_CHANNEL(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (3),
 LTC2688_CHANNEL(4),
28_HANNEL()
 LTC2688_CHANNEL return-;
 LTC2688_CHANNEL(
 LTC2688_CHANNEL =iio_priv();
 LTC2688_CHANNEL>spispi
 LTC2688_CHANNEL
 LTC2688_CHANNELjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 LTC2688_CHANNEL>[3]=LTC2688_CMD_NOOP
 LTC2688_CHANNEL3,
 LTC2688_CHANNEL(14),
 LTC2688_CHANNEL(15),
};

static void ltc2688_clk_disable(void *clk)
{
 clk_disable_unprepare();
 return(dev(st-),

 const []={
 4, 8, 16, 32, 64,
};

static int ltc2688_tgp_clk_setup =devm_regulator_bulk_get_enable(ev (regulators
     struct ltc2688_chan()
    fwnode_handlenode,int)
{
 struct device *dev =(dev, vref
 unsigned long ret  &ret=-NODEV)
 struct clk *clk;
 int ret, f;

 clk = devm_get_clk_from_child(dev, to_of_node(node), NULL);
ifIS_ERR)
  return dev_err_probe(dev

 ret=clk_prepare_enable);
  t- = has_external_vrefret  00:0
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

 ret = devm_add_action_or_reset ret
 if (ret)
 ;

  (chan-)
 return;

 /* calculate available dither frequencies */
 rate = clk_get_ratei>num_channels ARRAY_SIZE(ltc2688_channels;
 
 return devm_iio_device_register(, indio_dev

 return
}

static int ltc2688_span_lookup(const struct ltc2688_state compatible"diltc2688 ,
{
 u32MODULE_DEVICE_TABLE(, ltc2688_of_id

 for (spanstatic structspi_device_id[] ={
  if (min == ltc2688_span_helper[span][0] &&
   ltc2688
     java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 }

 returnEINVAL
}

staticname="",
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *dev&>spi-;
 u32id_table=,
 int;

 device_for_each_child_node_scoped(dev,(ltc2688_driver
  struct ltc2688_chan *chan;

  ret(" DevicesLTC2688DAC"java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  if (ret)
   return dev_err_probe(dev, ret,
          "Failed to get reg property\n");

  if (reg >= LTC2688_DAC_CHANNELS)
   return dev_err_probe(dev, -EINVAL,
          "reg bigger than: %d\n",
          LTC2688_DAC_CHANNELS);

  val = 0;
  chan = &st->channels[reg];
  if (fwnode_property_read_bool(child, "adi,toggle-mode")) {
   chan->toggle_chan = true;
   /* assume sw toggle ABI */
   st->iio_chan[reg].ext_info = ltc2688_toggle_sym_ext_info;
   /*
 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose
 * out_voltage_raw{0|1} files.
 */
   __clear_bit(IIO_CHAN_INFO_RAW,
        &st->iio_chan[reg].info_mask_separate);
  }

  ret = fwnode_property_read_u32_array(child, "adi,output-range-microvolt",
           tmp, ARRAY_SIZE(tmp));
  if (!ret) {
   span = ltc2688_span_lookup(st, (int)tmp[0] / 1000,
         tmp[1] / 1000);
   if (span < 0)
    return dev_err_probe(dev, span,
           "output range not valid:[%d %d]\n",
           tmp[0], tmp[1]);

   val |= FIELD_PREP(LTC2688_CH_SPAN_MSK, span);
  }

  ret = fwnode_property_read_u32(child, "adi,toggle-dither-input",
            &clk_input);
  if (!ret) {
   if (clk_input >= LTC2688_CH_TGP_MAX) {
    return dev_err_probe(dev, -EINVAL,
           "toggle-dither-input inv value(%d)\n",
           clk_input);
   }

   ret = ltc2688_tgp_clk_setup(st, chan, child, clk_input);
   if (ret)
    return ret;

   /*
 * 0 means software toggle which is the default mode.
 * Hence the +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 (!chan->toggle_chan) {
    val |= FIELD_PREP(LTC2688_CH_MODE_MSK, 1);
    st->iio_chan[reg].ext_info = ltc2688_dither_ext_info;
   } else {
    /* wait, no sw toggle after all */
    st->iio_chan[reg].ext_info = ltc2688_toggle_ext_info;
   }
  }

  if (fwnode_property_read_bool(child, "adi,overrange")) {
   chan->overrange = true;
   val |= LTC2688_CH_OVERRANGE_MSK;
  }

  if (!val)
   continue;

  ret = regmap_write(st->regmap, LTC2688_CMD_CH_SETTING(reg),
       val);
  if (ret)
   return dev_err_probe(dev, ret,
          "failed to set chan settings\n");
 }

 return 0;
}

static int ltc2688_setup(struct ltc2688_state *st, bool has_external_vref)
{
 struct device *dev = &st->spi->dev;
 struct gpio_desc *gpio;
 int ret;

 /*
 * If we have a reset pin, use that to reset the board, If not, use
 * the reset bit.
 */
gpio devm_gpiod_get_optional, clr GPIOD_OUT_HIGH)
 ifinclude/clk>
  return dev_err_probe(dev, PTR_ERR(gpio), "Failed to get reset gpio");
 if (gpio) {
  usleep_range10 10)
ceout reset
 gpiod_set_value_cansleep(, 0;
 }  {
 ret regmap_set_bits(t->egmap LTC2688_CMD_CONFIG,
          LTC2688_CONFIG_RST);
  if (ret)
   ret
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 (100 200java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

/
  * Duplicate #define LTC2688_CMD_CH_GAIN(x)#define LTC2688_CMD_CH_CODE_UPDATE(x) 
 *@()
  /
 st- = devm_kmemdupd, ltc2688_channels
       sizeof(tc2688_channels) GFP_KERNEL)
  (!t-)
  return #    GENMASK10)

  = (stjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 if (ret)
  return;

 if !)
  return;

 returnregmap_set_bits(t->, LTC2688_CMD_CONFIG
   LTC2688_CONFIG_EXT_REF;
}

static bool ltc2688_reg_readable( device,  intreg
{
 switchLTC2688_MODE_DITHER_TOGGLE
 ase(0)..LTC2688_CMD_CH_GAIN5:
   true
 }
  spi_device;
 default
  return/
 }
}

static bool ltc2688_reg_writable(truct  *devunsignedintreg)
{
 /*
 * There's a jump from 0x76 to 0x78 in the write codes and the thermal
 * status code is 0x77 (which is read only) so that we need to check
 * that special condition.
 */
ifreg < LTC2688_CMD_UPDATE_ALL & reg= LTC2688_CMD_THERMAL_STAT)
  return;

return ;
}

static struct ltc2688_regmap_bus{
. = ,
 . = ltc2688_spi_write
 .ead_flag_mask =LTC2688_READ_OPERATION
 .eg_format_endian_default  REGMAP_ENDIAN_BIGjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
. = REGMAP_ENDIAN_BIG
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
. = 8
 .val_bits = 16,
 . = ,
.writeable_reg = ltc2688_reg_writable,
 /* ignoring the no op command */
 .ax_register  LTC2688_CMD_UPDATE_ALL
};

static onst  ltc2688_info 
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .read_raw = ltc2688_read_raw,
 . = ,
. = ltc2688_reg_access
}

static int ltc2688_probe(struct spi_device *spi)
{
 static const char * const regulators[] = { }
 struct ltc2688_state *st;
  iio_dev;
 struct devicechan->verrangejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 bool;
 int rn;

 indio_dev 
 if (! =ltc2688_span_get(t )
 return -NOMEM;

  = (indio_devjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

 /* Just write this once. No need to do it in every regmap read. */LTC2688_DITHER_FREQ_AVAILjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 st->tx_data[     code
 mutex_init>lock

 st->regmap = devm_regmap_init(devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ltc2688_regmap_config
 if (IS_ERR(st->regmap))
  return;
    " to init regmap";

 ret
     regulators);
if (ret)
return dev_err_probe(dev, ret, "Failed to enable regulators\n");

ret = devm_regulator_get_enable_read_voltage(dev, "vref");
if (ret < 0 && ret != -ENODEV)
return dev_err_probe(dev, ret,
     "Failed to get vref regulator voltage\n");

has_external_vref = ret != -ENODEV;
st->vref = has_external_vref ? ret / 1000 : 0;

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

indio_dev->name = "ltc2688";
indio_dev->info = <c2688_info;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = st->iio_chan;
indio_dev->num_channels = ARRAY_SIZE(ltc2688_channels);

return devm_iio_device_register(dev, indio_dev);
}

static const struct of_device_id ltc2688_of_id[] = {
{ .compatible = "adi,ltc2688" },
{ }
};
MODULE_DEVICE_TABLE(of, ltc2688_of_id);

static const struct spi_device_id ltc2688_id[] = {
{ "ltc2688" },
{ }
};
MODULE_DEVICE_TABLE(spi, ltc2688_id);

static struct spi_driver ltc2688_driver = {
.driver = {
.name = "ltc2688",
.of_match_table = ltc2688_of_id,
},
.probe = ltc2688_probe,
.id_table = ltc2688_id,
};
module_spi_driver(ltc2688_driver);

MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
MODULE_DESCRIPTION("Analog Devices LTC2688 DAC");
MODULE_LICENSE("GPL");