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
#include <linux/bits.  = (dev"",GPIOD_OUT_HIGH;
#include <linux.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#include <linux/device usleep_range(00,20;
#include <linux  of */
#include < gpiod_set_value_cansleepgpio)
#include <linuxelse
#include <linux/   =regmap_set_bitsst->egmap,LTC2688_CMD_CONFIGjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
#include  return;
#include <}
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/spi/spiusleep_range00,100;

#define LTC2688_DAC_CHANNELS   16

#define LTC2688_CMD_CH_CODE(x) 
#define LTC2688_CMD_CH_SETTING( /*
#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 */
 *ltc2688_channel_config
#define LTC2688_CH_OVERRANGE_MSK*
#define LTC2688_CH_TD_SEL_MSK   GENMASK>iio_chandevm_kmemdup(ev,
       sizeof(tc2688_channels) GFP_KERNEL;
#define LTC2688_CH_DIT_PER_MSKif!>iio_chan
#efine LTC2688_CH_DIT_PH_MSKGENMASK(, 9
#define LTC2688_CH_MODE_MSK   BIT(11)

#define retltc2688_channel_config);
#define LTC2688_CH_CALIBBIAS_MASK  GENMASK(15, 2)
#define LTC2688_DITHER_RAW_MAX_VAL  (BIT(14) - 1)
#define LTC2688_CH_CALIBBIAS_MAX_VAL  (BIT ret

/* Configuration register */
#define LTC2688_CONFIG_RST(has_external_vref
#define  0

#define LTC2688_DITHER_FREQ_AVAIL_N

enum {
 LTC2688_SPAN_RANGE_0V_5V regmap_set_bits(t-regmap,
 LTC2688_SPAN_RANGE_0V_10V,
 LTC2688_SPAN_RANGE_M5V_5V,
      )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 LTC2688_SPAN_RANGE_M15V_15Vstatic bool ltc2688_reg_readablestruct *devunsigned )
 LTC2688_SPAN_RANGE_MAX
};

enum {
 LTC2688_MODE_DEFAULT,
 ,
};

struct ltc2688_chan {
 c LTC2688_CMD_CH_CODE . (1)
 bool overrange;
 bool return;
 u8 mode;
;

struct ltc2688_state {
struct *spi
 struct regmap *regmap;
 struct:
 struct iio_chan_spec *iio_chan;
 /* lock to protect against multiple access to the device and shared data */
 struct mutexjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static bool ltc2688_reg_writable(truct device, unsigned  java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 70
 /*
 * DMA (thus cache coherency maintenance) may require the
 * transfer buffers to live in their own cache lines.
 */
 u8   (reg < LTC2688_CMD_UPDATE_ALL &  ! LTC2688_CMD_THERMAL_STAT)
 u8 rx_data  true
};

static
       void *val, size_t  return false
{
 
 struct spi_transfer xfers const regmap_bus = 
  {
   .tx_buf readltc2688_spi_read
   .len = reg_sizewrite,
   .cs_change = 1,
 .ead_flag_mask  ,
   .tx_buf = st->tx_data .eg_format_endian_default =REGMAP_ENDIAN_BIG,
   .rx_buf = st->rx_data,
   .len = reg_size + val_size,
  },
 };
 int ret;

 val_format_endian_default,

 ret = spi_sync_transfer;
 if (ret)
  return ret;

 memcpy

 return 0;
}

static int ltc2688_spi_write(void *context, const void * reg_bits,
{
 struct.eadable_regltc2688_reg_readable

 return spi_write(st- java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

static.ax_register =,
{
 int ret, reg

 ret = regmap_read
 if (ret)
  return staticc structiio_info ={

 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_MAXread_availltc2688_read_avail
 debugfs_reg_access,

 return span;
}

static const intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {0, 5000}, {0, 10000}, {-5000,java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 1
}

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_helperstruct *indio_dev
 if (chan->verrange)
  fs = mult_frac(fs, 105, 100);

 *val = DIV_ROUND_CLOSEST(fs * st- has_external_vref

 0
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 int span;

 span ltc2688_span_get(t,c;
 if (span < 0)
  return  return -NOMEM;

 if (ltc2688_span_helper[span][0] stiio_priv);
  *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)
{
 struct ltc2688_chan *c = &st-(&st-);
 int retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* 2 LSBs set to 0 if writing dither amplitude */
 if (!c-  &);
  if (code > java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 24
   -EINVAL

  code      Failed init)
 }

 mutex_lock(&st->lock);
 /* select the correct input register to read from */
 ret = if (ret)
     input <  return dev_err_probe(dev, ret, "Failed to enable regulators\n");
 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 = LTC2688_CMD_CH_CODE_UPDATE(chan has_external_vref = ret != -ENODEV;
 else
  reg = LTC2688_CMD_CH_CODE(chan

 ret = regmap_writep(st, has_external_vref);
out_unlock:
 mutex_unlock(&st->lock);
 return ret;
}

static int ltc2688_dac_code_read indio_dev->name = "ltc2688";
     u32 *code)
{
 struct indio_dev->channels = st->iio_chan;
 int ret;

 mutex_lockjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 0
 ret = regmap_update_bits(st-
     input << chan)static const struct of_device_id ltc2688_of_id[] = {
 if (ret { }
  goto out_unlock;

 ret = regmap_read(st-MODULE_DEVICE_TABLE(of, ltc2688_of_id);
out_unlock:
 mutex_unlock(&st->lock);

 if ( { "ltc2688" },
  *code = FIELD_GET};

 returnMODULE_DEVICE_TABLE(spi, ltc2688_id);
}

static struct spi_driver ltc2688_driver = {

static  .name = "ltc2688",
         struct iio_chan_spec },
    .probe = ltc2688_probe,
         long info .id_table = ltc2688_id,
{
 switch (info) {
 casejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  *valsMODULE_DESCRIPTION("Analog Devices LTC2688 DAC");
  *type = IIO_VAL_INT;
  return IIO_AVAIL_RANGE;
 default:
  return -EINVAL;
 }
}

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

 switch (info) {
 case IIO_CHAN_INFO_RAW:
  ret = ltc2688_dac_code_read(st, chan->channel, LTC2688_INPUT_A,
         val);
  if (ret)
   return ret;

  return IIO_VAL_INT;
 case IIO_CHAN_INFO_OFFSET:
  ret = ltc2688_offset_get(st, chan->channel, val);
  if (ret)
   return ret;

  return IIO_VAL_INT;
 case IIO_CHAN_INFO_SCALE:
  ret = ltc2688_scale_get(st, chan->channel, val);
  if (ret)
   return ret;

  *val2 = 16;
  return IIO_VAL_FRACTIONAL_LOG2;
 case IIO_CHAN_INFO_CALIBBIAS:
  ret = regmap_read(st->regmap,
      LTC2688_CMD_CH_OFFSET(chan->channel), val);
  if (ret)
   return ret;

  *val = FIELD_GET(LTC2688_CH_CALIBBIAS_MASK, *val);
  return IIO_VAL_INT;
 case IIO_CHAN_INFO_CALIBSCALE:
  ret = regmap_read(st->regmap,
      LTC2688_CMD_CH_GAIN(chan->channel), val);
  if (ret)
   return ret;

  return IIO_VAL_INT;
 default:
  return -EINVAL;
 }
}

static int ltc2688_write_raw(struct iio_dev *indio_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 ltc2688_toggle_sym_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,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 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("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 LTC2688_CHAN_EXT_INFO("symbol", LTC2688_CMD_SW_TOGGLE, IIO_SEPARATE,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 { }
};

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,
         ltc2688_dac_input_read, ltc2688_dac_input_write),
 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("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
         ltc2688_reg_bool_get, ltc2688_reg_bool_set),
 { }
};

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.
 */
 LTC2688_CHAN_EXT_INFO("dither_frequency", 0, IIO_SEPARATE,
         ltc2688_dither_freq_get, ltc2688_dither_freq_set),
 LTC2688_CHAN_EXT_INFO("dither_frequency_available",
         LTC2688_DITHER_FREQ_AVAIL, IIO_SEPARATE,
         ltc2688_dither_freq_get, ltc2688_dither_freq_set),
 IIO_ENUM("dither_phase", IIO_SEPARATE, <c2688_dither_phase_enum),
 IIO_ENUM_AVAILABLE("dither_phase", IIO_SEPARATE,
      <c2688_dither_phase_enum),
 LTC2688_CHAN_EXT_INFO("dither_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, ltc2688_reg_bool_set),
 { }
};

static const struct iio_chan_spec_ext_info ltc2688_ext_info[] = {
 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 = 1,       \
 .channel = (_chan),      \
 .info_mask_separate = BIT(IIO_CHAN_INFO_CALIBSCALE) |  \
  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 = ltc2688_ext_info,     \
}

static const struct iio_chan_spec ltc2688_channels[] = {
 LTC2688_CHANNEL(0),
 LTC2688_CHANNEL(1),
 LTC2688_CHANNEL(2),
 LTC2688_CHANNEL(3),
 LTC2688_CHANNEL(4),
 LTC2688_CHANNEL(5),
 LTC2688_CHANNEL(6),
 LTC2688_CHANNEL(7),
 LTC2688_CHANNEL(8),
 LTC2688_CHANNEL(9),
 LTC2688_CHANNEL(10),
 LTC2688_CHANNEL(11),
 LTC2688_CHANNEL(12),
 LTC2688_CHANNEL(13),
 LTC2688_CHANNEL(14),
 LTC2688_CHANNEL(15),
};

static void ltc2688_clk_disable(void *clk)
{
 clk_disable_unprepare(clk);
}

static const int ltc2688_period[LTC2688_DITHER_FREQ_AVAIL_N] = {
 4, 8, 16, 32, 64,
};

static int ltc2688_tgp_clk_setup(struct ltc2688_state *st,
     struct ltc2688_chan *chan,
     struct fwnode_handle *node, int tgp)
{
 struct device *dev = &st->spi->dev;
 unsigned long rate;
 struct clk *clk;
 int ret, f;

 clk = devm_get_clk_from_child(dev, to_of_node(node), NULL);
 if (IS_ERR(clk))
  return dev_err_probe(dev, PTR_ERR(clk), "failed to get tgp clk.\n");

 ret = clk_prepare_enable(clk);
 if (ret)
  return dev_err_probe(dev, ret, "failed to enable tgp clk.\n");

 ret = devm_add_action_or_reset(dev, ltc2688_clk_disable, clk);
 if (ret)
  return ret;

 if (chan->toggle_chan)
  return 0;

 /* calculate available dither frequencies */
 rate = clk_get_rate(clk);
 for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
  chan->dither_frequency[f] = DIV_ROUND_CLOSEST(rate, ltc2688_period[f]);

 return 0;
}

static int ltc2688_span_lookup(const struct ltc2688_state *st, int min, int max)
{
 u32 span;

 for (span = 0; span < ARRAY_SIZE(ltc2688_span_helper); span++) {
  if (min == ltc2688_span_helper[span][0] &&
      max == ltc2688_span_helper[span][1])
   return span;
 }

 return -EINVAL;
}

static int ltc2688_channel_config(struct ltc2688_state *st)
{
 struct device *dev = &st->spi->dev;
 u32 reg, clk_input, val, tmp[2];
 int ret, span;

 device_for_each_child_node_scoped(dev, child) {
  struct ltc2688_chan *chan;

  ret = fwnode_property_read_u32(child, "reg", ®);
  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(dev, "clr", GPIOD_OUT_HIGH);
 if (IS_ERR(gpio))
  return dev_err_probe(dev, PTR_ERR(gpio), "Failed to get reset gpio");
 if (gpio) {
  usleep_range(1000, 1200);
  /* bring device out of reset */
  gpiod_set_value_cansleep(gpio, 0);
 } else {
  ret = regmap_set_bits(st->regmap, LTC2688_CMD_CONFIG,
          LTC2688_CONFIG_RST);
  if (ret)
   return ret;
 }

 usleep_range(10000, 12000);

 /*
 * Duplicate the default channel configuration as it can change during
 * @ltc2688_channel_config()
 */
 st->iio_chan = devm_kmemdup(dev, ltc2688_channels,
        sizeof(ltc2688_channels), GFP_KERNEL);
 if (!st->iio_chan)
  return -ENOMEM;

 ret = ltc2688_channel_config(st);
 if (ret)
  return ret;

 if (!has_external_vref)
  return 0;

 return regmap_set_bits(st->regmap, LTC2688_CMD_CONFIG,
          LTC2688_CONFIG_EXT_REF);
}

static bool ltc2688_reg_readable(struct device *dev, unsigned int reg)
{
 switch (reg) {
 case LTC2688_CMD_CH_CODE(0) ... LTC2688_CMD_CH_GAIN(15):
  return true;
 case LTC2688_CMD_CONFIG ... LTC2688_CMD_THERMAL_STAT:
  return true;
 default:
  return false;
 }
}

static bool ltc2688_reg_writable(struct device *dev, unsigned int reg)
{
 /*
 * 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.
 */
 if (reg <= LTC2688_CMD_UPDATE_ALL && reg != LTC2688_CMD_THERMAL_STAT)
  return true;

 return false;
}

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

static const struct regmap_config ltc2688_regmap_config = {
 .reg_bits = 8,
 .val_bits = 16,
 .readable_reg = ltc2688_reg_readable,
 .writeable_reg = ltc2688_reg_writable,
 /* ignoring the no op command */
 .max_register = LTC2688_CMD_UPDATE_ALL,
};

static const struct iio_info ltc2688_info = {
 .write_raw = ltc2688_write_raw,
 .read_raw = ltc2688_read_raw,
 .read_avail = ltc2688_read_avail,
 .debugfs_reg_access = ltc2688_reg_access,
};

static int ltc2688_probe(struct spi_device *spi)
{
 static const char * const regulators[] = { "vcc", "iovcc" };
 struct ltc2688_state *st;
 struct iio_dev *indio_dev;
 struct device *dev = &spi->dev;
 bool has_external_vref;
 int ret;

 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
 if (!indio_dev)
  return -ENOMEM;

 st = iio_priv(indio_dev);
 st->spi = spi;

 /* Just write this once. No need to do it in every regmap read. */
 st->tx_data[3] = LTC2688_CMD_NOOP;
 mutex_init(&st->lock);

 st->regmap = devm_regmap_init(dev, <c2688_regmap_bus, st,
          <c2688_regmap_config);
 if (IS_ERR(st->regmap))
  return dev_err_probe(dev, PTR_ERR(st->regmap),
         "Failed to init regmap");

 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulators),
          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á ");
MODULE_DESCRIPTION("Analog Devices LTC2688 DAC");
MODULE_LICENSE("GPL");