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 "../iio.h"
  19 #include "../sysfs.h"
  20 #include "../ring_generic.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 *dev_info,
  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(dev_info);
  43         unsigned int scale_uv;
  44
  45         switch (m) {
  46         case 0:
  47                 mutex_lock(&dev_info->mlock);
  48                 if (iio_ring_enabled(dev_info))
  49                         ret = ad7476_scan_from_ring(dev_info);
  50                 else
  51                         ret = ad7476_scan_direct(st);
  52                 mutex_unlock(&dev_info->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 (1 << IIO_CHAN_INFO_SCALE_SHARED):
  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 static const struct ad7476_chip_info ad7476_chip_info_tbl[] = {
  70         [ID_AD7466] = {
  71                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
  72                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
  73                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
  74                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  75         },
  76         [ID_AD7467] = {
  77                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
  78                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
  79                                        0, 0, IIO_ST('u', 10, 16, 2), 0),
  80                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  81         },
  82         [ID_AD7468] = {
  83                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1 , 0, NULL, 0, 0,
  84                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
  85                                        0, 0, IIO_ST('u', 8, 16, 4), 0),
  86                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  87         },
  88         [ID_AD7475] = {
  89                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
  90                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
  91                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
  92                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  93         },
  94         [ID_AD7476] = {
  95                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
  96                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
  97                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
  98                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
  99         },
 100         [ID_AD7477] = {
 101                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 102                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 103                                        0, 0, IIO_ST('u', 10, 16, 2), 0),
 104                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 105         },
 106         [ID_AD7478] = {
 107                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 108                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 109                                        0, 0, IIO_ST('u', 8, 16, 4), 0),
 110                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 111         },
 112         [ID_AD7495] = {
 113                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 114                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 115                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
 116                 .channel[1] = IIO_CHAN_SOFT_TIMESTAMP(1),
 117                 .int_vref_mv = 2500,
 118         },
 119 };
 120
 121 static const struct iio_info ad7476_info = {
 122         .driver_module = THIS_MODULE,
 123         .read_raw = &ad7476_read_raw,
 124 };
 125
 126 static int __devinit ad7476_probe(struct spi_device *spi)
 127 {
 128         struct ad7476_platform_data *pdata = spi->dev.platform_data;
 129         struct ad7476_state *st;
 130         struct iio_dev *indio_dev;
 131         int ret, voltage_uv = 0;
 132
 133         indio_dev = iio_allocate_device(sizeof(*st));
 134         if (indio_dev == NULL) {
 135                 ret = -ENOMEM;
 136                 goto error_ret;
 137         }
 138         st = iio_priv(indio_dev);
 139         st->reg = regulator_get(&spi->dev, "vcc");
 140         if (!IS_ERR(st->reg)) {
 141                 ret = regulator_enable(st->reg);
 142                 if (ret)
 143                         goto error_put_reg;
 144
 145                 voltage_uv = regulator_get_voltage(st->reg);
 146         }
 147         st->chip_info =
 148                 &ad7476_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 149
 150         if (st->chip_info->int_vref_mv)
 151                 st->int_vref_mv = st->chip_info->int_vref_mv;
 152         else if (pdata && pdata->vref_mv)
 153                 st->int_vref_mv = pdata->vref_mv;
 154         else if (voltage_uv)
 155                 st->int_vref_mv = voltage_uv / 1000;
 156         else
 157                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 158
 159         spi_set_drvdata(spi, indio_dev);
 160
 161         st->spi = spi;
 162
 163         /* Establish that the iio_dev is a child of the spi device */
 164         indio_dev->dev.parent = &spi->dev;
 165         indio_dev->name = spi_get_device_id(spi)->name;
 166         indio_dev->modes = INDIO_DIRECT_MODE;
 167         indio_dev->channels = st->chip_info->channel;
 168         indio_dev->num_channels = 2;
 169         indio_dev->info = &ad7476_info;
 170         /* Setup default message */
 171
 172         st->xfer.rx_buf = &st->data;
 173         st->xfer.len = st->chip_info->channel[0].scan_type.storagebits / 8;
 174
 175         spi_message_init(&st->msg);
 176         spi_message_add_tail(&st->xfer, &st->msg);
 177
 178         ret = ad7476_register_ring_funcs_and_init(indio_dev);
 179         if (ret)
 180                 goto error_disable_reg;
 181
 182         ret = iio_ring_buffer_register(indio_dev,
 183                                        st->chip_info->channel,
 184                                        ARRAY_SIZE(st->chip_info->channel));
 185         if (ret)
 186                 goto error_cleanup_ring;
 187
 188         ret = iio_device_register(indio_dev);
 189         if (ret)
 190                 goto error_ring_unregister;
 191         return 0;
 192
 193 error_ring_unregister:
 194         iio_ring_buffer_unregister(indio_dev);
 195 error_cleanup_ring:
 196         ad7476_ring_cleanup(indio_dev);
 197 error_disable_reg:
 198         if (!IS_ERR(st->reg))
 199                 regulator_disable(st->reg);
 200 error_put_reg:
 201         if (!IS_ERR(st->reg))
 202                 regulator_put(st->reg);
 203         iio_free_device(indio_dev);
 204
 205 error_ret:
 206         return ret;
 207 }
 208
 209 static int ad7476_remove(struct spi_device *spi)
 210 {
 211         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 212         struct ad7476_state *st = iio_priv(indio_dev);
 213
 214         iio_ring_buffer_unregister(indio_dev);
 215         ad7476_ring_cleanup(indio_dev);
 216         if (!IS_ERR(st->reg)) {
 217                 regulator_disable(st->reg);
 218                 regulator_put(st->reg);
 219         }
 220         iio_device_unregister(indio_dev);
 221
 222         return 0;
 223 }
 224
 225 static const struct spi_device_id ad7476_id[] = {
 226         {"ad7466", ID_AD7466},
 227         {"ad7467", ID_AD7467},
 228         {"ad7468", ID_AD7468},
 229         {"ad7475", ID_AD7475},
 230         {"ad7476", ID_AD7476},
 231         {"ad7476a", ID_AD7476},
 232         {"ad7477", ID_AD7477},
 233         {"ad7477a", ID_AD7477},
 234         {"ad7478", ID_AD7478},
 235         {"ad7478a", ID_AD7478},
 236         {"ad7495", ID_AD7495},
 237         {}
 238 };
 239
 240 static struct spi_driver ad7476_driver = {
 241         .driver = {
 242                 .name   = "ad7476",
 243                 .bus    = &spi_bus_type,
 244                 .owner  = THIS_MODULE,
 245         },
 246         .probe          = ad7476_probe,
 247         .remove         = __devexit_p(ad7476_remove),
 248         .id_table       = ad7476_id,
 249 };
 250
 251 static int __init ad7476_init(void)
 252 {
 253         return spi_register_driver(&ad7476_driver);
 254 }
 255 module_init(ad7476_init);
 256
 257 static void __exit ad7476_exit(void)
 258 {
 259         spi_unregister_driver(&ad7476_driver);
 260 }
 261 module_exit(ad7476_exit);
 262
 263 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 264 MODULE_DESCRIPTION("Analog Devices AD7475/6/7/8(A) AD7466/7/8 ADC");
 265 MODULE_LICENSE("GPL v2");
 266 MODULE_ALIAS("spi:ad7476");