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