iio: light: vl6180: Add support for Continuous Mode

Added support for getting continuous readings from vl6180 using
triggered buffer approach. The continuous mode can be enabled by enabling
the buffer. Also added a trigger and appropriate checks to see that it is
used with this device.

Signed-off-by: Abhash Jha <abhashkumarjha123@gmail.com>
Link: https://patch.msgid.link/20241007152223.59008-4-abhashkumarjha123@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/light/vl6180.c b/drivers/iio/light/vl6180.c
index 0801071..6e2183a 100644 (file)
--- a/drivers/iio/light/vl6180.c
+++ b/drivers/iio/light/vl6180.c
@@ -25,6 +25,10 @@
 
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
 
 #define VL6180_DRV_NAME "vl6180"
 
@@ -87,10 +91,16 @@ struct vl6180_data {
        struct i2c_client *client;
        struct mutex lock;
        struct completion completion;
+       struct iio_trigger *trig;
        unsigned int als_gain_milli;
        unsigned int als_it_ms;
        unsigned int als_meas_rate;
        unsigned int range_meas_rate;
+
+       struct {
+               u16 chan[2];
+               aligned_s64 timestamp;
+       } scan;
 };
 
 enum { VL6180_ALS, VL6180_RANGE, VL6180_PROX };
@@ -274,6 +284,12 @@ static const struct iio_chan_spec vl6180_channels[] = {
        {
                .type = IIO_LIGHT,
                .address = VL6180_ALS,
+               .scan_index = VL6180_ALS,
+               .scan_type = {
+                       .sign = 'u',
+                       .realbits = 16,
+                       .storagebits = 16,
+               },
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                        BIT(IIO_CHAN_INFO_INT_TIME) |
                        BIT(IIO_CHAN_INFO_SCALE) |
@@ -282,14 +298,27 @@ static const struct iio_chan_spec vl6180_channels[] = {
        }, {
                .type = IIO_DISTANCE,
                .address = VL6180_RANGE,
+               .scan_index = VL6180_RANGE,
+               .scan_type = {
+                       .sign = 'u',
+                       .realbits = 8,
+                       .storagebits = 8,
+               },
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                        BIT(IIO_CHAN_INFO_SCALE) |
                        BIT(IIO_CHAN_INFO_SAMP_FREQ),
        }, {
                .type = IIO_PROXIMITY,
                .address = VL6180_PROX,
+               .scan_index = VL6180_PROX,
+               .scan_type = {
+                       .sign = 'u',
+                       .realbits = 16,
+                       .storagebits = 16,
+               },
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
-       }
+       },
+       IIO_CHAN_SOFT_TIMESTAMP(3),
 };
 
 /*
@@ -501,7 +530,48 @@ static irqreturn_t vl6180_threaded_irq(int irq, void *priv)
        struct iio_dev *indio_dev = priv;
        struct vl6180_data *data = iio_priv(indio_dev);
 
-       complete(&data->completion);
+       if (iio_buffer_enabled(indio_dev))
+               iio_trigger_poll_nested(indio_dev->trig);
+       else
+               complete(&data->completion);
+
+       return IRQ_HANDLED;
+}
+
+static irqreturn_t vl6180_trigger_handler(int irq, void *priv)
+{
+       struct iio_poll_func *pf = priv;
+       struct iio_dev *indio_dev = pf->indio_dev;
+       struct vl6180_data *data = iio_priv(indio_dev);
+       s64 time_ns = iio_get_time_ns(indio_dev);
+       int ret, bit, i = 0;
+
+       iio_for_each_active_channel(indio_dev, bit) {
+               if (vl6180_chan_regs_table[bit].word)
+                       ret = vl6180_read_word(data->client,
+                               vl6180_chan_regs_table[bit].value_reg);
+               else
+                       ret = vl6180_read_byte(data->client,
+                               vl6180_chan_regs_table[bit].value_reg);
+
+               if (ret < 0) {
+                       dev_err(&data->client->dev,
+                               "failed to read from value regs: %d\n", ret);
+                       return IRQ_HANDLED;
+               }
+
+               data->scan.chan[i++] = ret;
+       }
+
+       iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, time_ns);
+       iio_trigger_notify_done(indio_dev->trig);
+
+       /* Clear the interrupt flag after data read */
+       ret = vl6180_write_byte(data->client, VL6180_INTR_CLEAR,
+               VL6180_CLEAR_ERROR | VL6180_CLEAR_ALS | VL6180_CLEAR_RANGE);
+       if (ret < 0)
+               dev_err(&data->client->dev, "failed to clear irq: %d\n", ret);
+
        return IRQ_HANDLED;
 }
 
@@ -509,9 +579,45 @@ static const struct iio_info vl6180_info = {
        .read_raw = vl6180_read_raw,
        .write_raw = vl6180_write_raw,
        .attrs = &vl6180_attribute_group,
+       .validate_trigger = iio_validate_own_trigger,
 };
 
-static int vl6180_init(struct vl6180_data *data)
+static int vl6180_buffer_postenable(struct iio_dev *indio_dev)
+{
+       struct vl6180_data *data = iio_priv(indio_dev);
+       int bit;
+
+       iio_for_each_active_channel(indio_dev, bit)
+               return vl6180_write_byte(data->client,
+                       vl6180_chan_regs_table[bit].start_reg,
+                       VL6180_MODE_CONT | VL6180_STARTSTOP);
+
+       return -EINVAL;
+}
+
+static int vl6180_buffer_postdisable(struct iio_dev *indio_dev)
+{
+       struct vl6180_data *data = iio_priv(indio_dev);
+       int bit;
+
+       iio_for_each_active_channel(indio_dev, bit)
+               return vl6180_write_byte(data->client,
+                       vl6180_chan_regs_table[bit].start_reg,
+                       VL6180_STARTSTOP);
+
+       return -EINVAL;
+}
+
+static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
+       .postenable = &vl6180_buffer_postenable,
+       .postdisable = &vl6180_buffer_postdisable,
+};
+
+static const struct iio_trigger_ops vl6180_trigger_ops = {
+       .validate_device = iio_trigger_validate_own_device,
+};
+
+static int vl6180_init(struct vl6180_data *data, struct iio_dev *indio_dev)
 {
        struct i2c_client *client = data->client;
        int ret;
@@ -546,6 +652,12 @@ static int vl6180_init(struct vl6180_data *data)
        if (ret < 0)
                return ret;
 
+       ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
+                                               &vl6180_trigger_handler,
+                                               &iio_triggered_buffer_setup_ops);
+       if (ret)
+               return ret;
+
        /* Default Range inter-measurement time: 50ms or 20000 mHz */
        ret = vl6180_write_byte(client, VL6180_RANGE_INTER_MEAS_TIME,
                                vl6180_meas_reg_val_from_mhz(20000));
@@ -600,7 +712,7 @@ static int vl6180_probe(struct i2c_client *client)
        indio_dev->name = VL6180_DRV_NAME;
        indio_dev->modes = INDIO_DIRECT_MODE;
 
-       ret = vl6180_init(data);
+       ret = vl6180_init(data, indio_dev);
        if (ret < 0)
                return ret;
 
@@ -613,6 +725,19 @@ static int vl6180_probe(struct i2c_client *client)
                        return dev_err_probe(&client->dev, ret, "devm_request_irq error \n");
 
                init_completion(&data->completion);
+
+               data->trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
+                                               indio_dev->name, iio_device_id(indio_dev));
+               if (!data->trig)
+                       return -ENOMEM;
+
+               data->trig->ops = &vl6180_trigger_ops;
+               iio_trigger_set_drvdata(data->trig, indio_dev);
+               ret = devm_iio_trigger_register(&client->dev, data->trig);
+               if (ret)
+                       return ret;
+
+               indio_dev->trig = iio_trigger_get(data->trig);
        }
 
        return devm_iio_device_register(&client->dev, indio_dev);