github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-26 16:12:59 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

iio: light: vl6180: Add support for Continuous Mode

Browse Source 
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>
This commit is contained in:
Abhash Jha 2024-10-07 20:52:23 +05:30 committed by Jonathan Cameron
parent 3a54586171
commit eeebe3937c
1 changed files with 129 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
drivers/iio/light/vl6180.c
View File

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