drivers/staging/iio/dac/ad5791.c

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