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 <[email protected]>
  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                 ret = iio_device_claim_direct_mode(indio_dev);
 141                 if (ret)
 142                         return ret;
 143
 144                 ret = ti_adc_read_measurement(data, chan, val);
 145                 iio_device_release_direct_mode(indio_dev);
 146
 147                 if (ret)
 148                         return ret;
 149
 150                 return IIO_VAL_INT;
 151         case IIO_CHAN_INFO_SCALE:
 152                 ret = regulator_get_voltage(data->ref);
 153                 if (ret < 0)
 154                         return ret;
 155
 156                 *val = ret / 1000;
 157                 *val2 = chan->scan_type.realbits;
 158
 159                 return IIO_VAL_FRACTIONAL_LOG2;
 160         case IIO_CHAN_INFO_OFFSET:
 161                 *val = 1 << (chan->scan_type.realbits - 1);
 162                 return IIO_VAL_INT;
 163         }
 164
 165         return 0;
 166 }
 167
 168 static const struct iio_info ti_adc_info = {
 169         .read_raw = ti_adc_read_raw,
 170 };
 171
 172 static void ti_adc_reg_disable(void *reg)
 173 {
 174         regulator_disable(reg);
 175 }
 176
 177 static int ti_adc_probe(struct spi_device *spi)
 178 {
 179         struct iio_dev *indio_dev;
 180         struct ti_adc_data *data;
 181         int ret;
 182
 183         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
 184         if (!indio_dev)
 185                 return -ENOMEM;
 186
 187         indio_dev->info = &ti_adc_info;
 188         indio_dev->name = TI_ADC_DRV_NAME;
 189         indio_dev->modes = INDIO_DIRECT_MODE;
 190
 191         data = iio_priv(indio_dev);
 192         data->spi = spi;
 193
 194         switch (spi_get_device_id(spi)->driver_data) {
 195         case TI_ADC141S626:
 196                 indio_dev->channels = ti_adc141s626_channels;
 197                 indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
 198                 data->shift = 0;
 199                 data->read_size = 2;
 200                 break;
 201         case TI_ADC161S626:
 202                 indio_dev->channels = ti_adc161s626_channels;
 203                 indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
 204                 data->shift = 6;
 205                 data->read_size = 3;
 206                 break;
 207         }
 208
 209         data->ref = devm_regulator_get(&spi->dev, "vdda");
 210         if (IS_ERR(data->ref))
 211                 return PTR_ERR(data->ref);
 212
 213         ret = regulator_enable(data->ref);
 214         if (ret < 0)
 215                 return ret;
 216
 217         ret = devm_add_action_or_reset(&spi->dev, ti_adc_reg_disable,
 218                                        data->ref);
 219         if (ret)
 220                 return ret;
 221
 222         ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
 223                                               ti_adc_trigger_handler, NULL);
 224         if (ret)
 225                 return ret;
 226
 227         return devm_iio_device_register(&spi->dev, indio_dev);
 228 }
 229
 230 static const struct of_device_id ti_adc_dt_ids[] = {
 231         { .compatible = "ti,adc141s626", },
 232         { .compatible = "ti,adc161s626", },
 233         {}
 234 };
 235 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 236
 237 static const struct spi_device_id ti_adc_id[] = {
 238         {"adc141s626", TI_ADC141S626},
 239         {"adc161s626", TI_ADC161S626},
 240         {},
 241 };
 242 MODULE_DEVICE_TABLE(spi, ti_adc_id);
 243
 244 static struct spi_driver ti_adc_driver = {
 245         .driver = {
 246                 .name   = TI_ADC_DRV_NAME,
 247                 .of_match_table = ti_adc_dt_ids,
 248         },
 249         .probe          = ti_adc_probe,
 250         .id_table       = ti_adc_id,
 251 };
 252 module_spi_driver(ti_adc_driver);
 253
 254 MODULE_AUTHOR("Matt Ranostay <[email protected]>");
 255 MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
 256 MODULE_LICENSE("GPL");