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         int ret;
 121
 122         st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) |
 123                               AD5686_ADDR(addr));
 124         st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP));
 125
 126         ret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t));
 127         if (ret < 0)
 128                 return ret;
 129
 130         return be32_to_cpu(st->data[2].d32);
 131 }
 132
 133 static const char * const ad5686_powerdown_modes[] = {
 134         "1kohm_to_gnd",
 135         "100kohm_to_gnd",
 136         "three_state"
 137 };
 138
 139 static int ad5686_get_powerdown_mode(struct iio_dev *indio_dev,
 140         const struct iio_chan_spec *chan)
 141 {
 142         struct ad5686_state *st = iio_priv(indio_dev);
 143
 144         return ((st->pwr_down_mode >> (chan->channel * 2)) & 0x3) - 1;
 145 }
 146
 147 static int ad5686_set_powerdown_mode(struct iio_dev *indio_dev,
 148         const struct iio_chan_spec *chan, unsigned int mode)
 149 {
 150         struct ad5686_state *st = iio_priv(indio_dev);
 151
 152         st->pwr_down_mode &= ~(0x3 << (chan->channel * 2));
 153         st->pwr_down_mode |= ((mode + 1) << (chan->channel * 2));
 154
 155         return 0;
 156 }
 157
 158 static const struct iio_enum ad5686_powerdown_mode_enum = {
 159         .items = ad5686_powerdown_modes,
 160         .num_items = ARRAY_SIZE(ad5686_powerdown_modes),
 161         .get = ad5686_get_powerdown_mode,
 162         .set = ad5686_set_powerdown_mode,
 163 };
 164
 165 static ssize_t ad5686_read_dac_powerdown(struct iio_dev *indio_dev,
 166         uintptr_t private, const struct iio_chan_spec *chan, char *buf)
 167 {
 168         struct ad5686_state *st = iio_priv(indio_dev);
 169
 170         return sprintf(buf, "%d\n", !!(st->pwr_down_mask &
 171                         (0x3 << (chan->channel * 2))));
 172 }
 173
 174 static ssize_t ad5686_write_dac_powerdown(struct iio_dev *indio_dev,
 175          uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
 176          size_t len)
 177 {
 178         bool readin;
 179         int ret;
 180         struct ad5686_state *st = iio_priv(indio_dev);
 181
 182         ret = strtobool(buf, &readin);
 183         if (ret)
 184                 return ret;
 185
 186         if (readin)
 187                 st->pwr_down_mask |= (0x3 << (chan->channel * 2));
 188         else
 189                 st->pwr_down_mask &= ~(0x3 << (chan->channel * 2));
 190
 191         ret = ad5686_spi_write(st, AD5686_CMD_POWERDOWN_DAC, 0,
 192                                st->pwr_down_mask & st->pwr_down_mode, 0);
 193
 194         return ret ? ret : len;
 195 }
 196
 197 static int ad5686_read_raw(struct iio_dev *indio_dev,
 198                            struct iio_chan_spec const *chan,
 199                            int *val,
 200                            int *val2,
 201                            long m)
 202 {
 203         struct ad5686_state *st = iio_priv(indio_dev);
 204         int ret;
 205
 206         switch (m) {
 207         case IIO_CHAN_INFO_RAW:
 208                 mutex_lock(&indio_dev->mlock);
 209                 ret = ad5686_spi_read(st, chan->address);
 210                 mutex_unlock(&indio_dev->mlock);
 211                 if (ret < 0)
 212                         return ret;
 213                 *val = ret;
 214                 return IIO_VAL_INT;
 215         case IIO_CHAN_INFO_SCALE:
 216                 *val = st->vref_mv;
 217                 *val2 = chan->scan_type.realbits;
 218                 return IIO_VAL_FRACTIONAL_LOG2;
 219         }
 220         return -EINVAL;
 221 }
 222
 223 static int ad5686_write_raw(struct iio_dev *indio_dev,
 224                                struct iio_chan_spec const *chan,
 225                                int val,
 226                                int val2,
 227                                long mask)
 228 {
 229         struct ad5686_state *st = iio_priv(indio_dev);
 230         int ret;
 231
 232         switch (mask) {
 233         case IIO_CHAN_INFO_RAW:
 234                 if (val > (1 << chan->scan_type.realbits) || val < 0)
 235                         return -EINVAL;
 236
 237                 mutex_lock(&indio_dev->mlock);
 238                 ret = ad5686_spi_write(st,
 239                                  AD5686_CMD_WRITE_INPUT_N_UPDATE_N,
 240                                  chan->address,
 241                                  val,
 242                                  chan->scan_type.shift);
 243                 mutex_unlock(&indio_dev->mlock);
 244                 break;
 245         default:
 246                 ret = -EINVAL;
 247         }
 248
 249         return ret;
 250 }
 251
 252 static const struct iio_info ad5686_info = {
 253         .read_raw = ad5686_read_raw,
 254         .write_raw = ad5686_write_raw,
 255         .driver_module = THIS_MODULE,
 256 };
 257
 258 static const struct iio_chan_spec_ext_info ad5686_ext_info[] = {
 259         {
 260                 .name = "powerdown",
 261                 .read = ad5686_read_dac_powerdown,
 262                 .write = ad5686_write_dac_powerdown,
 263                 .shared = IIO_SEPARATE,
 264         },
 265         IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad5686_powerdown_mode_enum),
 266         IIO_ENUM_AVAILABLE("powerdown_mode", &ad5686_powerdown_mode_enum),
 267         { },
 268 };
 269
 270 #define AD5868_CHANNEL(chan, bits, shift) {                     \
 271                 .type = IIO_VOLTAGE,                            \
 272                 .indexed = 1,                                   \
 273                 .output = 1,                                    \
 274                 .channel = chan,                                \
 275                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
 276                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
 277                 .address = AD5686_ADDR_DAC(chan),               \
 278                 .scan_type = IIO_ST('u', bits, 16, shift),      \
 279                 .ext_info = ad5686_ext_info,                    \
 280 }
 281
 282 static const struct ad5686_chip_info ad5686_chip_info_tbl[] = {
 283         [ID_AD5684] = {
 284                 .channel[0] = AD5868_CHANNEL(0, 12, 4),
 285                 .channel[1] = AD5868_CHANNEL(1, 12, 4),
 286                 .channel[2] = AD5868_CHANNEL(2, 12, 4),
 287                 .channel[3] = AD5868_CHANNEL(3, 12, 4),
 288                 .int_vref_mv = 2500,
 289         },
 290         [ID_AD5685] = {
 291                 .channel[0] = AD5868_CHANNEL(0, 14, 2),
 292                 .channel[1] = AD5868_CHANNEL(1, 14, 2),
 293                 .channel[2] = AD5868_CHANNEL(2, 14, 2),
 294                 .channel[3] = AD5868_CHANNEL(3, 14, 2),
 295                 .int_vref_mv = 2500,
 296         },
 297         [ID_AD5686] = {
 298                 .channel[0] = AD5868_CHANNEL(0, 16, 0),
 299                 .channel[1] = AD5868_CHANNEL(1, 16, 0),
 300                 .channel[2] = AD5868_CHANNEL(2, 16, 0),
 301                 .channel[3] = AD5868_CHANNEL(3, 16, 0),
 302                 .int_vref_mv = 2500,
 303         },
 304 };
 305
 306
 307 static int ad5686_probe(struct spi_device *spi)
 308 {
 309         struct ad5686_state *st;
 310         struct iio_dev *indio_dev;
 311         int ret, regdone = 0, voltage_uv = 0;
 312
 313         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 314         if (indio_dev == NULL)
 315                 return  -ENOMEM;
 316
 317         st = iio_priv(indio_dev);
 318         spi_set_drvdata(spi, indio_dev);
 319
 320         st->reg = devm_regulator_get(&spi->dev, "vcc");
 321         if (!IS_ERR(st->reg)) {
 322                 ret = regulator_enable(st->reg);
 323                 if (ret)
 324                         return ret;
 325
 326                 ret = regulator_get_voltage(st->reg);
 327                 if (ret < 0)
 328                         goto error_disable_reg;
 329
 330                 voltage_uv = ret;
 331         }
 332
 333         st->chip_info =
 334                 &ad5686_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 335
 336         if (voltage_uv)
 337                 st->vref_mv = voltage_uv / 1000;
 338         else
 339                 st->vref_mv = st->chip_info->int_vref_mv;
 340
 341         st->spi = spi;
 342
 343         /* Set all the power down mode for all channels to 1K pulldown */
 344         st->pwr_down_mode = 0x55;
 345
 346         indio_dev->dev.parent = &spi->dev;
 347         indio_dev->name = spi_get_device_id(spi)->name;
 348         indio_dev->info = &ad5686_info;
 349         indio_dev->modes = INDIO_DIRECT_MODE;
 350         indio_dev->channels = st->chip_info->channel;
 351         indio_dev->num_channels = AD5686_DAC_CHANNELS;
 352
 353         regdone = 1;
 354         ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0,
 355                                 !!voltage_uv, 0);
 356         if (ret)
 357                 goto error_disable_reg;
 358
 359         ret = iio_device_register(indio_dev);
 360         if (ret)
 361                 goto error_disable_reg;
 362
 363         return 0;
 364
 365 error_disable_reg:
 366         if (!IS_ERR(st->reg))
 367                 regulator_disable(st->reg);
 368         return ret;
 369 }
 370
 371 static int ad5686_remove(struct spi_device *spi)
 372 {
 373         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 374         struct ad5686_state *st = iio_priv(indio_dev);
 375
 376         iio_device_unregister(indio_dev);
 377         if (!IS_ERR(st->reg))
 378                 regulator_disable(st->reg);
 379
 380         return 0;
 381 }
 382
 383 static const struct spi_device_id ad5686_id[] = {
 384         {"ad5684", ID_AD5684},
 385         {"ad5685", ID_AD5685},
 386         {"ad5686", ID_AD5686},
 387         {}
 388 };
 389 MODULE_DEVICE_TABLE(spi, ad5686_id);
 390
 391 static struct spi_driver ad5686_driver = {
 392         .driver = {
 393                    .name = "ad5686",
 394                    .owner = THIS_MODULE,
 395                    },
 396         .probe = ad5686_probe,
 397         .remove = ad5686_remove,
 398         .id_table = ad5686_id,
 399 };
 400 module_spi_driver(ad5686_driver);
 401
 402 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 403 MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC");
 404 MODULE_LICENSE("GPL v2");