Commit eeebe393 authored by Abhash Jha's avatar Abhash Jha Committed by Jonathan Cameron
Browse files

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: default avatarAbhash Jha <abhashkumarjha123@gmail.com>
Link: https://patch.msgid.link/20241007152223.59008-4-abhashkumarjha123@gmail.com


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 3a545861

drivers/iio/light/vl6180.c

+129 −4
Original line number Diff line number Diff line
@@ -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);



	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_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)

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);