drivers/iio/dac/ad5686.c

   1 /*
   2  * AD5686R, AD5685R, AD5684R Digital to analog converters  driver
   3  *
   4  * Copyright 2011 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/fs.h>
  11 #include <linux/device.h>
  12 #include <linux/module.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
  19 #include <linux/iio/iio.h>
  20 #include <linux/iio/sysfs.h>
  21
  22 #define AD5686_DAC_CHANNELS                     4
  23
  24 #define AD5686_ADDR(x)                          ((x) << 16)
  25 #define AD5686_CMD(x)                           ((x) << 20)
  26
  27 #define AD5686_ADDR_DAC(chan)           (0x1 << (chan))
  28 #define AD5686_ADDR_ALL_DAC                     0xF
  29
  30 #define AD5686_CMD_NOOP                         0x0
  31 #define AD5686_CMD_WRITE_INPUT_N                0x1
  32 #define AD5686_CMD_UPDATE_DAC_N                 0x2
  33 #define AD5686_CMD_WRITE_INPUT_N_UPDATE_N       0x3
  34 #define AD5686_CMD_POWERDOWN_DAC                0x4
  35 #define AD5686_CMD_LDAC_MASK                    0x5
  36 #define AD5686_CMD_RESET                        0x6
  37 #define AD5686_CMD_INTERNAL_REFER_SETUP         0x7
  38 #define AD5686_CMD_DAISY_CHAIN_ENABLE           0x8
  39 #define AD5686_CMD_READBACK_ENABLE              0x9
  40
  41 #define AD5686_LDAC_PWRDN_NONE                  0x0
  42 #define AD5686_LDAC_PWRDN_1K                    0x1
  43 #define AD5686_LDAC_PWRDN_100K                  0x2
  44 #define AD5686_LDAC_PWRDN_3STATE                0x3
  45
  46 /**
  47  * struct ad5686_chip_info - chip specific information
  48  * @int_vref_mv:        AD5620/40/60: the internal reference voltage
  49  * @channel:            channel specification
  50 */
  51
  52 struct ad5686_chip_info {
  53         u16                             int_vref_mv;
  54         struct iio_chan_spec            channel[AD5686_DAC_CHANNELS];
  55 };
  56
  57 /**
  58  * struct ad5446_state - driver instance specific data
  59  * @spi:                spi_device
  60  * @chip_info:          chip model specific constants, available modes etc
  61  * @reg:                supply regulator
  62  * @vref_mv:            actual reference voltage used
  63  * @pwr_down_mask:      power down mask
  64  * @pwr_down_mode:      current power down mode
  65  * @data:               spi transfer buffers
  66  */
  67
  68 struct ad5686_state {
  69         struct spi_device               *spi;
  70         const struct ad5686_chip_info   *chip_info;
  71         struct regulator                *reg;
  72         unsigned short                  vref_mv;
  73         unsigned                        pwr_down_mask;
  74         unsigned                        pwr_down_mode;
  75         /*
  76          * DMA (thus cache coherency maintenance) requires the
  77          * transfer buffers to live in their own cache lines.
  78          */
  79
  80         union {
  81                 u32 d32;
  82                 u8 d8[4];
  83         } data[3] ____cacheline_aligned;
  84 };
  85
  86 /**
  87  * ad5686_supported_device_ids:
  88  */
  89
  90 enum ad5686_supported_device_ids {
  91         ID_AD5684,
  92         ID_AD5685,
  93         ID_AD5686,
  94 };
  95 static int ad5686_spi_write(struct ad5686_state *st,
  96                              u8 cmd, u8 addr, u16 val, u8 shift)
  97 {
  98         val <<= shift;
  99
 100         st->data[0].d32 = cpu_to_be32(AD5686_CMD(cmd) |
 101                               AD5686_ADDR(addr) |
 102                               val);
 103
 104         return spi_write(st->spi, &st->data[0].d8[1], 3);
 105 }
 106
 107 static int ad5686_spi_read(struct ad5686_state *st, u8 addr)
 108 {
 109         struct spi_transfer t[] = {
 110                 {
 111                         .tx_buf = &st->data[0].d8[1],
 112                         .len = 3,
 113                         .cs_change = 1,
 114                 }, {
 115                         .tx_buf = &st->data[1].d8[1],
 116                         .rx_buf = &st->data[2].d8[1],
 117                         .len = 3,
 118                 },
 119         };
 120         struct spi_message m;
 121         int ret;
 122
 123         spi_message_init(&m);
 124         spi_message_add_tail(&t[0], &m);
 125         spi_message_add_tail(&t[1], &m);
 126
 127         st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) |
 128                               AD5686_ADDR(addr));
 129         st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP));
 130
 131         ret = spi_sync(st->spi, &m);
 132         if (ret < 0)
 133                 return ret;
 134
 135         return be32_to_cpu(st->data[2].d32);
 136 }
 137
 138 static const char * const ad5686_powerdown_modes[] = {
 139         "1kohm_to_gnd",
 140         "100kohm_to_gnd",
 141         "three_state"
 142 };
 143
 144 static int ad5686_get_powerdown_mode(struct iio_dev *indio_dev,
 145         const struct iio_chan_spec *chan)
 146 {
 147         struct ad5686_state *st = iio_priv(indio_dev);
 148
 149         return ((st->pwr_down_mode >> (chan->channel * 2)) & 0x3) - 1;
 150 }
 151
 152 static int ad5686_set_powerdown_mode(struct iio_dev *indio_dev,
 153         const struct iio_chan_spec *chan, unsigned int mode)
 154 {
 155         struct ad5686_state *st = iio_priv(indio_dev);
 156
 157         st->pwr_down_mode &= ~(0x3 << (chan->channel * 2));
 158         st->pwr_down_mode |= ((mode + 1) << (chan->channel * 2));
 159
 160         return 0;
 161 }
 162
 163 static const struct iio_enum ad5686_powerdown_mode_enum = {
 164         .items = ad5686_powerdown_modes,
 165         .num_items = ARRAY_SIZE(ad5686_powerdown_modes),
 166         .get = ad5686_get_powerdown_mode,
 167         .set = ad5686_set_powerdown_mode,
 168 };
 169
 170 static ssize_t ad5686_read_dac_powerdown(struct iio_dev *indio_dev,
 171         uintptr_t private, const struct iio_chan_spec *chan, char *buf)
 172 {
 173         struct ad5686_state *st = iio_priv(indio_dev);
 174
 175         return sprintf(buf, "%d\n", !!(st->pwr_down_mask &
 176                         (0x3 << (chan->channel * 2))));
 177 }
 178
 179 static ssize_t ad5686_write_dac_powerdown(struct iio_dev *indio_dev,
 180          uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
 181          size_t len)
 182 {
 183         bool readin;
 184         int ret;
 185         struct ad5686_state *st = iio_priv(indio_dev);
 186
 187         ret = strtobool(buf, &readin);
 188         if (ret)
 189                 return ret;
 190
 191         if (readin)
 192                 st->pwr_down_mask |= (0x3 << (chan->channel * 2));
 193         else
 194                 st->pwr_down_mask &= ~(0x3 << (chan->channel * 2));
 195
 196         ret = ad5686_spi_write(st, AD5686_CMD_POWERDOWN_DAC, 0,
 197                                st->pwr_down_mask & st->pwr_down_mode, 0);
 198
 199         return ret ? ret : len;
 200 }
 201
 202 static int ad5686_read_raw(struct iio_dev *indio_dev,
 203                            struct iio_chan_spec const *chan,
 204                            int *val,
 205                            int *val2,
 206                            long m)
 207 {
 208         struct ad5686_state *st = iio_priv(indio_dev);
 209         unsigned long scale_uv;
 210         int ret;
 211
 212         switch (m) {
 213         case IIO_CHAN_INFO_RAW:
 214                 mutex_lock(&indio_dev->mlock);
 215                 ret = ad5686_spi_read(st, chan->address);
 216                 mutex_unlock(&indio_dev->mlock);
 217                 if (ret < 0)
 218                         return ret;
 219                 *val = ret;
 220                 return IIO_VAL_INT;
 221                 break;
 222         case IIO_CHAN_INFO_SCALE:
 223                 scale_uv = (st->vref_mv * 100000)
 224                         >> (chan->scan_type.realbits);
 225                 *val =  scale_uv / 100000;
 226                 *val2 = (scale_uv % 100000) * 10;
 227                 return IIO_VAL_INT_PLUS_MICRO;
 228
 229         }
 230         return -EINVAL;
 231 }
 232
 233 static int ad5686_write_raw(struct iio_dev *indio_dev,
 234                                struct iio_chan_spec const *chan,
 235                                int val,
 236                                int val2,
 237                                long mask)
 238 {
 239         struct ad5686_state *st = iio_priv(indio_dev);
 240         int ret;
 241
 242         switch (mask) {
 243         case IIO_CHAN_INFO_RAW:
 244                 if (val > (1 << chan->scan_type.realbits) || val < 0)
 245                         return -EINVAL;
 246
 247                 mutex_lock(&indio_dev->mlock);
 248                 ret = ad5686_spi_write(st,
 249                                  AD5686_CMD_WRITE_INPUT_N_UPDATE_N,
 250                                  chan->address,
 251                                  val,
 252                                  chan->scan_type.shift);
 253                 mutex_unlock(&indio_dev->mlock);
 254                 break;
 255         default:
 256                 ret = -EINVAL;
 257         }
 258
 259         return ret;
 260 }
 261
 262 static const struct iio_info ad5686_info = {
 263         .read_raw = ad5686_read_raw,
 264         .write_raw = ad5686_write_raw,
 265         .driver_module = THIS_MODULE,
 266 };
 267
 268 static const struct iio_chan_spec_ext_info ad5686_ext_info[] = {
 269         {
 270                 .name = "powerdown",
 271                 .read = ad5686_read_dac_powerdown,
 272                 .write = ad5686_write_dac_powerdown,
 273         },
 274         IIO_ENUM("powerdown_mode", false, &ad5686_powerdown_mode_enum),
 275         IIO_ENUM_AVAILABLE("powerdown_mode", &ad5686_powerdown_mode_enum),
 276         { },
 277 };
 278
 279 #define AD5868_CHANNEL(chan, bits, shift) {                     \
 280                 .type = IIO_VOLTAGE,                            \
 281                 .indexed = 1,                                   \
 282                 .output = 1,                                    \
 283                 .channel = chan,                                \
 284                 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |   \
 285                 IIO_CHAN_INFO_SCALE_SHARED_BIT,                 \
 286                 .address = AD5686_ADDR_DAC(chan),                       \
 287                 .scan_type = IIO_ST('u', bits, 16, shift),      \
 288                 .ext_info = ad5686_ext_info,                    \
 289 }
 290
 291 static const struct ad5686_chip_info ad5686_chip_info_tbl[] = {
 292         [ID_AD5684] = {
 293                 .channel[0] = AD5868_CHANNEL(0, 12, 4),
 294                 .channel[1] = AD5868_CHANNEL(1, 12, 4),
 295                 .channel[2] = AD5868_CHANNEL(2, 12, 4),
 296                 .channel[3] = AD5868_CHANNEL(3, 12, 4),
 297                 .int_vref_mv = 2500,
 298         },
 299         [ID_AD5685] = {
 300                 .channel[0] = AD5868_CHANNEL(0, 14, 2),
 301                 .channel[1] = AD5868_CHANNEL(1, 14, 2),
 302                 .channel[2] = AD5868_CHANNEL(2, 14, 2),
 303                 .channel[3] = AD5868_CHANNEL(3, 14, 2),
 304                 .int_vref_mv = 2500,
 305         },
 306         [ID_AD5686] = {
 307                 .channel[0] = AD5868_CHANNEL(0, 16, 0),
 308                 .channel[1] = AD5868_CHANNEL(1, 16, 0),
 309                 .channel[2] = AD5868_CHANNEL(2, 16, 0),
 310                 .channel[3] = AD5868_CHANNEL(3, 16, 0),
 311                 .int_vref_mv = 2500,
 312         },
 313 };
 314
 315
 316 static int ad5686_probe(struct spi_device *spi)
 317 {
 318         struct ad5686_state *st;
 319         struct iio_dev *indio_dev;
 320         int ret, regdone = 0, voltage_uv = 0;
 321
 322         indio_dev = iio_device_alloc(sizeof(*st));
 323         if (indio_dev == NULL)
 324                 return  -ENOMEM;
 325
 326         st = iio_priv(indio_dev);
 327         spi_set_drvdata(spi, indio_dev);
 328
 329         st->reg = regulator_get(&spi->dev, "vcc");
 330         if (!IS_ERR(st->reg)) {
 331                 ret = regulator_enable(st->reg);
 332                 if (ret)
 333                         goto error_put_reg;
 334
 335                 ret = regulator_get_voltage(st->reg);
 336                 if (ret < 0)
 337                         goto error_disable_reg;
 338
 339                 voltage_uv = ret;
 340         }
 341
 342         st->chip_info =
 343                 &ad5686_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 344
 345         if (voltage_uv)
 346                 st->vref_mv = voltage_uv / 1000;
 347         else
 348                 st->vref_mv = st->chip_info->int_vref_mv;
 349
 350         st->spi = spi;
 351
 352         /* Set all the power down mode for all channels to 1K pulldown */
 353         st->pwr_down_mode = 0x55;
 354
 355         indio_dev->dev.parent = &spi->dev;
 356         indio_dev->name = spi_get_device_id(spi)->name;
 357         indio_dev->info = &ad5686_info;
 358         indio_dev->modes = INDIO_DIRECT_MODE;
 359         indio_dev->channels = st->chip_info->channel;
 360         indio_dev->num_channels = AD5686_DAC_CHANNELS;
 361
 362         regdone = 1;
 363         ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0,
 364                                 !!voltage_uv, 0);
 365         if (ret)
 366                 goto error_disable_reg;
 367
 368         ret = iio_device_register(indio_dev);
 369         if (ret)
 370                 goto error_disable_reg;
 371
 372         return 0;
 373
 374 error_disable_reg:
 375         if (!IS_ERR(st->reg))
 376                 regulator_disable(st->reg);
 377 error_put_reg:
 378         if (!IS_ERR(st->reg))
 379                 regulator_put(st->reg);
 380
 381         iio_device_free(indio_dev);
 382
 383         return ret;
 384 }
 385
 386 static int ad5686_remove(struct spi_device *spi)
 387 {
 388         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 389         struct ad5686_state *st = iio_priv(indio_dev);
 390
 391         iio_device_unregister(indio_dev);
 392         if (!IS_ERR(st->reg)) {
 393                 regulator_disable(st->reg);
 394                 regulator_put(st->reg);
 395         }
 396         iio_device_free(indio_dev);
 397
 398         return 0;
 399 }
 400
 401 static const struct spi_device_id ad5686_id[] = {
 402         {"ad5684", ID_AD5684},
 403         {"ad5685", ID_AD5685},
 404         {"ad5686", ID_AD5686},
 405         {}
 406 };
 407 MODULE_DEVICE_TABLE(spi, ad5686_id);
 408
 409 static struct spi_driver ad5686_driver = {
 410         .driver = {
 411                    .name = "ad5686",
 412                    .owner = THIS_MODULE,
 413                    },
 414         .probe = ad5686_probe,
 415         .remove = ad5686_remove,
 416         .id_table = ad5686_id,
 417 };
 418 module_spi_driver(ad5686_driver);
 419
 420 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 421 MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC");
 422 MODULE_LICENSE("GPL v2");