iio/adc/ad7266.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * AD7266/65 SPI ADC driver
0004  *
0005  * Copyright 2012 Analog Devices Inc.
0006  */
0007
0008 #include <linux/device.h>
0009 #include <linux/kernel.h>
0010 #include <linux/slab.h>
0011 #include <linux/spi/spi.h>
0012 #include <linux/regulator/consumer.h>
0013 #include <linux/err.h>
0014 #include <linux/gpio/consumer.h>
0015 #include <linux/module.h>
0016
0017 #include <linux/interrupt.h>
0018
0019 #include <linux/iio/iio.h>
0020 #include <linux/iio/buffer.h>
0021 #include <linux/iio/trigger_consumer.h>
0022 #include <linux/iio/triggered_buffer.h>
0023
0024 #include <linux/platform_data/ad7266.h>
0025
0026 struct ad7266_state {
0027     struct spi_device   *spi;
0028     struct regulator    *reg;
0029     unsigned long       vref_mv;
0030
0031     struct spi_transfer single_xfer[3];
0032     struct spi_message  single_msg;
0033
0034     enum ad7266_range   range;
0035     enum ad7266_mode    mode;
0036     bool            fixed_addr;
0037     struct gpio_desc    *gpios[3];
0038
0039     /*
0040      * DMA (thus cache coherency maintenance) may require the
0041      * transfer buffers to live in their own cache lines.
0042      * The buffer needs to be large enough to hold two samples (4 bytes) and
0043      * the naturally aligned timestamp (8 bytes).
0044      */
0045     struct {
0046         __be16 sample[2];
0047         s64 timestamp;
0048     } data __aligned(IIO_DMA_MINALIGN);
0049 };
0050
0051 static int ad7266_wakeup(struct ad7266_state *st)
0052 {
0053     /* Any read with >= 2 bytes will wake the device */
0054     return spi_read(st->spi, &st->data.sample[0], 2);
0055 }
0056
0057 static int ad7266_powerdown(struct ad7266_state *st)
0058 {
0059     /* Any read with < 2 bytes will powerdown the device */
0060     return spi_read(st->spi, &st->data.sample[0], 1);
0061 }
0062
0063 static int ad7266_preenable(struct iio_dev *indio_dev)
0064 {
0065     struct ad7266_state *st = iio_priv(indio_dev);
0066     return ad7266_wakeup(st);
0067 }
0068
0069 static int ad7266_postdisable(struct iio_dev *indio_dev)
0070 {
0071     struct ad7266_state *st = iio_priv(indio_dev);
0072     return ad7266_powerdown(st);
0073 }
0074
0075 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
0076     .preenable = &ad7266_preenable,
0077     .postdisable = &ad7266_postdisable,
0078 };
0079
0080 static irqreturn_t ad7266_trigger_handler(int irq, void *p)
0081 {
0082     struct iio_poll_func *pf = p;
0083     struct iio_dev *indio_dev = pf->indio_dev;
0084     struct ad7266_state *st = iio_priv(indio_dev);
0085     int ret;
0086
0087     ret = spi_read(st->spi, st->data.sample, 4);
0088     if (ret == 0) {
0089         iio_push_to_buffers_with_timestamp(indio_dev, &st->data,
0090                 pf->timestamp);
0091     }
0092
0093     iio_trigger_notify_done(indio_dev->trig);
0094
0095     return IRQ_HANDLED;
0096 }
0097
0098 static void ad7266_select_input(struct ad7266_state *st, unsigned int nr)
0099 {
0100     unsigned int i;
0101
0102     if (st->fixed_addr)
0103         return;
0104
0105     switch (st->mode) {
0106     case AD7266_MODE_SINGLE_ENDED:
0107         nr >>= 1;
0108         break;
0109     case AD7266_MODE_PSEUDO_DIFF:
0110         nr |= 1;
0111         break;
0112     case AD7266_MODE_DIFF:
0113         nr &= ~1;
0114         break;
0115     }
0116
0117     for (i = 0; i < 3; ++i)
0118         gpiod_set_value(st->gpios[i], (bool)(nr & BIT(i)));
0119 }
0120
0121 static int ad7266_update_scan_mode(struct iio_dev *indio_dev,
0122     const unsigned long *scan_mask)
0123 {
0124     struct ad7266_state *st = iio_priv(indio_dev);
0125     unsigned int nr = find_first_bit(scan_mask, indio_dev->masklength);
0126
0127     ad7266_select_input(st, nr);
0128
0129     return 0;
0130 }
0131
0132 static int ad7266_read_single(struct ad7266_state *st, int *val,
0133     unsigned int address)
0134 {
0135     int ret;
0136
0137     ad7266_select_input(st, address);
0138
0139     ret = spi_sync(st->spi, &st->single_msg);
0140     *val = be16_to_cpu(st->data.sample[address % 2]);
0141
0142     return ret;
0143 }
0144
0145 static int ad7266_read_raw(struct iio_dev *indio_dev,
0146     struct iio_chan_spec const *chan, int *val, int *val2, long m)
0147 {
0148     struct ad7266_state *st = iio_priv(indio_dev);
0149     unsigned long scale_mv;
0150     int ret;
0151
0152     switch (m) {
0153     case IIO_CHAN_INFO_RAW:
0154         ret = iio_device_claim_direct_mode(indio_dev);
0155         if (ret)
0156             return ret;
0157         ret = ad7266_read_single(st, val, chan->address);
0158         iio_device_release_direct_mode(indio_dev);
0159
0160         *val = (*val >> 2) & 0xfff;
0161         if (chan->scan_type.sign == 's')
0162             *val = sign_extend32(*val,
0163                          chan->scan_type.realbits - 1);
0164
0165         return IIO_VAL_INT;
0166     case IIO_CHAN_INFO_SCALE:
0167         scale_mv = st->vref_mv;
0168         if (st->mode == AD7266_MODE_DIFF)
0169             scale_mv *= 2;
0170         if (st->range == AD7266_RANGE_2VREF)
0171             scale_mv *= 2;
0172
0173         *val = scale_mv;
0174         *val2 = chan->scan_type.realbits;
0175         return IIO_VAL_FRACTIONAL_LOG2;
0176     case IIO_CHAN_INFO_OFFSET:
0177         if (st->range == AD7266_RANGE_2VREF &&
0178             st->mode != AD7266_MODE_DIFF)
0179             *val = 2048;
0180         else
0181             *val = 0;
0182         return IIO_VAL_INT;
0183     }
0184     return -EINVAL;
0185 }
0186
0187 #define AD7266_CHAN(_chan, _sign) {         \
0188     .type = IIO_VOLTAGE,                \
0189     .indexed = 1,                   \
0190     .channel = (_chan),             \
0191     .address = (_chan),             \
0192     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
0193     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
0194         | BIT(IIO_CHAN_INFO_OFFSET),            \
0195     .scan_index = (_chan),              \
0196     .scan_type = {                  \
0197         .sign = (_sign),            \
0198         .realbits = 12,             \
0199         .storagebits = 16,          \
0200         .shift = 2,             \
0201         .endianness = IIO_BE,           \
0202     },                      \
0203 }
0204
0205 #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS(_name, _sign) \
0206 const struct iio_chan_spec ad7266_channels_##_name[] = { \
0207     AD7266_CHAN(0, (_sign)), \
0208     AD7266_CHAN(1, (_sign)), \
0209     AD7266_CHAN(2, (_sign)), \
0210     AD7266_CHAN(3, (_sign)), \
0211     AD7266_CHAN(4, (_sign)), \
0212     AD7266_CHAN(5, (_sign)), \
0213     AD7266_CHAN(6, (_sign)), \
0214     AD7266_CHAN(7, (_sign)), \
0215     AD7266_CHAN(8, (_sign)), \
0216     AD7266_CHAN(9, (_sign)), \
0217     AD7266_CHAN(10, (_sign)), \
0218     AD7266_CHAN(11, (_sign)), \
0219     IIO_CHAN_SOFT_TIMESTAMP(13), \
0220 }
0221
0222 #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(_name, _sign) \
0223 const struct iio_chan_spec ad7266_channels_##_name##_fixed[] = { \
0224     AD7266_CHAN(0, (_sign)), \
0225     AD7266_CHAN(1, (_sign)), \
0226     IIO_CHAN_SOFT_TIMESTAMP(2), \
0227 }
0228
0229 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(u, 'u');
0230 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(s, 's');
0231 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(u, 'u');
0232 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(s, 's');
0233
0234 #define AD7266_CHAN_DIFF(_chan, _sign) {            \
0235     .type = IIO_VOLTAGE,                \
0236     .indexed = 1,                   \
0237     .channel = (_chan) * 2,             \
0238     .channel2 = (_chan) * 2 + 1,            \
0239     .address = (_chan),             \
0240     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
0241     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE)    \
0242         | BIT(IIO_CHAN_INFO_OFFSET),            \
0243     .scan_index = (_chan),              \
0244     .scan_type = {                  \
0245         .sign = _sign,          \
0246         .realbits = 12,             \
0247         .storagebits = 16,          \
0248         .shift = 2,             \
0249         .endianness = IIO_BE,           \
0250     },                      \
0251     .differential = 1,              \
0252 }
0253
0254 #define AD7266_DECLARE_DIFF_CHANNELS(_name, _sign) \
0255 const struct iio_chan_spec ad7266_channels_diff_##_name[] = { \
0256     AD7266_CHAN_DIFF(0, (_sign)), \
0257     AD7266_CHAN_DIFF(1, (_sign)), \
0258     AD7266_CHAN_DIFF(2, (_sign)), \
0259     AD7266_CHAN_DIFF(3, (_sign)), \
0260     AD7266_CHAN_DIFF(4, (_sign)), \
0261     AD7266_CHAN_DIFF(5, (_sign)), \
0262     IIO_CHAN_SOFT_TIMESTAMP(6), \
0263 }
0264
0265 static AD7266_DECLARE_DIFF_CHANNELS(s, 's');
0266 static AD7266_DECLARE_DIFF_CHANNELS(u, 'u');
0267
0268 #define AD7266_DECLARE_DIFF_CHANNELS_FIXED(_name, _sign) \
0269 const struct iio_chan_spec ad7266_channels_diff_fixed_##_name[] = { \
0270     AD7266_CHAN_DIFF(0, (_sign)), \
0271     AD7266_CHAN_DIFF(1, (_sign)), \
0272     IIO_CHAN_SOFT_TIMESTAMP(2), \
0273 }
0274
0275 static AD7266_DECLARE_DIFF_CHANNELS_FIXED(s, 's');
0276 static AD7266_DECLARE_DIFF_CHANNELS_FIXED(u, 'u');
0277
0278 static const struct iio_info ad7266_info = {
0279     .read_raw = &ad7266_read_raw,
0280     .update_scan_mode = &ad7266_update_scan_mode,
0281 };
0282
0283 static const unsigned long ad7266_available_scan_masks[] = {
0284     0x003,
0285     0x00c,
0286     0x030,
0287     0x0c0,
0288     0x300,
0289     0xc00,
0290     0x000,
0291 };
0292
0293 static const unsigned long ad7266_available_scan_masks_diff[] = {
0294     0x003,
0295     0x00c,
0296     0x030,
0297     0x000,
0298 };
0299
0300 static const unsigned long ad7266_available_scan_masks_fixed[] = {
0301     0x003,
0302     0x000,
0303 };
0304
0305 struct ad7266_chan_info {
0306     const struct iio_chan_spec *channels;
0307     unsigned int num_channels;
0308     const unsigned long *scan_masks;
0309 };
0310
0311 #define AD7266_CHAN_INFO_INDEX(_differential, _signed, _fixed) \
0312     (((_differential) << 2) | ((_signed) << 1) | ((_fixed) << 0))
0313
0314 static const struct ad7266_chan_info ad7266_chan_infos[] = {
0315     [AD7266_CHAN_INFO_INDEX(0, 0, 0)] = {
0316         .channels = ad7266_channels_u,
0317         .num_channels = ARRAY_SIZE(ad7266_channels_u),
0318         .scan_masks = ad7266_available_scan_masks,
0319     },
0320     [AD7266_CHAN_INFO_INDEX(0, 0, 1)] = {
0321         .channels = ad7266_channels_u_fixed,
0322         .num_channels = ARRAY_SIZE(ad7266_channels_u_fixed),
0323         .scan_masks = ad7266_available_scan_masks_fixed,
0324     },
0325     [AD7266_CHAN_INFO_INDEX(0, 1, 0)] = {
0326         .channels = ad7266_channels_s,
0327         .num_channels = ARRAY_SIZE(ad7266_channels_s),
0328         .scan_masks = ad7266_available_scan_masks,
0329     },
0330     [AD7266_CHAN_INFO_INDEX(0, 1, 1)] = {
0331         .channels = ad7266_channels_s_fixed,
0332         .num_channels = ARRAY_SIZE(ad7266_channels_s_fixed),
0333         .scan_masks = ad7266_available_scan_masks_fixed,
0334     },
0335     [AD7266_CHAN_INFO_INDEX(1, 0, 0)] = {
0336         .channels = ad7266_channels_diff_u,
0337         .num_channels = ARRAY_SIZE(ad7266_channels_diff_u),
0338         .scan_masks = ad7266_available_scan_masks_diff,
0339     },
0340     [AD7266_CHAN_INFO_INDEX(1, 0, 1)] = {
0341         .channels = ad7266_channels_diff_fixed_u,
0342         .num_channels = ARRAY_SIZE(ad7266_channels_diff_fixed_u),
0343         .scan_masks = ad7266_available_scan_masks_fixed,
0344     },
0345     [AD7266_CHAN_INFO_INDEX(1, 1, 0)] = {
0346         .channels = ad7266_channels_diff_s,
0347         .num_channels = ARRAY_SIZE(ad7266_channels_diff_s),
0348         .scan_masks = ad7266_available_scan_masks_diff,
0349     },
0350     [AD7266_CHAN_INFO_INDEX(1, 1, 1)] = {
0351         .channels = ad7266_channels_diff_fixed_s,
0352         .num_channels = ARRAY_SIZE(ad7266_channels_diff_fixed_s),
0353         .scan_masks = ad7266_available_scan_masks_fixed,
0354     },
0355 };
0356
0357 static void ad7266_init_channels(struct iio_dev *indio_dev)
0358 {
0359     struct ad7266_state *st = iio_priv(indio_dev);
0360     bool is_differential, is_signed;
0361     const struct ad7266_chan_info *chan_info;
0362     int i;
0363
0364     is_differential = st->mode != AD7266_MODE_SINGLE_ENDED;
0365     is_signed = (st->range == AD7266_RANGE_2VREF) |
0366             (st->mode == AD7266_MODE_DIFF);
0367
0368     i = AD7266_CHAN_INFO_INDEX(is_differential, is_signed, st->fixed_addr);
0369     chan_info = &ad7266_chan_infos[i];
0370
0371     indio_dev->channels = chan_info->channels;
0372     indio_dev->num_channels = chan_info->num_channels;
0373     indio_dev->available_scan_masks = chan_info->scan_masks;
0374     indio_dev->masklength = chan_info->num_channels - 1;
0375 }
0376
0377 static const char * const ad7266_gpio_labels[] = {
0378     "ad0", "ad1", "ad2",
0379 };
0380
0381 static void ad7266_reg_disable(void *reg)
0382 {
0383     regulator_disable(reg);
0384 }
0385
0386 static int ad7266_probe(struct spi_device *spi)
0387 {
0388     struct ad7266_platform_data *pdata = spi->dev.platform_data;
0389     struct iio_dev *indio_dev;
0390     struct ad7266_state *st;
0391     unsigned int i;
0392     int ret;
0393
0394     indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
0395     if (indio_dev == NULL)
0396         return -ENOMEM;
0397
0398     st = iio_priv(indio_dev);
0399
0400     st->reg = devm_regulator_get_optional(&spi->dev, "vref");
0401     if (!IS_ERR(st->reg)) {
0402         ret = regulator_enable(st->reg);
0403         if (ret)
0404             return ret;
0405
0406         ret = devm_add_action_or_reset(&spi->dev, ad7266_reg_disable, st->reg);
0407         if (ret)
0408             return ret;
0409
0410         ret = regulator_get_voltage(st->reg);
0411         if (ret < 0)
0412             return ret;
0413
0414         st->vref_mv = ret / 1000;
0415     } else {
0416         /* Any other error indicates that the regulator does exist */
0417         if (PTR_ERR(st->reg) != -ENODEV)
0418             return PTR_ERR(st->reg);
0419         /* Use internal reference */
0420         st->vref_mv = 2500;
0421     }
0422
0423     if (pdata) {
0424         st->fixed_addr = pdata->fixed_addr;
0425         st->mode = pdata->mode;
0426         st->range = pdata->range;
0427
0428         if (!st->fixed_addr) {
0429             for (i = 0; i < ARRAY_SIZE(st->gpios); ++i) {
0430                 st->gpios[i] = devm_gpiod_get(&spi->dev,
0431                               ad7266_gpio_labels[i],
0432                               GPIOD_OUT_LOW);
0433                 if (IS_ERR(st->gpios[i])) {
0434                     ret = PTR_ERR(st->gpios[i]);
0435                     return ret;
0436                 }
0437             }
0438         }
0439     } else {
0440         st->fixed_addr = true;
0441         st->range = AD7266_RANGE_VREF;
0442         st->mode = AD7266_MODE_DIFF;
0443     }
0444
0445     st->spi = spi;
0446
0447     indio_dev->name = spi_get_device_id(spi)->name;
0448     indio_dev->modes = INDIO_DIRECT_MODE;
0449     indio_dev->info = &ad7266_info;
0450
0451     ad7266_init_channels(indio_dev);
0452
0453     /* wakeup */
0454     st->single_xfer[0].rx_buf = &st->data.sample[0];
0455     st->single_xfer[0].len = 2;
0456     st->single_xfer[0].cs_change = 1;
0457     /* conversion */
0458     st->single_xfer[1].rx_buf = st->data.sample;
0459     st->single_xfer[1].len = 4;
0460     st->single_xfer[1].cs_change = 1;
0461     /* powerdown */
0462     st->single_xfer[2].tx_buf = &st->data.sample[0];
0463     st->single_xfer[2].len = 1;
0464
0465     spi_message_init(&st->single_msg);
0466     spi_message_add_tail(&st->single_xfer[0], &st->single_msg);
0467     spi_message_add_tail(&st->single_xfer[1], &st->single_msg);
0468     spi_message_add_tail(&st->single_xfer[2], &st->single_msg);
0469
0470     ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, &iio_pollfunc_store_time,
0471         &ad7266_trigger_handler, &iio_triggered_buffer_setup_ops);
0472     if (ret)
0473         return ret;
0474
0475     return devm_iio_device_register(&spi->dev, indio_dev);
0476 }
0477
0478 static const struct spi_device_id ad7266_id[] = {
0479     {"ad7265", 0},
0480     {"ad7266", 0},
0481     { }
0482 };
0483 MODULE_DEVICE_TABLE(spi, ad7266_id);
0484
0485 static struct spi_driver ad7266_driver = {
0486     .driver = {
0487         .name   = "ad7266",
0488     },
0489     .probe      = ad7266_probe,
0490     .id_table   = ad7266_id,
0491 };
0492 module_spi_driver(ad7266_driver);
0493
0494 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
0495 MODULE_DESCRIPTION("Analog Devices AD7266/65 ADC");
0496 MODULE_LICENSE("GPL v2");