drivers/iio/dac/ad5504.c

   1 /*
   2  * AD5504, AD5501 High Voltage 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/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 #include <linux/bitops.h>
  19
  20 #include <linux/iio/iio.h>
  21 #include <linux/iio/sysfs.h>
  22 #include <linux/iio/events.h>
  23 #include <linux/iio/dac/ad5504.h>
  24
  25 #define AD5504_RES_MASK                 GENMASK(11, 0)
  26 #define AD5504_CMD_READ                 BIT(15)
  27 #define AD5504_CMD_WRITE                0
  28 #define AD5504_ADDR(addr)               ((addr) << 12)
  29
  30 /* Registers */
  31 #define AD5504_ADDR_NOOP                0
  32 #define AD5504_ADDR_DAC(x)              ((x) + 1)
  33 #define AD5504_ADDR_ALL_DAC             5
  34 #define AD5504_ADDR_CTRL                7
  35
  36 /* Control Register */
  37 #define AD5504_DAC_PWR(ch)              ((ch) << 2)
  38 #define AD5504_DAC_PWRDWN_MODE(mode)    ((mode) << 6)
  39 #define AD5504_DAC_PWRDN_20K            0
  40 #define AD5504_DAC_PWRDN_3STATE         1
  41
  42 /**
  43  * struct ad5446_state - driver instance specific data
  44  * @spi:                        spi_device
  45  * @reg:                supply regulator
  46  * @vref_mv:            actual reference voltage used
  47  * @pwr_down_mask       power down mask
  48  * @pwr_down_mode       current power down mode
  49  * @data:               transfer buffer
  50  */
  51 struct ad5504_state {
  52         struct spi_device               *spi;
  53         struct regulator                *reg;
  54         unsigned short                  vref_mv;
  55         unsigned                        pwr_down_mask;
  56         unsigned                        pwr_down_mode;
  57
  58         __be16                          data[2] ____cacheline_aligned;
  59 };
  60
  61 /**
  62  * ad5504_supported_device_ids:
  63  */
  64
  65 enum ad5504_supported_device_ids {
  66         ID_AD5504,
  67         ID_AD5501,
  68 };
  69
  70 static int ad5504_spi_write(struct ad5504_state *st, u8 addr, u16 val)
  71 {
  72         st->data[0] = cpu_to_be16(AD5504_CMD_WRITE | AD5504_ADDR(addr) |
  73                               (val & AD5504_RES_MASK));
  74
  75         return spi_write(st->spi, &st->data[0], 2);
  76 }
  77
  78 static int ad5504_spi_read(struct ad5504_state *st, u8 addr)
  79 {
  80         int ret;
  81         struct spi_transfer t = {
  82             .tx_buf = &st->data[0],
  83             .rx_buf = &st->data[1],
  84             .len = 2,
  85         };
  86
  87         st->data[0] = cpu_to_be16(AD5504_CMD_READ | AD5504_ADDR(addr));
  88         ret = spi_sync_transfer(st->spi, &t, 1);
  89         if (ret < 0)
  90                 return ret;
  91
  92         return be16_to_cpu(st->data[1]) & AD5504_RES_MASK;
  93 }
  94
  95 static int ad5504_read_raw(struct iio_dev *indio_dev,
  96                            struct iio_chan_spec const *chan,
  97                            int *val,
  98                            int *val2,
  99                            long m)
 100 {
 101         struct ad5504_state *st = iio_priv(indio_dev);
 102         int ret;
 103
 104         switch (m) {
 105         case IIO_CHAN_INFO_RAW:
 106                 ret = ad5504_spi_read(st, chan->address);
 107                 if (ret < 0)
 108                         return ret;
 109
 110                 *val = ret;
 111
 112                 return IIO_VAL_INT;
 113         case IIO_CHAN_INFO_SCALE:
 114                 *val = st->vref_mv;
 115                 *val2 = chan->scan_type.realbits;
 116                 return IIO_VAL_FRACTIONAL_LOG2;
 117         }
 118         return -EINVAL;
 119 }
 120
 121 static int ad5504_write_raw(struct iio_dev *indio_dev,
 122                                struct iio_chan_spec const *chan,
 123                                int val,
 124                                int val2,
 125                                long mask)
 126 {
 127         struct ad5504_state *st = iio_priv(indio_dev);
 128
 129         switch (mask) {
 130         case IIO_CHAN_INFO_RAW:
 131                 if (val >= (1 << chan->scan_type.realbits) || val < 0)
 132                         return -EINVAL;
 133
 134                 return ad5504_spi_write(st, chan->address, val);
 135         default:
 136                 return -EINVAL;
 137         }
 138 }
 139
 140 static const char * const ad5504_powerdown_modes[] = {
 141         "20kohm_to_gnd",
 142         "three_state",
 143 };
 144
 145 static int ad5504_get_powerdown_mode(struct iio_dev *indio_dev,
 146         const struct iio_chan_spec *chan)
 147 {
 148         struct ad5504_state *st = iio_priv(indio_dev);
 149
 150         return st->pwr_down_mode;
 151 }
 152
 153 static int ad5504_set_powerdown_mode(struct iio_dev *indio_dev,
 154         const struct iio_chan_spec *chan, unsigned int mode)
 155 {
 156         struct ad5504_state *st = iio_priv(indio_dev);
 157
 158         st->pwr_down_mode = mode;
 159
 160         return 0;
 161 }
 162
 163 static const struct iio_enum ad5504_powerdown_mode_enum = {
 164         .items = ad5504_powerdown_modes,
 165         .num_items = ARRAY_SIZE(ad5504_powerdown_modes),
 166         .get = ad5504_get_powerdown_mode,
 167         .set = ad5504_set_powerdown_mode,
 168 };
 169
 170 static ssize_t ad5504_read_dac_powerdown(struct iio_dev *indio_dev,
 171         uintptr_t private, const struct iio_chan_spec *chan, char *buf)
 172 {
 173         struct ad5504_state *st = iio_priv(indio_dev);
 174
 175         return sprintf(buf, "%d\n",
 176                         !(st->pwr_down_mask & (1 << chan->channel)));
 177 }
 178
 179 static ssize_t ad5504_write_dac_powerdown(struct iio_dev *indio_dev,
 180         uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
 181         size_t len)
 182 {
 183         bool pwr_down;
 184         int ret;
 185         struct ad5504_state *st = iio_priv(indio_dev);
 186
 187         ret = strtobool(buf, &pwr_down);
 188         if (ret)
 189                 return ret;
 190
 191         if (pwr_down)
 192                 st->pwr_down_mask |= (1 << chan->channel);
 193         else
 194                 st->pwr_down_mask &= ~(1 << chan->channel);
 195
 196         ret = ad5504_spi_write(st, AD5504_ADDR_CTRL,
 197                                 AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) |
 198                                 AD5504_DAC_PWR(st->pwr_down_mask));
 199
 200         /* writes to the CTRL register must be followed by a NOOP */
 201         ad5504_spi_write(st, AD5504_ADDR_NOOP, 0);
 202
 203         return ret ? ret : len;
 204 }
 205
 206 static IIO_CONST_ATTR(temp0_thresh_rising_value, "110000");
 207 static IIO_CONST_ATTR(temp0_thresh_rising_en, "1");
 208
 209 static struct attribute *ad5504_ev_attributes[] = {
 210         &iio_const_attr_temp0_thresh_rising_value.dev_attr.attr,
 211         &iio_const_attr_temp0_thresh_rising_en.dev_attr.attr,
 212         NULL,
 213 };
 214
 215 static struct attribute_group ad5504_ev_attribute_group = {
 216         .attrs = ad5504_ev_attributes,
 217         .name = "events",
 218 };
 219
 220 static irqreturn_t ad5504_event_handler(int irq, void *private)
 221 {
 222         iio_push_event(private,
 223                        IIO_UNMOD_EVENT_CODE(IIO_TEMP,
 224                                             0,
 225                                             IIO_EV_TYPE_THRESH,
 226                                             IIO_EV_DIR_RISING),
 227                        iio_get_time_ns());
 228
 229         return IRQ_HANDLED;
 230 }
 231
 232 static const struct iio_info ad5504_info = {
 233         .write_raw = ad5504_write_raw,
 234         .read_raw = ad5504_read_raw,
 235         .event_attrs = &ad5504_ev_attribute_group,
 236         .driver_module = THIS_MODULE,
 237 };
 238
 239 static const struct iio_chan_spec_ext_info ad5504_ext_info[] = {
 240         {
 241                 .name = "powerdown",
 242                 .read = ad5504_read_dac_powerdown,
 243                 .write = ad5504_write_dac_powerdown,
 244                 .shared = IIO_SEPARATE,
 245         },
 246         IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
 247                  &ad5504_powerdown_mode_enum),
 248         IIO_ENUM_AVAILABLE("powerdown_mode", &ad5504_powerdown_mode_enum),
 249         { },
 250 };
 251
 252 #define AD5504_CHANNEL(_chan) { \
 253         .type = IIO_VOLTAGE, \
 254         .indexed = 1, \
 255         .output = 1, \
 256         .channel = (_chan), \
 257         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 258         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 259         .address = AD5504_ADDR_DAC(_chan), \
 260         .scan_type = { \
 261                 .sign = 'u', \
 262                 .realbits = 12, \
 263                 .storagebits = 16, \
 264         }, \
 265         .ext_info = ad5504_ext_info, \
 266 }
 267
 268 static const struct iio_chan_spec ad5504_channels[] = {
 269         AD5504_CHANNEL(0),
 270         AD5504_CHANNEL(1),
 271         AD5504_CHANNEL(2),
 272         AD5504_CHANNEL(3),
 273 };
 274
 275 static int ad5504_probe(struct spi_device *spi)
 276 {
 277         struct ad5504_platform_data *pdata = spi->dev.platform_data;
 278         struct iio_dev *indio_dev;
 279         struct ad5504_state *st;
 280         struct regulator *reg;
 281         int ret, voltage_uv = 0;
 282
 283         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 284         if (!indio_dev)
 285                 return -ENOMEM;
 286         reg = devm_regulator_get(&spi->dev, "vcc");
 287         if (!IS_ERR(reg)) {
 288                 ret = regulator_enable(reg);
 289                 if (ret)
 290                         return ret;
 291
 292                 ret = regulator_get_voltage(reg);
 293                 if (ret < 0)
 294                         goto error_disable_reg;
 295
 296                 voltage_uv = ret;
 297         }
 298
 299         spi_set_drvdata(spi, indio_dev);
 300         st = iio_priv(indio_dev);
 301         if (voltage_uv)
 302                 st->vref_mv = voltage_uv / 1000;
 303         else if (pdata)
 304                 st->vref_mv = pdata->vref_mv;
 305         else
 306                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 307
 308         st->reg = reg;
 309         st->spi = spi;
 310         indio_dev->dev.parent = &spi->dev;
 311         indio_dev->name = spi_get_device_id(st->spi)->name;
 312         indio_dev->info = &ad5504_info;
 313         if (spi_get_device_id(st->spi)->driver_data == ID_AD5501)
 314                 indio_dev->num_channels = 1;
 315         else
 316                 indio_dev->num_channels = 4;
 317         indio_dev->channels = ad5504_channels;
 318         indio_dev->modes = INDIO_DIRECT_MODE;
 319
 320         if (spi->irq) {
 321                 ret = devm_request_threaded_irq(&spi->dev, spi->irq,
 322                                            NULL,
 323                                            &ad5504_event_handler,
 324                                            IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 325                                            spi_get_device_id(st->spi)->name,
 326                                            indio_dev);
 327                 if (ret)
 328                         goto error_disable_reg;
 329         }
 330
 331         ret = iio_device_register(indio_dev);
 332         if (ret)
 333                 goto error_disable_reg;
 334
 335         return 0;
 336
 337 error_disable_reg:
 338         if (!IS_ERR(reg))
 339                 regulator_disable(reg);
 340
 341         return ret;
 342 }
 343
 344 static int ad5504_remove(struct spi_device *spi)
 345 {
 346         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 347         struct ad5504_state *st = iio_priv(indio_dev);
 348
 349         iio_device_unregister(indio_dev);
 350
 351         if (!IS_ERR(st->reg))
 352                 regulator_disable(st->reg);
 353
 354         return 0;
 355 }
 356
 357 static const struct spi_device_id ad5504_id[] = {
 358         {"ad5504", ID_AD5504},
 359         {"ad5501", ID_AD5501},
 360         {}
 361 };
 362 MODULE_DEVICE_TABLE(spi, ad5504_id);
 363
 364 static struct spi_driver ad5504_driver = {
 365         .driver = {
 366                    .name = "ad5504",
 367                    .owner = THIS_MODULE,
 368                    },
 369         .probe = ad5504_probe,
 370         .remove = ad5504_remove,
 371         .id_table = ad5504_id,
 372 };
 373 module_spi_driver(ad5504_driver);
 374
 375 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 376 MODULE_DESCRIPTION("Analog Devices AD5501/AD5501 DAC");
 377 MODULE_LICENSE("GPL v2");