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
  17 #include "../iio.h"
  18 #include "../sysfs.h"
  19 #include "../ring_generic.h"
  20 #include "adc.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         bool reg_done = false;
 133         struct regulator *reg;
 134
 135         indio_dev = iio_allocate_device(sizeof(*st));
 136         if (indio_dev == NULL) {
 137                 ret = -ENOMEM;
 138                 goto error_ret;
 139         }
 140         st = iio_priv(indio_dev);
 141         reg = regulator_get(&spi->dev, "vcc");
 142         if (!IS_ERR(reg)) {
 143                 ret = regulator_enable(reg);
 144                 if (ret)
 145                         goto error_put_reg;
 146
 147                 voltage_uv = regulator_get_voltage(reg);
 148         }
 149         st->reg = reg;
 150         st->chip_info =
 151                 &ad7476_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 152
 153         if (st->chip_info->int_vref_mv)
 154                 st->int_vref_mv = st->chip_info->int_vref_mv;
 155         else if (pdata && pdata->vref_mv)
 156                 st->int_vref_mv = pdata->vref_mv;
 157         else if (voltage_uv)
 158                 st->int_vref_mv = voltage_uv / 1000;
 159         else
 160                 dev_warn(&spi->dev, "reference voltage unspecified\n");
 161
 162         spi_set_drvdata(spi, indio_dev);
 163
 164         st->spi = spi;
 165
 166         /* Establish that the iio_dev is a child of the spi device */
 167         indio_dev->dev.parent = &spi->dev;
 168         indio_dev->name = spi_get_device_id(spi)->name;
 169         indio_dev->modes = INDIO_DIRECT_MODE;
 170         indio_dev->channels = st->chip_info->channel;
 171         indio_dev->num_channels = 2;
 172         indio_dev->info = &ad7476_info;
 173         /* Setup default message */
 174
 175         st->xfer.rx_buf = &st->data;
 176         st->xfer.len = st->chip_info->channel[0].scan_type.storagebits / 8;
 177
 178         spi_message_init(&st->msg);
 179         spi_message_add_tail(&st->xfer, &st->msg);
 180
 181         ret = ad7476_register_ring_funcs_and_init(indio_dev);
 182         if (ret)
 183                 goto error_disable_reg;
 184
 185         ret = iio_device_register(indio_dev);
 186         if (ret)
 187                 goto error_disable_reg;
 188
 189         ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,
 190                                           st->chip_info->channel,
 191                                           ARRAY_SIZE(st->chip_info->channel));
 192         if (ret)
 193                 goto error_cleanup_ring;
 194         return 0;
 195
 196 error_cleanup_ring:
 197         ad7476_ring_cleanup(indio_dev);
 198         iio_device_unregister(indio_dev);
 199 error_disable_reg:
 200         if (!IS_ERR(reg))
 201                 regulator_disable(st->reg);
 202 error_put_reg:
 203         if (!IS_ERR(reg))
 204                 regulator_put(reg);
 205         if (!reg_done)
 206                 iio_free_device(indio_dev);
 207 error_ret:
 208         return ret;
 209 }
 210
 211 static int ad7476_remove(struct spi_device *spi)
 212 {
 213         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 214         struct ad7476_state *st = iio_priv(indio_dev);
 215         /* copy needed as st will have been freed */
 216         struct regulator *reg = st->reg;
 217
 218         iio_ring_buffer_unregister(indio_dev->ring);
 219         ad7476_ring_cleanup(indio_dev);
 220         iio_device_unregister(indio_dev);
 221         if (!IS_ERR(reg)) {
 222                 regulator_disable(reg);
 223                 regulator_put(reg);
 224         }
 225
 226         return 0;
 227 }
 228
 229 static const struct spi_device_id ad7476_id[] = {
 230         {"ad7466", ID_AD7466},
 231         {"ad7467", ID_AD7467},
 232         {"ad7468", ID_AD7468},
 233         {"ad7475", ID_AD7475},
 234         {"ad7476", ID_AD7476},
 235         {"ad7476a", ID_AD7476},
 236         {"ad7477", ID_AD7477},
 237         {"ad7477a", ID_AD7477},
 238         {"ad7478", ID_AD7478},
 239         {"ad7478a", ID_AD7478},
 240         {"ad7495", ID_AD7495},
 241         {}
 242 };
 243
 244 static struct spi_driver ad7476_driver = {
 245         .driver = {
 246                 .name   = "ad7476",
 247                 .bus    = &spi_bus_type,
 248                 .owner  = THIS_MODULE,
 249         },
 250         .probe          = ad7476_probe,
 251         .remove         = __devexit_p(ad7476_remove),
 252         .id_table       = ad7476_id,
 253 };
 254
 255 static int __init ad7476_init(void)
 256 {
 257         return spi_register_driver(&ad7476_driver);
 258 }
 259 module_init(ad7476_init);
 260
 261 static void __exit ad7476_exit(void)
 262 {
 263         spi_unregister_driver(&ad7476_driver);
 264 }
 265 module_exit(ad7476_exit);
 266
 267 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 268 MODULE_DESCRIPTION("Analog Devices AD7475/6/7/8(A) AD7466/7/8 ADC");
 269 MODULE_LICENSE("GPL v2");
 270 MODULE_ALIAS("spi:ad7476");