drivers/iio/dac/ad5791.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
   4  * Converter
   5  *
   6  * Copyright 2011 Analog Devices Inc.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/fs.h>
  11 #include <linux/device.h>
  12 #include <linux/delay.h>
  13 #include <linux/kernel.h>
  14 #include <linux/spi/spi.h>
  15 #include <linux/slab.h>
  16 #include <linux/sysfs.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/module.h>
  19 #include <linux/bitops.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23 #include <linux/iio/dac/ad5791.h>
  24
  25 #define AD5791_DAC_MASK                 GENMASK(19, 0)
  26
  27 #define AD5791_CMD_READ                 BIT(23)
  28 #define AD5791_CMD_WRITE                0
  29 #define AD5791_ADDR(addr)               ((addr) << 20)
  30
  31 /* Registers */
  32 #define AD5791_ADDR_NOOP                0
  33 #define AD5791_ADDR_DAC0                1
  34 #define AD5791_ADDR_CTRL                2
  35 #define AD5791_ADDR_CLRCODE             3
  36 #define AD5791_ADDR_SW_CTRL             4
  37
  38 /* Control Register */
  39 #define AD5791_CTRL_RBUF                BIT(1)
  40 #define AD5791_CTRL_OPGND               BIT(2)
  41 #define AD5791_CTRL_DACTRI              BIT(3)
  42 #define AD5791_CTRL_BIN2SC              BIT(4)
  43 #define AD5791_CTRL_SDODIS              BIT(5)
  44 #define AD5761_CTRL_LINCOMP(x)          ((x) << 6)
  45
  46 #define AD5791_LINCOMP_0_10             0
  47 #define AD5791_LINCOMP_10_12            1
  48 #define AD5791_LINCOMP_12_16            2
  49 #define AD5791_LINCOMP_16_19            3
  50 #define AD5791_LINCOMP_19_20            12
  51
  52 #define AD5780_LINCOMP_0_10             0
  53 #define AD5780_LINCOMP_10_20            12
  54
  55 /* Software Control Register */
  56 #define AD5791_SWCTRL_LDAC              BIT(0)
  57 #define AD5791_SWCTRL_CLR               BIT(1)
  58 #define AD5791_SWCTRL_RESET             BIT(2)
  59
  60 #define AD5791_DAC_PWRDN_6K             0
  61 #define AD5791_DAC_PWRDN_3STATE         1
  62
  63 /**
  64  * struct ad5791_chip_info - chip specific information
  65  * @name:               name of the dac chip
  66  * @channel:            channel specification
  67  * @get_lin_comp:       function pointer to the device specific function
  68  */
  69 struct ad5791_chip_info {
  70         const char *name;
  71         const struct iio_chan_spec channel;
  72         int (*get_lin_comp)(unsigned int span);
  73 };
  74
  75 /**
  76  * struct ad5791_state - driver instance specific data
  77  * @spi:                        spi_device
  78  * @reg_vdd:            positive supply regulator
  79  * @reg_vss:            negative supply regulator
  80  * @gpio_reset:         reset gpio
  81  * @gpio_clear:         clear gpio
  82  * @gpio_ldac:          load dac gpio
  83  * @chip_info:          chip model specific constants
  84  * @vref_mv:            actual reference voltage used
  85  * @vref_neg_mv:        voltage of the negative supply
  86  * @ctrl:               control register cache
  87  * @pwr_down_mode:      current power down mode
  88  * @pwr_down:           true if device is powered down
  89  * @data:               spi transfer buffers
  90  */
  91 struct ad5791_state {
  92         struct spi_device               *spi;
  93         struct regulator                *reg_vdd;
  94         struct regulator                *reg_vss;
  95         struct gpio_desc                *gpio_reset;
  96         struct gpio_desc                *gpio_clear;
  97         struct gpio_desc                *gpio_ldac;
  98         const struct ad5791_chip_info   *chip_info;
  99         unsigned short                  vref_mv;
 100         unsigned int                    vref_neg_mv;
 101         unsigned                        ctrl;
 102         unsigned                        pwr_down_mode;
 103         bool                            pwr_down;
 104
 105         union {
 106                 __be32 d32;
 107                 u8 d8[4];
 108         } data[3] __aligned(IIO_DMA_MINALIGN);
 109 };
 110
 111 static int ad5791_spi_write(struct ad5791_state *st, u8 addr, u32 val)
 112 {
 113         st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE |
 114                               AD5791_ADDR(addr) |
 115                               (val & AD5791_DAC_MASK));
 116
 117         return spi_write(st->spi, &st->data[0].d8[1], 3);
 118 }
 119
 120 static int ad5791_spi_read(struct ad5791_state *st, u8 addr, u32 *val)
 121 {
 122         int ret;
 123         struct spi_transfer xfers[] = {
 124                 {
 125                         .tx_buf = &st->data[0].d8[1],
 126                         .bits_per_word = 8,
 127                         .len = 3,
 128                         .cs_change = 1,
 129                 }, {
 130                         .tx_buf = &st->data[1].d8[1],
 131                         .rx_buf = &st->data[2].d8[1],
 132                         .bits_per_word = 8,
 133                         .len = 3,
 134                 },
 135         };
 136
 137         st->data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
 138                               AD5791_ADDR(addr));
 139         st->data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
 140
 141         ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
 142
 143         *val = be32_to_cpu(st->data[2].d32);
 144
 145         return ret;
 146 }
 147
 148 static const char * const ad5791_powerdown_modes[] = {
 149         "6kohm_to_gnd",
 150         "three_state",
 151 };
 152
 153 static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
 154         const struct iio_chan_spec *chan)
 155 {
 156         struct ad5791_state *st = iio_priv(indio_dev);
 157
 158         return st->pwr_down_mode;
 159 }
 160
 161 static int ad5791_set_powerdown_mode(struct iio_dev *indio_dev,
 162         const struct iio_chan_spec *chan, unsigned int mode)
 163 {
 164         struct ad5791_state *st = iio_priv(indio_dev);
 165
 166         st->pwr_down_mode = mode;
 167
 168         return 0;
 169 }
 170
 171 static const struct iio_enum ad5791_powerdown_mode_enum = {
 172         .items = ad5791_powerdown_modes,
 173         .num_items = ARRAY_SIZE(ad5791_powerdown_modes),
 174         .get = ad5791_get_powerdown_mode,
 175         .set = ad5791_set_powerdown_mode,
 176 };
 177
 178 static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
 179         uintptr_t private, const struct iio_chan_spec *chan, char *buf)
 180 {
 181         struct ad5791_state *st = iio_priv(indio_dev);
 182
 183         return sysfs_emit(buf, "%d\n", st->pwr_down);
 184 }
 185
 186 static ssize_t ad5791_write_dac_powerdown(struct iio_dev *indio_dev,
 187          uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
 188          size_t len)
 189 {
 190         bool pwr_down;
 191         int ret;
 192         struct ad5791_state *st = iio_priv(indio_dev);
 193
 194         ret = kstrtobool(buf, &pwr_down);
 195         if (ret)
 196                 return ret;
 197
 198         if (!pwr_down) {
 199                 st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 200         } else {
 201                 if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
 202                         st->ctrl |= AD5791_CTRL_OPGND;
 203                 else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
 204                         st->ctrl |= AD5791_CTRL_DACTRI;
 205         }
 206         st->pwr_down = pwr_down;
 207
 208         ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl);
 209
 210         return ret ? ret : len;
 211 }
 212
 213 static int ad5791_get_lin_comp(unsigned int span)
 214 {
 215         if (span <= 10000)
 216                 return AD5791_LINCOMP_0_10;
 217         else if (span <= 12000)
 218                 return AD5791_LINCOMP_10_12;
 219         else if (span <= 16000)
 220                 return AD5791_LINCOMP_12_16;
 221         else if (span <= 19000)
 222                 return AD5791_LINCOMP_16_19;
 223         else
 224                 return AD5791_LINCOMP_19_20;
 225 }
 226
 227 static int ad5780_get_lin_comp(unsigned int span)
 228 {
 229         if (span <= 10000)
 230                 return AD5780_LINCOMP_0_10;
 231         else
 232                 return AD5780_LINCOMP_10_20;
 233 }
 234
 235 static int ad5791_read_raw(struct iio_dev *indio_dev,
 236                            struct iio_chan_spec const *chan,
 237                            int *val,
 238                            int *val2,
 239                            long m)
 240 {
 241         struct ad5791_state *st = iio_priv(indio_dev);
 242         u64 val64;
 243         int ret;
 244
 245         switch (m) {
 246         case IIO_CHAN_INFO_RAW:
 247                 ret = ad5791_spi_read(st, chan->address, val);
 248                 if (ret)
 249                         return ret;
 250                 *val &= AD5791_DAC_MASK;
 251                 *val >>= chan->scan_type.shift;
 252                 return IIO_VAL_INT;
 253         case IIO_CHAN_INFO_SCALE:
 254                 *val = st->vref_mv;
 255                 *val2 = (1 << chan->scan_type.realbits) - 1;
 256                 return IIO_VAL_FRACTIONAL;
 257         case IIO_CHAN_INFO_OFFSET:
 258                 val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
 259                 do_div(val64, st->vref_mv);
 260                 *val = -val64;
 261                 return IIO_VAL_INT;
 262         default:
 263                 return -EINVAL;
 264         }
 265
 266 };
 267
 268 static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
 269         {
 270                 .name = "powerdown",
 271                 .shared = IIO_SHARED_BY_TYPE,
 272                 .read = ad5791_read_dac_powerdown,
 273                 .write = ad5791_write_dac_powerdown,
 274         },
 275         IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
 276                  &ad5791_powerdown_mode_enum),
 277         IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ad5791_powerdown_mode_enum),
 278         { },
 279 };
 280
 281 #define AD5791_DEFINE_CHIP_INFO(_name, bits, _shift, _lin_comp)         \
 282 static const struct ad5791_chip_info _name##_chip_info = {              \
 283         .name = #_name,                                                 \
 284         .get_lin_comp = &(_lin_comp),                                   \
 285         .channel = {                                                    \
 286                         .type = IIO_VOLTAGE,                            \
 287                         .output = 1,                                    \
 288                         .indexed = 1,                                   \
 289                         .address = AD5791_ADDR_DAC0,                    \
 290                         .channel = 0,                                   \
 291                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 292                         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
 293                                 BIT(IIO_CHAN_INFO_OFFSET),              \
 294                         .scan_type = {                                  \
 295                                 .sign = 'u',                            \
 296                                 .realbits = (bits),                     \
 297                                 .storagebits = 24,                      \
 298                                 .shift = (_shift),                      \
 299                         },                                              \
 300                         .ext_info = ad5791_ext_info,                    \
 301         },                                                              \
 302 }
 303
 304 AD5791_DEFINE_CHIP_INFO(ad5760, 16, 4, ad5780_get_lin_comp);
 305 AD5791_DEFINE_CHIP_INFO(ad5780, 18, 2, ad5780_get_lin_comp);
 306 AD5791_DEFINE_CHIP_INFO(ad5781, 18, 2, ad5791_get_lin_comp);
 307 AD5791_DEFINE_CHIP_INFO(ad5790, 20, 0, ad5791_get_lin_comp);
 308 AD5791_DEFINE_CHIP_INFO(ad5791, 20, 0, ad5791_get_lin_comp);
 309
 310 static int ad5791_write_raw(struct iio_dev *indio_dev,
 311                             struct iio_chan_spec const *chan,
 312                             int val,
 313                             int val2,
 314                             long mask)
 315 {
 316         struct ad5791_state *st = iio_priv(indio_dev);
 317
 318         switch (mask) {
 319         case IIO_CHAN_INFO_RAW:
 320                 val &= GENMASK(chan->scan_type.realbits - 1, 0);
 321                 val <<= chan->scan_type.shift;
 322
 323                 return ad5791_spi_write(st, chan->address, val);
 324
 325         default:
 326                 return -EINVAL;
 327         }
 328 }
 329
 330 static const struct iio_info ad5791_info = {
 331         .read_raw = &ad5791_read_raw,
 332         .write_raw = &ad5791_write_raw,
 333 };
 334
 335 static int ad5791_probe(struct spi_device *spi)
 336 {
 337         const struct ad5791_platform_data *pdata = dev_get_platdata(&spi->dev);
 338         struct iio_dev *indio_dev;
 339         struct ad5791_state *st;
 340         int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
 341         bool use_rbuf_gain2;
 342
 343         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 344         if (!indio_dev)
 345                 return -ENOMEM;
 346         st = iio_priv(indio_dev);
 347
 348         st->gpio_reset = devm_gpiod_get_optional(&spi->dev, "reset",
 349                                                  GPIOD_OUT_HIGH);
 350         if (IS_ERR(st->gpio_reset))
 351                 return PTR_ERR(st->gpio_reset);
 352
 353         st->gpio_clear = devm_gpiod_get_optional(&spi->dev, "clear",
 354                                                  GPIOD_OUT_LOW);
 355         if (IS_ERR(st->gpio_clear))
 356                 return PTR_ERR(st->gpio_clear);
 357
 358         st->gpio_ldac = devm_gpiod_get_optional(&spi->dev, "ldac",
 359                                                 GPIOD_OUT_HIGH);
 360         if (IS_ERR(st->gpio_ldac))
 361                 return PTR_ERR(st->gpio_ldac);
 362
 363         st->pwr_down = true;
 364         st->spi = spi;
 365
 366         if (pdata)
 367                 use_rbuf_gain2 = pdata->use_rbuf_gain2;
 368         else
 369                 use_rbuf_gain2 = device_property_read_bool(&spi->dev,
 370                                                            "adi,rbuf-gain2-en");
 371
 372         pos_voltage_uv = devm_regulator_get_enable_read_voltage(&spi->dev, "vdd");
 373         if (pos_voltage_uv < 0 && pos_voltage_uv != -ENODEV)
 374                 return dev_err_probe(&spi->dev, pos_voltage_uv,
 375                                      "failed to get vdd voltage\n");
 376
 377         neg_voltage_uv = devm_regulator_get_enable_read_voltage(&spi->dev, "vss");
 378         if (neg_voltage_uv < 0 && neg_voltage_uv != -ENODEV)
 379                 return dev_err_probe(&spi->dev, neg_voltage_uv,
 380                                      "failed to get vss voltage\n");
 381
 382         if (neg_voltage_uv >= 0 && pos_voltage_uv >= 0) {
 383                 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
 384                 st->vref_neg_mv = neg_voltage_uv / 1000;
 385         } else if (pdata) {
 386                 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
 387                 st->vref_neg_mv = pdata->vref_neg_mv;
 388         } else {
 389                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 390         }
 391
 392         if (st->gpio_reset) {
 393                 fsleep(20);
 394                 gpiod_set_value_cansleep(st->gpio_reset, 0);
 395         } else {
 396                 ret = ad5791_spi_write(st, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
 397                 if (ret)
 398                         return dev_err_probe(&spi->dev, ret, "fail to reset\n");
 399         }
 400
 401         st->chip_info = spi_get_device_match_data(spi);
 402         if (!st->chip_info)
 403                 return dev_err_probe(&spi->dev, -EINVAL, "no chip info\n");
 404
 405         st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
 406                   | (use_rbuf_gain2 ? 0 : AD5791_CTRL_RBUF) |
 407                   AD5791_CTRL_BIN2SC;
 408
 409         ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl |
 410                 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 411         if (ret)
 412                 return dev_err_probe(&spi->dev, ret, "fail to write ctrl register\n");
 413
 414         indio_dev->info = &ad5791_info;
 415         indio_dev->modes = INDIO_DIRECT_MODE;
 416         indio_dev->channels = &st->chip_info->channel;
 417         indio_dev->num_channels = 1;
 418         indio_dev->name = st->chip_info->name;
 419         return devm_iio_device_register(&spi->dev, indio_dev);
 420 }
 421
 422 static const struct of_device_id ad5791_of_match[] = {
 423         { .compatible = "adi,ad5760", .data = &ad5760_chip_info },
 424         { .compatible = "adi,ad5780", .data = &ad5780_chip_info },
 425         { .compatible = "adi,ad5781", .data = &ad5781_chip_info },
 426         { .compatible = "adi,ad5790", .data = &ad5790_chip_info },
 427         { .compatible = "adi,ad5791", .data = &ad5791_chip_info },
 428         { }
 429 };
 430 MODULE_DEVICE_TABLE(of, ad5791_of_match);
 431
 432 static const struct spi_device_id ad5791_id[] = {
 433         { "ad5760", (kernel_ulong_t)&ad5760_chip_info },
 434         { "ad5780", (kernel_ulong_t)&ad5780_chip_info },
 435         { "ad5781", (kernel_ulong_t)&ad5781_chip_info },
 436         { "ad5790", (kernel_ulong_t)&ad5790_chip_info },
 437         { "ad5791", (kernel_ulong_t)&ad5791_chip_info },
 438         { }
 439 };
 440 MODULE_DEVICE_TABLE(spi, ad5791_id);
 441
 442 static struct spi_driver ad5791_driver = {
 443         .driver = {
 444                    .name = "ad5791",
 445                    .of_match_table = ad5791_of_match,
 446                    },
 447         .probe = ad5791_probe,
 448         .id_table = ad5791_id,
 449 };
 450 module_spi_driver(ad5791_driver);
 451
 452 MODULE_AUTHOR("Michael Hennerich <[email protected]>");
 453 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
 454 MODULE_LICENSE("GPL v2");