drivers/iio/dac/ad3552r.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Analog Devices AD3552R
   4  * Digital to Analog converter driver
   5  *
   6  * Copyright 2021 Analog Devices Inc.
   7  */
   8 #include <asm/unaligned.h>
   9 #include <linux/device.h>
  10 #include <linux/iio/triggered_buffer.h>
  11 #include <linux/iio/trigger_consumer.h>
  12 #include <linux/iopoll.h>
  13 #include <linux/kernel.h>
  14 #include <linux/regulator/consumer.h>
  15 #include <linux/spi/spi.h>
  16
  17 /* Register addresses */
  18 /* Primary address space */
  19 #define AD3552R_REG_ADDR_INTERFACE_CONFIG_A             0x00
  20 #define   AD3552R_MASK_SOFTWARE_RESET                   (BIT(7) | BIT(0))
  21 #define   AD3552R_MASK_ADDR_ASCENSION                   BIT(5)
  22 #define   AD3552R_MASK_SDO_ACTIVE                       BIT(4)
  23 #define AD3552R_REG_ADDR_INTERFACE_CONFIG_B             0x01
  24 #define   AD3552R_MASK_SINGLE_INST                      BIT(7)
  25 #define   AD3552R_MASK_SHORT_INSTRUCTION                BIT(3)
  26 #define AD3552R_REG_ADDR_DEVICE_CONFIG                  0x02
  27 #define   AD3552R_MASK_DEVICE_STATUS(n)                 BIT(4 + (n))
  28 #define   AD3552R_MASK_CUSTOM_MODES                     GENMASK(3, 2)
  29 #define   AD3552R_MASK_OPERATING_MODES                  GENMASK(1, 0)
  30 #define AD3552R_REG_ADDR_CHIP_TYPE                      0x03
  31 #define   AD3552R_MASK_CLASS                            GENMASK(7, 0)
  32 #define AD3552R_REG_ADDR_PRODUCT_ID_L                   0x04
  33 #define AD3552R_REG_ADDR_PRODUCT_ID_H                   0x05
  34 #define AD3552R_REG_ADDR_CHIP_GRADE                     0x06
  35 #define   AD3552R_MASK_GRADE                            GENMASK(7, 4)
  36 #define   AD3552R_MASK_DEVICE_REVISION                  GENMASK(3, 0)
  37 #define AD3552R_REG_ADDR_SCRATCH_PAD                    0x0A
  38 #define AD3552R_REG_ADDR_SPI_REVISION                   0x0B
  39 #define AD3552R_REG_ADDR_VENDOR_L                       0x0C
  40 #define AD3552R_REG_ADDR_VENDOR_H                       0x0D
  41 #define AD3552R_REG_ADDR_STREAM_MODE                    0x0E
  42 #define   AD3552R_MASK_LENGTH                           GENMASK(7, 0)
  43 #define AD3552R_REG_ADDR_TRANSFER_REGISTER              0x0F
  44 #define   AD3552R_MASK_MULTI_IO_MODE                    GENMASK(7, 6)
  45 #define   AD3552R_MASK_STREAM_LENGTH_KEEP_VALUE         BIT(2)
  46 #define AD3552R_REG_ADDR_INTERFACE_CONFIG_C             0x10
  47 #define   AD3552R_MASK_CRC_ENABLE                       (GENMASK(7, 6) |\
  48                                                          GENMASK(1, 0))
  49 #define   AD3552R_MASK_STRICT_REGISTER_ACCESS           BIT(5)
  50 #define AD3552R_REG_ADDR_INTERFACE_STATUS_A             0x11
  51 #define   AD3552R_MASK_INTERFACE_NOT_READY              BIT(7)
  52 #define   AD3552R_MASK_CLOCK_COUNTING_ERROR             BIT(5)
  53 #define   AD3552R_MASK_INVALID_OR_NO_CRC                BIT(3)
  54 #define   AD3552R_MASK_WRITE_TO_READ_ONLY_REGISTER      BIT(2)
  55 #define   AD3552R_MASK_PARTIAL_REGISTER_ACCESS          BIT(1)
  56 #define   AD3552R_MASK_REGISTER_ADDRESS_INVALID         BIT(0)
  57 #define AD3552R_REG_ADDR_INTERFACE_CONFIG_D             0x14
  58 #define   AD3552R_MASK_ALERT_ENABLE_PULLUP              BIT(6)
  59 #define   AD3552R_MASK_MEM_CRC_EN                       BIT(4)
  60 #define   AD3552R_MASK_SDO_DRIVE_STRENGTH               GENMASK(3, 2)
  61 #define   AD3552R_MASK_DUAL_SPI_SYNCHROUNOUS_EN         BIT(1)
  62 #define   AD3552R_MASK_SPI_CONFIG_DDR                   BIT(0)
  63 #define AD3552R_REG_ADDR_SH_REFERENCE_CONFIG            0x15
  64 #define   AD3552R_MASK_IDUMP_FAST_MODE                  BIT(6)
  65 #define   AD3552R_MASK_SAMPLE_HOLD_DIFFERENTIAL_USER_EN BIT(5)
  66 #define   AD3552R_MASK_SAMPLE_HOLD_USER_TRIM            GENMASK(4, 3)
  67 #define   AD3552R_MASK_SAMPLE_HOLD_USER_ENABLE          BIT(2)
  68 #define   AD3552R_MASK_REFERENCE_VOLTAGE_SEL            GENMASK(1, 0)
  69 #define AD3552R_REG_ADDR_ERR_ALARM_MASK                 0x16
  70 #define   AD3552R_MASK_REF_RANGE_ALARM                  BIT(6)
  71 #define   AD3552R_MASK_CLOCK_COUNT_ERR_ALARM            BIT(5)
  72 #define   AD3552R_MASK_MEM_CRC_ERR_ALARM                BIT(4)
  73 #define   AD3552R_MASK_SPI_CRC_ERR_ALARM                BIT(3)
  74 #define   AD3552R_MASK_WRITE_TO_READ_ONLY_ALARM         BIT(2)
  75 #define   AD3552R_MASK_PARTIAL_REGISTER_ACCESS_ALARM    BIT(1)
  76 #define   AD3552R_MASK_REGISTER_ADDRESS_INVALID_ALARM   BIT(0)
  77 #define AD3552R_REG_ADDR_ERR_STATUS                     0x17
  78 #define   AD3552R_MASK_REF_RANGE_ERR_STATUS                     BIT(6)
  79 #define   AD3552R_MASK_DUAL_SPI_STREAM_EXCEEDS_DAC_ERR_STATUS   BIT(5)
  80 #define   AD3552R_MASK_MEM_CRC_ERR_STATUS                       BIT(4)
  81 #define   AD3552R_MASK_RESET_STATUS                             BIT(0)
  82 #define AD3552R_REG_ADDR_POWERDOWN_CONFIG               0x18
  83 #define   AD3552R_MASK_CH_DAC_POWERDOWN(ch)             BIT(4 + (ch))
  84 #define   AD3552R_MASK_CH_AMPLIFIER_POWERDOWN(ch)       BIT(ch)
  85 #define AD3552R_REG_ADDR_CH0_CH1_OUTPUT_RANGE           0x19
  86 #define   AD3552R_MASK_CH_OUTPUT_RANGE_SEL(ch)          ((ch) ? GENMASK(7, 4) :\
  87                                                          GENMASK(3, 0))
  88 #define AD3552R_REG_ADDR_CH_OFFSET(ch)                  (0x1B + (ch) * 2)
  89 #define   AD3552R_MASK_CH_OFFSET_BITS_0_7               GENMASK(7, 0)
  90 #define AD3552R_REG_ADDR_CH_GAIN(ch)                    (0x1C + (ch) * 2)
  91 #define   AD3552R_MASK_CH_RANGE_OVERRIDE                BIT(7)
  92 #define   AD3552R_MASK_CH_GAIN_SCALING_N                GENMASK(6, 5)
  93 #define   AD3552R_MASK_CH_GAIN_SCALING_P                GENMASK(4, 3)
  94 #define   AD3552R_MASK_CH_OFFSET_POLARITY               BIT(2)
  95 #define   AD3552R_MASK_CH_OFFSET_BIT_8                  BIT(0)
  96 /*
  97  * Secondary region
  98  * For multibyte registers specify the highest address because the access is
  99  * done in descending order
 100  */
 101 #define AD3552R_SECONDARY_REGION_START                  0x28
 102 #define AD3552R_REG_ADDR_HW_LDAC_16B                    0x28
 103 #define AD3552R_REG_ADDR_CH_DAC_16B(ch)                 (0x2C - (1 - ch) * 2)
 104 #define AD3552R_REG_ADDR_DAC_PAGE_MASK_16B              0x2E
 105 #define AD3552R_REG_ADDR_CH_SELECT_16B                  0x2F
 106 #define AD3552R_REG_ADDR_INPUT_PAGE_MASK_16B            0x31
 107 #define AD3552R_REG_ADDR_SW_LDAC_16B                    0x32
 108 #define AD3552R_REG_ADDR_CH_INPUT_16B(ch)               (0x36 - (1 - ch) * 2)
 109 /* 3 bytes registers */
 110 #define AD3552R_REG_START_24B                           0x37
 111 #define AD3552R_REG_ADDR_HW_LDAC_24B                    0x37
 112 #define AD3552R_REG_ADDR_CH_DAC_24B(ch)                 (0x3D - (1 - ch) * 3)
 113 #define AD3552R_REG_ADDR_DAC_PAGE_MASK_24B              0x40
 114 #define AD3552R_REG_ADDR_CH_SELECT_24B                  0x41
 115 #define AD3552R_REG_ADDR_INPUT_PAGE_MASK_24B            0x44
 116 #define AD3552R_REG_ADDR_SW_LDAC_24B                    0x45
 117 #define AD3552R_REG_ADDR_CH_INPUT_24B(ch)               (0x4B - (1 - ch) * 3)
 118
 119 /* Useful defines */
 120 #define AD3552R_NUM_CH                                  2
 121 #define AD3552R_MASK_CH(ch)                             BIT(ch)
 122 #define AD3552R_MASK_ALL_CH                             GENMASK(1, 0)
 123 #define AD3552R_MAX_REG_SIZE                            3
 124 #define AD3552R_READ_BIT                                BIT(7)
 125 #define AD3552R_ADDR_MASK                               GENMASK(6, 0)
 126 #define AD3552R_MASK_DAC_12B                            0xFFF0
 127 #define AD3552R_DEFAULT_CONFIG_B_VALUE                  0x8
 128 #define AD3552R_SCRATCH_PAD_TEST_VAL1                   0x34
 129 #define AD3552R_SCRATCH_PAD_TEST_VAL2                   0xB2
 130 #define AD3552R_GAIN_SCALE                              1000
 131 #define AD3552R_LDAC_PULSE_US                           100
 132
 133 enum ad3552r_ch_vref_select {
 134         /* Internal source with Vref I/O floating */
 135         AD3552R_INTERNAL_VREF_PIN_FLOATING,
 136         /* Internal source with Vref I/O at 2.5V */
 137         AD3552R_INTERNAL_VREF_PIN_2P5V,
 138         /* External source with Vref I/O as input */
 139         AD3552R_EXTERNAL_VREF_PIN_INPUT
 140 };
 141
 142 enum ad3542r_id {
 143         AD3542R_ID = 0x4008,
 144         AD3552R_ID = 0x4009,
 145 };
 146
 147 enum ad3552r_ch_output_range {
 148         /* Range from 0 V to 2.5 V. Requires Rfb1x connection */
 149         AD3552R_CH_OUTPUT_RANGE_0__2P5V,
 150         /* Range from 0 V to 5 V. Requires Rfb1x connection  */
 151         AD3552R_CH_OUTPUT_RANGE_0__5V,
 152         /* Range from 0 V to 10 V. Requires Rfb2x connection  */
 153         AD3552R_CH_OUTPUT_RANGE_0__10V,
 154         /* Range from -5 V to 5 V. Requires Rfb2x connection  */
 155         AD3552R_CH_OUTPUT_RANGE_NEG_5__5V,
 156         /* Range from -10 V to 10 V. Requires Rfb4x connection  */
 157         AD3552R_CH_OUTPUT_RANGE_NEG_10__10V,
 158 };
 159
 160 static const s32 ad3552r_ch_ranges[][2] = {
 161         [AD3552R_CH_OUTPUT_RANGE_0__2P5V]       = {0, 2500},
 162         [AD3552R_CH_OUTPUT_RANGE_0__5V]         = {0, 5000},
 163         [AD3552R_CH_OUTPUT_RANGE_0__10V]        = {0, 10000},
 164         [AD3552R_CH_OUTPUT_RANGE_NEG_5__5V]     = {-5000, 5000},
 165         [AD3552R_CH_OUTPUT_RANGE_NEG_10__10V]   = {-10000, 10000}
 166 };
 167
 168 enum ad3542r_ch_output_range {
 169         /* Range from 0 V to 2.5 V. Requires Rfb1x connection */
 170         AD3542R_CH_OUTPUT_RANGE_0__2P5V,
 171         /* Range from 0 V to 3 V. Requires Rfb1x connection  */
 172         AD3542R_CH_OUTPUT_RANGE_0__3V,
 173         /* Range from 0 V to 5 V. Requires Rfb1x connection  */
 174         AD3542R_CH_OUTPUT_RANGE_0__5V,
 175         /* Range from 0 V to 10 V. Requires Rfb2x connection  */
 176         AD3542R_CH_OUTPUT_RANGE_0__10V,
 177         /* Range from -2.5 V to 7.5 V. Requires Rfb2x connection  */
 178         AD3542R_CH_OUTPUT_RANGE_NEG_2P5__7P5V,
 179         /* Range from -5 V to 5 V. Requires Rfb2x connection  */
 180         AD3542R_CH_OUTPUT_RANGE_NEG_5__5V,
 181 };
 182
 183 static const s32 ad3542r_ch_ranges[][2] = {
 184         [AD3542R_CH_OUTPUT_RANGE_0__2P5V]       = {0, 2500},
 185         [AD3542R_CH_OUTPUT_RANGE_0__3V]         = {0, 3000},
 186         [AD3542R_CH_OUTPUT_RANGE_0__5V]         = {0, 5000},
 187         [AD3542R_CH_OUTPUT_RANGE_0__10V]        = {0, 10000},
 188         [AD3542R_CH_OUTPUT_RANGE_NEG_2P5__7P5V] = {-2500, 7500},
 189         [AD3542R_CH_OUTPUT_RANGE_NEG_5__5V]     = {-5000, 5000}
 190 };
 191
 192 enum ad3552r_ch_gain_scaling {
 193         /* Gain scaling of 1 */
 194         AD3552R_CH_GAIN_SCALING_1,
 195         /* Gain scaling of 0.5 */
 196         AD3552R_CH_GAIN_SCALING_0_5,
 197         /* Gain scaling of 0.25 */
 198         AD3552R_CH_GAIN_SCALING_0_25,
 199         /* Gain scaling of 0.125 */
 200         AD3552R_CH_GAIN_SCALING_0_125,
 201 };
 202
 203 /* Gain * AD3552R_GAIN_SCALE */
 204 static const s32 gains_scaling_table[] = {
 205         [AD3552R_CH_GAIN_SCALING_1]             = 1000,
 206         [AD3552R_CH_GAIN_SCALING_0_5]           = 500,
 207         [AD3552R_CH_GAIN_SCALING_0_25]          = 250,
 208         [AD3552R_CH_GAIN_SCALING_0_125]         = 125
 209 };
 210
 211 enum ad3552r_dev_attributes {
 212         /* - Direct register values */
 213         /* From 0-3 */
 214         AD3552R_SDO_DRIVE_STRENGTH,
 215         /*
 216          * 0 -> Internal Vref, vref_io pin floating (default)
 217          * 1 -> Internal Vref, vref_io driven by internal vref
 218          * 2 or 3 -> External Vref
 219          */
 220         AD3552R_VREF_SELECT,
 221         /* Read registers in ascending order if set. Else descending */
 222         AD3552R_ADDR_ASCENSION,
 223 };
 224
 225 enum ad3552r_ch_attributes {
 226         /* DAC powerdown */
 227         AD3552R_CH_DAC_POWERDOWN,
 228         /* DAC amplifier powerdown */
 229         AD3552R_CH_AMPLIFIER_POWERDOWN,
 230         /* Select the output range. Select from enum ad3552r_ch_output_range */
 231         AD3552R_CH_OUTPUT_RANGE_SEL,
 232         /*
 233          * Over-rider the range selector in order to manually set the output
 234          * voltage range
 235          */
 236         AD3552R_CH_RANGE_OVERRIDE,
 237         /* Manually set the offset voltage */
 238         AD3552R_CH_GAIN_OFFSET,
 239         /* Sets the polarity of the offset. */
 240         AD3552R_CH_GAIN_OFFSET_POLARITY,
 241         /* PDAC gain scaling */
 242         AD3552R_CH_GAIN_SCALING_P,
 243         /* NDAC gain scaling */
 244         AD3552R_CH_GAIN_SCALING_N,
 245         /* Rfb value */
 246         AD3552R_CH_RFB,
 247         /* Channel select. When set allow Input -> DAC and Mask -> DAC */
 248         AD3552R_CH_SELECT,
 249 };
 250
 251 struct ad3552r_ch_data {
 252         s32     scale_int;
 253         s32     scale_dec;
 254         s32     offset_int;
 255         s32     offset_dec;
 256         s16     gain_offset;
 257         u16     rfb;
 258         u8      n;
 259         u8      p;
 260         u8      range;
 261         bool    range_override;
 262 };
 263
 264 struct ad3552r_desc {
 265         /* Used to look the spi bus for atomic operations where needed */
 266         struct mutex            lock;
 267         struct gpio_desc        *gpio_reset;
 268         struct gpio_desc        *gpio_ldac;
 269         struct spi_device       *spi;
 270         struct ad3552r_ch_data  ch_data[AD3552R_NUM_CH];
 271         struct iio_chan_spec    channels[AD3552R_NUM_CH + 1];
 272         unsigned long           enabled_ch;
 273         unsigned int            num_ch;
 274         enum ad3542r_id         chip_id;
 275 };
 276
 277 static const u16 addr_mask_map[][2] = {
 278         [AD3552R_ADDR_ASCENSION] = {
 279                         AD3552R_REG_ADDR_INTERFACE_CONFIG_A,
 280                         AD3552R_MASK_ADDR_ASCENSION
 281         },
 282         [AD3552R_SDO_DRIVE_STRENGTH] = {
 283                         AD3552R_REG_ADDR_INTERFACE_CONFIG_D,
 284                         AD3552R_MASK_SDO_DRIVE_STRENGTH
 285         },
 286         [AD3552R_VREF_SELECT] = {
 287                         AD3552R_REG_ADDR_SH_REFERENCE_CONFIG,
 288                         AD3552R_MASK_REFERENCE_VOLTAGE_SEL
 289         },
 290 };
 291
 292 /* 0 -> reg addr, 1->ch0 mask, 2->ch1 mask */
 293 static const u16 addr_mask_map_ch[][3] = {
 294         [AD3552R_CH_DAC_POWERDOWN] = {
 295                         AD3552R_REG_ADDR_POWERDOWN_CONFIG,
 296                         AD3552R_MASK_CH_DAC_POWERDOWN(0),
 297                         AD3552R_MASK_CH_DAC_POWERDOWN(1)
 298         },
 299         [AD3552R_CH_AMPLIFIER_POWERDOWN] = {
 300                         AD3552R_REG_ADDR_POWERDOWN_CONFIG,
 301                         AD3552R_MASK_CH_AMPLIFIER_POWERDOWN(0),
 302                         AD3552R_MASK_CH_AMPLIFIER_POWERDOWN(1)
 303         },
 304         [AD3552R_CH_OUTPUT_RANGE_SEL] = {
 305                         AD3552R_REG_ADDR_CH0_CH1_OUTPUT_RANGE,
 306                         AD3552R_MASK_CH_OUTPUT_RANGE_SEL(0),
 307                         AD3552R_MASK_CH_OUTPUT_RANGE_SEL(1)
 308         },
 309         [AD3552R_CH_SELECT] = {
 310                         AD3552R_REG_ADDR_CH_SELECT_16B,
 311                         AD3552R_MASK_CH(0),
 312                         AD3552R_MASK_CH(1)
 313         }
 314 };
 315
 316 static u8 _ad3552r_reg_len(u8 addr)
 317 {
 318         switch (addr) {
 319         case AD3552R_REG_ADDR_HW_LDAC_16B:
 320         case AD3552R_REG_ADDR_CH_SELECT_16B:
 321         case AD3552R_REG_ADDR_SW_LDAC_16B:
 322         case AD3552R_REG_ADDR_HW_LDAC_24B:
 323         case AD3552R_REG_ADDR_CH_SELECT_24B:
 324         case AD3552R_REG_ADDR_SW_LDAC_24B:
 325                 return 1;
 326         default:
 327                 break;
 328         }
 329
 330         if (addr > AD3552R_REG_ADDR_HW_LDAC_24B)
 331                 return 3;
 332         if (addr > AD3552R_REG_ADDR_HW_LDAC_16B)
 333                 return 2;
 334
 335         return 1;
 336 }
 337
 338 /* SPI transfer to device */
 339 static int ad3552r_transfer(struct ad3552r_desc *dac, u8 addr, u32 len,
 340                             u8 *data, bool is_read)
 341 {
 342         /* Maximum transfer: Addr (1B) + 2 * (Data Reg (3B)) + SW LDAC(1B) */
 343         u8 buf[8];
 344
 345         buf[0] = addr & AD3552R_ADDR_MASK;
 346         buf[0] |= is_read ? AD3552R_READ_BIT : 0;
 347         if (is_read)
 348                 return spi_write_then_read(dac->spi, buf, 1, data, len);
 349
 350         memcpy(buf + 1, data, len);
 351         return spi_write_then_read(dac->spi, buf, len + 1, NULL, 0);
 352 }
 353
 354 static int ad3552r_write_reg(struct ad3552r_desc *dac, u8 addr, u16 val)
 355 {
 356         u8 reg_len;
 357         u8 buf[AD3552R_MAX_REG_SIZE] = { 0 };
 358
 359         reg_len = _ad3552r_reg_len(addr);
 360         if (reg_len == 2)
 361                 /* Only DAC register are 2 bytes wide */
 362                 val &= AD3552R_MASK_DAC_12B;
 363         if (reg_len == 1)
 364                 buf[0] = val & 0xFF;
 365         else
 366                 /* reg_len can be 2 or 3, but 3rd bytes needs to be set to 0 */
 367                 put_unaligned_be16(val, buf);
 368
 369         return ad3552r_transfer(dac, addr, reg_len, buf, false);
 370 }
 371
 372 static int ad3552r_read_reg(struct ad3552r_desc *dac, u8 addr, u16 *val)
 373 {
 374         int err;
 375         u8  reg_len, buf[AD3552R_MAX_REG_SIZE] = { 0 };
 376
 377         reg_len = _ad3552r_reg_len(addr);
 378         err = ad3552r_transfer(dac, addr, reg_len, buf, true);
 379         if (err)
 380                 return err;
 381
 382         if (reg_len == 1)
 383                 *val = buf[0];
 384         else
 385                 /* reg_len can be 2 or 3, but only first 2 bytes are relevant */
 386                 *val = get_unaligned_be16(buf);
 387
 388         return 0;
 389 }
 390
 391 static u16 ad3552r_field_prep(u16 val, u16 mask)
 392 {
 393         return (val << __ffs(mask)) & mask;
 394 }
 395
 396 /* Update field of a register, shift val if needed */
 397 static int ad3552r_update_reg_field(struct ad3552r_desc *dac, u8 addr, u16 mask,
 398                                     u16 val)
 399 {
 400         int ret;
 401         u16 reg;
 402
 403         ret = ad3552r_read_reg(dac, addr, &reg);
 404         if (ret < 0)
 405                 return ret;
 406
 407         reg &= ~mask;
 408         reg |= ad3552r_field_prep(val, mask);
 409
 410         return ad3552r_write_reg(dac, addr, reg);
 411 }
 412
 413 static int ad3552r_set_ch_value(struct ad3552r_desc *dac,
 414                                 enum ad3552r_ch_attributes attr,
 415                                 u8 ch,
 416                                 u16 val)
 417 {
 418         /* Update register related to attributes in chip */
 419         return ad3552r_update_reg_field(dac, addr_mask_map_ch[attr][0],
 420                                        addr_mask_map_ch[attr][ch + 1], val);
 421 }
 422
 423 #define AD3552R_CH_DAC(_idx) ((struct iio_chan_spec) {          \
 424         .type = IIO_VOLTAGE,                                    \
 425         .output = true,                                         \
 426         .indexed = true,                                        \
 427         .channel = _idx,                                        \
 428         .scan_index = _idx,                                     \
 429         .scan_type = {                                          \
 430                 .sign = 'u',                                    \
 431                 .realbits = 16,                                 \
 432                 .storagebits = 16,                              \
 433                 .endianness = IIO_BE,                           \
 434         },                                                      \
 435         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
 436                                 BIT(IIO_CHAN_INFO_SCALE) |      \
 437                                 BIT(IIO_CHAN_INFO_ENABLE) |     \
 438                                 BIT(IIO_CHAN_INFO_OFFSET),      \
 439 })
 440
 441 static int ad3552r_read_raw(struct iio_dev *indio_dev,
 442                             struct iio_chan_spec const *chan,
 443                             int *val,
 444                             int *val2,
 445                             long mask)
 446 {
 447         struct ad3552r_desc *dac = iio_priv(indio_dev);
 448         u16 tmp_val;
 449         int err;
 450         u8 ch = chan->channel;
 451
 452         switch (mask) {
 453         case IIO_CHAN_INFO_RAW:
 454                 mutex_lock(&dac->lock);
 455                 err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_CH_DAC_24B(ch),
 456                                        &tmp_val);
 457                 mutex_unlock(&dac->lock);
 458                 if (err < 0)
 459                         return err;
 460                 *val = tmp_val;
 461                 return IIO_VAL_INT;
 462         case IIO_CHAN_INFO_ENABLE:
 463                 mutex_lock(&dac->lock);
 464                 err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_POWERDOWN_CONFIG,
 465                                        &tmp_val);
 466                 mutex_unlock(&dac->lock);
 467                 if (err < 0)
 468                         return err;
 469                 *val = !((tmp_val & AD3552R_MASK_CH_DAC_POWERDOWN(ch)) >>
 470                           __ffs(AD3552R_MASK_CH_DAC_POWERDOWN(ch)));
 471                 return IIO_VAL_INT;
 472         case IIO_CHAN_INFO_SCALE:
 473                 *val = dac->ch_data[ch].scale_int;
 474                 *val2 = dac->ch_data[ch].scale_dec;
 475                 return IIO_VAL_INT_PLUS_MICRO;
 476         case IIO_CHAN_INFO_OFFSET:
 477                 *val = dac->ch_data[ch].offset_int;
 478                 *val2 = dac->ch_data[ch].offset_dec;
 479                 return IIO_VAL_INT_PLUS_MICRO;
 480         default:
 481                 return -EINVAL;
 482         }
 483 }
 484
 485 static int ad3552r_write_raw(struct iio_dev *indio_dev,
 486                              struct iio_chan_spec const *chan,
 487                              int val,
 488                              int val2,
 489                              long mask)
 490 {
 491         struct ad3552r_desc *dac = iio_priv(indio_dev);
 492         int err;
 493
 494         mutex_lock(&dac->lock);
 495         switch (mask) {
 496         case IIO_CHAN_INFO_RAW:
 497                 err = ad3552r_write_reg(dac,
 498                                         AD3552R_REG_ADDR_CH_DAC_24B(chan->channel),
 499                                         val);
 500                 break;
 501         case IIO_CHAN_INFO_ENABLE:
 502                 err = ad3552r_set_ch_value(dac, AD3552R_CH_DAC_POWERDOWN,
 503                                            chan->channel, !val);
 504                 break;
 505         default:
 506                 err = -EINVAL;
 507                 break;
 508         }
 509         mutex_unlock(&dac->lock);
 510
 511         return err;
 512 }
 513
 514 static const struct iio_info ad3552r_iio_info = {
 515         .read_raw = ad3552r_read_raw,
 516         .write_raw = ad3552r_write_raw
 517 };
 518
 519 static int32_t ad3552r_trigger_hw_ldac(struct gpio_desc *ldac)
 520 {
 521         gpiod_set_value_cansleep(ldac, 0);
 522         usleep_range(AD3552R_LDAC_PULSE_US, AD3552R_LDAC_PULSE_US + 10);
 523         gpiod_set_value_cansleep(ldac, 1);
 524
 525         return 0;
 526 }
 527
 528 static int ad3552r_write_all_channels(struct ad3552r_desc *dac, u8 *data)
 529 {
 530         int err, len;
 531         u8 addr, buff[AD3552R_NUM_CH * AD3552R_MAX_REG_SIZE + 1];
 532
 533         addr = AD3552R_REG_ADDR_CH_INPUT_24B(1);
 534         /* CH1 */
 535         memcpy(buff, data + 2, 2);
 536         buff[2] = 0;
 537         /* CH0 */
 538         memcpy(buff + 3, data, 2);
 539         buff[5] = 0;
 540         len = 6;
 541         if (!dac->gpio_ldac) {
 542                 /* Software LDAC */
 543                 buff[6] = AD3552R_MASK_ALL_CH;
 544                 ++len;
 545         }
 546         err = ad3552r_transfer(dac, addr, len, buff, false);
 547         if (err)
 548                 return err;
 549
 550         if (dac->gpio_ldac)
 551                 return ad3552r_trigger_hw_ldac(dac->gpio_ldac);
 552
 553         return 0;
 554 }
 555
 556 static int ad3552r_write_codes(struct ad3552r_desc *dac, u32 mask, u8 *data)
 557 {
 558         int err;
 559         u8 addr, buff[AD3552R_MAX_REG_SIZE];
 560
 561         if (mask == AD3552R_MASK_ALL_CH) {
 562                 if (memcmp(data, data + 2, 2) != 0)
 563                         return ad3552r_write_all_channels(dac, data);
 564
 565                 addr = AD3552R_REG_ADDR_INPUT_PAGE_MASK_24B;
 566         } else {
 567                 addr = AD3552R_REG_ADDR_CH_INPUT_24B(__ffs(mask));
 568         }
 569
 570         memcpy(buff, data, 2);
 571         buff[2] = 0;
 572         err = ad3552r_transfer(dac, addr, 3, data, false);
 573         if (err)
 574                 return err;
 575
 576         if (dac->gpio_ldac)
 577                 return ad3552r_trigger_hw_ldac(dac->gpio_ldac);
 578
 579         return ad3552r_write_reg(dac, AD3552R_REG_ADDR_SW_LDAC_24B, mask);
 580 }
 581
 582 static irqreturn_t ad3552r_trigger_handler(int irq, void *p)
 583 {
 584         struct iio_poll_func *pf = p;
 585         struct iio_dev *indio_dev = pf->indio_dev;
 586         struct iio_buffer *buf = indio_dev->buffer;
 587         struct ad3552r_desc *dac = iio_priv(indio_dev);
 588         /* Maximum size of a scan */
 589         u8 buff[AD3552R_NUM_CH * AD3552R_MAX_REG_SIZE];
 590         int err;
 591
 592         memset(buff, 0, sizeof(buff));
 593         err = iio_pop_from_buffer(buf, buff);
 594         if (err)
 595                 goto end;
 596
 597         mutex_lock(&dac->lock);
 598         ad3552r_write_codes(dac, *indio_dev->active_scan_mask, buff);
 599         mutex_unlock(&dac->lock);
 600 end:
 601         iio_trigger_notify_done(indio_dev->trig);
 602
 603         return IRQ_HANDLED;
 604 }
 605
 606 static int ad3552r_check_scratch_pad(struct ad3552r_desc *dac)
 607 {
 608         const u16 val1 = AD3552R_SCRATCH_PAD_TEST_VAL1;
 609         const u16 val2 = AD3552R_SCRATCH_PAD_TEST_VAL2;
 610         u16 val;
 611         int err;
 612
 613         err = ad3552r_write_reg(dac, AD3552R_REG_ADDR_SCRATCH_PAD, val1);
 614         if (err < 0)
 615                 return err;
 616
 617         err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_SCRATCH_PAD, &val);
 618         if (err < 0)
 619                 return err;
 620
 621         if (val1 != val)
 622                 return -ENODEV;
 623
 624         err = ad3552r_write_reg(dac, AD3552R_REG_ADDR_SCRATCH_PAD, val2);
 625         if (err < 0)
 626                 return err;
 627
 628         err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_SCRATCH_PAD, &val);
 629         if (err < 0)
 630                 return err;
 631
 632         if (val2 != val)
 633                 return -ENODEV;
 634
 635         return 0;
 636 }
 637
 638 struct reg_addr_pool {
 639         struct ad3552r_desc *dac;
 640         u8                  addr;
 641 };
 642
 643 static int ad3552r_read_reg_wrapper(struct reg_addr_pool *addr)
 644 {
 645         int err;
 646         u16 val;
 647
 648         err = ad3552r_read_reg(addr->dac, addr->addr, &val);
 649         if (err)
 650                 return err;
 651
 652         return val;
 653 }
 654
 655 static int ad3552r_reset(struct ad3552r_desc *dac)
 656 {
 657         struct reg_addr_pool addr;
 658         int ret;
 659         int val;
 660
 661         dac->gpio_reset = devm_gpiod_get_optional(&dac->spi->dev, "reset",
 662                                                   GPIOD_OUT_LOW);
 663         if (IS_ERR(dac->gpio_reset))
 664                 return dev_err_probe(&dac->spi->dev, PTR_ERR(dac->gpio_reset),
 665                                      "Error while getting gpio reset");
 666
 667         if (dac->gpio_reset) {
 668                 /* Perform hardware reset */
 669                 usleep_range(10, 20);
 670                 gpiod_set_value_cansleep(dac->gpio_reset, 1);
 671         } else {
 672                 /* Perform software reset if no GPIO provided */
 673                 ret = ad3552r_update_reg_field(dac,
 674                                                AD3552R_REG_ADDR_INTERFACE_CONFIG_A,
 675                                                AD3552R_MASK_SOFTWARE_RESET,
 676                                                AD3552R_MASK_SOFTWARE_RESET);
 677                 if (ret < 0)
 678                         return ret;
 679
 680         }
 681
 682         addr.dac = dac;
 683         addr.addr = AD3552R_REG_ADDR_INTERFACE_CONFIG_B;
 684         ret = readx_poll_timeout(ad3552r_read_reg_wrapper, &addr, val,
 685                                  val == AD3552R_DEFAULT_CONFIG_B_VALUE ||
 686                                  val < 0,
 687                                  5000, 50000);
 688         if (val < 0)
 689                 ret = val;
 690         if (ret) {
 691                 dev_err(&dac->spi->dev, "Error while resetting");
 692                 return ret;
 693         }
 694
 695         ret = readx_poll_timeout(ad3552r_read_reg_wrapper, &addr, val,
 696                                  !(val & AD3552R_MASK_INTERFACE_NOT_READY) ||
 697                                  val < 0,
 698                                  5000, 50000);
 699         if (val < 0)
 700                 ret = val;
 701         if (ret) {
 702                 dev_err(&dac->spi->dev, "Error while resetting");
 703                 return ret;
 704         }
 705
 706         return ad3552r_update_reg_field(dac,
 707                                         addr_mask_map[AD3552R_ADDR_ASCENSION][0],
 708                                         addr_mask_map[AD3552R_ADDR_ASCENSION][1],
 709                                         val);
 710 }
 711
 712 static void ad3552r_get_custom_range(struct ad3552r_desc *dac, s32 i, s32 *v_min,
 713                                      s32 *v_max)
 714 {
 715         s64 vref, tmp, common, offset, gn, gp;
 716         /*
 717          * From datasheet formula (In Volts):
 718          *      Vmin = 2.5 + [(GainN + Offset / 1024) * 2.5 * Rfb * 1.03]
 719          *      Vmax = 2.5 - [(GainP + Offset / 1024) * 2.5 * Rfb * 1.03]
 720          * Calculus are converted to milivolts
 721          */
 722         vref = 2500;
 723         /* 2.5 * 1.03 * 1000 (To mV) */
 724         common = 2575 * dac->ch_data[i].rfb;
 725         offset = dac->ch_data[i].gain_offset;
 726
 727         gn = gains_scaling_table[dac->ch_data[i].n];
 728         tmp = (1024 * gn + AD3552R_GAIN_SCALE * offset) * common;
 729         tmp = div_s64(tmp, 1024  * AD3552R_GAIN_SCALE);
 730         *v_max = vref + tmp;
 731
 732         gp = gains_scaling_table[dac->ch_data[i].p];
 733         tmp = (1024 * gp - AD3552R_GAIN_SCALE * offset) * common;
 734         tmp = div_s64(tmp, 1024 * AD3552R_GAIN_SCALE);
 735         *v_min = vref - tmp;
 736 }
 737
 738 static void ad3552r_calc_gain_and_offset(struct ad3552r_desc *dac, s32 ch)
 739 {
 740         s32 idx, v_max, v_min, span, rem;
 741         s64 tmp;
 742
 743         if (dac->ch_data[ch].range_override) {
 744                 ad3552r_get_custom_range(dac, ch, &v_min, &v_max);
 745         } else {
 746                 /* Normal range */
 747                 idx = dac->ch_data[ch].range;
 748                 if (dac->chip_id == AD3542R_ID) {
 749                         v_min = ad3542r_ch_ranges[idx][0];
 750                         v_max = ad3542r_ch_ranges[idx][1];
 751                 } else {
 752                         v_min = ad3552r_ch_ranges[idx][0];
 753                         v_max = ad3552r_ch_ranges[idx][1];
 754                 }
 755         }
 756
 757         /*
 758          * From datasheet formula:
 759          *      Vout = Span * (D / 65536) + Vmin
 760          * Converted to scale and offset:
 761          *      Scale = Span / 65536
 762          *      Offset = 65536 * Vmin / Span
 763          *
 764          * Reminders are in micros in order to be printed as
 765          * IIO_VAL_INT_PLUS_MICRO
 766          */
 767         span = v_max - v_min;
 768         dac->ch_data[ch].scale_int = div_s64_rem(span, 65536, &rem);
 769         /* Do operations in microvolts */
 770         dac->ch_data[ch].scale_dec = DIV_ROUND_CLOSEST((s64)rem * 1000000,
 771                                                         65536);
 772
 773         dac->ch_data[ch].offset_int = div_s64_rem(v_min * 65536, span, &rem);
 774         tmp = (s64)rem * 1000000;
 775         dac->ch_data[ch].offset_dec = div_s64(tmp, span);
 776 }
 777
 778 static int ad3552r_find_range(u16 id, s32 *vals)
 779 {
 780         int i, len;
 781         const s32 (*ranges)[2];
 782
 783         if (id == AD3542R_ID) {
 784                 len = ARRAY_SIZE(ad3542r_ch_ranges);
 785                 ranges = ad3542r_ch_ranges;
 786         } else {
 787                 len = ARRAY_SIZE(ad3552r_ch_ranges);
 788                 ranges = ad3552r_ch_ranges;
 789         }
 790
 791         for (i = 0; i < len; i++)
 792                 if (vals[0] == ranges[i][0] * 1000 &&
 793                     vals[1] == ranges[i][1] * 1000)
 794                         return i;
 795
 796         return -EINVAL;
 797 }
 798
 799 static int ad3552r_configure_custom_gain(struct ad3552r_desc *dac,
 800                                          struct fwnode_handle *child,
 801                                          u32 ch)
 802 {
 803         struct device *dev = &dac->spi->dev;
 804         struct fwnode_handle *gain_child;
 805         u32 val;
 806         int err;
 807         u8 addr;
 808         u16 reg = 0, offset;
 809
 810         gain_child = fwnode_get_named_child_node(child,
 811                                                  "custom-output-range-config");
 812         if (!gain_child) {
 813                 dev_err(dev,
 814                         "mandatory custom-output-range-config property missing\n");
 815                 return -EINVAL;
 816         }
 817
 818         dac->ch_data[ch].range_override = 1;
 819         reg |= ad3552r_field_prep(1, AD3552R_MASK_CH_RANGE_OVERRIDE);
 820
 821         err = fwnode_property_read_u32(gain_child, "adi,gain-scaling-p", &val);
 822         if (err) {
 823                 dev_err(dev, "mandatory adi,gain-scaling-p property missing\n");
 824                 goto put_child;
 825         }
 826         reg |= ad3552r_field_prep(val, AD3552R_MASK_CH_GAIN_SCALING_P);
 827         dac->ch_data[ch].p = val;
 828
 829         err = fwnode_property_read_u32(gain_child, "adi,gain-scaling-n", &val);
 830         if (err) {
 831                 dev_err(dev, "mandatory adi,gain-scaling-n property missing\n");
 832                 goto put_child;
 833         }
 834         reg |= ad3552r_field_prep(val, AD3552R_MASK_CH_GAIN_SCALING_N);
 835         dac->ch_data[ch].n = val;
 836
 837         err = fwnode_property_read_u32(gain_child, "adi,rfb-ohms", &val);
 838         if (err) {
 839                 dev_err(dev, "mandatory adi,rfb-ohms property missing\n");
 840                 goto put_child;
 841         }
 842         dac->ch_data[ch].rfb = val;
 843
 844         err = fwnode_property_read_u32(gain_child, "adi,gain-offset", &val);
 845         if (err) {
 846                 dev_err(dev, "mandatory adi,gain-offset property missing\n");
 847                 goto put_child;
 848         }
 849         dac->ch_data[ch].gain_offset = val;
 850
 851         offset = abs((s32)val);
 852         reg |= ad3552r_field_prep((offset >> 8), AD3552R_MASK_CH_OFFSET_BIT_8);
 853
 854         reg |= ad3552r_field_prep((s32)val < 0, AD3552R_MASK_CH_OFFSET_POLARITY);
 855         addr = AD3552R_REG_ADDR_CH_GAIN(ch);
 856         err = ad3552r_write_reg(dac, addr,
 857                                 offset & AD3552R_MASK_CH_OFFSET_BITS_0_7);
 858         if (err) {
 859                 dev_err(dev, "Error writing register\n");
 860                 goto put_child;
 861         }
 862
 863         err = ad3552r_write_reg(dac, addr, reg);
 864         if (err) {
 865                 dev_err(dev, "Error writing register\n");
 866                 goto put_child;
 867         }
 868
 869 put_child:
 870         fwnode_handle_put(gain_child);
 871
 872         return err;
 873 }
 874
 875 static void ad3552r_reg_disable(void *reg)
 876 {
 877         regulator_disable(reg);
 878 }
 879
 880 static int ad3552r_configure_device(struct ad3552r_desc *dac)
 881 {
 882         struct device *dev = &dac->spi->dev;
 883         struct fwnode_handle *child;
 884         struct regulator *vref;
 885         int err, cnt = 0, voltage, delta = 100000;
 886         u32 vals[2], val, ch;
 887
 888         dac->gpio_ldac = devm_gpiod_get_optional(dev, "ldac", GPIOD_OUT_HIGH);
 889         if (IS_ERR(dac->gpio_ldac))
 890                 return dev_err_probe(dev, PTR_ERR(dac->gpio_ldac),
 891                                      "Error getting gpio ldac");
 892
 893         vref = devm_regulator_get_optional(dev, "vref");
 894         if (IS_ERR(vref)) {
 895                 if (PTR_ERR(vref) != -ENODEV)
 896                         return dev_err_probe(dev, PTR_ERR(vref),
 897                                              "Error getting vref");
 898
 899                 if (device_property_read_bool(dev, "adi,vref-out-en"))
 900                         val = AD3552R_INTERNAL_VREF_PIN_2P5V;
 901                 else
 902                         val = AD3552R_INTERNAL_VREF_PIN_FLOATING;
 903         } else {
 904                 err = regulator_enable(vref);
 905                 if (err) {
 906                         dev_err(dev, "Failed to enable external vref supply\n");
 907                         return err;
 908                 }
 909
 910                 err = devm_add_action_or_reset(dev, ad3552r_reg_disable, vref);
 911                 if (err) {
 912                         regulator_disable(vref);
 913                         return err;
 914                 }
 915
 916                 voltage = regulator_get_voltage(vref);
 917                 if (voltage > 2500000 + delta || voltage < 2500000 - delta) {
 918                         dev_warn(dev, "vref-supply must be 2.5V");
 919                         return -EINVAL;
 920                 }
 921                 val = AD3552R_EXTERNAL_VREF_PIN_INPUT;
 922         }
 923
 924         err = ad3552r_update_reg_field(dac,
 925                                        addr_mask_map[AD3552R_VREF_SELECT][0],
 926                                        addr_mask_map[AD3552R_VREF_SELECT][1],
 927                                        val);
 928         if (err)
 929                 return err;
 930
 931         err = device_property_read_u32(dev, "adi,sdo-drive-strength", &val);
 932         if (!err) {
 933                 if (val > 3) {
 934                         dev_err(dev, "adi,sdo-drive-strength must be less than 4\n");
 935                         return -EINVAL;
 936                 }
 937
 938                 err = ad3552r_update_reg_field(dac,
 939                                                addr_mask_map[AD3552R_SDO_DRIVE_STRENGTH][0],
 940                                                addr_mask_map[AD3552R_SDO_DRIVE_STRENGTH][1],
 941                                                val);
 942                 if (err)
 943                         return err;
 944         }
 945
 946         dac->num_ch = device_get_child_node_count(dev);
 947         if (!dac->num_ch) {
 948                 dev_err(dev, "No channels defined\n");
 949                 return -ENODEV;
 950         }
 951
 952         device_for_each_child_node(dev, child) {
 953                 err = fwnode_property_read_u32(child, "reg", &ch);
 954                 if (err) {
 955                         dev_err(dev, "mandatory reg property missing\n");
 956                         goto put_child;
 957                 }
 958                 if (ch >= AD3552R_NUM_CH) {
 959                         dev_err(dev, "reg must be less than %d\n",
 960                                 AD3552R_NUM_CH);
 961                         err = -EINVAL;
 962                         goto put_child;
 963                 }
 964
 965                 if (fwnode_property_present(child, "adi,output-range-microvolt")) {
 966                         err = fwnode_property_read_u32_array(child,
 967                                                              "adi,output-range-microvolt",
 968                                                              vals,
 969                                                              2);
 970                         if (err) {
 971                                 dev_err(dev,
 972                                         "adi,output-range-microvolt property could not be parsed\n");
 973                                 goto put_child;
 974                         }
 975
 976                         err = ad3552r_find_range(dac->chip_id, vals);
 977                         if (err < 0) {
 978                                 dev_err(dev,
 979                                         "Invalid adi,output-range-microvolt value\n");
 980                                 goto put_child;
 981                         }
 982                         val = err;
 983                         err = ad3552r_set_ch_value(dac,
 984                                                    AD3552R_CH_OUTPUT_RANGE_SEL,
 985                                                    ch, val);
 986                         if (err)
 987                                 goto put_child;
 988
 989                         dac->ch_data[ch].range = val;
 990                 } else if (dac->chip_id == AD3542R_ID) {
 991                         dev_err(dev,
 992                                 "adi,output-range-microvolt is required for ad3542r\n");
 993                         err = -EINVAL;
 994                         goto put_child;
 995                 } else {
 996                         err = ad3552r_configure_custom_gain(dac, child, ch);
 997                         if (err)
 998                                 goto put_child;
 999                 }
1000
1001                 ad3552r_calc_gain_and_offset(dac, ch);
1002                 dac->enabled_ch |= BIT(ch);
1003
1004                 err = ad3552r_set_ch_value(dac, AD3552R_CH_SELECT, ch, 1);
1005                 if (err < 0)
1006                         goto put_child;
1007
1008                 dac->channels[cnt] = AD3552R_CH_DAC(ch);
1009                 ++cnt;
1010
1011         }
1012
1013         /* Disable unused channels */
1014         for_each_clear_bit(ch, &dac->enabled_ch, AD3552R_NUM_CH) {
1015                 err = ad3552r_set_ch_value(dac, AD3552R_CH_AMPLIFIER_POWERDOWN,
1016                                            ch, 1);
1017                 if (err)
1018                         return err;
1019         }
1020
1021         dac->num_ch = cnt;
1022
1023         return 0;
1024 put_child:
1025         fwnode_handle_put(child);
1026
1027         return err;
1028 }
1029
1030 static int ad3552r_init(struct ad3552r_desc *dac)
1031 {
1032         int err;
1033         u16 val, id;
1034
1035         err = ad3552r_reset(dac);
1036         if (err) {
1037                 dev_err(&dac->spi->dev, "Reset failed\n");
1038                 return err;
1039         }
1040
1041         err = ad3552r_check_scratch_pad(dac);
1042         if (err) {
1043                 dev_err(&dac->spi->dev, "Scratch pad test failed\n");
1044                 return err;
1045         }
1046
1047         err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_PRODUCT_ID_L, &val);
1048         if (err) {
1049                 dev_err(&dac->spi->dev, "Fail read PRODUCT_ID_L\n");
1050                 return err;
1051         }
1052
1053         id = val;
1054         err = ad3552r_read_reg(dac, AD3552R_REG_ADDR_PRODUCT_ID_H, &val);
1055         if (err) {
1056                 dev_err(&dac->spi->dev, "Fail read PRODUCT_ID_H\n");
1057                 return err;
1058         }
1059
1060         id |= val << 8;
1061         if (id != dac->chip_id) {
1062                 dev_err(&dac->spi->dev, "Product id not matching\n");
1063                 return -ENODEV;
1064         }
1065
1066         return ad3552r_configure_device(dac);
1067 }
1068
1069 static int ad3552r_probe(struct spi_device *spi)
1070 {
1071         const struct spi_device_id *id = spi_get_device_id(spi);
1072         struct ad3552r_desc *dac;
1073         struct iio_dev *indio_dev;
1074         int err;
1075
1076         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*dac));
1077         if (!indio_dev)
1078                 return -ENOMEM;
1079
1080         dac = iio_priv(indio_dev);
1081         dac->spi = spi;
1082         dac->chip_id = id->driver_data;
1083
1084         mutex_init(&dac->lock);
1085
1086         err = ad3552r_init(dac);
1087         if (err)
1088                 return err;
1089
1090         /* Config triggered buffer device */
1091         if (dac->chip_id == AD3552R_ID)
1092                 indio_dev->name = "ad3552r";
1093         else
1094                 indio_dev->name = "ad3542r";
1095         indio_dev->dev.parent = &spi->dev;
1096         indio_dev->info = &ad3552r_iio_info;
1097         indio_dev->num_channels = dac->num_ch;
1098         indio_dev->channels = dac->channels;
1099         indio_dev->modes = INDIO_DIRECT_MODE;
1100
1101         err = devm_iio_triggered_buffer_setup_ext(&indio_dev->dev, indio_dev, NULL,
1102                                                   &ad3552r_trigger_handler,
1103                                                   IIO_BUFFER_DIRECTION_OUT,
1104                                                   NULL,
1105                                                   NULL);
1106         if (err)
1107                 return err;
1108
1109         return devm_iio_device_register(&spi->dev, indio_dev);
1110 }
1111
1112 static const struct spi_device_id ad3552r_id[] = {
1113         { "ad3542r", AD3542R_ID },
1114         { "ad3552r", AD3552R_ID },
1115         { }
1116 };
1117 MODULE_DEVICE_TABLE(spi, ad3552r_id);
1118
1119 static const struct of_device_id ad3552r_of_match[] = {
1120         { .compatible = "adi,ad3542r"},
1121         { .compatible = "adi,ad3552r"},
1122         { }
1123 };
1124 MODULE_DEVICE_TABLE(of, ad3552r_of_match);
1125
1126 static struct spi_driver ad3552r_driver = {
1127         .driver = {
1128                 .name = "ad3552r",
1129                 .of_match_table = ad3552r_of_match,
1130         },
1131         .probe = ad3552r_probe,
1132         .id_table = ad3552r_id
1133 };
1134 module_spi_driver(ad3552r_driver);
1135
1136 MODULE_AUTHOR("Mihail Chindris <mihail.chindris@analog.com>");
1137 MODULE_DESCRIPTION("Analog Device AD3552R DAC");
1138 MODULE_LICENSE("GPL v2");