drivers/iio/dac/ad5791.c

   1 /*
   2  * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
   3  * Converter
   4  *
   5  * Copyright 2011 Analog Devices Inc.
   6  *
   7  * Licensed under the GPL-2.
   8  */
   9
  10 #include <linux/interrupt.h>
  11 #include <linux/fs.h>
  12 #include <linux/device.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  * @get_lin_comp:       function pointer to the device specific function
  66  */
  67
  68 struct ad5791_chip_info {
  69         int (*get_lin_comp)     (unsigned int span);
  70 };
  71
  72 /**
  73  * struct ad5791_state - driver instance specific data
  74  * @spi:                        spi_device
  75  * @reg_vdd:            positive supply regulator
  76  * @reg_vss:            negative supply regulator
  77  * @chip_info:          chip model specific constants
  78  * @vref_mv:            actual reference voltage used
  79  * @vref_neg_mv:        voltage of the negative supply
  80  * @pwr_down_mode       current power down mode
  81  */
  82
  83 struct ad5791_state {
  84         struct spi_device               *spi;
  85         struct regulator                *reg_vdd;
  86         struct regulator                *reg_vss;
  87         const struct ad5791_chip_info   *chip_info;
  88         unsigned short                  vref_mv;
  89         unsigned int                    vref_neg_mv;
  90         unsigned                        ctrl;
  91         unsigned                        pwr_down_mode;
  92         bool                            pwr_down;
  93
  94         union {
  95                 __be32 d32;
  96                 u8 d8[4];
  97         } data[3] ____cacheline_aligned;
  98 };
  99
 100 /**
 101  * ad5791_supported_device_ids:
 102  */
 103
 104 enum ad5791_supported_device_ids {
 105         ID_AD5760,
 106         ID_AD5780,
 107         ID_AD5781,
 108         ID_AD5791,
 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 sprintf(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 = strtobool(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 static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
 235         [ID_AD5760] = {
 236                 .get_lin_comp = ad5780_get_lin_comp,
 237         },
 238         [ID_AD5780] = {
 239                 .get_lin_comp = ad5780_get_lin_comp,
 240         },
 241         [ID_AD5781] = {
 242                 .get_lin_comp = ad5791_get_lin_comp,
 243         },
 244         [ID_AD5791] = {
 245                 .get_lin_comp = ad5791_get_lin_comp,
 246         },
 247 };
 248
 249 static int ad5791_read_raw(struct iio_dev *indio_dev,
 250                            struct iio_chan_spec const *chan,
 251                            int *val,
 252                            int *val2,
 253                            long m)
 254 {
 255         struct ad5791_state *st = iio_priv(indio_dev);
 256         u64 val64;
 257         int ret;
 258
 259         switch (m) {
 260         case IIO_CHAN_INFO_RAW:
 261                 ret = ad5791_spi_read(st, chan->address, val);
 262                 if (ret)
 263                         return ret;
 264                 *val &= AD5791_DAC_MASK;
 265                 *val >>= chan->scan_type.shift;
 266                 return IIO_VAL_INT;
 267         case IIO_CHAN_INFO_SCALE:
 268                 *val = st->vref_mv;
 269                 *val2 = (1 << chan->scan_type.realbits) - 1;
 270                 return IIO_VAL_FRACTIONAL;
 271         case IIO_CHAN_INFO_OFFSET:
 272                 val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
 273                 do_div(val64, st->vref_mv);
 274                 *val = -val64;
 275                 return IIO_VAL_INT;
 276         default:
 277                 return -EINVAL;
 278         }
 279
 280 };
 281
 282 static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
 283         {
 284                 .name = "powerdown",
 285                 .shared = IIO_SHARED_BY_TYPE,
 286                 .read = ad5791_read_dac_powerdown,
 287                 .write = ad5791_write_dac_powerdown,
 288         },
 289         IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
 290                  &ad5791_powerdown_mode_enum),
 291         IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum),
 292         { },
 293 };
 294
 295 #define AD5791_CHAN(bits, _shift) {                     \
 296         .type = IIO_VOLTAGE,                            \
 297         .output = 1,                                    \
 298         .indexed = 1,                                   \
 299         .address = AD5791_ADDR_DAC0,                    \
 300         .channel = 0,                                   \
 301         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 302         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
 303                 BIT(IIO_CHAN_INFO_OFFSET),              \
 304         .scan_type = {                                  \
 305                 .sign = 'u',                            \
 306                 .realbits = (bits),                     \
 307                 .storagebits = 24,                      \
 308                 .shift = (_shift),                      \
 309         },                                              \
 310         .ext_info = ad5791_ext_info,                    \
 311 }
 312
 313 static const struct iio_chan_spec ad5791_channels[] = {
 314         [ID_AD5760] = AD5791_CHAN(16, 4),
 315         [ID_AD5780] = AD5791_CHAN(18, 2),
 316         [ID_AD5781] = AD5791_CHAN(18, 2),
 317         [ID_AD5791] = AD5791_CHAN(20, 0)
 318 };
 319
 320 static int ad5791_write_raw(struct iio_dev *indio_dev,
 321                             struct iio_chan_spec const *chan,
 322                             int val,
 323                             int val2,
 324                             long mask)
 325 {
 326         struct ad5791_state *st = iio_priv(indio_dev);
 327
 328         switch (mask) {
 329         case IIO_CHAN_INFO_RAW:
 330                 val &= GENMASK(chan->scan_type.realbits - 1, 0);
 331                 val <<= chan->scan_type.shift;
 332
 333                 return ad5791_spi_write(st, chan->address, val);
 334
 335         default:
 336                 return -EINVAL;
 337         }
 338 }
 339
 340 static const struct iio_info ad5791_info = {
 341         .read_raw = &ad5791_read_raw,
 342         .write_raw = &ad5791_write_raw,
 343         .driver_module = THIS_MODULE,
 344 };
 345
 346 static int ad5791_probe(struct spi_device *spi)
 347 {
 348         struct ad5791_platform_data *pdata = spi->dev.platform_data;
 349         struct iio_dev *indio_dev;
 350         struct ad5791_state *st;
 351         int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
 352
 353         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 354         if (!indio_dev)
 355                 return -ENOMEM;
 356         st = iio_priv(indio_dev);
 357         st->reg_vdd = devm_regulator_get(&spi->dev, "vdd");
 358         if (!IS_ERR(st->reg_vdd)) {
 359                 ret = regulator_enable(st->reg_vdd);
 360                 if (ret)
 361                         return ret;
 362
 363                 ret = regulator_get_voltage(st->reg_vdd);
 364                 if (ret < 0)
 365                         goto error_disable_reg_pos;
 366
 367                 pos_voltage_uv = ret;
 368         }
 369
 370         st->reg_vss = devm_regulator_get(&spi->dev, "vss");
 371         if (!IS_ERR(st->reg_vss)) {
 372                 ret = regulator_enable(st->reg_vss);
 373                 if (ret)
 374                         goto error_disable_reg_pos;
 375
 376                 ret = regulator_get_voltage(st->reg_vss);
 377                 if (ret < 0)
 378                         goto error_disable_reg_neg;
 379
 380                 neg_voltage_uv = ret;
 381         }
 382
 383         st->pwr_down = true;
 384         st->spi = spi;
 385
 386         if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
 387                 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
 388                 st->vref_neg_mv = neg_voltage_uv / 1000;
 389         } else if (pdata) {
 390                 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
 391                 st->vref_neg_mv = pdata->vref_neg_mv;
 392         } else {
 393                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 394         }
 395
 396         ret = ad5791_spi_write(st, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
 397         if (ret)
 398                 goto error_disable_reg_neg;
 399
 400         st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
 401                                               ->driver_data];
 402
 403
 404         st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
 405                   | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
 406                   AD5791_CTRL_BIN2SC;
 407
 408         ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl |
 409                 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 410         if (ret)
 411                 goto error_disable_reg_neg;
 412
 413         spi_set_drvdata(spi, indio_dev);
 414         indio_dev->dev.parent = &spi->dev;
 415         indio_dev->info = &ad5791_info;
 416         indio_dev->modes = INDIO_DIRECT_MODE;
 417         indio_dev->channels
 418                 = &ad5791_channels[spi_get_device_id(spi)->driver_data];
 419         indio_dev->num_channels = 1;
 420         indio_dev->name = spi_get_device_id(st->spi)->name;
 421         ret = iio_device_register(indio_dev);
 422         if (ret)
 423                 goto error_disable_reg_neg;
 424
 425         return 0;
 426
 427 error_disable_reg_neg:
 428         if (!IS_ERR(st->reg_vss))
 429                 regulator_disable(st->reg_vss);
 430 error_disable_reg_pos:
 431         if (!IS_ERR(st->reg_vdd))
 432                 regulator_disable(st->reg_vdd);
 433         return ret;
 434 }
 435
 436 static int ad5791_remove(struct spi_device *spi)
 437 {
 438         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 439         struct ad5791_state *st = iio_priv(indio_dev);
 440
 441         iio_device_unregister(indio_dev);
 442         if (!IS_ERR(st->reg_vdd))
 443                 regulator_disable(st->reg_vdd);
 444
 445         if (!IS_ERR(st->reg_vss))
 446                 regulator_disable(st->reg_vss);
 447
 448         return 0;
 449 }
 450
 451 static const struct spi_device_id ad5791_id[] = {
 452         {"ad5760", ID_AD5760},
 453         {"ad5780", ID_AD5780},
 454         {"ad5781", ID_AD5781},
 455         {"ad5790", ID_AD5791},
 456         {"ad5791", ID_AD5791},
 457         {}
 458 };
 459 MODULE_DEVICE_TABLE(spi, ad5791_id);
 460
 461 static struct spi_driver ad5791_driver = {
 462         .driver = {
 463                    .name = "ad5791",
 464                    },
 465         .probe = ad5791_probe,
 466         .remove = ad5791_remove,
 467         .id_table = ad5791_id,
 468 };
 469 module_spi_driver(ad5791_driver);
 470
 471 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 472 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
 473 MODULE_LICENSE("GPL v2");