iio: adc: ad7606: add support for AD7606C-{16,18} parts

The AD7606C-16 and AD7606C-18 are pretty similar with the AD7606B.
The main difference between AD7606C-16 & AD7606C-18 is the precision in
bits (16 vs 18).
Because of that, some scales need to be defined for the 18-bit variants, as
they need to be computed against 2**18 (vs 2**16 for the 16 bit-variants).

Because the AD7606C-16,18 also supports bipolar & differential channels,
for SW-mode, the default range of 10 V or ±10V should be set at probe.
On reset, the default range (in the registers) is set to value 0x3 which
corresponds to '±10 V single-ended range', regardless of bipolar or
differential configuration.

Aside from the scale/ranges, the AD7606C-16 is similar to the AD7606B.

The AD7606C-18 variant offers 18-bit precision. Because of this, the
requirement to use this chip is that the SPI controller supports padding
of 18-bit sequences to 32-bit arrays.

Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ad7606c-16.pdf
Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/ad7606c-18.pdf

Signed-off-by: Alexandru Ardelean <aardelean@baylibre.com>
Link: https://patch.msgid.link/20240919130444.2100447-9-aardelean@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/ad7606.c b/drivers/iio/adc/ad7606.c
index b909ee14fd81c5d18e81eb44311e0cba2dd6ed06..e8da44d8e0aeb911b2801f47fa0880efa023ce96 100644 (file)
--- a/drivers/iio/adc/ad7606.c
+++ b/drivers/iio/adc/ad7606.c
@@ -36,6 +36,33 @@ static const unsigned int ad7606_16bit_hw_scale_avail[2] = {
        152588, 305176
 };
 
+static const unsigned int ad7606_18bit_hw_scale_avail[2] = {
+       38147, 76294
+};
+
+static const unsigned int ad7606c_16bit_single_ended_unipolar_scale_avail[3] = {
+       76294, 152588, 190735,
+};
+
+static const unsigned int ad7606c_16bit_single_ended_bipolar_scale_avail[5] = {
+       76294, 152588, 190735, 305176, 381470
+};
+
+static const unsigned int ad7606c_16bit_differential_bipolar_scale_avail[4] = {
+       152588, 305176, 381470, 610352
+};
+
+static const unsigned int ad7606c_18bit_single_ended_unipolar_scale_avail[3] = {
+       19073, 38147, 47684
+};
+
+static const unsigned int ad7606c_18bit_single_ended_bipolar_scale_avail[5] = {
+       19073, 38147, 47684, 76294, 95367
+};
+
+static const unsigned int ad7606c_18bit_differential_bipolar_scale_avail[4] = {
+       38147, 76294, 95367, 152588
+};
 
 static const unsigned int ad7606_16bit_sw_scale_avail[3] = {
        76293, 152588, 305176
@@ -62,7 +89,8 @@ int ad7606_reset(struct ad7606_state *st)
 }
 EXPORT_SYMBOL_NS_GPL(ad7606_reset, IIO_AD7606);
 
-static int ad7606_16bit_chan_scale_setup(struct ad7606_state *st, int ch)
+static int ad7606_16bit_chan_scale_setup(struct ad7606_state *st,
+                                        struct iio_chan_spec *chan, int ch)
 {
        struct ad7606_chan_scale *cs = &st->chan_scales[ch];
 
@@ -83,6 +111,173 @@ static int ad7606_16bit_chan_scale_setup(struct ad7606_state *st, int ch)
        return 0;
 }
 
+static int ad7606_get_chan_config(struct ad7606_state *st, int ch,
+                                 bool *bipolar, bool *differential)
+{
+       unsigned int num_channels = st->chip_info->num_channels - 1;
+       struct device *dev = st->dev;
+       int ret;
+
+       *bipolar = false;
+       *differential = false;
+
+       device_for_each_child_node_scoped(dev, child) {
+               u32 pins[2];
+               int reg;
+
+               ret = fwnode_property_read_u32(child, "reg", &reg);
+               if (ret)
+                       continue;
+
+               /* channel number (here) is from 1 to num_channels */
+               if (reg == 0 || reg > num_channels) {
+                       dev_warn(dev,
+                                "Invalid channel number (ignoring): %d\n", reg);
+                       continue;
+               }
+
+               if (reg != (ch + 1))
+                       continue;
+
+               *bipolar = fwnode_property_read_bool(child, "bipolar");
+
+               ret = fwnode_property_read_u32_array(child, "diff-channels",
+                                                    pins, ARRAY_SIZE(pins));
+               /* Channel is differential, if pins are the same as 'reg' */
+               if (ret == 0 && (pins[0] != reg || pins[1] != reg)) {
+                       dev_err(dev,
+                               "Differential pins must be the same as 'reg'");
+                       return -EINVAL;
+               }
+
+               *differential = (ret == 0);
+
+               if (*differential && !*bipolar) {
+                       dev_err(dev,
+                               "'bipolar' must be added for diff channel %d\n",
+                               reg);
+                       return -EINVAL;
+               }
+
+               return 0;
+       }
+
+       return 0;
+}
+
+static int ad7606c_18bit_chan_scale_setup(struct ad7606_state *st,
+                                         struct iio_chan_spec *chan, int ch)
+{
+       struct ad7606_chan_scale *cs = &st->chan_scales[ch];
+       bool bipolar, differential;
+       int ret;
+
+       if (!st->sw_mode_en) {
+               cs->range = 0;
+               cs->scale_avail = ad7606_18bit_hw_scale_avail;
+               cs->num_scales = ARRAY_SIZE(ad7606_18bit_hw_scale_avail);
+               return 0;
+       }
+
+       ret = ad7606_get_chan_config(st, ch, &bipolar, &differential);
+       if (ret)
+               return ret;
+
+       if (differential) {
+               cs->scale_avail = ad7606c_18bit_differential_bipolar_scale_avail;
+               cs->num_scales =
+                       ARRAY_SIZE(ad7606c_18bit_differential_bipolar_scale_avail);
+               /* Bipolar differential ranges start at 8 (b1000) */
+               cs->reg_offset = 8;
+               cs->range = 1;
+               chan->differential = 1;
+               chan->channel2 = chan->channel;
+
+               return 0;
+       }
+
+       chan->differential = 0;
+
+       if (bipolar) {
+               cs->scale_avail = ad7606c_18bit_single_ended_bipolar_scale_avail;
+               cs->num_scales =
+                       ARRAY_SIZE(ad7606c_18bit_single_ended_bipolar_scale_avail);
+               /* Bipolar single-ended ranges start at 0 (b0000) */
+               cs->reg_offset = 0;
+               cs->range = 3;
+               chan->scan_type.sign = 's';
+
+               return 0;
+       }
+
+       cs->scale_avail = ad7606c_18bit_single_ended_unipolar_scale_avail;
+       cs->num_scales =
+               ARRAY_SIZE(ad7606c_18bit_single_ended_unipolar_scale_avail);
+       /* Unipolar single-ended ranges start at 5 (b0101) */
+       cs->reg_offset = 5;
+       cs->range = 1;
+       chan->scan_type.sign = 'u';
+
+       return 0;
+}
+
+static int ad7606c_16bit_chan_scale_setup(struct ad7606_state *st,
+                                         struct iio_chan_spec *chan, int ch)
+{
+       struct ad7606_chan_scale *cs = &st->chan_scales[ch];
+       bool bipolar, differential;
+       int ret;
+
+       if (!st->sw_mode_en) {
+               cs->range = 0;
+               cs->scale_avail = ad7606_16bit_hw_scale_avail;
+               cs->num_scales = ARRAY_SIZE(ad7606_16bit_hw_scale_avail);
+               return 0;
+       }
+
+       ret = ad7606_get_chan_config(st, ch, &bipolar, &differential);
+       if (ret)
+               return ret;
+
+       if (differential) {
+               cs->scale_avail = ad7606c_16bit_differential_bipolar_scale_avail;
+               cs->num_scales =
+                       ARRAY_SIZE(ad7606c_16bit_differential_bipolar_scale_avail);
+               /* Bipolar differential ranges start at 8 (b1000) */
+               cs->reg_offset = 8;
+               cs->range = 1;
+               chan->differential = 1;
+               chan->channel2 = chan->channel;
+               chan->scan_type.sign = 's';
+
+               return 0;
+       }
+
+       chan->differential = 0;
+
+       if (bipolar) {
+               cs->scale_avail = ad7606c_16bit_single_ended_bipolar_scale_avail;
+               cs->num_scales =
+                       ARRAY_SIZE(ad7606c_16bit_single_ended_bipolar_scale_avail);
+               /* Bipolar single-ended ranges start at 0 (b0000) */
+               cs->reg_offset = 0;
+               cs->range = 3;
+               chan->scan_type.sign = 's';
+
+               return 0;
+       }
+
+       cs->scale_avail = ad7606c_16bit_single_ended_unipolar_scale_avail;
+       cs->num_scales =
+               ARRAY_SIZE(ad7606c_16bit_single_ended_unipolar_scale_avail);
+       /* Unipolar single-ended ranges start at 5 (b0101) */
+       cs->reg_offset = 5;
+       cs->range = 1;
+       chan->scan_type.sign = 'u';
+
+       return 0;
+}
+
 static int ad7606_reg_access(struct iio_dev *indio_dev,
                             unsigned int reg,
                             unsigned int writeval,
@@ -107,9 +302,8 @@ static int ad7606_reg_access(struct iio_dev *indio_dev,
 static int ad7606_read_samples(struct ad7606_state *st)
 {
        unsigned int num = st->chip_info->num_channels - 1;
-       u16 *data = st->data;
 
-       return st->bops->read_block(st->dev, num, data);
+       return st->bops->read_block(st->dev, num, &st->data);
 }
 
 static irqreturn_t ad7606_trigger_handler(int irq, void *p)
@@ -125,7 +319,7 @@ static irqreturn_t ad7606_trigger_handler(int irq, void *p)
        if (ret)
                goto error_ret;
 
-       iio_push_to_buffers_with_timestamp(indio_dev, st->data,
+       iio_push_to_buffers_with_timestamp(indio_dev, &st->data,
                                           iio_get_time_ns(indio_dev));
 error_ret:
        iio_trigger_notify_done(indio_dev->trig);
@@ -139,6 +333,8 @@ static int ad7606_scan_direct(struct iio_dev *indio_dev, unsigned int ch,
                              int *val)
 {
        struct ad7606_state *st = iio_priv(indio_dev);
+       unsigned int storagebits = st->chip_info->channels[1].scan_type.storagebits;
+       const struct iio_chan_spec *chan;
        int ret;
 
        gpiod_set_value(st->gpio_convst, 1);
@@ -153,7 +349,18 @@ static int ad7606_scan_direct(struct iio_dev *indio_dev, unsigned int ch,
        if (ret)
                goto error_ret;
 
-       *val = sign_extend32(st->data[ch], 15);
+       chan = &indio_dev->channels[ch + 1];
+       if (chan->scan_type.sign == 'u') {
+               if (storagebits > 16)
+                       *val = st->data.buf32[ch];
+               else
+                       *val = st->data.buf16[ch];
+       } else {
+               if (storagebits > 16)
+                       *val = sign_extend32(st->data.buf32[ch], 17);
+               else
+                       *val = sign_extend32(st->data.buf16[ch], 15);
+       }
 
 error_ret:
        gpiod_set_value(st->gpio_convst, 0);
@@ -266,7 +473,7 @@ static int ad7606_write_raw(struct iio_dev *indio_dev,
                        ch = chan->address;
                cs = &st->chan_scales[ch];
                i = find_closest(val2, cs->scale_avail, cs->num_scales);
-               ret = st->write_scale(indio_dev, ch, i);
+               ret = st->write_scale(indio_dev, ch, i + cs->reg_offset);
                if (ret < 0)
                        return ret;
                cs->range = i;
@@ -349,6 +556,18 @@ static const struct iio_chan_spec ad7606_channels_16bit[] = {
        AD7606_CHANNEL(7, 16),
 };
 
+static const struct iio_chan_spec ad7606_channels_18bit[] = {
+       IIO_CHAN_SOFT_TIMESTAMP(8),
+       AD7606_CHANNEL(0, 18),
+       AD7606_CHANNEL(1, 18),
+       AD7606_CHANNEL(2, 18),
+       AD7606_CHANNEL(3, 18),
+       AD7606_CHANNEL(4, 18),
+       AD7606_CHANNEL(5, 18),
+       AD7606_CHANNEL(6, 18),
+       AD7606_CHANNEL(7, 18),
+};
+
 /*
  * The current assumption that this driver makes for AD7616, is that it's
  * working in Hardware Mode with Serial, Burst and Sequencer modes activated.
@@ -414,6 +633,20 @@ static const struct ad7606_chip_info ad7606_chip_info_tbl[] = {
                .oversampling_avail = ad7606_oversampling_avail,
                .oversampling_num = ARRAY_SIZE(ad7606_oversampling_avail),
        },
+       [ID_AD7606C_16] = {
+               .channels = ad7606_channels_16bit,
+               .num_channels = 9,
+               .scale_setup_cb = ad7606c_16bit_chan_scale_setup,
+               .oversampling_avail = ad7606_oversampling_avail,
+               .oversampling_num = ARRAY_SIZE(ad7606_oversampling_avail),
+       },
+       [ID_AD7606C_18] = {
+               .channels = ad7606_channels_18bit,
+               .num_channels = 9,
+               .scale_setup_cb = ad7606c_18bit_chan_scale_setup,
+               .oversampling_avail = ad7606_oversampling_avail,
+               .oversampling_num = ARRAY_SIZE(ad7606_oversampling_avail),
+       },
        [ID_AD7616] = {
                .channels = ad7616_channels,
                .num_channels = 17,
@@ -586,7 +819,7 @@ static const struct iio_trigger_ops ad7606_trigger_ops = {
        .validate_device = iio_trigger_validate_own_device,
 };
 
-static int ad7606_sw_mode_setup(struct iio_dev *indio_dev)
+static int ad7606_sw_mode_setup(struct iio_dev *indio_dev, unsigned int id)
 {
        struct ad7606_state *st = iio_priv(indio_dev);
 
@@ -604,13 +837,24 @@ static int ad7606_chan_scales_setup(struct iio_dev *indio_dev)
 {
        unsigned int num_channels = indio_dev->num_channels - 1;
        struct ad7606_state *st = iio_priv(indio_dev);
+       struct iio_chan_spec *chans;
+       size_t size;
        int ch, ret;
 
+       /* Clone IIO channels, since some may be differential */
+       size = indio_dev->num_channels * sizeof(*indio_dev->channels);
+       chans = devm_kzalloc(st->dev, size, GFP_KERNEL);
+       if (!chans)
+               return -ENOMEM;
+
+       memcpy(chans, indio_dev->channels, size);
+       indio_dev->channels = chans;
+
        for (ch = 0; ch < num_channels; ch++) {
                struct ad7606_chan_scale *cs;
                int i;
 
-               ret = st->chip_info->scale_setup_cb(st, ch);
+               ret = st->chip_info->scale_setup_cb(st, &chans[ch + 1], ch);
                if (ret)
                        return ret;
 
@@ -698,7 +942,7 @@ int ad7606_probe(struct device *dev, int irq, void __iomem *base_address,
        st->write_scale = ad7606_write_scale_hw;
        st->write_os = ad7606_write_os_hw;
 
-       ret = ad7606_sw_mode_setup(indio_dev);
+       ret = ad7606_sw_mode_setup(indio_dev, id);
        if (ret)
                return ret;
 

diff --git a/drivers/iio/adc/ad7606.h b/drivers/iio/adc/ad7606.h
index 25e84efd15c334f070de20bb476c4c0c3664e2bc..14ee75aa225b0dbd8f4a843a30cdc6bd725cc50d 100644 (file)
--- a/drivers/iio/adc/ad7606.h
+++ b/drivers/iio/adc/ad7606.h
@@ -63,7 +63,8 @@
 
 struct ad7606_state;
 
-typedef int (*ad7606_scale_setup_cb_t)(struct ad7606_state *st, int ch);
+typedef int (*ad7606_scale_setup_cb_t)(struct ad7606_state *st,
+                                      struct iio_chan_spec *chan, int ch);
 
 /**
  * struct ad7606_chip_info - chip specific information
@@ -94,6 +95,8 @@ struct ad7606_chip_info {
  *                     such that it can be read via the 'read_avail' hook
  * @num_scales         number of elements stored in the scale_avail array
  * @range              voltage range selection, selects which scale to apply
+ * @reg_offset         offset for the register value, to be applied when
+ *                     writing the value of 'range' to the register value
  */
 struct ad7606_chan_scale {
 #define AD760X_MAX_SCALES              16
@@ -102,6 +105,7 @@ struct ad7606_chan_scale {
        int                             scale_avail_show[AD760X_MAX_SCALE_SHOW];
        unsigned int                    num_scales;
        unsigned int                    range;
+       unsigned int                    reg_offset;
 };
 
 /**
@@ -158,9 +162,13 @@ struct ad7606_state {
        /*
         * DMA (thus cache coherency maintenance) may require the
         * transfer buffers to live in their own cache lines.
-        * 16 * 16-bit samples + 64-bit timestamp
+        * 16 * 16-bit samples + 64-bit timestamp - for AD7616
+        * 8 * 32-bit samples + 64-bit timestamp - for AD7616C-18 (and similar)
         */
-       unsigned short                  data[20] __aligned(IIO_DMA_MINALIGN);
+       union {
+               u16 buf16[20];
+               u32 buf32[10];
+       } data __aligned(IIO_DMA_MINALIGN);
        __be16                          d16[2];
 };
 
@@ -201,6 +209,8 @@ enum ad7606_supported_device_ids {
        ID_AD7606_6,
        ID_AD7606_4,
        ID_AD7606B,
+       ID_AD7606C_16,
+       ID_AD7606C_18,
        ID_AD7616,
 };
 

diff --git a/drivers/iio/adc/ad7606_spi.c b/drivers/iio/adc/ad7606_spi.c
index e00f58a6a0e966fd9febd116ae7c8cd6babf7251..143440e73aab80b6de1728732342ac3eb628ce29 100644 (file)
--- a/drivers/iio/adc/ad7606_spi.c
+++ b/drivers/iio/adc/ad7606_spi.c
@@ -77,6 +77,18 @@ static const struct iio_chan_spec ad7606b_sw_channels[] = {
        AD7606_SW_CHANNEL(7, 16),
 };
 
+static const struct iio_chan_spec ad7606c_18_sw_channels[] = {
+       IIO_CHAN_SOFT_TIMESTAMP(8),
+       AD7606_SW_CHANNEL(0, 18),
+       AD7606_SW_CHANNEL(1, 18),
+       AD7606_SW_CHANNEL(2, 18),
+       AD7606_SW_CHANNEL(3, 18),
+       AD7606_SW_CHANNEL(4, 18),
+       AD7606_SW_CHANNEL(5, 18),
+       AD7606_SW_CHANNEL(6, 18),
+       AD7606_SW_CHANNEL(7, 18),
+};
+
 static const unsigned int ad7606B_oversampling_avail[9] = {
        1, 2, 4, 8, 16, 32, 64, 128, 256
 };
@@ -120,6 +132,19 @@ static int ad7606_spi_read_block(struct device *dev,
        return 0;
 }
 
+static int ad7606_spi_read_block18to32(struct device *dev,
+                                      int count, void *buf)
+{
+       struct spi_device *spi = to_spi_device(dev);
+       struct spi_transfer xfer = {
+               .bits_per_word = 18,
+               .len = count * sizeof(u32),
+               .rx_buf = buf,
+       };
+
+       return spi_sync_transfer(spi, &xfer, 1);
+}
+
 static int ad7606_spi_reg_read(struct ad7606_state *st, unsigned int addr)
 {
        struct spi_device *spi = to_spi_device(st->dev);
@@ -283,6 +308,19 @@ static int ad7606B_sw_mode_config(struct iio_dev *indio_dev)
        return 0;
 }
 
+static int ad7606c_18_sw_mode_config(struct iio_dev *indio_dev)
+{
+       int ret;
+
+       ret = ad7606B_sw_mode_config(indio_dev);
+       if (ret)
+               return ret;
+
+       indio_dev->channels = ad7606c_18_sw_channels;
+
+       return 0;
+}
+
 static const struct ad7606_bus_ops ad7606_spi_bops = {
        .read_block = ad7606_spi_read_block,
 };
@@ -305,6 +343,15 @@ static const struct ad7606_bus_ops ad7606B_spi_bops = {
        .sw_mode_config = ad7606B_sw_mode_config,
 };
 
+static const struct ad7606_bus_ops ad7606c_18_spi_bops = {
+       .read_block = ad7606_spi_read_block18to32,
+       .reg_read = ad7606_spi_reg_read,
+       .reg_write = ad7606_spi_reg_write,
+       .write_mask = ad7606_spi_write_mask,
+       .rd_wr_cmd = ad7606B_spi_rd_wr_cmd,
+       .sw_mode_config = ad7606c_18_sw_mode_config,
+};
+
 static int ad7606_spi_probe(struct spi_device *spi)
 {
        const struct spi_device_id *id = spi_get_device_id(spi);
@@ -315,8 +362,12 @@ static int ad7606_spi_probe(struct spi_device *spi)
                bops = &ad7616_spi_bops;
                break;
        case ID_AD7606B:
+       case ID_AD7606C_16:
                bops = &ad7606B_spi_bops;
                break;
+       case ID_AD7606C_18:
+               bops = &ad7606c_18_spi_bops;
+               break;
        default:
                bops = &ad7606_spi_bops;
                break;
@@ -333,6 +384,8 @@ static const struct spi_device_id ad7606_id_table[] = {
        { "ad7606-6", ID_AD7606_6 },
        { "ad7606-8", ID_AD7606_8 },
        { "ad7606b",  ID_AD7606B },
+       { "ad7606c-16",  ID_AD7606C_16 },
+       { "ad7606c-18",  ID_AD7606C_18 },
        { "ad7616",   ID_AD7616 },
        { }
 };
@@ -344,6 +397,8 @@ static const struct of_device_id ad7606_of_match[] = {
        { .compatible = "adi,ad7606-6" },
        { .compatible = "adi,ad7606-8" },
        { .compatible = "adi,ad7606b" },
+       { .compatible = "adi,ad7606c-16" },
+       { .compatible = "adi,ad7606c-18" },
        { .compatible = "adi,ad7616" },
        { }
 };