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