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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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_dev_get_devdata(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 ad5791_state *st;
 299         int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
 300
 301         st = kzalloc(sizeof(*st), GFP_KERNEL);
 302         if (st == NULL) {
 303                 ret = -ENOMEM;
 304                 goto error_ret;
 305         }
 306
 307         spi_set_drvdata(spi, st);
 308
 309         st->reg_vdd = regulator_get(&spi->dev, "vdd");
 310         if (!IS_ERR(st->reg_vdd)) {
 311                 ret = regulator_enable(st->reg_vdd);
 312                 if (ret)
 313                         goto error_put_reg_pos;
 314
 315                 pos_voltage_uv = regulator_get_voltage(st->reg_vdd);
 316         }
 317
 318         st->reg_vss = regulator_get(&spi->dev, "vss");
 319         if (!IS_ERR(st->reg_vss)) {
 320                 ret = regulator_enable(st->reg_vss);
 321                 if (ret)
 322                         goto error_put_reg_neg;
 323
 324                 neg_voltage_uv = regulator_get_voltage(st->reg_vss);
 325         }
 326
 327         if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd))
 328                 st->vref_mv = (pos_voltage_uv - neg_voltage_uv) / 1000;
 329         else if (pdata)
 330                 st->vref_mv = pdata->vref_pos_mv - pdata->vref_neg_mv;
 331         else
 332                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 333
 334         ret = ad5791_spi_write(spi, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
 335         if (ret)
 336                 goto error_disable_reg_neg;
 337
 338         st->chip_info =
 339                 &ad5791_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 340
 341
 342         st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
 343                   | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
 344                   AD5791_CTRL_BIN2SC;
 345
 346         ret = ad5791_spi_write(spi, AD5791_ADDR_CTRL, st->ctrl |
 347                 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
 348         if (ret)
 349                 goto error_disable_reg_neg;
 350
 351         st->pwr_down = true;
 352
 353         st->spi = spi;
 354         st->indio_dev = iio_allocate_device(0);
 355         if (st->indio_dev == NULL) {
 356                 ret = -ENOMEM;
 357                 goto error_disable_reg_neg;
 358         }
 359         st->indio_dev->dev.parent = &spi->dev;
 360         st->indio_dev->dev_data = (void *)(st);
 361         st->indio_dev->info = &ad5791_info;
 362         st->indio_dev->modes = INDIO_DIRECT_MODE;
 363
 364         ret = iio_device_register(st->indio_dev);
 365         if (ret)
 366                 goto error_free_dev;
 367
 368         return 0;
 369
 370 error_free_dev:
 371         iio_free_device(st->indio_dev);
 372
 373 error_disable_reg_neg:
 374         if (!IS_ERR(st->reg_vss))
 375                 regulator_disable(st->reg_vss);
 376 error_put_reg_neg:
 377         if (!IS_ERR(st->reg_vss))
 378                 regulator_put(st->reg_vss);
 379
 380         if (!IS_ERR(st->reg_vdd))
 381                 regulator_disable(st->reg_vdd);
 382 error_put_reg_pos:
 383         if (!IS_ERR(st->reg_vdd))
 384                 regulator_put(st->reg_vdd);
 385
 386         kfree(st);
 387 error_ret:
 388         return ret;
 389 }
 390
 391 static int __devexit ad5791_remove(struct spi_device *spi)
 392 {
 393         struct ad5791_state *st = spi_get_drvdata(spi);
 394
 395         iio_device_unregister(st->indio_dev);
 396
 397         if (!IS_ERR(st->reg_vdd)) {
 398                 regulator_disable(st->reg_vdd);
 399                 regulator_put(st->reg_vdd);
 400         }
 401
 402         if (!IS_ERR(st->reg_vss)) {
 403                 regulator_disable(st->reg_vss);
 404                 regulator_put(st->reg_vss);
 405         }
 406
 407         kfree(st);
 408
 409         return 0;
 410 }
 411
 412 static const struct spi_device_id ad5791_id[] = {
 413         {"ad5760", ID_AD5760},
 414         {"ad5780", ID_AD5780},
 415         {"ad5781", ID_AD5781},
 416         {"ad5791", ID_AD5791},
 417         {}
 418 };
 419
 420 static struct spi_driver ad5791_driver = {
 421         .driver = {
 422                    .name = "ad5791",
 423                    .owner = THIS_MODULE,
 424                    },
 425         .probe = ad5791_probe,
 426         .remove = __devexit_p(ad5791_remove),
 427         .id_table = ad5791_id,
 428 };
 429
 430 static __init int ad5791_spi_init(void)
 431 {
 432         return spi_register_driver(&ad5791_driver);
 433 }
 434 module_init(ad5791_spi_init);
 435
 436 static __exit void ad5791_spi_exit(void)
 437 {
 438         spi_unregister_driver(&ad5791_driver);
 439 }
 440 module_exit(ad5791_spi_exit);
 441
 442 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 443 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5791 DAC");
 444 MODULE_LICENSE("GPL v2");