drivers/iio/adc/ti-adc161s626.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC
   4  *
   5  * ADC Devices Supported:
   6  *  adc141s626 - 14-bit ADC
   7  *  adc161s626 - 16-bit ADC
   8  *
   9  * Copyright (C) 2016-2018
  10  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/mod_devicetable.h>
  15 #include <linux/init.h>
  16 #include <linux/err.h>
  17 #include <linux/spi/spi.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/trigger.h>
  20 #include <linux/iio/buffer.h>
  21 #include <linux/iio/trigger_consumer.h>
  22 #include <linux/iio/triggered_buffer.h>
  23 #include <linux/regulator/consumer.h>
  24
  25 #define TI_ADC_DRV_NAME "ti-adc161s626"
  26
  27 enum {
  28         TI_ADC141S626,
  29         TI_ADC161S626,
  30 };
  31
  32 static const struct iio_chan_spec ti_adc141s626_channels[] = {
  33         {
  34                 .type = IIO_VOLTAGE,
  35                 .channel = 0,
  36                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  37                                       BIT(IIO_CHAN_INFO_SCALE) |
  38                                       BIT(IIO_CHAN_INFO_OFFSET),
  39                 .scan_index = 0,
  40                 .scan_type = {
  41                         .sign = 's',
  42                         .realbits = 14,
  43                         .storagebits = 16,
  44                 },
  45         },
  46         IIO_CHAN_SOFT_TIMESTAMP(1),
  47 };
  48
  49 static const struct iio_chan_spec ti_adc161s626_channels[] = {
  50         {
  51                 .type = IIO_VOLTAGE,
  52                 .channel = 0,
  53                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  54                                       BIT(IIO_CHAN_INFO_SCALE) |
  55                                       BIT(IIO_CHAN_INFO_OFFSET),
  56                 .scan_index = 0,
  57                 .scan_type = {
  58                         .sign = 's',
  59                         .realbits = 16,
  60                         .storagebits = 16,
  61                 },
  62         },
  63         IIO_CHAN_SOFT_TIMESTAMP(1),
  64 };
  65
  66 struct ti_adc_data {
  67         struct iio_dev *indio_dev;
  68         struct spi_device *spi;
  69         struct regulator *ref;
  70
  71         u8 read_size;
  72         u8 shift;
  73
  74         u8 buffer[16] __aligned(IIO_DMA_MINALIGN);
  75 };
  76
  77 static int ti_adc_read_measurement(struct ti_adc_data *data,
  78                                    struct iio_chan_spec const *chan, int *val)
  79 {
  80         int ret;
  81
  82         switch (data->read_size) {
  83         case 2: {
  84                 __be16 buf;
  85
  86                 ret = spi_read(data->spi, (void *) &buf, 2);
  87                 if (ret)
  88                         return ret;
  89
  90                 *val = be16_to_cpu(buf);
  91                 break;
  92         }
  93         case 3: {
  94                 __be32 buf;
  95
  96                 ret = spi_read(data->spi, (void *) &buf, 3);
  97                 if (ret)
  98                         return ret;
  99
 100                 *val = be32_to_cpu(buf) >> 8;
 101                 break;
 102         }
 103         default:
 104                 return -EINVAL;
 105         }
 106
 107         *val = sign_extend32(*val >> data->shift, chan->scan_type.realbits - 1);
 108
 109         return 0;
 110 }
 111
 112 static irqreturn_t ti_adc_trigger_handler(int irq, void *private)
 113 {
 114         struct iio_poll_func *pf = private;
 115         struct iio_dev *indio_dev = pf->indio_dev;
 116         struct ti_adc_data *data = iio_priv(indio_dev);
 117         int ret;
 118
 119         ret = ti_adc_read_measurement(data, &indio_dev->channels[0],
 120                                      (int *) &data->buffer);
 121         if (!ret)
 122                 iio_push_to_buffers_with_timestamp(indio_dev,
 123                                         data->buffer,
 124                                         iio_get_time_ns(indio_dev));
 125
 126         iio_trigger_notify_done(indio_dev->trig);
 127
 128         return IRQ_HANDLED;
 129 }
 130
 131 static int ti_adc_read_raw(struct iio_dev *indio_dev,
 132                            struct iio_chan_spec const *chan,
 133                            int *val, int *val2, long mask)
 134 {
 135         struct ti_adc_data *data = iio_priv(indio_dev);
 136         int ret;
 137
 138         switch (mask) {
 139         case IIO_CHAN_INFO_RAW:
 140                 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) {
 141                         ret = ti_adc_read_measurement(data, chan, val);
 142                         if (ret)
 143                                 return ret;
 144                         return IIO_VAL_INT;
 145                 }
 146                 unreachable();
 147         case IIO_CHAN_INFO_SCALE:
 148                 ret = regulator_get_voltage(data->ref);
 149                 if (ret < 0)
 150                         return ret;
 151
 152                 *val = ret / 1000;
 153                 *val2 = chan->scan_type.realbits;
 154
 155                 return IIO_VAL_FRACTIONAL_LOG2;
 156         case IIO_CHAN_INFO_OFFSET:
 157                 *val = 1 << (chan->scan_type.realbits - 1);
 158                 return IIO_VAL_INT;
 159         }
 160
 161         return 0;
 162 }
 163
 164 static const struct iio_info ti_adc_info = {
 165         .read_raw = ti_adc_read_raw,
 166 };
 167
 168 static void ti_adc_reg_disable(void *reg)
 169 {
 170         regulator_disable(reg);
 171 }
 172
 173 static int ti_adc_probe(struct spi_device *spi)
 174 {
 175         struct iio_dev *indio_dev;
 176         struct ti_adc_data *data;
 177         int ret;
 178
 179         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
 180         if (!indio_dev)
 181                 return -ENOMEM;
 182
 183         indio_dev->info = &ti_adc_info;
 184         indio_dev->name = TI_ADC_DRV_NAME;
 185         indio_dev->modes = INDIO_DIRECT_MODE;
 186
 187         data = iio_priv(indio_dev);
 188         data->spi = spi;
 189
 190         switch (spi_get_device_id(spi)->driver_data) {
 191         case TI_ADC141S626:
 192                 indio_dev->channels = ti_adc141s626_channels;
 193                 indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
 194                 data->shift = 0;
 195                 data->read_size = 2;
 196                 break;
 197         case TI_ADC161S626:
 198                 indio_dev->channels = ti_adc161s626_channels;
 199                 indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
 200                 data->shift = 6;
 201                 data->read_size = 3;
 202                 break;
 203         }
 204
 205         data->ref = devm_regulator_get(&spi->dev, "vdda");
 206         if (IS_ERR(data->ref))
 207                 return PTR_ERR(data->ref);
 208
 209         ret = regulator_enable(data->ref);
 210         if (ret < 0)
 211                 return ret;
 212
 213         ret = devm_add_action_or_reset(&spi->dev, ti_adc_reg_disable,
 214                                        data->ref);
 215         if (ret)
 216                 return ret;
 217
 218         ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
 219                                               ti_adc_trigger_handler, NULL);
 220         if (ret)
 221                 return ret;
 222
 223         return devm_iio_device_register(&spi->dev, indio_dev);
 224 }
 225
 226 static const struct of_device_id ti_adc_dt_ids[] = {
 227         { .compatible = "ti,adc141s626", },
 228         { .compatible = "ti,adc161s626", },
 229         { }
 230 };
 231 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 232
 233 static const struct spi_device_id ti_adc_id[] = {
 234         { "adc141s626", TI_ADC141S626 },
 235         { "adc161s626", TI_ADC161S626 },
 236         { }
 237 };
 238 MODULE_DEVICE_TABLE(spi, ti_adc_id);
 239
 240 static struct spi_driver ti_adc_driver = {
 241         .driver = {
 242                 .name   = TI_ADC_DRV_NAME,
 243                 .of_match_table = ti_adc_dt_ids,
 244         },
 245         .probe          = ti_adc_probe,
 246         .id_table       = ti_adc_id,
 247 };
 248 module_spi_driver(ti_adc_driver);
 249
 250 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
 251 MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
 252 MODULE_LICENSE("GPL");