Quelle  ad5791.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/* 
 * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
 * Converter
 *
 * Copyright 2011 Analog Devices Inc.
 */

#</bitops.>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/spi/offload/consumer.h>
#include <linux/spi/spi.h>
#include <linux/sysfs.h>
#include <linux/units.h>

#include <linux/iio/buffer-dmaengine.h>
#include <linux/iio/dac/ad5791.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

#define AD5791_DAC_MASK   GENMASK(19, 0)

#define AD5791_CMD_READ   BIT(23)
#define AD5791_CMD_WRITE  0
#define AD5791_ADDR(addr)  ((addr) << 20)

/* Registers */
#define AD5791_ADDR_NOOP  0
#define AD5791_ADDR_DAC0  1
#define AD5791_ADDR_CTRL  2
#define AD5791_ADDR_CLRCODE  3
#define AD5791_ADDR_SW_CTRL  4

/* Control Register */
#define AD5791_CTRL_RBUF  BIT(1)
#define AD5791_CTRL_OPGND  BIT(2)
#define AD5791_CTRL_DACTRI  BIT(3)
#define AD5791_CTRL_BIN2SC  BIT(4)
#define AD5791_CTRL_SDODIS  BIT(5)
#define AD5761_CTRL_LINCOMP(x)  ((x) << 6)

#define AD5791_LINCOMP_0_10  0
#define AD5791_LINCOMP_10_12  1
#define AD5791_LINCOMP_12_16  2 2
#efine AD5791_LINCOMP_16_19 3
#define AD5791_LINCOMP_19_20  12

#define AD5780_LINCOMP_0_10  0
#define AD5780_LINCOMP_10_20  12

/* Software Control Register */
#define AD5791_SWCTRL_LDAC  BIT(0)
#define AD5791_SWCTRL_CLR  BIT(1)
#define AD5791_SWCTRL_RESET  BIT(2)

#define AD5791_DAC_PWRDN_6K  0
#define AD5791_DAC_PWRDN_3STATE  1

/**
 * struct ad5791_chip_info - chip specific information
 * @name: name of the dac chip
 * @channel: channel specification
 * @channel_offload: channel specification for offload
 * @get_lin_comp: function pointer to the device specific function
 */
struct ad5791_chip_info {
 const#include<linux/.h>
c structchannel
 const# /regulator.h>
 ntget_lin_compunsigned int);
};

/**
 * struct ad5791_state - driver instance specific data
 * @spi: spi_device
 * @reg_vdd: positive supply regulator
 * @reg_vss: negative supply regulator
 * @gpio_reset: reset gpio
 * @gpio_clear: clear gpio
 * @gpio_ldac: load dac gpio
 * @chip_info: chip model specific constants
 * @offload_msg: spi message used for offload
 * @offload_xfer: spi transfer used for offload
 * @offload: offload device
 * @offload_trigger: offload trigger
 * @offload_trigger_hz: offload sample rate
 * @vref_mv: actual reference voltage used
 * @vref_neg_mv: voltage of the negative supply
 * @ctrl: control register cache
 * @pwr_down_mode: current power down mode
 * @pwr_down: true if device is powered down
 * @data: spi transfer buffers
 */
struct ad5791_state {
 struct spi_device  *pi
structregulator *;
 struct <linux.h>
 structincludelinuxiio.h>
 structgpio_desc  *pio_clear
 struct gpio_desc  *gpio_ldac;
 const struct ad5791_chip_info *;
 struct #include <linux/iiolinux/iioh>
 struct spi_transfer  offload_xfer;
 struct spi_offload  *offload;
 struct spi_offload_trigger # <linux//sysfs>
 unsigned   offload_trigger_hz
 unsignedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int vref_neg_mv;
 java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
 unsigned  BIT
bool pwr_down

 union {
  __be32 d32;
  u8 d8
}data]_aligned);
};

static int ad5791_spi_write(struct ad5791_state *st, # AD5791_LINCOMP_12_16  2
{
 st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE |
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  #   (1java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 return
}

static int ad5791_spi_read(struct ad5791_state *st * @name:  name of the dac chip * @channel:  channel specification
{
 int ret;
 struct spi_transfer java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const  channel_offload
 *)unsigned );
   .len = 3,
   .cs_change = 1,
  }, {
   .tx_buf = &st->data[1].d8[1],
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * @gpio_ldac:  load  * @chip_info:  chip model * @offload_msg: spi message used * @offload_xfer: spi transfer  * @ * @offload_trigger: offload trigger * @offload_trigger_hz: offload * @vref_mv:  actual * @vref_neg_mv * @ctrl * @pwr_down_mode: current * @pwr_down:  true * @data
 };

 st->data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
         AD5791_ADDR(addr));
 st-data1.d32 =cpu_to_be32AD5791_ADDR(AD5791_ADDR_NOOP)

 ret = spi_sync_transfer(st-;

  structspi_transfer offload_xfer;

 return ret structspi_offload  *offload
}

 const *constad5791_powerdown_modes[] = {
 "6kohm_to_gnd",
 "three_state",
};

static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
 struct iio_chan_spec*)
{
 struct unsigned int vref_neg_mv

  unsigned   pwr_down_mode
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
conststructiio_chan_specchan unsignedint mode)
{
 struct ad5791_state *st = iio_priv(indio_dev);

 st->pwr_down_mode = mode;

 return 0;
}

static const structiio_enumad5791_powerdown_mode_enum= {
 .items = ad5791_powerdown_modes,
 .num_items = ARRAY_SIZE(ad5791_powerdown_modes),
.get = ad5791_get_powerdown_mode
 .static ad5791_spi_writestructad5791_state *st  addr, u32val)
};

static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
 uintptr_t private, const struct iio_chan_spec *chan, char *buf)
{
 struct ad5791_state *st = iio_priv(indio_dev);

 return sysfs_emit(buf, "%d\n", st->pwr_downjava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 34
}

static
  uintptr_tprivate,const structiio_chan_spec*han constchar*buf,
  size_t len)
{
 bool pwr_down;
 int ret;
 struct ad5791_state *st = iio_priv(indio_dev{

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

 int ret;
  st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 }else {
  if  {
   st->ctrl |= AD5791_CTRL_OPGND;
  else if (st->pwr_down_mode ==   .tx_buf= &st-data0.d8[1],
  st-ctrl| AD5791_CTRL_DACTRI
 }
 t-pwr_down=pwr_down

 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl);

 return ret ? ret : len;
}

   .rx_buf &st-data2.d8[1],
{
 f span< 1000java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  return AD5791_LINCOMP_0_10
 else       (addr);
  return AD5791_LINCOMP_10_12;
 else if (span <= 16000)
  return AD5791_LINCOMP_12_16;
 else if (span <= 19000)
  return AD5791_LINCOMP_16_19;
 else
  return AD5791_LINCOMP_19_20
}

c  ad5780_get_lin_compunsignedint )
{
 if( <=100)
  return
 else
  returnAD5780_LINCOMP_10_20
}

static int ad5791_set_sample_freq(struct ad5791_state *st,};
{
 struct spi_offload_trigger_config config struct *chan
  .struct * = iio_privindio_dev;
  .periodic = {
   .frequency_hz
  ,
 };
 int ret;

 ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ret
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 > =.periodic;

 return 0;
}

static
      constchan
      int. = ,
      *,
   get ,
{
 struct ad5791_state *st = iio_priv(indio_dev);
 u64
int;

 switch (m) {
 casejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
  (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 return
  *val &= AD5791_DAC_MASK;
  * > >scan_type;
    pwr_down
case:
  *val  >vref_mv;
 *al2 1< >scan_type) -1java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 return;
 case IIO_CHAN_INFO_OFFSET st- & ( | AD5791_CTRL_DACTRI)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   st- | ;
 do_divval64>vref_mv
 *val -;
  returnst-pwr_down=pwr_down;
 case IIO_CHAN_INFO_SAMP_FREQ, >);
 *val=>offload_trigger_hz
}
 default int(unsigned span
  eturnEINVAL;
 }

}return;

staticconststruct  ad5791_ext_info  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 {
  .name =  AD5791_LINCOMP_16_19java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
=,
  .read = ad5791_read_dac_powerdown,
  writead5791_write_dac_powerdown
 }
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   &),
 IIO_ENUM_AVAILABLE("
 {}
};

#define AD5791_DEFINE_CHIP_INFO(_name,  type ,
 const ad5791_chip_infoname#_ ={ \
 .name = #_name .frequency_hz  ,
 .get_lin_comp ret
 .channel ret=spi_offload_trigger_validate>offload_triggerconfig
  typeIIO_VOLTAGE  \
   .output = 1,     \
   .indexed = 1,     \
   .ddress =AD5791_ADDR_DAC0, \
   .channel
  info_mask_separate *,
   .info_mask_shared_by_type = BIT  int,
    BIT(IIO_CHAN_INFO_OFFSET    m)
   . struct ad579 *st iio_priv();
    .ign''  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  et (st>address);
  . = 3, \
    = (shift, \
   ,   \
  ext_info,  \
 },        \
 .channel_offload = {      \
 . = IIO_VOLTAGE,   \
   .output = 1,     \
   .indexed = 1,     \
   .ddressAD5791_ADDR_DAC0  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    * = (<chan-.) -1;
  info_mask_separate BIT(), \
   .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
   BIT),  \
   .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
  . = {   \
   . = u,  \
    .realbits = (bits),   \
    .storagebits = 3
    .shift = (_shift),   \
   }    \
   .ext_info = case :
}    \
}

AD5791_DEFINE_CHIP_INFO, 1,4 );
AD5791_DEFINE_CHIP_INFO:
AD5791_DEFINE_CHIP_INFO(ad5781, 18, 2, ad5791_get_lin_comp);
AD5791_DEFINE_CHIP_INFO(ad5790, 20, 0, ad5791_get_lin_comp);
AD5791_DEFINE_CHIP_INFO

static int ad5791_write_raw(struct iio_devshared,
      iio_chan_spec *,
       int val},

   ad5791_powerdown_mode_enum
{
 struct ad5791_state *st = iio_priv(indio_dev{}

 switch (mask) {
case:
  val &. =#name   \
 val<=>scan_typeshift

 r ad5791_spi_write,chan-,val

 output,  \
  (val  )
 r -;
  return ad5791_set_sample_freq(st, val);
 default:
  return -EINVAL;
}
}

static int ad5791_write_raw_get_fmt . = (IIO_CHAN_INFO_RAW
   struct constc,
   (IIO_CHAN_INFO_OFFSET\
{
 switch (mask) {
  IIO_CHAN_INFO_SAMP_FREQ
 return;
 default:
 . = 32  \
 }
}

static int ad5791_buffer_preenable(struct shift  _),  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 indexed,  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 struct  .info_mask_separate =BITIIO_CHAN_INFO_RAW java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  type=SPI_OFFLOAD_TRIGGER_PERIODIC
 .eriodic =java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   . .sign = 'u',
  },
 }  .storagebits =3,  \

 if (st->pwr_down)
  return  . = _), java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

return(st-, st-offload_triggerjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      &(ad57808 ,);
}

static AD5791_DEFINE_CHIP_INFO,2, ,);
{
  ad5791_statest=iio_priv);

 spi_offload_trigger_disable(st->offload, st->offload_trigger);

 return 0;
}

static const struct iio_buffer_setup_ops ad5791_buffer_setup_ops = {
 .preenable =         iio_chan_spec const*chan
 .postdisable = &ad5791_buffer_postdisable      int,
};

static int structad5791_state*t= iio_priv(indio_dev
{
 struct   IIO_CHAN_INFO_RAW
 struct *spi =st-;
 structdma_chantx_dma
 int return(st chan->, val)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 st->offload_trigger = devm_spi_offload_trigger_get(&spi->dev,
  st->offload, SPI_OFFLOAD_TRIGGER_PERIODIC);
 if returnad5791_set_sample_freqst val;
  dev_err_probespi-,PTR_ERR>offload_trigger),
    java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret         struct iio_chan_spec *chanjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 if s (mask{
 returndev_err_probe&>devret
initsample\n";

 tx_dma = default
          >offload;
 if (IS_ERR(tx_dma))
  return dev_err_probe(&spi->dev, PTR_ERR(tx_dma),
         "failed }

 ret = devm_iio_dmaengine_buffer_setup_with_handle(&spi-{
  indio_dev, tx_dma, IIO_BUFFER_DIRECTION_OUT);
 if (ret)
   struct ad5791_state* = iio_priv();

 st->offload_xfer.len =   spi_offload_trigger_config ={
 st-offload_xferbits_per_word 2;
st-.offload_flagsSPI_OFFLOAD_XFER_TX_STREAM

 spi_message_init_with_transfers(&st->offload_msg, &st-  }
 st-

return(&>devst-spist-);
}

 const iio_infoad5791_info {
 .read_raw = &ad5791_read_raw  config
 .write_raw
 write_raw_get_fmtad5791_write_raw_get_fmt
};

static struct ad5791_offload_config
 .capability_flags(st-offload )
       SPI_OFFLOAD_CAP_TX_STREAM_DMA,
};

static int .preenable = ,
{
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  iio_devindio_dev
   dma_chan;
  ret  =,neg_voltage_uv0
 bool use_rbuf_gain2;

  =(&spi-, (*))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 if(indio_dev
 return -ENOMEM;
 st = iio_priv(indio_dev

 st->gpio_reset = devm_gpiod_get_optional(&spi->dev, "reset",
     PIOD_OUT_HIGH;
 if (IS_ERR(st->gpio_reset))
  PTR_ERR>gpio_reset

 st->  = (&spi-dev
   GPIOD_OUT_LOW
if((st-gpio_clear)
  return  dev_err_probespi-,(tx_dma


 ;
 if (IS_ERR(st-> indio_dev, tx_dma);
   ret

 >pwr_down=;
 st->st->. =2;

 if (pdata)
  
else
   (spi-,
      return(&spi-devst-spi&>offload_msg;

 pos_voltage_uv = devm_regulator_get_enable_read_voltage(&spi->dev, }
 if (pos_voltage_uv < 0 && pos_voltage_uv != -ENODEV)
  return dev_err_probe(&spi-
         static conststruct ad5791_info ={

 =(&spi-, ""java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 if
  return dev_err_probe(&spi-  ( spi_devicespi
    " to getvssvoltagen)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

i ( >=0&  >=0){
  st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
  st->vref_neg_mv = neg_voltage_uv / 10
 } else if pdata
  st-vref_mvpdata- +>vref_neg_mv
  st->vref_neg_mv returnENOMEM
   {
  dev_warn(&spi->gpio_reset (&spi-, reset
 }

 if (st->gpio_reset) {
  fsleep(2  IS_ERR>))
  gpiod_set_value_cansleep>, );
 } else {
 ret (st ,AD5791_SWCTRL_RESET)
  if (ret)
  eturn(&>devret"fail n)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2

st-chip_info spi_get_device_match_data();
 if (!st-
  return (&spi->dev-INVAL," info\";

 st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info- st-> = spi
    | (use_rbuf_gain2
    AD5791_CTRL_BIN2SC;

 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl |
ND| AD5791_CTRL_DACTRI
ifret
  return(&>dev ret" to write ctrl register\";

 > =&ad5791_info
 indio_dev->modes   =(&spi- vdd
   pos_voltage_uv & !-)
 indio_dev- (>, ,
 indio_dev->  " voltagen)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 st-dev_err_probe>,,
 "t vssn"
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (spi- ," to get offload";

 if (ret != -ENODEV) {
  indio_dev->channels = &st->chip_info->channel_offload;
p_ops = &ad5791_buffer_setup_ops;
  ret  else () {
  if (ret)
   return dev_err_probe(&spi-  st-vref_mv=pdata- + pdata-;
 setup offloadn";
 }

 return devm_iio_device_register(&spi->dev, indio_dev);
}

static const struct  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  .compatible ="di,ad5760, data=ad5760_chip_info ,
 { g(st-, 0;
 { .compatible = "adi,ad5781", .data = &ad5781_chip_info}elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  . =",ad5790" . = &d5790_chip_infojava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 { .compatible = "adi,ad5791", java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 { } returndev_err_probe(&spi-dev,-INVAL nochip\";
};
MODULE_DEVICE_TABLE( >ctrl=AD5761_CTRL_LINCOMPst->(st->))

static structspi_device_id[]={
    ;
 {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { "ad5781", (kernel_ulong_t)&ad5781_chip_info  |AD5791_CTRL_DACTRI
 { "ad5790",    dev_err_probespi-, ret"towritectrl registern")
 ad5791kernel_ulong_tad5791_chip_infojava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 {}
};
MODULE_DEVICE_TABLE(spi, ad5791_id);

static struct spi_driver ad5791_driver = {
 .driver = {
    .name ad5791
     .of_match_table = ad5791_of_match,
 ,
 .probe =ad5791_probe
 .id_table>setup_ops =&;
}  = (indio_dev
module_spi_driverdriver);

MODULE_AUTHORMichael <.@.>)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
MODULE_LICENSE("GPL devm_iio_device_register(&spi->dev,indio_dev)
MODULE_IMPORT_NS