drivers/staging/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
  20 #include "../iio.h"
  21 #include "../sysfs.h"
  22 #include "dac.h"
  23 #include "ad5791.h"
  24
  25 static int ad5791_spi_write(struct spi_device *spi, u8 addr, u32 val)
  26 {
  27         union {
  28                 u32 d32;
  29                 u8 d8[4];
  30         } data;
  31
  32         data.d32 = cpu_to_be32(AD5791_CMD_WRITE |
  33                               AD5791_ADDR(addr) |
  34                               (val & AD5791_DAC_MASK));
  35
  36         return spi_write(spi, &data.d8[1], 3);
  37 }
  38
  39 static int ad5791_spi_read(struct spi_device *spi, u8 addr, u32 *val)
  40 {
  41         union {
  42                 u32 d32;
  43                 u8 d8[4];
  44         } data[3];
  45         int ret;
  46         struct spi_message msg;
  47         struct spi_transfer xfers[] = {
  48                 {
  49                         .tx_buf = &data[0].d8[1],
  50                         .bits_per_word = 8,
  51                         .len = 3,
  52                         .cs_change = 1,
  53                 }, {
  54                         .tx_buf = &data[1].d8[1],
  55                         .rx_buf = &data[2].d8[1],
  56                         .bits_per_word = 8,
  57                         .len = 3,
  58                 },
  59         };
  60
  61         data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
  62                               AD5791_ADDR(addr));
  63         data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
  64
  65         spi_message_init(&msg);
  66         spi_message_add_tail(&xfers[0], &msg);
  67         spi_message_add_tail(&xfers[1], &msg);
  68         ret = spi_sync(spi, &msg);
  69
  70         *val = be32_to_cpu(data[2].d32);
  71
  72         return ret;
  73 }
  74
  75 #define AD5791_CHAN(bits, shift) {                      \
  76         .type = IIO_VOLTAGE,                            \
  77         .output = 1,                                    \
  78         .indexed = 1,                                   \
  79         .address = AD5791_ADDR_DAC0,                    \
  80         .channel = 0,                                   \
  81         .info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT | \
  82                 IIO_CHAN_INFO_OFFSET_SHARED_BIT,        \
  83         .scan_type = IIO_ST('u', bits, 24, shift)       \
  84 }
  85
  86 static const struct iio_chan_spec ad5791_channels[] = {
  87         [ID_AD5760] = AD5791_CHAN(16, 4),
  88         [ID_AD5780] = AD5791_CHAN(18, 2),
  89         [ID_AD5781] = AD5791_CHAN(18, 2),
  90         [ID_AD5791] = AD5791_CHAN(20, 0)
  91 };
  92
  93 static ssize_t ad5791_read_powerdown_mode(struct device *dev,
  94                                       struct device_attribute *attr, char *buf)
  95 {
  96         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  97         struct ad5791_state *st = iio_priv(indio_dev);
  98
  99         const char mode[][14] = {"6kohm_to_gnd", "three_state"};
 100
 101         return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
 102 }
 103
 104 static ssize_t ad5791_write_powerdown_mode(struct device *dev,
 105                                        struct device_attribute *attr,
 106                                        const char *buf, size_t len)
 107 {
 108         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 109         struct ad5791_state *st = iio_priv(indio_dev);
 110         int ret;
 111
 112         if (sysfs_streq(buf, "6kohm_to_gnd"))
 113                 st->pwr_down_mode = AD5791_DAC_PWRDN_6K;
 114         else if (sysfs_streq(buf, "three_state"))
 115                 st->pwr_down_mode = AD5791_DAC_PWRDN_3STATE;
 116         else
 117                 ret = -EINVAL;
 118
 119         return ret ? ret : len;
 120 }
 121
 122 static ssize_t ad5791_read_dac_powerdown(struct device *dev,
 123                                            struct device_attribute *attr,
 124                                            char *buf)
 125 {
 126         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 127         struct ad5791_state *st = iio_priv(indio_dev);
 128
 129         return sprintf(buf, "%d\n", st->pwr_down);
 130 }
 131
 132 static ssize_t ad5791_write_dac_powerdown(struct device *dev,
 133                                             struct device_attribute *attr,
 134                                             const char *buf, size_t len)
 135 {
 136         long readin;
 137         int ret;
 138         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 139         struct ad5791_state *st = iio_priv(indio_dev);
 140
 141         ret = strict_strtol(buf, 10, &readin);
 142         if (ret)
 143                 return ret;
 144
 145         if (readin == 0) {
 146                 st->pwr_down = false;
 147                 st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 148         } else if (readin == 1) {
 149                 st->pwr_down = true;
 150                 if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
 151                         st->ctrl |= AD5791_CTRL_OPGND;
 152                 else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
 153                         st->ctrl |= AD5791_CTRL_DACTRI;
 154         } else
 155                 ret = -EINVAL;
 156
 157         ret = ad5791_spi_write(st->spi, AD5791_ADDR_CTRL, st->ctrl);
 158
 159         return ret ? ret : len;
 160 }
 161
 162 static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO |
 163                         S_IWUSR, ad5791_read_powerdown_mode,
 164                         ad5791_write_powerdown_mode, 0);
 165
 166 static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
 167                         "6kohm_to_gnd three_state");
 168
 169 #define IIO_DEV_ATTR_DAC_POWERDOWN(_num, _show, _store, _addr)          \
 170         IIO_DEVICE_ATTR(out_voltage##_num##_powerdown,                  \
 171                         S_IRUGO | S_IWUSR, _show, _store, _addr)
 172
 173 static IIO_DEV_ATTR_DAC_POWERDOWN(0, ad5791_read_dac_powerdown,
 174                                    ad5791_write_dac_powerdown, 0);
 175
 176 static struct attribute *ad5791_attributes[] = {
 177         &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
 178         &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
 179         &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
 180         NULL,
 181 };
 182
 183 static const struct attribute_group ad5791_attribute_group = {
 184         .attrs = ad5791_attributes,
 185 };
 186
 187 static int ad5791_get_lin_comp(unsigned int span)
 188 {
 189         if (span <= 10000)
 190                 return AD5791_LINCOMP_0_10;
 191         else if (span <= 12000)
 192                 return AD5791_LINCOMP_10_12;
 193         else if (span <= 16000)
 194                 return AD5791_LINCOMP_12_16;
 195         else if (span <= 19000)
 196                 return AD5791_LINCOMP_16_19;
 197         else
 198                 return AD5791_LINCOMP_19_20;
 199 }
 200
 201 static int ad5780_get_lin_comp(unsigned int span)
 202 {
 203         if (span <= 10000)
 204                 return AD5780_LINCOMP_0_10;
 205         else
 206                 return AD5780_LINCOMP_10_20;
 207 }
 208 static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
 209         [ID_AD5760] = {
 210                 .get_lin_comp = ad5780_get_lin_comp,
 211         },
 212         [ID_AD5780] = {
 213                 .get_lin_comp = ad5780_get_lin_comp,
 214         },
 215         [ID_AD5781] = {
 216                 .get_lin_comp = ad5791_get_lin_comp,
 217         },
 218         [ID_AD5791] = {
 219                 .get_lin_comp = ad5791_get_lin_comp,
 220         },
 221 };
 222
 223 static int ad5791_read_raw(struct iio_dev *indio_dev,
 224                            struct iio_chan_spec const *chan,
 225                            int *val,
 226                            int *val2,
 227                            long m)
 228 {
 229         struct ad5791_state *st = iio_priv(indio_dev);
 230         u64 val64;
 231         int ret;
 232
 233         switch (m) {
 234         case 0:
 235                 ret = ad5791_spi_read(st->spi, chan->address, val);
 236                 if (ret)
 237                         return ret;
 238                 *val &= AD5791_DAC_MASK;
 239                 *val >>= chan->scan_type.shift;
 240                 return IIO_VAL_INT;
 241         case IIO_CHAN_INFO_SCALE:
 242                 *val = 0;
 243                 *val2 = (((u64)st->vref_mv) * 1000000ULL) >> chan->scan_type.realbits;
 244                 return IIO_VAL_INT_PLUS_MICRO;
 245         case IIO_CHAN_INFO_OFFSET:
 246                 val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
 247                 do_div(val64, st->vref_mv);
 248                 *val = -val64;
 249                 return IIO_VAL_INT;
 250         default:
 251                 return -EINVAL;
 252         }
 253
 254 };
 255
 256
 257 static int ad5791_write_raw(struct iio_dev *indio_dev,
 258                             struct iio_chan_spec const *chan,
 259                             int val,
 260                             int val2,
 261                             long mask)
 262 {
 263         struct ad5791_state *st = iio_priv(indio_dev);
 264
 265         switch (mask) {
 266         case 0:
 267                 val &= AD5791_RES_MASK(chan->scan_type.realbits);
 268                 val <<= chan->scan_type.shift;
 269
 270                 return ad5791_spi_write(st->spi, chan->address, val);
 271
 272         default:
 273                 return -EINVAL;
 274         }
 275 }
 276
 277 static const struct iio_info ad5791_info = {
 278         .read_raw = &ad5791_read_raw,
 279         .write_raw = &ad5791_write_raw,
 280         .attrs = &ad5791_attribute_group,
 281         .driver_module = THIS_MODULE,
 282 };
 283
 284 static int __devinit ad5791_probe(struct spi_device *spi)
 285 {
 286         struct ad5791_platform_data *pdata = spi->dev.platform_data;
 287         struct iio_dev *indio_dev;
 288         struct ad5791_state *st;
 289         int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
 290
 291         indio_dev = iio_allocate_device(sizeof(*st));
 292         if (indio_dev == NULL) {
 293                 ret = -ENOMEM;
 294                 goto error_ret;
 295         }
 296         st = iio_priv(indio_dev);
 297         st->reg_vdd = regulator_get(&spi->dev, "vdd");
 298         if (!IS_ERR(st->reg_vdd)) {
 299                 ret = regulator_enable(st->reg_vdd);
 300                 if (ret)
 301                         goto error_put_reg_pos;
 302
 303                 pos_voltage_uv = regulator_get_voltage(st->reg_vdd);
 304         }
 305
 306         st->reg_vss = regulator_get(&spi->dev, "vss");
 307         if (!IS_ERR(st->reg_vss)) {
 308                 ret = regulator_enable(st->reg_vss);
 309                 if (ret)
 310                         goto error_put_reg_neg;
 311
 312                 neg_voltage_uv = regulator_get_voltage(st->reg_vss);
 313         }
 314
 315         st->pwr_down = true;
 316         st->spi = spi;
 317
 318         if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
 319                 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
 320                 st->vref_neg_mv = neg_voltage_uv / 1000;
 321         } else if (pdata) {
 322                 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
 323                 st->vref_neg_mv = pdata->vref_neg_mv;
 324         } else {
 325                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 326         }
 327
 328         ret = ad5791_spi_write(spi, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
 329         if (ret)
 330                 goto error_disable_reg_neg;
 331
 332         st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
 333                                               ->driver_data];
 334
 335
 336         st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
 337                   | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
 338                   AD5791_CTRL_BIN2SC;
 339
 340         ret = ad5791_spi_write(spi, AD5791_ADDR_CTRL, st->ctrl |
 341                 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 342         if (ret)
 343                 goto error_disable_reg_neg;
 344
 345         spi_set_drvdata(spi, indio_dev);
 346         indio_dev->dev.parent = &spi->dev;
 347         indio_dev->info = &ad5791_info;
 348         indio_dev->modes = INDIO_DIRECT_MODE;
 349         indio_dev->channels
 350                 = &ad5791_channels[spi_get_device_id(spi)->driver_data];
 351         indio_dev->num_channels = 1;
 352         indio_dev->name = spi_get_device_id(st->spi)->name;
 353         ret = iio_device_register(indio_dev);
 354         if (ret)
 355                 goto error_disable_reg_neg;
 356
 357         return 0;
 358
 359 error_disable_reg_neg:
 360         if (!IS_ERR(st->reg_vss))
 361                 regulator_disable(st->reg_vss);
 362 error_put_reg_neg:
 363         if (!IS_ERR(st->reg_vss))
 364                 regulator_put(st->reg_vss);
 365
 366         if (!IS_ERR(st->reg_vdd))
 367                 regulator_disable(st->reg_vdd);
 368 error_put_reg_pos:
 369         if (!IS_ERR(st->reg_vdd))
 370                 regulator_put(st->reg_vdd);
 371         iio_free_device(indio_dev);
 372 error_ret:
 373
 374         return ret;
 375 }
 376
 377 static int __devexit ad5791_remove(struct spi_device *spi)
 378 {
 379         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 380         struct ad5791_state *st = iio_priv(indio_dev);
 381
 382         iio_device_unregister(indio_dev);
 383         if (!IS_ERR(st->reg_vdd)) {
 384                 regulator_disable(st->reg_vdd);
 385                 regulator_put(st->reg_vdd);
 386         }
 387
 388         if (!IS_ERR(st->reg_vss)) {
 389                 regulator_disable(st->reg_vss);
 390                 regulator_put(st->reg_vss);
 391         }
 392         iio_free_device(indio_dev);
 393
 394         return 0;
 395 }
 396
 397 static const struct spi_device_id ad5791_id[] = {
 398         {"ad5760", ID_AD5760},
 399         {"ad5780", ID_AD5780},
 400         {"ad5781", ID_AD5781},
 401         {"ad5790", ID_AD5791},
 402         {"ad5791", ID_AD5791},
 403         {}
 404 };
 405 MODULE_DEVICE_TABLE(spi, ad5791_id);
 406
 407 static struct spi_driver ad5791_driver = {
 408         .driver = {
 409                    .name = "ad5791",
 410                    .owner = THIS_MODULE,
 411                    },
 412         .probe = ad5791_probe,
 413         .remove = __devexit_p(ad5791_remove),
 414         .id_table = ad5791_id,
 415 };
 416 module_spi_driver(ad5791_driver);
 417
 418 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 419 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
 420 MODULE_LICENSE("GPL v2");