Quelle  ad8460.c

// SPDX-License-Identifier: GPL-2.0
/*
 * AD8460 Waveform generator DAC Driver
 *
 * Copyright (C) 2024 Analog Devices, Inc.
 */

#include <linux/bitfield.h>
#include <linux/cleanup.h>
#include <linux/clk.h>
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/dmaengine.h>
#include <linux/gpio/consumer.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/spi/spi.h>

#include <linux/iio/buffer.h>
#include <linux/iio/buffer-dma.h>
#include <linux/iio/buffer-dmaengine.h>
#include <linux/iio/consumer.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>

#define AD8460_CTRL_REG(x)   (x)
#define AD8460_HVDAC_DATA_WORD(x)  (0x60 + (2 * (x)))

#define AD8460_HV_RESET_MSK   BIT(7)
#define AD8460_HV_SLEEP_MSK   BIT(4)
#define AD8460_WAVE_GEN_MODE_MSK  BIT(0)

#define AD8460_HVDAC_SLEEP_MSK   BIT(3)

#define AD8460_FAULT_ARM_MSK   BIT(7)
#define AD8460_FAULT_LIMIT_MSK   GENMASK(6, 0)

#define AD8460_APG_MODE_ENABLE_MSK  BIT(5)
#define AD8460_PATTERN_DEPTH_MSK  GENMASK(3, 0)

#define AD8460_QUIESCENT_CURRENT_MSK  GENMASK(7, 0)

#define AD8460_SHUTDOWN_FLAG_MSK  BIT(7)

#define AD8460_DATA_BYTE_LOW_MSK  GENMASK(7, 0)
#define AD8460_DATA_BYTE_HIGH_MSK  GENMASK(5, 0)
#define AD8460_DATA_BYTE_FULL_MSK  GENMASK(13, 0)

#define AD8460_DEFAULT_FAULT_PROTECT  0x00
#define AD8460_DATA_BYTE_WORD_LENGTH  2
#define AD8460_NUM_DATA_WORDS   16
#define AD8460_NOMINAL_VOLTAGE_SPAN  80
#define AD8460_MIN_EXT_RESISTOR_OHMS  2000
#define AD8460_MAX_EXT_RESISTOR_OHMS  20000
#define AD8460_MIN_VREFIO_UV   120000
#define AD8460_MAX_VREFIO_UV   1200000
#define AD8460_ABS_MAX_OVERVOLTAGE_UV  55000000
#define AD8460_ABS_MAX_OVERCURRENT_UA  1000000
#define AD8460_MAX_OVERTEMPERATURE_MC  150000
#define AD8460_MIN_OVERTEMPERATURE_MC  20000
#define AD8460_CURRENT_LIMIT_CONV(x)  ((x) / 15625)
#define AD8460_VOLTAGE_LIMIT_CONV(x)  ((x) / 1953000)
#define AD8460_TEMP_LIMIT_CONV(x)  (((x) + 266640) / 6510)

enum ad8460_fault_type {
 AD8460_OVERCURRENT_SRC,
 AD8460_OVERCURRENT_SNK,
 AD8460_OVERVOLTAGE_POS,
 AD8460_OVERVOLTAGE_NEG,
 AD8460_OVERTEMPERATURE,
};

struct ad8460_state {
 struct spi_device *spi;
 struct regmap *regmap;
 struct iio_channel *tmp_adc_channel;
 struct clk *sync_clk;
 /* lock to protect against multiple access to the device and shared data */
 struct mutex lock;
 int refio_1p2v_mv;
 u32 ext_resistor_ohms;
 /*
 * DMA (thus cache coherency maintenance) requires the
 * transfer buffers to live in their own cache lines.
 */
 __le16 spi_tx_buf __aligned(IIO_DMA_MINALIGN);
};

static int ad8460_hv_reset(struct ad8460_state *state)
{
 int ret;

 ret = regmap_set_bits(state->regmap, AD8460_CTRL_REG(0x00),
         AD8460_HV_RESET_MSK);
 if (ret)
  return ret;

 fsleep(20);

 return regmap_clear_bits(state->regmap, AD8460_CTRL_REG(0x00),
     AD8460_HV_RESET_MSK);
}

static int ad8460_reset(const struct ad8460_state *state)
{
 struct device *dev = &state->spi->dev;
 struct gpio_desc *reset;

 reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
 if (IS_ERR(reset))
  return dev_err_probe(dev, PTR_ERR(reset),
         "Failed to get reset gpio");
 if (reset) {
  /* minimum duration of 10ns */
  ndelay(10);
  gpiod_set_value_cansleep(reset, 1);
  return 0;
 }

 /* bring all registers to their default state */
 return regmap_write(state->regmap, AD8460_CTRL_REG(0x03), 1);
}

static int ad8460_enable_apg_mode(struct ad8460_state *state, int val)
{
 int ret;

 ret = regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x02),
     AD8460_APG_MODE_ENABLE_MSK,
     FIELD_PREP(AD8460_APG_MODE_ENABLE_MSK, val));
 if (ret)
  return ret;

 return regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x00),
      AD8460_WAVE_GEN_MODE_MSK,
      FIELD_PREP(AD8460_WAVE_GEN_MODE_MSK, val));
}

static int ad8460_read_shutdown_flag(struct ad8460_state *state, u64 *flag)
{
 int ret, val;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x0E), &val);
 if (ret)
  return ret;

 *flag = FIELD_GET(AD8460_SHUTDOWN_FLAG_MSK, val);
 return 0;
}

static int ad8460_get_hvdac_word(struct ad8460_state *state, int index, int *val)
{
 int ret;

 ret = regmap_bulk_read(state->regmap, AD8460_HVDAC_DATA_WORD(index),
          &state->spi_tx_buf, AD8460_DATA_BYTE_WORD_LENGTH);
 if (ret)
  return ret;

 *val = le16_to_cpu(state->spi_tx_buf);

 return ret;
}

static int ad8460_set_hvdac_word(struct ad8460_state *state, int index, int val)
{
 state->spi_tx_buf = cpu_to_le16(FIELD_PREP(AD8460_DATA_BYTE_FULL_MSK, val));

 return regmap_bulk_write(state->regmap, AD8460_HVDAC_DATA_WORD(index),
     &state->spi_tx_buf, AD8460_DATA_BYTE_WORD_LENGTH);
}

static ssize_t ad8460_dac_input_read(struct iio_dev *indio_dev, uintptr_t private,
         const struct iio_chan_spec *chan, char *buf)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 unsigned int reg;
 int ret;

 ret = ad8460_get_hvdac_word(state, private, ®);
 if (ret)
  return ret;

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

static ssize_t ad8460_dac_input_write(struct iio_dev *indio_dev, uintptr_t private,
          const struct iio_chan_spec *chan,
          const char *buf, size_t len)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 unsigned int reg;
 int ret;

 ret = kstrtou32(buf, 10, ®);
 if (ret)
  return ret;

 guard(mutex)(&state->lock);

 return ad8460_set_hvdac_word(state, private, reg);
}

static ssize_t ad8460_read_symbol(struct iio_dev *indio_dev, uintptr_t private,
      const struct iio_chan_spec *chan, char *buf)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 unsigned int reg;
 int ret;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x02), ®);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%lu\n", FIELD_GET(AD8460_PATTERN_DEPTH_MSK, reg));
}

static ssize_t ad8460_write_symbol(struct iio_dev *indio_dev, uintptr_t private,
       const struct iio_chan_spec *chan,
       const char *buf, size_t len)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 uint16_t sym;
 int ret;

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

 guard(mutex)(&state->lock);

 return regmap_update_bits(state->regmap,
      AD8460_CTRL_REG(0x02),
      AD8460_PATTERN_DEPTH_MSK,
      FIELD_PREP(AD8460_PATTERN_DEPTH_MSK, sym));
}

static ssize_t ad8460_read_toggle_en(struct iio_dev *indio_dev, uintptr_t private,
         const struct iio_chan_spec *chan, char *buf)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 unsigned int reg;
 int ret;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x02), ®);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%ld\n", FIELD_GET(AD8460_APG_MODE_ENABLE_MSK, reg));
}

static ssize_t ad8460_write_toggle_en(struct iio_dev *indio_dev, uintptr_t private,
          const struct iio_chan_spec *chan,
          const char *buf, size_t len)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 bool toggle_en;
 int ret;

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

 if (!iio_device_claim_direct(indio_dev))
  return -EBUSY;

 ret = ad8460_enable_apg_mode(state, toggle_en);
 iio_device_release_direct(indio_dev);
 return ret;
}

static ssize_t ad8460_read_powerdown(struct iio_dev *indio_dev, uintptr_t private,
         const struct iio_chan_spec *chan, char *buf)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 unsigned int reg;
 int ret;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x01), ®);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%ld\n", FIELD_GET(AD8460_HVDAC_SLEEP_MSK, reg));
}

static ssize_t ad8460_write_powerdown(struct iio_dev *indio_dev, uintptr_t private,
          const struct iio_chan_spec *chan,
          const char *buf, size_t len)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 bool pwr_down;
 u64 sdn_flag;
 int ret;

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

 guard(mutex)(&state->lock);

 /*
 * If powerdown is set, HVDAC is enabled and the HV driver is
 * enabled via HV_RESET in case it is in shutdown mode,
 * If powerdown is cleared, HVDAC is set to shutdown state
 * as well as the HV driver. Quiescent current decreases and ouput is
 * floating (high impedance).
 */

 ret = regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x01),
     AD8460_HVDAC_SLEEP_MSK,
     FIELD_PREP(AD8460_HVDAC_SLEEP_MSK, pwr_down));
 if (ret)
  return ret;

 if (!pwr_down) {
  ret = ad8460_read_shutdown_flag(state, &sdn_flag);
  if (ret)
   return ret;

  if (sdn_flag) {
   ret = ad8460_hv_reset(state);
   if (ret)
    return ret;
  }
 }

 ret = regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x00),
     AD8460_HV_SLEEP_MSK,
     FIELD_PREP(AD8460_HV_SLEEP_MSK, !pwr_down));
 if (ret)
  return ret;

 return len;
}

static const char * const ad8460_powerdown_modes[] = {
 "three_state",
};

static int ad8460_get_powerdown_mode(struct iio_dev *indio_dev,
         const struct iio_chan_spec *chan)
{
 return 0;
}

static int ad8460_set_powerdown_mode(struct iio_dev *indio_dev,
         const struct iio_chan_spec *chan,
         unsigned int type)
{
 return 0;
}

static int ad8460_set_sample(struct ad8460_state *state, int val)
{
 int ret;

 ret = ad8460_enable_apg_mode(state, 1);
 if (ret)
  return ret;

 guard(mutex)(&state->lock);
 ret = ad8460_set_hvdac_word(state, 0, val);
 if (ret)
  return ret;

 return regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x02),
      AD8460_PATTERN_DEPTH_MSK,
      FIELD_PREP(AD8460_PATTERN_DEPTH_MSK, 0));
}

static int ad8460_set_fault_threshold(struct ad8460_state *state,
          enum ad8460_fault_type fault,
          unsigned int threshold)
{
 return regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x08 + fault),
      AD8460_FAULT_LIMIT_MSK,
      FIELD_PREP(AD8460_FAULT_LIMIT_MSK, threshold));
}

static int ad8460_get_fault_threshold(struct ad8460_state *state,
          enum ad8460_fault_type fault,
          unsigned int *threshold)
{
 unsigned int val;
 int ret;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x08 + fault), &val);
 if (ret)
  return ret;

 *threshold = FIELD_GET(AD8460_FAULT_LIMIT_MSK, val);

 return ret;
}

static int ad8460_set_fault_threshold_en(struct ad8460_state *state,
      enum ad8460_fault_type fault, bool en)
{
 return regmap_update_bits(state->regmap, AD8460_CTRL_REG(0x08 + fault),
      AD8460_FAULT_ARM_MSK,
      FIELD_PREP(AD8460_FAULT_ARM_MSK, en));
}

static int ad8460_get_fault_threshold_en(struct ad8460_state *state,
      enum ad8460_fault_type fault, bool *en)
{
 unsigned int val;
 int ret;

 ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x08 + fault), &val);
 if (ret)
  return ret;

 *en = FIELD_GET(AD8460_FAULT_ARM_MSK, val);

 return 0;
}

static int ad8460_write_raw(struct iio_dev *indio_dev,
       struct iio_chan_spec const *chan, int val, int val2,
       long mask)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int ret;

 switch (mask) {
 case IIO_CHAN_INFO_RAW:
  switch (chan->type) {
  case IIO_VOLTAGE:
   if (!iio_device_claim_direct(indio_dev))
    return -EBUSY;
   ret = ad8460_set_sample(state, val);
   iio_device_release_direct(indio_dev);
   return ret;
  case IIO_CURRENT:
   return regmap_write(state->regmap, AD8460_CTRL_REG(0x04),
         FIELD_PREP(AD8460_QUIESCENT_CURRENT_MSK, val));
  default:
   return -EINVAL;
  }
 default:
  return -EINVAL;
 }
}

static int ad8460_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
      int *val, int *val2, long mask)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int data, ret;

 switch (mask) {
 case IIO_CHAN_INFO_RAW:
  switch (chan->type) {
  case IIO_VOLTAGE:
   scoped_guard(mutex, &state->lock) {
    ret = ad8460_get_hvdac_word(state, 0, &data);
    if (ret)
     return ret;
   }
   *val = data;
   return IIO_VAL_INT;
  case IIO_CURRENT:
   ret = regmap_read(state->regmap, AD8460_CTRL_REG(0x04),
       &data);
   if (ret)
    return ret;
   *val = data;
   return IIO_VAL_INT;
  case IIO_TEMP:
   ret = iio_read_channel_raw(state->tmp_adc_channel, &data);
   if (ret)
    return ret;
   *val = data;
   return IIO_VAL_INT;
  default:
   return -EINVAL;
  }
 case IIO_CHAN_INFO_SAMP_FREQ:
  *val = clk_get_rate(state->sync_clk);
  return IIO_VAL_INT;
 case IIO_CHAN_INFO_SCALE:
  /*
 * vCONV = vNOMINAL_SPAN * (DAC_CODE / 2**14) - 40V
 * vMAX  = vNOMINAL_SPAN * (2**14 / 2**14) - 40V
 * vMIN  = vNOMINAL_SPAN * (0 / 2**14) - 40V
 * vADJ  = vCONV * (2000 / rSET) * (vREF / 1.2)
 * vSPAN = vADJ_MAX - vADJ_MIN
 * See datasheet page 49, section FULL-SCALE REDUCTION
 */
  *val = AD8460_NOMINAL_VOLTAGE_SPAN * 2000 * state->refio_1p2v_mv;
  *val2 = state->ext_resistor_ohms * 1200;
  return IIO_VAL_FRACTIONAL;
 default:
  return -EINVAL;
 }
}

static int ad8460_select_fault_type(int chan_type, enum iio_event_direction dir)
{
 switch (chan_type) {
 case IIO_VOLTAGE:
  switch (dir) {
  case IIO_EV_DIR_RISING:
   return AD8460_OVERVOLTAGE_POS;
  case IIO_EV_DIR_FALLING:
   return AD8460_OVERVOLTAGE_NEG;
  default:
   return -EINVAL;
  }
 case IIO_CURRENT:
  switch (dir) {
  case IIO_EV_DIR_RISING:
   return AD8460_OVERCURRENT_SRC;
  case IIO_EV_DIR_FALLING:
   return AD8460_OVERCURRENT_SNK;
  default:
   return -EINVAL;
  }
 case IIO_TEMP:
  switch (dir) {
  case IIO_EV_DIR_RISING:
   return AD8460_OVERTEMPERATURE;
  default:
   return -EINVAL;
  }
 default:
  return -EINVAL;
 }
}

static int ad8460_write_event_value(struct iio_dev *indio_dev,
        const struct iio_chan_spec *chan,
        enum iio_event_type type,
        enum iio_event_direction dir,
        enum iio_event_info info, int val, int val2)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int fault;

 if (type != IIO_EV_TYPE_THRESH)
  return -EINVAL;

 if (info != IIO_EV_INFO_VALUE)
  return -EINVAL;

 fault = ad8460_select_fault_type(chan->type, dir);
 if (fault < 0)
  return fault;

 return ad8460_set_fault_threshold(state, fault, val);
}

static int ad8460_read_event_value(struct iio_dev *indio_dev,
       const struct iio_chan_spec *chan,
       enum iio_event_type type,
       enum iio_event_direction dir,
       enum iio_event_info info, int *val, int *val2)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int fault;

 if (type != IIO_EV_TYPE_THRESH)
  return -EINVAL;

 if (info != IIO_EV_INFO_VALUE)
  return -EINVAL;

 fault = ad8460_select_fault_type(chan->type, dir);
 if (fault < 0)
  return fault;

 return ad8460_get_fault_threshold(state, fault, val);
}

static int ad8460_write_event_config(struct iio_dev *indio_dev,
         const struct iio_chan_spec *chan,
         enum iio_event_type type,
         enum iio_event_direction dir, bool val)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int fault;

 if (type != IIO_EV_TYPE_THRESH)
  return -EINVAL;

 fault = ad8460_select_fault_type(chan->type, dir);
 if (fault < 0)
  return fault;

 return ad8460_set_fault_threshold_en(state, fault, val);
}

static int ad8460_read_event_config(struct iio_dev *indio_dev,
        const struct iio_chan_spec *chan,
        enum iio_event_type type,
        enum iio_event_direction dir)
{
 struct ad8460_state *state = iio_priv(indio_dev);
 int fault, ret;
 bool en;

 if (type != IIO_EV_TYPE_THRESH)
  return -EINVAL;

 fault = ad8460_select_fault_type(chan->type, dir);
 if (fault < 0)
  return fault;

 ret = ad8460_get_fault_threshold_en(state, fault, &en);
 if (ret)
  return ret;

 return en;
}

static int ad8460_reg_access(struct iio_dev *indio_dev, unsigned int reg,
        unsigned int writeval, unsigned int *readval)
{
 struct ad8460_state *state = iio_priv(indio_dev);

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

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

static int ad8460_buffer_preenable(struct iio_dev *indio_dev)
{
 struct ad8460_state *state = iio_priv(indio_dev);

 return ad8460_enable_apg_mode(state, 0);
}

static int ad8460_buffer_postdisable(struct iio_dev *indio_dev)
{
 struct ad8460_state *state = iio_priv(indio_dev);

 return ad8460_enable_apg_mode(state, 1);
}

static const struct iio_buffer_setup_ops ad8460_buffer_setup_ops = {
 .preenable = &ad8460_buffer_preenable,
 .postdisable = &ad8460_buffer_postdisable,
};

static const struct iio_info ad8460_info = {
 .read_raw = &ad8460_read_raw,
 .write_raw = &ad8460_write_raw,
 .write_event_value = &ad8460_write_event_value,
 .read_event_value = &ad8460_read_event_value,
 .write_event_config = &ad8460_write_event_config,
 .read_event_config = &ad8460_read_event_config,
 .debugfs_reg_access = &ad8460_reg_access,
};

static const struct iio_enum ad8460_powerdown_mode_enum = {
 .items = ad8460_powerdown_modes,
 .num_items = ARRAY_SIZE(ad8460_powerdown_modes),
 .get = ad8460_get_powerdown_mode,
 .set = ad8460_set_powerdown_mode,
};

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

static const struct iio_chan_spec_ext_info ad8460_ext_info[] = {
 AD8460_CHAN_EXT_INFO("raw0", 0, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw1", 1, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw2", 2, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw3", 3, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw4", 4, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw5", 5, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw6", 6, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw7", 7, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw8", 8, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw9", 9, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw10", 10, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw11", 11, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw12", 12, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw13", 13, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw14", 14, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("raw15", 15, ad8460_dac_input_read,
        ad8460_dac_input_write),
 AD8460_CHAN_EXT_INFO("toggle_en", 0, ad8460_read_toggle_en,
        ad8460_write_toggle_en),
 AD8460_CHAN_EXT_INFO("symbol", 0, ad8460_read_symbol,
        ad8460_write_symbol),
 AD8460_CHAN_EXT_INFO("powerdown", 0, ad8460_read_powerdown,
        ad8460_write_powerdown),
 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad8460_powerdown_mode_enum),
 IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE,
      &ad8460_powerdown_mode_enum),
 { }
};

static const struct iio_event_spec ad8460_events[] = {
 {
  .type = IIO_EV_TYPE_THRESH,
  .dir = IIO_EV_DIR_RISING,
  .mask_separate = BIT(IIO_EV_INFO_VALUE) |
     BIT(IIO_EV_INFO_ENABLE),
 },
 {
  .type = IIO_EV_TYPE_THRESH,
  .dir = IIO_EV_DIR_FALLING,
  .mask_separate = BIT(IIO_EV_INFO_VALUE) |
     BIT(IIO_EV_INFO_ENABLE),
 },
};

#define AD8460_VOLTAGE_CHAN {     \
 .type = IIO_VOLTAGE,     \
 .info_mask_separate = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
         BIT(IIO_CHAN_INFO_RAW) |  \
         BIT(IIO_CHAN_INFO_SCALE),  \
 .output = 1,      \
 .indexed = 1,      \
 .channel = 0,      \
 .scan_index = 0,     \
 .scan_type = {      \
  .sign = 'u',     \
  .realbits = 14,     \
  .storagebits = 16,    \
  .endianness = IIO_CPU,    \
 },                                                      \
 .ext_info = ad8460_ext_info,                            \
 .event_spec = ad8460_events,    \
 .num_event_specs = ARRAY_SIZE(ad8460_events),  \
}

#define AD8460_CURRENT_CHAN {     \
 .type = IIO_CURRENT,     \
 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),  \
 .output = 1,      \
 .indexed = 1,      \
 .channel = 0,      \
 .scan_index = -1,     \
 .event_spec = ad8460_events,    \
 .num_event_specs = ARRAY_SIZE(ad8460_events),  \
}

#define AD8460_TEMP_CHAN {     \
 .type = IIO_TEMP,     \
 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),  \
 .indexed = 1,      \
 .channel = 0,      \
 .scan_index = -1,     \
 .event_spec = ad8460_events,    \
 .num_event_specs = 1,     \
}

static const struct iio_chan_spec ad8460_channels[] = {
 AD8460_VOLTAGE_CHAN,
 AD8460_CURRENT_CHAN,
};

static const struct iio_chan_spec ad8460_channels_with_tmp_adc[] = {
 AD8460_VOLTAGE_CHAN,
 AD8460_CURRENT_CHAN,
 AD8460_TEMP_CHAN,
};

static const struct regmap_config ad8460_regmap_config = {
 .reg_bits = 8,
 .val_bits = 8,
 .max_register = 0x7F,
};

static const char * const ad8460_supplies[] = {
 "avdd_3p3v", "dvdd_3p3v", "vcc_5v", "hvcc", "hvee", "vref_5v"
};

static int ad8460_probe(struct spi_device *spi)
{
 struct device *dev  = &spi->dev;
 struct ad8460_state *state;
 struct iio_dev *indio_dev;
 u32 tmp[2], temp;
 int ret;

 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*state));
 if (!indio_dev)
  return -ENOMEM;

 state = iio_priv(indio_dev);

 indio_dev->name = "ad8460";
 indio_dev->info = &ad8460_info;

 state->spi = spi;

 state->regmap = devm_regmap_init_spi(spi, &ad8460_regmap_config);
 if (IS_ERR(state->regmap))
  return dev_err_probe(dev, PTR_ERR(state->regmap),
         "Failed to initialize regmap");

 ret = devm_mutex_init(dev, &state->lock);
 if (ret)
  return ret;

 state->sync_clk = devm_clk_get_enabled(dev, NULL);
 if (IS_ERR(state->sync_clk))
  return dev_err_probe(dev, PTR_ERR(state->sync_clk),
         "Failed to get sync clk\n");

 state->tmp_adc_channel = devm_iio_channel_get(dev, "ad8460-tmp");
 if (IS_ERR(state->tmp_adc_channel)) {
  if (PTR_ERR(state->tmp_adc_channel) == -EPROBE_DEFER)
   return -EPROBE_DEFER;
  indio_dev->channels = ad8460_channels;
  indio_dev->num_channels = ARRAY_SIZE(ad8460_channels);
 } else {
  indio_dev->channels = ad8460_channels_with_tmp_adc;
  indio_dev->num_channels = ARRAY_SIZE(ad8460_channels_with_tmp_adc);
 }

 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(ad8460_supplies),
          ad8460_supplies);
 if (ret)
  return dev_err_probe(dev, ret,
         "Failed to enable power supplies\n");

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

 state->refio_1p2v_mv = ret == -ENODEV ? 1200 : ret / 1000;

 if (!in_range(state->refio_1p2v_mv, AD8460_MIN_VREFIO_UV / 1000,
        AD8460_MAX_VREFIO_UV / 1000))
  return dev_err_probe(dev, -EINVAL,
         "Invalid ref voltage range(%u mV) [%u mV, %u mV]\n",
         state->refio_1p2v_mv,
         AD8460_MIN_VREFIO_UV / 1000,
         AD8460_MAX_VREFIO_UV / 1000);

 ret = device_property_read_u32(dev, "adi,external-resistor-ohms",
           &state->ext_resistor_ohms);
 if (ret)
  state->ext_resistor_ohms = 2000;
 else if (!in_range(state->ext_resistor_ohms, AD8460_MIN_EXT_RESISTOR_OHMS,
      AD8460_MAX_EXT_RESISTOR_OHMS))
  return dev_err_probe(dev, -EINVAL,
         "Invalid resistor set range(%u) [%u, %u]\n",
         state->ext_resistor_ohms,
         AD8460_MIN_EXT_RESISTOR_OHMS,
         AD8460_MAX_EXT_RESISTOR_OHMS);

 ret = device_property_read_u32_array(dev, "adi,range-microamp",
          tmp, ARRAY_SIZE(tmp));
 if (!ret) {
  if (in_range(tmp[1], 0, AD8460_ABS_MAX_OVERCURRENT_UA))
   regmap_write(state->regmap, AD8460_CTRL_REG(0x08),
         FIELD_PREP(AD8460_FAULT_ARM_MSK, 1) |
         AD8460_CURRENT_LIMIT_CONV(tmp[1]));

  if (in_range(tmp[0], -AD8460_ABS_MAX_OVERCURRENT_UA, 0))
   regmap_write(state->regmap, AD8460_CTRL_REG(0x09),
         FIELD_PREP(AD8460_FAULT_ARM_MSK, 1) |
         AD8460_CURRENT_LIMIT_CONV(abs(tmp[0])));
 }

 ret = device_property_read_u32_array(dev, "adi,range-microvolt",
          tmp, ARRAY_SIZE(tmp));
 if (!ret) {
  if (in_range(tmp[1], 0, AD8460_ABS_MAX_OVERVOLTAGE_UV))
   regmap_write(state->regmap, AD8460_CTRL_REG(0x0A),
         FIELD_PREP(AD8460_FAULT_ARM_MSK, 1) |
         AD8460_VOLTAGE_LIMIT_CONV(tmp[1]));

  if (in_range(tmp[0], -AD8460_ABS_MAX_OVERVOLTAGE_UV, 0))
   regmap_write(state->regmap, AD8460_CTRL_REG(0x0B),
         FIELD_PREP(AD8460_FAULT_ARM_MSK, 1) |
         AD8460_VOLTAGE_LIMIT_CONV(abs(tmp[0])));
 }

 ret = device_property_read_u32(dev, "adi,max-millicelsius", &temp);
 if (!ret) {
  if (in_range(temp, AD8460_MIN_OVERTEMPERATURE_MC,
        AD8460_MAX_OVERTEMPERATURE_MC))
   regmap_write(state->regmap, AD8460_CTRL_REG(0x0C),
         FIELD_PREP(AD8460_FAULT_ARM_MSK, 1) |
         AD8460_TEMP_LIMIT_CONV(abs(temp)));
 }

 ret = ad8460_reset(state);
 if (ret)
  return ret;

 /* Enables DAC by default */
 ret = regmap_clear_bits(state->regmap, AD8460_CTRL_REG(0x01),
    AD8460_HVDAC_SLEEP_MSK);
 if (ret)
  return ret;

 indio_dev->modes = INDIO_DIRECT_MODE;
 indio_dev->setup_ops = &ad8460_buffer_setup_ops;

 ret = devm_iio_dmaengine_buffer_setup_ext(dev, indio_dev, "tx",
        IIO_BUFFER_DIRECTION_OUT);
 if (ret)
  return dev_err_probe(dev, ret,
         "Failed to get DMA buffer\n");

 return devm_iio_device_register(dev, indio_dev);
}

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

static const struct spi_device_id ad8460_spi_match[] = {
 { .name = "ad8460" },
 { }
};
MODULE_DEVICE_TABLE(spi, ad8460_spi_match);

static struct spi_driver ad8460_driver = {
 .driver = {
  .name = "ad8460",
  .of_match_table = ad8460_of_match,
 },
 .probe = ad8460_probe,
 .id_table = ad8460_spi_match,
};
module_spi_driver(ad8460_driver);

MODULE_AUTHOR("Mariel Tinaco <mariel.tinaco@analog.com");
MODULE_DESCRIPTION("AD8460 DAC driver");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("IIO_DMAENGINE_BUFFER");