Pileus Git - ~andy/linux/blob - drivers/staging/iio/adc/ad7476_core.c

   1 /*
   2  * AD7466/7/8 AD7476/5/7/8 (A) SPI ADC driver
   3  *
   4  * Copyright 2010 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/kernel.h>
  11 #include <linux/slab.h>
  12 #include <linux/sysfs.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/regulator/consumer.h>
  15 #include <linux/err.h>
  16 #include <linux/module.h>
  17
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20 #include <linux/iio/buffer.h>
  21
  22 #include "ad7476.h"
  23
  24 static int ad7476_scan_direct(struct ad7476_state *st)
  25 {
  26         int ret;
  27
  28         ret = spi_sync(st->spi, &st->msg);
  29         if (ret)
  30                 return ret;
  31
  32         return (st->data[0] << 8) | st->data[1];
  33 }
  34
  35 static int ad7476_read_raw(struct iio_dev *indio_dev,
  36                            struct iio_chan_spec const *chan,
  37                            int *val,
  38                            int *val2,
  39                            long m)
  40 {
  41         int ret;
  42         struct ad7476_state *st = iio_priv(indio_dev);
  43         unsigned int scale_uv;
  44
  45         switch (m) {
  46         case IIO_CHAN_INFO_RAW:
  47                 mutex_lock(&indio_dev->mlock);
  48                 if (iio_buffer_enabled(indio_dev))
  49                         ret = -EBUSY;
  50                 else
  51                         ret = ad7476_scan_direct(st);
  52                 mutex_unlock(&indio_dev->mlock);
  53
  54                 if (ret < 0)
  55                         return ret;
  56                 *val = (ret >> st->chip_info->channel[0].scan_type.shift) &
  57                         RES_MASK(st->chip_info->channel[0].scan_type.realbits);
  58                 return IIO_VAL_INT;
  59         case IIO_CHAN_INFO_SCALE:
  60                 scale_uv = (st->int_vref_mv * 1000)
  61                         >> st->chip_info->channel[0].scan_type.realbits;
  62                 *val =  scale_uv/1000;
  63                 *val2 = (scale_uv%1000)*1000;
  64                 return IIO_VAL_INT_PLUS_MICRO;
  65         }
  66         return -EINVAL;
  67 }
  68
  69 #define AD7476_CHAN(bits)                                       \
  70         {                                                       \
  71         .type = IIO_VOLTAGE,                                    \
  72         .indexed = 1,                                           \
  73         .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |           \
  74         IIO_CHAN_INFO_SCALE_SHARED_BIT,                         \
  75         .scan_type = {                                          \
  76                 .sign = 'u',                                    \
  77                 .realbits = bits,                               \
  78                 .storagebits = 16,                              \
  79                 .shift = 12 - bits,                             \
  80         },                                                      \
  81 }
  82
  83 static const struct ad7476_chip_info ad7476_chip_info_tbl[] = {
  84         [ID_AD7466] = {
  85                 .channel[0] = AD7476_CHAN(12),
  86                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  87         },
  88         [ID_AD7467] = {
  89                 .channel[0] = AD7476_CHAN(10),
  90                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  91         },
  92         [ID_AD7468] = {
  93                 .channel[0] = AD7476_CHAN(8),
  94                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  95         },
  96         [ID_AD7475] = {
  97                 .channel[0] = AD7476_CHAN(12),
  98                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  99         },
 100         [ID_AD7476] = {
 101                 .channel[0] = AD7476_CHAN(12),
 102                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 103         },
 104         [ID_AD7477] = {
 105                 .channel[0] = AD7476_CHAN(10),
 106                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 107         },
 108         [ID_AD7478] = {
 109                 .channel[0] = AD7476_CHAN(8),
 110                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 111         },
 112         [ID_AD7495] = {
 113                 .channel[0] = AD7476_CHAN(12),
 114                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 115                 .int_vref_mv = 2500,
 116         },
 117 };
 118
 119 static const struct iio_info ad7476_info = {
 120         .driver_module = THIS_MODULE,
 121         .read_raw = &ad7476_read_raw,
 122 };
 123
 124 static int __devinit ad7476_probe(struct spi_device *spi)
 125 {
 126         struct ad7476_platform_data *pdata = spi->dev.platform_data;
 127         struct ad7476_state *st;
 128         struct iio_dev *indio_dev;
 129         int ret, voltage_uv = 0;
 130
 131         indio_dev = iio_device_alloc(sizeof(*st));
 132         if (indio_dev == NULL) {
 133                 ret = -ENOMEM;
 134                 goto error_ret;
 135         }
 136         st = iio_priv(indio_dev);
 137         st->reg = regulator_get(&spi->dev, "vcc");
 138         if (!IS_ERR(st->reg)) {
 139                 ret = regulator_enable(st->reg);
 140                 if (ret)
 141                         goto error_put_reg;
 142
 143                 voltage_uv = regulator_get_voltage(st->reg);
 144         }
 145         st->chip_info =
 146                 &ad7476_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 147
 148         if (st->chip_info->int_vref_mv)
 149                 st->int_vref_mv = st->chip_info->int_vref_mv;
 150         else if (pdata && pdata->vref_mv)
 151                 st->int_vref_mv = pdata->vref_mv;
 152         else if (voltage_uv)
 153                 st->int_vref_mv = voltage_uv / 1000;
 154         else
 155                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 156
 157         spi_set_drvdata(spi, indio_dev);
 158
 159         st->spi = spi;
 160
 161         /* Establish that the iio_dev is a child of the spi device */
 162         indio_dev->dev.parent = &spi->dev;
 163         indio_dev->name = spi_get_device_id(spi)->name;
 164         indio_dev->modes = INDIO_DIRECT_MODE;
 165         indio_dev->channels = st->chip_info->channel;
 166         indio_dev->num_channels = 2;
 167         indio_dev->info = &ad7476_info;
 168         /* Setup default message */
 169
 170         st->xfer.rx_buf = &st->data;
 171         st->xfer.len = st->chip_info->channel[0].scan_type.storagebits / 8;
 172
 173         spi_message_init(&st->msg);
 174         spi_message_add_tail(&st->xfer, &st->msg);
 175
 176         ret = ad7476_register_ring_funcs_and_init(indio_dev);
 177         if (ret)
 178                 goto error_disable_reg;
 179
 180         ret = iio_buffer_register(indio_dev,
 181                                   st->chip_info->channel,
 182                                   ARRAY_SIZE(st->chip_info->channel));
 183         if (ret)
 184                 goto error_cleanup_ring;
 185
 186         ret = iio_device_register(indio_dev);
 187         if (ret)
 188                 goto error_ring_unregister;
 189         return 0;
 190
 191 error_ring_unregister:
 192         iio_buffer_unregister(indio_dev);
 193 error_cleanup_ring:
 194         ad7476_ring_cleanup(indio_dev);
 195 error_disable_reg:
 196         if (!IS_ERR(st->reg))
 197                 regulator_disable(st->reg);
 198 error_put_reg:
 199         if (!IS_ERR(st->reg))
 200                 regulator_put(st->reg);
 201         iio_device_free(indio_dev);
 202
 203 error_ret:
 204         return ret;
 205 }
 206
 207 static int ad7476_remove(struct spi_device *spi)
 208 {
 209         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 210         struct ad7476_state *st = iio_priv(indio_dev);
 211
 212         iio_device_unregister(indio_dev);
 213         iio_buffer_unregister(indio_dev);
 214         ad7476_ring_cleanup(indio_dev);
 215         if (!IS_ERR(st->reg)) {
 216                 regulator_disable(st->reg);
 217                 regulator_put(st->reg);
 218         }
 219         iio_device_free(indio_dev);
 220
 221         return 0;
 222 }
 223
 224 static const struct spi_device_id ad7476_id[] = {
 225         {"ad7466", ID_AD7466},
 226         {"ad7467", ID_AD7467},
 227         {"ad7468", ID_AD7468},
 228         {"ad7475", ID_AD7475},
 229         {"ad7476", ID_AD7476},
 230         {"ad7476a", ID_AD7476},
 231         {"ad7477", ID_AD7477},
 232         {"ad7477a", ID_AD7477},
 233         {"ad7478", ID_AD7478},
 234         {"ad7478a", ID_AD7478},
 235         {"ad7495", ID_AD7495},
 236         {}
 237 };
 238 MODULE_DEVICE_TABLE(spi, ad7476_id);
 239
 240 static struct spi_driver ad7476_driver = {
 241         .driver = {
 242                 .name   = "ad7476",
 243                 .owner  = THIS_MODULE,
 244         },
 245         .probe          = ad7476_probe,
 246         .remove         = __devexit_p(ad7476_remove),
 247         .id_table       = ad7476_id,
 248 };
 249 module_spi_driver(ad7476_driver);
 250
 251 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 252 MODULE_DESCRIPTION("Analog Devices AD7475/6/7/8(A) AD7466/7/8 ADC");
 253 MODULE_LICENSE("GPL v2");