drivers/iio/adc/ti-adc108s102.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * TI ADC108S102 SPI ADC driver
   4  *
   5  * Copyright (c) 2013-2015 Intel Corporation.
   6  * Copyright (c) 2017 Siemens AG
   7  *
   8  * This IIO device driver is designed to work with the following
   9  * analog to digital converters from Texas Instruments:
  10  *  ADC108S102
  11  *  ADC128S102
  12  * The communication with ADC chip is via the SPI bus (mode 3).
  13  */
  14
  15 #include <linux/acpi.h>
  16 #include <linux/iio/iio.h>
  17 #include <linux/iio/buffer.h>
  18 #include <linux/iio/types.h>
  19 #include <linux/iio/triggered_buffer.h>
  20 #include <linux/iio/trigger_consumer.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/module.h>
  23 #include <linux/mod_devicetable.h>
  24 #include <linux/property.h>
  25 #include <linux/regulator/consumer.h>
  26 #include <linux/spi/spi.h>
  27
  28 /*
  29  * In case of ACPI, we use the hard-wired 5000 mV of the Galileo and IOT2000
  30  * boards as default for the reference pin VA. Device tree users encode that
  31  * via the vref-supply regulator.
  32  */
  33 #define ADC108S102_VA_MV_ACPI_DEFAULT   5000
  34
  35 /*
  36  * Defining the ADC resolution being 12 bits, we can use the same driver for
  37  * both ADC108S102 (10 bits resolution) and ADC128S102 (12 bits resolution)
  38  * chips. The ADC108S102 effectively returns a 12-bit result with the 2
  39  * least-significant bits unset.
  40  */
  41 #define ADC108S102_BITS         12
  42 #define ADC108S102_MAX_CHANNELS 8
  43
  44 /*
  45  * 16-bit SPI command format:
  46  *   [15:14] Ignored
  47  *   [13:11] 3-bit channel address
  48  *   [10:0]  Ignored
  49  */
  50 #define ADC108S102_CMD(ch)              ((u16)(ch) << 11)
  51
  52 /*
  53  * 16-bit SPI response format:
  54  *   [15:12] Zeros
  55  *   [11:0]  12-bit ADC sample (for ADC108S102, [1:0] will always be 0).
  56  */
  57 #define ADC108S102_RES_DATA(res)        ((u16)res & GENMASK(11, 0))
  58
  59 struct adc108s102_state {
  60         struct spi_device               *spi;
  61         u32                             va_millivolt;
  62         /* SPI transfer used by triggered buffer handler*/
  63         struct spi_transfer             ring_xfer;
  64         /* SPI transfer used by direct scan */
  65         struct spi_transfer             scan_single_xfer;
  66         /* SPI message used by ring_xfer SPI transfer */
  67         struct spi_message              ring_msg;
  68         /* SPI message used by scan_single_xfer SPI transfer */
  69         struct spi_message              scan_single_msg;
  70
  71         /*
  72          * SPI message buffers:
  73          *  tx_buf: |C0|C1|C2|C3|C4|C5|C6|C7|XX|
  74          *  rx_buf: |XX|R0|R1|R2|R3|R4|R5|R6|R7|tt|tt|tt|tt|
  75          *
  76          *  tx_buf: 8 channel read commands, plus 1 dummy command
  77          *  rx_buf: 1 dummy response, 8 channel responses
  78          */
  79         __be16                          rx_buf[9] __aligned(IIO_DMA_MINALIGN);
  80         __be16                          tx_buf[9] __aligned(IIO_DMA_MINALIGN);
  81 };
  82
  83 #define ADC108S102_V_CHAN(index)                                        \
  84         {                                                               \
  85                 .type = IIO_VOLTAGE,                                    \
  86                 .indexed = 1,                                           \
  87                 .channel = index,                                       \
  88                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
  89                         BIT(IIO_CHAN_INFO_SCALE),                       \
  90                 .address = index,                                       \
  91                 .scan_index = index,                                    \
  92                 .scan_type = {                                          \
  93                         .sign = 'u',                                    \
  94                         .realbits = ADC108S102_BITS,                    \
  95                         .storagebits = 16,                              \
  96                         .endianness = IIO_BE,                           \
  97                 },                                                      \
  98         }
  99
 100 static const struct iio_chan_spec adc108s102_channels[] = {
 101         ADC108S102_V_CHAN(0),
 102         ADC108S102_V_CHAN(1),
 103         ADC108S102_V_CHAN(2),
 104         ADC108S102_V_CHAN(3),
 105         ADC108S102_V_CHAN(4),
 106         ADC108S102_V_CHAN(5),
 107         ADC108S102_V_CHAN(6),
 108         ADC108S102_V_CHAN(7),
 109         IIO_CHAN_SOFT_TIMESTAMP(8),
 110 };
 111
 112 static int adc108s102_update_scan_mode(struct iio_dev *indio_dev,
 113                 unsigned long const *active_scan_mask)
 114 {
 115         struct adc108s102_state *st = iio_priv(indio_dev);
 116         unsigned int bit, cmds;
 117
 118         /*
 119          * Fill in the first x shorts of tx_buf with the number of channels
 120          * enabled for sampling by the triggered buffer.
 121          */
 122         cmds = 0;
 123         for_each_set_bit(bit, active_scan_mask, ADC108S102_MAX_CHANNELS)
 124                 st->tx_buf[cmds++] = cpu_to_be16(ADC108S102_CMD(bit));
 125
 126         /* One dummy command added, to clock in the last response */
 127         st->tx_buf[cmds++] = 0x00;
 128
 129         /* build SPI ring message */
 130         st->ring_xfer.tx_buf = &st->tx_buf[0];
 131         st->ring_xfer.rx_buf = &st->rx_buf[0];
 132         st->ring_xfer.len = cmds * sizeof(st->tx_buf[0]);
 133
 134         spi_message_init_with_transfers(&st->ring_msg, &st->ring_xfer, 1);
 135
 136         return 0;
 137 }
 138
 139 static irqreturn_t adc108s102_trigger_handler(int irq, void *p)
 140 {
 141         struct iio_poll_func *pf = p;
 142         struct iio_dev *indio_dev = pf->indio_dev;
 143         struct adc108s102_state *st = iio_priv(indio_dev);
 144         int ret;
 145
 146         ret = spi_sync(st->spi, &st->ring_msg);
 147         if (ret < 0)
 148                 goto out_notify;
 149
 150         /* Skip the dummy response in the first slot */
 151         iio_push_to_buffers_with_ts_unaligned(indio_dev,
 152                                               &st->rx_buf[1],
 153                                               st->ring_xfer.len - sizeof(st->rx_buf[1]),
 154                                               iio_get_time_ns(indio_dev));
 155
 156 out_notify:
 157         iio_trigger_notify_done(indio_dev->trig);
 158
 159         return IRQ_HANDLED;
 160 }
 161
 162 static int adc108s102_scan_direct(struct adc108s102_state *st, unsigned int ch)
 163 {
 164         int ret;
 165
 166         st->tx_buf[0] = cpu_to_be16(ADC108S102_CMD(ch));
 167         ret = spi_sync(st->spi, &st->scan_single_msg);
 168         if (ret)
 169                 return ret;
 170
 171         /* Skip the dummy response in the first slot */
 172         return be16_to_cpu(st->rx_buf[1]);
 173 }
 174
 175 static int adc108s102_read_raw(struct iio_dev *indio_dev,
 176                                struct iio_chan_spec const *chan,
 177                                int *val, int *val2, long m)
 178 {
 179         struct adc108s102_state *st = iio_priv(indio_dev);
 180         int ret;
 181
 182         switch (m) {
 183         case IIO_CHAN_INFO_RAW:
 184                 ret = iio_device_claim_direct_mode(indio_dev);
 185                 if (ret)
 186                         return ret;
 187
 188                 ret = adc108s102_scan_direct(st, chan->address);
 189
 190                 iio_device_release_direct_mode(indio_dev);
 191
 192                 if (ret < 0)
 193                         return ret;
 194
 195                 *val = ADC108S102_RES_DATA(ret);
 196
 197                 return IIO_VAL_INT;
 198         case IIO_CHAN_INFO_SCALE:
 199                 if (chan->type != IIO_VOLTAGE)
 200                         break;
 201
 202                 *val = st->va_millivolt;
 203                 *val2 = chan->scan_type.realbits;
 204
 205                 return IIO_VAL_FRACTIONAL_LOG2;
 206         default:
 207                 break;
 208         }
 209
 210         return -EINVAL;
 211 }
 212
 213 static const struct iio_info adc108s102_info = {
 214         .read_raw               = &adc108s102_read_raw,
 215         .update_scan_mode       = &adc108s102_update_scan_mode,
 216 };
 217
 218 static int adc108s102_probe(struct spi_device *spi)
 219 {
 220         struct adc108s102_state *st;
 221         struct iio_dev *indio_dev;
 222         int ret;
 223
 224         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 225         if (!indio_dev)
 226                 return -ENOMEM;
 227
 228         st = iio_priv(indio_dev);
 229
 230         if (ACPI_COMPANION(&spi->dev)) {
 231                 st->va_millivolt = ADC108S102_VA_MV_ACPI_DEFAULT;
 232         } else {
 233                 ret = devm_regulator_get_enable_read_voltage(&spi->dev, "vref");
 234                 if (ret < 0)
 235                         return dev_err_probe(&spi->dev, ret, "failed get vref voltage\n");
 236
 237                 st->va_millivolt = ret / 1000;
 238         }
 239
 240         st->spi = spi;
 241
 242         indio_dev->name = spi->modalias;
 243         indio_dev->modes = INDIO_DIRECT_MODE;
 244         indio_dev->channels = adc108s102_channels;
 245         indio_dev->num_channels = ARRAY_SIZE(adc108s102_channels);
 246         indio_dev->info = &adc108s102_info;
 247
 248         /* Setup default message */
 249         st->scan_single_xfer.tx_buf = st->tx_buf;
 250         st->scan_single_xfer.rx_buf = st->rx_buf;
 251         st->scan_single_xfer.len = 2 * sizeof(st->tx_buf[0]);
 252
 253         spi_message_init_with_transfers(&st->scan_single_msg,
 254                                         &st->scan_single_xfer, 1);
 255
 256         ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
 257                                               &adc108s102_trigger_handler,
 258                                               NULL);
 259         if (ret)
 260                 return ret;
 261
 262         ret = devm_iio_device_register(&spi->dev, indio_dev);
 263         if (ret)
 264                 dev_err(&spi->dev, "Failed to register IIO device\n");
 265         return ret;
 266 }
 267
 268 static const struct of_device_id adc108s102_of_match[] = {
 269         { .compatible = "ti,adc108s102" },
 270         { }
 271 };
 272 MODULE_DEVICE_TABLE(of, adc108s102_of_match);
 273
 274 static const struct acpi_device_id adc108s102_acpi_ids[] = {
 275         { "INT3495", 0 },
 276         { }
 277 };
 278 MODULE_DEVICE_TABLE(acpi, adc108s102_acpi_ids);
 279
 280 static const struct spi_device_id adc108s102_id[] = {
 281         { "adc108s102", 0 },
 282         { }
 283 };
 284 MODULE_DEVICE_TABLE(spi, adc108s102_id);
 285
 286 static struct spi_driver adc108s102_driver = {
 287         .driver = {
 288                 .name   = "adc108s102",
 289                 .of_match_table = adc108s102_of_match,
 290                 .acpi_match_table = adc108s102_acpi_ids,
 291         },
 292         .probe          = adc108s102_probe,
 293         .id_table       = adc108s102_id,
 294 };
 295 module_spi_driver(adc108s102_driver);
 296
 297 MODULE_AUTHOR("Bogdan Pricop <bogdan.pricop@emutex.com>");
 298 MODULE_DESCRIPTION("Texas Instruments ADC108S102 and ADC128S102 driver");
 299 MODULE_LICENSE("GPL v2");