drivers/staging/iio/dac/ad5624r_spi.c

   1 /*
   2  * AD5624R, AD5644R, AD5664R Digital to analog convertors spi driver
   3  *
   4  * Copyright 2010-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/kernel.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/slab.h>
  15 #include <linux/sysfs.h>
  16 #include <linux/regulator/consumer.h>
  17 #include <linux/module.h>
  18
  19 #include <linux/iio/iio.h>
  20 #include <linux/iio/sysfs.h>
  21 #include "dac.h"
  22 #include "ad5624r.h"
  23
  24 #define AD5624R_CHANNEL(_chan, _bits) { \
  25         .type = IIO_VOLTAGE, \
  26         .indexed = 1, \
  27         .output = 1, \
  28         .channel = (_chan), \
  29         .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
  30                      IIO_CHAN_INFO_SCALE_SHARED_BIT, \
  31         .address = (_chan), \
  32         .scan_type = IIO_ST('u', (_bits), 16, 16 - (_bits)), \
  33 }
  34
  35 #define DECLARE_AD5624R_CHANNELS(_name, _bits) \
  36         const struct iio_chan_spec _name##_channels[] = { \
  37                 AD5624R_CHANNEL(0, _bits), \
  38                 AD5624R_CHANNEL(1, _bits), \
  39                 AD5624R_CHANNEL(2, _bits), \
  40                 AD5624R_CHANNEL(3, _bits), \
  41 }
  42
  43 static DECLARE_AD5624R_CHANNELS(ad5624r, 12);
  44 static DECLARE_AD5624R_CHANNELS(ad5644r, 14);
  45 static DECLARE_AD5624R_CHANNELS(ad5664r, 16);
  46
  47 static const struct ad5624r_chip_info ad5624r_chip_info_tbl[] = {
  48         [ID_AD5624R3] = {
  49                 .channels = ad5624r_channels,
  50                 .int_vref_mv = 1250,
  51         },
  52         [ID_AD5624R5] = {
  53                 .channels = ad5624r_channels,
  54                 .int_vref_mv = 2500,
  55         },
  56         [ID_AD5644R3] = {
  57                 .channels = ad5644r_channels,
  58                 .int_vref_mv = 1250,
  59         },
  60         [ID_AD5644R5] = {
  61                 .channels = ad5644r_channels,
  62                 .int_vref_mv = 2500,
  63         },
  64         [ID_AD5664R3] = {
  65                 .channels = ad5664r_channels,
  66                 .int_vref_mv = 1250,
  67         },
  68         [ID_AD5664R5] = {
  69                 .channels = ad5664r_channels,
  70                 .int_vref_mv = 2500,
  71         },
  72 };
  73
  74 static int ad5624r_spi_write(struct spi_device *spi,
  75                              u8 cmd, u8 addr, u16 val, u8 len)
  76 {
  77         u32 data;
  78         u8 msg[3];
  79
  80         /*
  81          * The input shift register is 24 bits wide. The first two bits are
  82          * don't care bits. The next three are the command bits, C2 to C0,
  83          * followed by the 3-bit DAC address, A2 to A0, and then the
  84          * 16-, 14-, 12-bit data-word. The data-word comprises the 16-,
  85          * 14-, 12-bit input code followed by 0, 2, or 4 don't care bits,
  86          * for the AD5664R, AD5644R, and AD5624R, respectively.
  87          */
  88         data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << (16 - len));
  89         msg[0] = data >> 16;
  90         msg[1] = data >> 8;
  91         msg[2] = data;
  92
  93         return spi_write(spi, msg, 3);
  94 }
  95
  96 static int ad5624r_read_raw(struct iio_dev *indio_dev,
  97                            struct iio_chan_spec const *chan,
  98                            int *val,
  99                            int *val2,
 100                            long m)
 101 {
 102         struct ad5624r_state *st = iio_priv(indio_dev);
 103         unsigned long scale_uv;
 104
 105         switch (m) {
 106         case IIO_CHAN_INFO_SCALE:
 107                 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
 108                 *val =  scale_uv / 1000;
 109                 *val2 = (scale_uv % 1000) * 1000;
 110                 return IIO_VAL_INT_PLUS_MICRO;
 111
 112         }
 113         return -EINVAL;
 114 }
 115
 116 static int ad5624r_write_raw(struct iio_dev *indio_dev,
 117                                struct iio_chan_spec const *chan,
 118                                int val,
 119                                int val2,
 120                                long mask)
 121 {
 122         struct ad5624r_state *st = iio_priv(indio_dev);
 123         int ret;
 124
 125         switch (mask) {
 126         case IIO_CHAN_INFO_RAW:
 127                 if (val >= (1 << chan->scan_type.realbits) || val < 0)
 128                         return -EINVAL;
 129
 130                 return ad5624r_spi_write(st->us,
 131                                 AD5624R_CMD_WRITE_INPUT_N_UPDATE_N,
 132                                 chan->address, val,
 133                                 chan->scan_type.shift);
 134         default:
 135                 ret = -EINVAL;
 136         }
 137
 138         return -EINVAL;
 139 }
 140
 141 static ssize_t ad5624r_read_powerdown_mode(struct device *dev,
 142                                       struct device_attribute *attr, char *buf)
 143 {
 144         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 145         struct ad5624r_state *st = iio_priv(indio_dev);
 146
 147         char mode[][15] = {"", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"};
 148
 149         return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
 150 }
 151
 152 static ssize_t ad5624r_write_powerdown_mode(struct device *dev,
 153                                        struct device_attribute *attr,
 154                                        const char *buf, size_t len)
 155 {
 156         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 157         struct ad5624r_state *st = iio_priv(indio_dev);
 158         int ret;
 159
 160         if (sysfs_streq(buf, "1kohm_to_gnd"))
 161                 st->pwr_down_mode = AD5624R_LDAC_PWRDN_1K;
 162         else if (sysfs_streq(buf, "100kohm_to_gnd"))
 163                 st->pwr_down_mode = AD5624R_LDAC_PWRDN_100K;
 164         else if (sysfs_streq(buf, "three_state"))
 165                 st->pwr_down_mode = AD5624R_LDAC_PWRDN_3STATE;
 166         else
 167                 ret = -EINVAL;
 168
 169         return ret ? ret : len;
 170 }
 171
 172 static ssize_t ad5624r_read_dac_powerdown(struct device *dev,
 173                                            struct device_attribute *attr,
 174                                            char *buf)
 175 {
 176         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 177         struct ad5624r_state *st = iio_priv(indio_dev);
 178         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 179
 180         return sprintf(buf, "%d\n",
 181                         !!(st->pwr_down_mask & (1 << this_attr->address)));
 182 }
 183
 184 static ssize_t ad5624r_write_dac_powerdown(struct device *dev,
 185                                             struct device_attribute *attr,
 186                                             const char *buf, size_t len)
 187 {
 188         long readin;
 189         int ret;
 190         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 191         struct ad5624r_state *st = iio_priv(indio_dev);
 192         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 193
 194         ret = strict_strtol(buf, 10, &readin);
 195         if (ret)
 196                 return ret;
 197
 198         if (readin == 1)
 199                 st->pwr_down_mask |= (1 << this_attr->address);
 200         else if (!readin)
 201                 st->pwr_down_mask &= ~(1 << this_attr->address);
 202         else
 203                 ret = -EINVAL;
 204
 205         ret = ad5624r_spi_write(st->us, AD5624R_CMD_POWERDOWN_DAC, 0,
 206                                 (st->pwr_down_mode << 4) |
 207                                 st->pwr_down_mask, 16);
 208
 209         return ret ? ret : len;
 210 }
 211
 212 static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO |
 213                         S_IWUSR, ad5624r_read_powerdown_mode,
 214                         ad5624r_write_powerdown_mode, 0);
 215
 216 static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
 217                         "1kohm_to_gnd 100kohm_to_gnd three_state");
 218
 219 #define IIO_DEV_ATTR_DAC_POWERDOWN(_num, _show, _store, _addr)          \
 220         IIO_DEVICE_ATTR(out_voltage##_num##_powerdown,                  \
 221                         S_IRUGO | S_IWUSR, _show, _store, _addr)
 222
 223 static IIO_DEV_ATTR_DAC_POWERDOWN(0, ad5624r_read_dac_powerdown,
 224                                    ad5624r_write_dac_powerdown, 0);
 225 static IIO_DEV_ATTR_DAC_POWERDOWN(1, ad5624r_read_dac_powerdown,
 226                                    ad5624r_write_dac_powerdown, 1);
 227 static IIO_DEV_ATTR_DAC_POWERDOWN(2, ad5624r_read_dac_powerdown,
 228                                    ad5624r_write_dac_powerdown, 2);
 229 static IIO_DEV_ATTR_DAC_POWERDOWN(3, ad5624r_read_dac_powerdown,
 230                                    ad5624r_write_dac_powerdown, 3);
 231
 232 static struct attribute *ad5624r_attributes[] = {
 233         &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
 234         &iio_dev_attr_out_voltage1_powerdown.dev_attr.attr,
 235         &iio_dev_attr_out_voltage2_powerdown.dev_attr.attr,
 236         &iio_dev_attr_out_voltage3_powerdown.dev_attr.attr,
 237         &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
 238         &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
 239         NULL,
 240 };
 241
 242 static const struct attribute_group ad5624r_attribute_group = {
 243         .attrs = ad5624r_attributes,
 244 };
 245
 246 static const struct iio_info ad5624r_info = {
 247         .write_raw = ad5624r_write_raw,
 248         .read_raw = ad5624r_read_raw,
 249         .attrs = &ad5624r_attribute_group,
 250         .driver_module = THIS_MODULE,
 251 };
 252
 253 static int __devinit ad5624r_probe(struct spi_device *spi)
 254 {
 255         struct ad5624r_state *st;
 256         struct iio_dev *indio_dev;
 257         int ret, voltage_uv = 0;
 258
 259         indio_dev = iio_allocate_device(sizeof(*st));
 260         if (indio_dev == NULL) {
 261                 ret = -ENOMEM;
 262                 goto error_ret;
 263         }
 264         st = iio_priv(indio_dev);
 265         st->reg = regulator_get(&spi->dev, "vcc");
 266         if (!IS_ERR(st->reg)) {
 267                 ret = regulator_enable(st->reg);
 268                 if (ret)
 269                         goto error_put_reg;
 270
 271                 voltage_uv = regulator_get_voltage(st->reg);
 272         }
 273
 274         spi_set_drvdata(spi, indio_dev);
 275         st->chip_info =
 276                 &ad5624r_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 277
 278         if (voltage_uv)
 279                 st->vref_mv = voltage_uv / 1000;
 280         else
 281                 st->vref_mv = st->chip_info->int_vref_mv;
 282
 283         st->us = spi;
 284
 285         indio_dev->dev.parent = &spi->dev;
 286         indio_dev->name = spi_get_device_id(spi)->name;
 287         indio_dev->info = &ad5624r_info;
 288         indio_dev->modes = INDIO_DIRECT_MODE;
 289         indio_dev->channels = st->chip_info->channels;
 290         indio_dev->num_channels = AD5624R_DAC_CHANNELS;
 291
 292         ret = ad5624r_spi_write(spi, AD5624R_CMD_INTERNAL_REFER_SETUP, 0,
 293                                 !!voltage_uv, 16);
 294         if (ret)
 295                 goto error_disable_reg;
 296
 297         ret = iio_device_register(indio_dev);
 298         if (ret)
 299                 goto error_disable_reg;
 300
 301         return 0;
 302
 303 error_disable_reg:
 304         if (!IS_ERR(st->reg))
 305                 regulator_disable(st->reg);
 306 error_put_reg:
 307         if (!IS_ERR(st->reg))
 308                 regulator_put(st->reg);
 309         iio_free_device(indio_dev);
 310 error_ret:
 311
 312         return ret;
 313 }
 314
 315 static int __devexit ad5624r_remove(struct spi_device *spi)
 316 {
 317         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 318         struct ad5624r_state *st = iio_priv(indio_dev);
 319
 320         iio_device_unregister(indio_dev);
 321         if (!IS_ERR(st->reg)) {
 322                 regulator_disable(st->reg);
 323                 regulator_put(st->reg);
 324         }
 325         iio_free_device(indio_dev);
 326
 327         return 0;
 328 }
 329
 330 static const struct spi_device_id ad5624r_id[] = {
 331         {"ad5624r3", ID_AD5624R3},
 332         {"ad5644r3", ID_AD5644R3},
 333         {"ad5664r3", ID_AD5664R3},
 334         {"ad5624r5", ID_AD5624R5},
 335         {"ad5644r5", ID_AD5644R5},
 336         {"ad5664r5", ID_AD5664R5},
 337         {}
 338 };
 339 MODULE_DEVICE_TABLE(spi, ad5624r_id);
 340
 341 static struct spi_driver ad5624r_driver = {
 342         .driver = {
 343                    .name = "ad5624r",
 344                    .owner = THIS_MODULE,
 345                    },
 346         .probe = ad5624r_probe,
 347         .remove = __devexit_p(ad5624r_remove),
 348         .id_table = ad5624r_id,
 349 };
 350 module_spi_driver(ad5624r_driver);
 351
 352 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 353 MODULE_DESCRIPTION("Analog Devices AD5624/44/64R DAC spi driver");
 354 MODULE_LICENSE("GPL v2");