Proxmox-Port/linux-loongson
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson synced 2025-08-28 09:22:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

iio: light: veml6030: add support for veml6035

Browse Source 
The veml6035 is an ALS that shares most of its functionality with the
veml6030, which allows for some code recycling.

Some chip-specific properties differ and dedicated functions to get and
set the sensor gain as well as its initialization are required.

Signed-off-by: Javier Carrasco <javier.carrasco.cruz@gmail.com>
Link: https://patch.msgid.link/20241001-veml6035-v3-9-d789f6ff147c@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
This commit is contained in:
Javier Carrasco 2024-10-01 22:21:22 +02:00 committed by Jonathan Cameron
parent f1bfc1c993
commit ccc26bd7d7
2 changed files with 265 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/iio/light/Kconfig
View File

@ -669,12 +669,12 @@ config VCNL4035
module will be called vcnl4035.
config VEML6030
tristate "VEML6030 ambient light sensor"
tristate "VEML6030 and VEML6035 ambient light sensors"
select REGMAP_I2C
depends on I2C
help
Say Y here if you want to build a driver for the Vishay VEML6030
ambient light sensor (ALS).
and VEML6035 ambient light sensors (ALS).
To compile this driver as a module, choose M here: the
module will be called veml6030.

290
drivers/iio/light/veml6030.c
View File

@ -1,13 +1,19 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* VEML6030 Ambient Light Sensor
* VEML6030 and VMEL6035 Ambient Light Sensors
*
* Copyright (c) 2019, Rishi Gupta <gupt21@gmail.com>
*
* VEML6030:
* Datasheet: https://www.vishay.com/docs/84366/veml6030.pdf
* Appnote-84367: https://www.vishay.com/docs/84367/designingveml6030.pdf
*
* VEML6035:
* Datasheet: https://www.vishay.com/docs/84889/veml6035.pdf
* Appnote-84944: https://www.vishay.com/docs/84944/designingveml6035.pdf
*/
#include <linux/bitfield.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
@ -39,16 +45,34 @@
#define VEML6030_ALS_INT_EN BIT(1)
#define VEML6030_ALS_SD BIT(0)
#define VEML6035_GAIN_M GENMASK(12, 10)
#define VEML6035_GAIN BIT(10)
#define VEML6035_DG BIT(11)
#define VEML6035_SENS BIT(12)
#define VEML6035_INT_CHAN BIT(3)
#define VEML6035_CHAN_EN BIT(2)
struct veml603x_chip {
const char *name;
const int(*scale_vals)[][2];
const int num_scale_vals;
const struct iio_info *info;
const struct iio_info *info_no_irq;
int (*hw_init)(struct iio_dev *indio_dev, struct device *dev);
int (*set_als_gain)(struct iio_dev *indio_dev, int val, int val2);
int (*get_als_gain)(struct iio_dev *indio_dev, int *val, int *val2);
};
/*
* The resolution depends on both gain and integration time. The
* cur_resolution stores one of the resolution mentioned in the
* table during startup and gets updated whenever integration time
* or gain is changed.
*
* Table 'resolution and maximum detection range' in appnote 84367
* Table 'resolution and maximum detection range' in the appnotes
* is visualized as a 2D array. The cur_gain stores index of gain
* in this table (0-3) while the cur_integration_time holds index
* of integration time (0-5).
* in this table (0-3 for VEML6030, 0-5 for VEML6035) while the
* cur_integration_time holds index of integration time (0-5).
*/
struct veml6030_data {
struct i2c_client *client;
@ -56,6 +80,7 @@ struct veml6030_data {
int cur_resolution;
int cur_gain;
int cur_integration_time;
const struct veml603x_chip *chip;
};
static const int veml6030_it_times[][2] = {
@ -69,7 +94,8 @@ static const int veml6030_it_times[][2] = {
/*
* Scale is 1/gain. Value 0.125 is ALS gain x (1/8), 0.25 is
* ALS gain x (1/4), 1.0 = ALS gain x 1 and 2.0 is ALS gain x 2.
* ALS gain x (1/4), 0.5 is ALS gain x (1/2), 1.0 is ALS gain x 1,
* 2.0 is ALS gain x2, and 4.0 is ALS gain x 4.
*/
static const int veml6030_scale_vals[][2] = {
{ 0, 125000 },
@ -78,6 +104,15 @@ static const int veml6030_scale_vals[][2] = {
{ 2, 0 },
};
static const int veml6035_scale_vals[][2] = {
{ 0, 125000 },
{ 0, 250000 },
{ 0, 500000 },
{ 1, 0 },
{ 2, 0 },
{ 4, 0 },
};
/*
* Persistence = 1/2/4/8 x integration time
* Minimum time for which light readings must stay above configured
@ -386,6 +421,21 @@ static int veml6030_write_persistence(struct iio_dev *indio_dev,
return ret;
}
/*
* Cache currently set gain & update resolution. For every
* increase in the gain to next level, resolution is halved
* and vice-versa.
*/
static void veml6030_update_gain_res(struct veml6030_data *data, int gain_idx)
{
if (data->cur_gain < gain_idx)
data->cur_resolution <<= gain_idx - data->cur_gain;
else if (data->cur_gain > gain_idx)
data->cur_resolution >>= data->cur_gain - gain_idx;
data->cur_gain = gain_idx;
}
static int veml6030_set_als_gain(struct iio_dev *indio_dev,
int val, int val2)
{
@ -416,19 +466,49 @@ static int veml6030_set_als_gain(struct iio_dev *indio_dev,
return ret;
}
/*
* Cache currently set gain & update resolution. For every
* increase in the gain to next level, resolution is halved
* and vice-versa.
*/
if (data->cur_gain < gain_idx)
data->cur_resolution <<= gain_idx - data->cur_gain;
else if (data->cur_gain > gain_idx)
data->cur_resolution >>= data->cur_gain - gain_idx;
veml6030_update_gain_res(data, gain_idx);
data->cur_gain = gain_idx;
return 0;
}
return ret;
static int veml6035_set_als_gain(struct iio_dev *indio_dev, int val, int val2)
{
int ret, new_gain, gain_idx;
struct veml6030_data *data = iio_priv(indio_dev);
if (val == 0 && val2 == 125000) {
new_gain = VEML6035_SENS;
gain_idx = 5;
} else if (val == 0 && val2 == 250000) {
new_gain = VEML6035_SENS | VEML6035_GAIN;
gain_idx = 4;
} else if (val == 0 && val2 == 500000) {
new_gain = VEML6035_SENS | VEML6035_GAIN |
VEML6035_DG;
gain_idx = 3;
} else if (val == 1 && val2 == 0) {
new_gain = 0x0000;
gain_idx = 2;
} else if (val == 2 && val2 == 0) {
new_gain = VEML6035_GAIN;
gain_idx = 1;
} else if (val == 4 && val2 == 0) {
new_gain = VEML6035_GAIN | VEML6035_DG;
gain_idx = 0;
} else {
return -EINVAL;
}
ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF,
VEML6035_GAIN_M, new_gain);
if (ret) {
dev_err(&data->client->dev, "can't set als gain %d\n", ret);
return ret;
}
veml6030_update_gain_res(data, gain_idx);
return 0;
}
static int veml6030_get_als_gain(struct iio_dev *indio_dev,
@ -468,6 +548,52 @@ static int veml6030_get_als_gain(struct iio_dev *indio_dev,
return IIO_VAL_INT_PLUS_MICRO;
}
static int veml6035_get_als_gain(struct iio_dev *indio_dev, int *val, int *val2)
{
int ret, reg;
struct veml6030_data *data = iio_priv(indio_dev);
ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, &reg);
if (ret) {
dev_err(&data->client->dev,
"can't read als conf register %d\n", ret);
return ret;
}
switch (FIELD_GET(VEML6035_GAIN_M, reg)) {
case 0:
*val = 1;
*val2 = 0;
break;
case 1:
case 2:
*val = 2;
*val2 = 0;
break;
case 3:
*val = 4;
*val2 = 0;
break;
case 4:
*val = 0;
*val2 = 125000;
break;
case 5:
case 6:
*val = 0;
*val2 = 250000;
break;
case 7:
*val = 0;
*val2 = 500000;
break;
default:
return -EINVAL;
}
return IIO_VAL_INT_PLUS_MICRO;
}
static int veml6030_read_thresh(struct iio_dev *indio_dev,
int *val, int *val2, int dir)
{
@ -556,7 +682,7 @@ static int veml6030_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_INT_TIME:
return veml6030_get_intgrn_tm(indio_dev, val, val2);
case IIO_CHAN_INFO_SCALE:
return veml6030_get_als_gain(indio_dev, val, val2);
return data->chip->get_als_gain(indio_dev, val, val2);
default:
return -EINVAL;
}
@ -567,6 +693,8 @@ static int veml6030_read_avail(struct iio_dev *indio_dev,
const int **vals, int *type, int *length,
long mask)
{
struct veml6030_data *data = iio_priv(indio_dev);
switch (mask) {
case IIO_CHAN_INFO_INT_TIME:
*vals = (int *)&veml6030_it_times;
@ -574,8 +702,8 @@ static int veml6030_read_avail(struct iio_dev *indio_dev,
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_LIST;
case IIO_CHAN_INFO_SCALE:
*vals = (int *)&veml6030_scale_vals;
*length = 2 * ARRAY_SIZE(veml6030_scale_vals);
*vals = (int *)*data->chip->scale_vals;
*length = 2 * data->chip->num_scale_vals;
*type = IIO_VAL_INT_PLUS_MICRO;
return IIO_AVAIL_LIST;
}
@ -587,11 +715,13 @@ static int veml6030_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct veml6030_data *data = iio_priv(indio_dev);
switch (mask) {
case IIO_CHAN_INFO_INT_TIME:
return veml6030_set_intgrn_tm(indio_dev, val, val2);
case IIO_CHAN_INFO_SCALE:
return veml6030_set_als_gain(indio_dev, val, val2);
return data->chip->set_als_gain(indio_dev, val, val2);
default:
return -EINVAL;
}
@ -699,12 +829,28 @@ static const struct iio_info veml6030_info = {
.event_attrs = &veml6030_event_attr_group,
};
static const struct iio_info veml6035_info = {
.read_raw = veml6030_read_raw,
.read_avail = veml6030_read_avail,
.write_raw = veml6030_write_raw,
.read_event_value = veml6030_read_event_val,
.write_event_value = veml6030_write_event_val,
.read_event_config = veml6030_read_interrupt_config,
.write_event_config = veml6030_write_interrupt_config,
.event_attrs = &veml6030_event_attr_group,
};
static const struct iio_info veml6030_info_no_irq = {
.read_raw = veml6030_read_raw,
.read_avail = veml6030_read_avail,
.write_raw = veml6030_write_raw,
};
static const struct iio_info veml6035_info_no_irq = {
.read_raw = veml6030_read_raw,
.write_raw = veml6030_write_raw,
};
static irqreturn_t veml6030_event_handler(int irq, void *private)
{
int ret, reg, evtdir;
@ -788,6 +934,62 @@ static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev)
return ret;
}
/*
* Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE
* channel enabled, ALS channel interrupt, PSM enabled,
* PSM_WAIT = 0.8 s, persistence to 1 x integration time and the
* threshold interrupt disabled by default. First shutdown the sensor,
* update registers and then power on the sensor.
*/
static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev)
{
int ret, val;
struct veml6030_data *data = iio_priv(indio_dev);
ret = veml6030_als_shut_down(data);
if (ret)
return dev_err_probe(dev, ret, "can't shutdown als\n");
ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF,
VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD);
if (ret)
return dev_err_probe(dev, ret, "can't setup als configs\n");
ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
VEML6030_PSM | VEML6030_PSM_EN, 0x03);
if (ret)
return dev_err_probe(dev, ret, "can't setup default PSM\n");
ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
if (ret)
return dev_err_probe(dev, ret, "can't setup high threshold\n");
ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
if (ret)
return dev_err_probe(dev, ret, "can't setup low threshold\n");
ret = veml6030_als_pwr_on(data);
if (ret)
return dev_err_probe(dev, ret, "can't poweron als\n");
ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
if (ret < 0)
return ret;
/* Clear stale interrupt status bits if any during start */
ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
if (ret < 0)
return dev_err_probe(dev, ret,
"can't clear als interrupt status\n");
/* Cache currently active measurement parameters */
data->cur_gain = 5;
data->cur_resolution = 1024;
data->cur_integration_time = 3;
return 0;
}
static int veml6030_probe(struct i2c_client *client)
{
int ret;
@ -818,7 +1020,11 @@ static int veml6030_probe(struct i2c_client *client)
return dev_err_probe(&client->dev, ret,
"failed to enable regulator\n");
indio_dev->name = "veml6030";
data->chip = i2c_get_match_data(client);
if (!data->chip)
return -EINVAL;
indio_dev->name = data->chip->name;
indio_dev->channels = veml6030_channels;
indio_dev->num_channels = ARRAY_SIZE(veml6030_channels);
indio_dev->modes = INDIO_DIRECT_MODE;
@ -827,18 +1033,18 @@ static int veml6030_probe(struct i2c_client *client)
ret = devm_request_threaded_irq(&client->dev, client->irq,
NULL, veml6030_event_handler,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
"veml6030", indio_dev);
indio_dev->name, indio_dev);
if (ret < 0)
return dev_err_probe(&client->dev, ret,
"irq %d request failed\n",
client->irq);
indio_dev->info = &veml6030_info;
indio_dev->info = data->chip->info;
} else {
indio_dev->info = &veml6030_info_no_irq;
indio_dev->info = data->chip->info_no_irq;
}
ret = veml6030_hw_init(indio_dev, &client->dev);
ret = data->chip->hw_init(indio_dev, &client->dev);
if (ret < 0)
return ret;
@ -874,14 +1080,44 @@ static int veml6030_runtime_resume(struct device *dev)
static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend,
veml6030_runtime_resume, NULL);
static const struct veml603x_chip veml6030_chip = {
.name = "veml6030",
.scale_vals = &veml6030_scale_vals,
.num_scale_vals = ARRAY_SIZE(veml6030_scale_vals),
.info = &veml6030_info,
.info_no_irq = &veml6030_info_no_irq,
.hw_init = veml6030_hw_init,
.set_als_gain = veml6030_set_als_gain,
.get_als_gain = veml6030_get_als_gain,
};
static const struct veml603x_chip veml6035_chip = {
.name = "veml6035",
.scale_vals = &veml6035_scale_vals,
.num_scale_vals = ARRAY_SIZE(veml6035_scale_vals),
.info = &veml6035_info,
.info_no_irq = &veml6035_info_no_irq,
.hw_init = veml6035_hw_init,
.set_als_gain = veml6035_set_als_gain,
.get_als_gain = veml6035_get_als_gain,
};
static const struct of_device_id veml6030_of_match[] = {
{ .compatible = "vishay,veml6030" },
{
.compatible = "vishay,veml6030",
.data = &veml6030_chip,
},
{
.compatible = "vishay,veml6035",
.data = &veml6035_chip,
},
{ }
};
MODULE_DEVICE_TABLE(of, veml6030_of_match);
static const struct i2c_device_id veml6030_id[] = {
{ "veml6030" },
{ "veml6030", (kernel_ulong_t)&veml6030_chip},
{ "veml6035", (kernel_ulong_t)&veml6035_chip},
{ }
};
MODULE_DEVICE_TABLE(i2c, veml6030_id);