iio: adc: ad_sigma_delta: Check for previous ready signals

It can happen if a previous conversion was aborted the ADC pulls down
the R̅D̅Y̅ line but the event wasn't handled before. In that case enabling
the irq might immediately fire (depending on the irq controller
capabilities) and even with a rdy-gpio isn't identified as an unrelated
one.

To cure that problem check for a pending event before the measurement is
started and clear it if needed.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Link: https://patch.msgid.link/3ec6b61fb1e527e935133dc56f589aab4b2094a3.1733504533.git.u.kleine-koenig@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/ad_sigma_delta.c b/drivers/iio/adc/ad_sigma_delta.c
index c290d07ab1c57e5e34cf9e35cdcdc443e0c0832d..0f355dac7813d71e29ab9fb21d34928a960e7bd2 100644 (file)
--- a/drivers/iio/adc/ad_sigma_delta.c
+++ b/drivers/iio/adc/ad_sigma_delta.c
@@ -29,8 +29,11 @@
 #define AD_SD_COMM_CHAN_MASK   0x3
 
 #define AD_SD_REG_COMM         0x00
+#define AD_SD_REG_STATUS       0x00
 #define AD_SD_REG_DATA         0x03
 
+#define AD_SD_REG_STATUS_RDY   0x80
+
 /**
  * ad_sd_set_comm() - Set communications register
  *
@@ -222,6 +225,86 @@ static void ad_sd_enable_irq(struct ad_sigma_delta *sigma_delta)
        enable_irq(sigma_delta->irq_line);
 }
 
+#define AD_SD_CLEAR_DATA_BUFLEN 9
+
+/* Called with `sigma_delta->bus_locked == true` only. */
+static int ad_sigma_delta_clear_pending_event(struct ad_sigma_delta *sigma_delta)
+{
+       bool pending_event;
+       unsigned int data_read_len = BITS_TO_BYTES(sigma_delta->info->num_resetclks);
+       u8 *data;
+       struct spi_transfer t[] = {
+               {
+                       .len = 1,
+               }, {
+                       .len = data_read_len,
+               }
+       };
+       struct spi_message m;
+       int ret;
+
+       /*
+        * Read R̅D̅Y̅ pin (if possible) or status register to check if there is an
+        * old event.
+        */
+       if (sigma_delta->rdy_gpiod) {
+               pending_event = gpiod_get_value(sigma_delta->rdy_gpiod);
+       } else {
+               unsigned status_reg;
+
+               ret = ad_sd_read_reg(sigma_delta, AD_SD_REG_STATUS, 1, &status_reg);
+               if (ret)
+                       return ret;
+
+               pending_event = !(status_reg & AD_SD_REG_STATUS_RDY);
+       }
+
+       if (!pending_event)
+               return 0;
+
+       /*
+        * In general the size of the data register is unknown. It varies from
+        * device to device, might be one byte longer if CONTROL.DATA_STATUS is
+        * set and even varies on some devices depending on which input is
+        * selected. So send one byte to start reading the data register and
+        * then just clock for some bytes with DIN (aka MOSI) high to not
+        * confuse the register access state machine after the data register was
+        * completely read. Note however that the sequence length must be
+        * shorter than the reset procedure.
+        */
+
+       data = kzalloc(data_read_len + 1, GFP_KERNEL);
+       if (!data)
+               return -ENOMEM;
+
+       spi_message_init(&m);
+       if (sigma_delta->info->has_registers) {
+               unsigned int data_reg = sigma_delta->info->data_reg ?: AD_SD_REG_DATA;
+
+               data[0] = data_reg << sigma_delta->info->addr_shift;
+               data[0] |= sigma_delta->info->read_mask;
+               data[0] |= sigma_delta->comm;
+               t[0].tx_buf = data;
+               spi_message_add_tail(&t[0], &m);
+       }
+
+       /*
+        * The first transferred byte is part of the real data register,
+        * so this doesn't need to be 0xff. In the remaining
+        * `data_read_len - 1` bytes are less than $num_resetclks ones.
+        */
+       t[1].tx_buf = data + 1;
+       data[1] = 0x00;
+       memset(data + 2, 0xff, data_read_len - 1);
+       spi_message_add_tail(&t[1], &m);
+
+       ret = spi_sync_locked(sigma_delta->spi, &m);
+
+       kfree(data);
+
+       return ret;
+}
+
 int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
        unsigned int mode, unsigned int channel)
 {
@@ -237,6 +320,10 @@ int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
        sigma_delta->keep_cs_asserted = true;
        reinit_completion(&sigma_delta->completion);
 
+       ret = ad_sigma_delta_clear_pending_event(sigma_delta);
+       if (ret)
+               goto out;
+
        ret = ad_sigma_delta_set_mode(sigma_delta, mode);
        if (ret < 0)
                goto out;
@@ -310,6 +397,10 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
        sigma_delta->keep_cs_asserted = true;
        reinit_completion(&sigma_delta->completion);
 
+       ret = ad_sigma_delta_clear_pending_event(sigma_delta);
+       if (ret)
+               goto out_unlock;
+
        ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);
 
        ad_sd_enable_irq(sigma_delta);
@@ -333,9 +424,11 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
 out:
        ad_sd_disable_irq(sigma_delta);
 
-       sigma_delta->keep_cs_asserted = false;
        ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
        ad_sigma_delta_disable_one(sigma_delta, chan->address);
+
+out_unlock:
+       sigma_delta->keep_cs_asserted = false;
        sigma_delta->bus_locked = false;
        spi_bus_unlock(sigma_delta->spi->controller);
        iio_device_release_direct_mode(indio_dev);
@@ -406,6 +499,10 @@ static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)
        sigma_delta->bus_locked = true;
        sigma_delta->keep_cs_asserted = true;
 
+       ret = ad_sigma_delta_clear_pending_event(sigma_delta);
+       if (ret)
+               goto err_unlock;
+
        ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);
        if (ret)
                goto err_unlock;