path: root/drivers/iio/light/veml6046x00.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * VEML6046X00 High Accuracy RGBIR Color Sensor
 *
 * Copyright (c) 2025 Andreas Klinger <ak@it-klinger.de>
 */

#include <linux/array_size.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/dev_printk.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/time.h>
#include <linux/types.h>
#include <linux/units.h>

#include <asm/byteorder.h>

#include <linux/iio/iio.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>

/*
 * Device registers
 * Those which are accessed as bulk io are omitted
 */
#define VEML6046X00_REG_CONF0       0x00
#define VEML6046X00_REG_CONF1       0x01
#define VEML6046X00_REG_THDH        0x04
#define VEML6046X00_REG_THDL        0x06
#define VEML6046X00_REG_R           0x10
#define VEML6046X00_REG_G           0x12
#define VEML6046X00_REG_B           0x14
#define VEML6046X00_REG_IR          0x16
#define VEML6046X00_REG_ID          0x18
#define VEML6046X00_REG_INT         0x1A
#define VEML6046X00_REG_INT_H       0x1B

/* Bit masks for specific functionality */
#define VEML6046X00_CONF0_ON_0      BIT(0)
#define VEML6046X00_CONF0_INT       BIT(1)
#define VEML6046X00_CONF0_AF_TRIG   BIT(2)
#define VEML6046X00_CONF0_AF        BIT(3)
#define VEML6046X00_CONF0_IT        GENMASK(6, 4)
#define VEML6046X00_CONF1_CAL       BIT(0)
#define VEML6046X00_CONF1_PERS      GENMASK(2, 1)
#define VEML6046X00_CONF1_GAIN      GENMASK(4, 3)
#define VEML6046X00_CONF1_PD_D2     BIT(6)
#define VEML6046X00_CONF1_ON_1      BIT(7)
#define VEML6046X00_INT_TH_H        BIT(1)
#define VEML6046X00_INT_TH_L        BIT(2)
#define VEML6046X00_INT_DRDY        BIT(3)
#define VEML6046X00_INT_MASK						       \
	(VEML6046X00_INT_TH_H | VEML6046X00_INT_TH_L | VEML6046X00_INT_DRDY)

#define	VEML6046X00_GAIN_1          0x0
#define	VEML6046X00_GAIN_2          0x1
#define	VEML6046X00_GAIN_0_66       0x2
#define	VEML6046X00_GAIN_0_5        0x3

#define VEML6046X00_PD_2_2          0x0
#define VEML6046X00_PD_1_2          BIT(6)

/* Autosuspend delay */
#define VEML6046X00_AUTOSUSPEND_MS  (3 * MSEC_PER_SEC)

enum veml6046x00_scan {
	VEML6046X00_SCAN_R,
	VEML6046X00_SCAN_G,
	VEML6046X00_SCAN_B,
	VEML6046X00_SCAN_IR,
	VEML6046X00_SCAN_TIMESTAMP,
};

/**
 * struct veml6046x00_rf - Regmap field of configuration registers.
 * @int_en:	Interrupt enable of green channel.
 * @mode:	Mode of operation.
 *		Driver uses always Active force mode.
 * @trig:	Trigger to be set in active force mode for starting
 *		measurement.
 * @it:		Integration time.
 * @pers:	Persistense - Number of threshold crossing for triggering
 *		interrupt.
 */
struct veml6046x00_rf {
	struct regmap_field *int_en;
	struct regmap_field *mode;
	struct regmap_field *trig;
	struct regmap_field *it;
	struct regmap_field *pers;
};

/**
 * struct veml6046x00_data - Private data of driver.
 * @regmap:	Regmap definition of sensor.
 * @trig:	Industrial-IO trigger.
 * @rf:		Regmap field of configuration.
 */
struct veml6046x00_data {
	struct regmap *regmap;
	struct iio_trigger *trig;
	struct veml6046x00_rf rf;
};

/**
 * DOC: Valid integration times (IT)
 *
 * static const int veml6046x00_it contains the array with valid IT.
 *
 * Register value to be read or written in regmap_field it on veml6046x00 is
 * identical with array index.
 * This means there is no separate translation table between valid integration
 * times and register values needed. The index of the array is identical with
 * the register value.
 *
 * The array is in the form as expected by the callback of the sysfs attribute
 * integration_time_available (IIO_CHAN_INFO_INT_TIME). So there is no
 * additional conversion needed.
 */
static const int veml6046x00_it[][2] = {
	{ 0, 3125 },
	{ 0, 6250 },
	{ 0, 12500 },
	{ 0, 25000 },
	{ 0, 50000 },
	{ 0, 100000 },
	{ 0, 200000 },
	{ 0, 400000 },
};

/**
 * DOC: Handling of gain and photodiode size (PD)
 *
 * Gains here in the driver are not exactly the same as in the datasheet of the
 * sensor. The gain in the driver is a combination of the gain of the sensor
 * with the photodiode size (PD).
 * The following combinations are possible:
 *   gain(driver) = gain(sensor) * PD
 *           0.25 = x0.5  * 1/2
 *           0.33 = x0.66 * 1/2
 *           0.5  = x0.5  * 2/2
 *           0.66 = x0.66 * 2/2
 *           1    = x1    * 2/2
 *           2    = x2    * 2/2
 */

/**
 * struct veml6046x00_gain_pd - Translation of gain and photodiode size (PD).
 * @gain_sen:	Gain used in the sensor as described in the datasheet of the
 *		sensor
 * @pd:		Photodiode size in the sensor
 *
 * This is the translation table from the gain used in the driver (and also used
 * by the userspace interface in sysfs) to the gain and PD used in the sensor
 * hardware.
 *
 * There are six gain values visible to the user (0.25 .. 2) which translate to
 * two different gains in the sensor hardware (x0.5 .. x2) and two PD (1/2 and
 * 2/2). Theoretical are there eight combinations, but gain values 0.5 and 1 are
 * doubled and therefore the combination with the larger PD (2/2) is taken as
 * more photodiode cells are supposed to deliver a more precise result.
 */
struct veml6046x00_gain_pd {
	unsigned int gain_sen;
	unsigned int pd;
};

static const struct veml6046x00_gain_pd veml6046x00_gain_pd[] = {
	{ .gain_sen = VEML6046X00_GAIN_0_5, .pd = VEML6046X00_PD_1_2 },
	{ .gain_sen = VEML6046X00_GAIN_0_66, .pd = VEML6046X00_PD_1_2 },
	{ .gain_sen = VEML6046X00_GAIN_0_5, .pd = VEML6046X00_PD_2_2 },
	{ .gain_sen = VEML6046X00_GAIN_0_66, .pd = VEML6046X00_PD_2_2 },
	{ .gain_sen = VEML6046X00_GAIN_1, .pd = VEML6046X00_PD_2_2 },
	{ .gain_sen = VEML6046X00_GAIN_2, .pd = VEML6046X00_PD_2_2 },
};

/**
 * DOC: Factors for calculation of lux
 *
 * static const int veml6046x00_it_gains contains the factors for calculation of
 * lux.
 *
 * Depending on the set up integration time (IT), gain and photodiode size (PD)
 * the measured raw values are different if the light is constant. As the gain
 * and PD are already coupled in the driver (see &struct veml6046x00_gain_pd)
 * there are two dimensions remaining: IT and gain(driver).
 *
 * The array of available factors for a certain IT are grouped together in the
 * same form as expected by the callback of scale_available
 * (IIO_CHAN_INFO_SCALE).
 *
 * Factors for lux / raw count are taken directly from the datasheet.
 */
static const int veml6046x00_it_gains[][6][2] = {
	/* integration time: 3.125 ms */
	{
		{ 5, 376000 },	/* gain: x0.25 */
		{ 4,  72700 },	/* gain: x0.33 */
		{ 2, 688000 },	/* gain: x0.5 */
		{ 2,  36400 },	/* gain: x0.66 */
		{ 1, 344000 },	/* gain: x1 */
		{ 0, 672000 },	/* gain: x2 */
	},
	/* integration time: 6.25 ms */
	{
		{ 2, 688000 },	/* gain: x0.25 */
		{ 2,  36350 },	/* gain: x0.33 */
		{ 1, 344000 },	/* gain: x0.5 */
		{ 1,  18200 },	/* gain: x0.66 */
		{ 0, 672000 },	/* gain: x1 */
		{ 0, 336000 },	/* gain: x2 */
	},
	/* integration time: 12.5 ms */
	{
		{ 1, 344000 },	/* gain: x0.25 */
		{ 1,  18175 },	/* gain: x0.33 */
		{ 0, 672000 },	/* gain: x0.5 */
		{ 0, 509100 },	/* gain: x0.66 */
		{ 0, 336000 },	/* gain: x1 */
		{ 0, 168000 },	/* gain: x2 */
	},
	/* integration time: 25 ms */
	{
		{ 0, 672000 },	/* gain: x0.25 */
		{ 0, 509087 },	/* gain: x0.33 */
		{ 0, 336000 },	/* gain: x0.5 */
		{ 0, 254550 },	/* gain: x0.66 */
		{ 0, 168000 },	/* gain: x1 */
		{ 0,  84000 },	/* gain: x2 */
	},
	/* integration time: 50 ms */
	{
		{ 0, 336000 },	/* gain: x0.25 */
		{ 0, 254543 },	/* gain: x0.33 */
		{ 0, 168000 },	/* gain: x0.5 */
		{ 0, 127275 },	/* gain: x0.66 */
		{ 0,  84000 },	/* gain: x1 */
		{ 0,  42000 },	/* gain: x2 */
	},
	/* integration time: 100 ms */
	{
		{ 0, 168000 },	/* gain: x0.25 */
		{ 0, 127271 },	/* gain: x0.33 */
		{ 0,  84000 },	/* gain: x0.5 */
		{ 0,  63637 },	/* gain: x0.66 */
		{ 0,  42000 },	/* gain: x1 */
		{ 0,  21000 },	/* gain: x2 */
	},
	/* integration time: 200 ms */
	{
		{ 0,  84000 },	/* gain: x0.25 */
		{ 0,  63635 },	/* gain: x0.33 */
		{ 0,  42000 },	/* gain: x0.5 */
		{ 0,  31818 },	/* gain: x0.66 */
		{ 0,  21000 },	/* gain: x1 */
		{ 0,  10500 },	/* gain: x2 */
	},
	/* integration time: 400 ms */
	{
		{ 0,  42000 },	/* gain: x0.25 */
		{ 0,  31817 },	/* gain: x0.33 */
		{ 0,  21000 },	/* gain: x0.5 */
		{ 0,  15909 },	/* gain: x0.66 */
		{ 0,  10500 },	/* gain: x1 */
		{ 0,   5250 },	/* gain: x2 */
	},
};

/*
 * Two bits (RGB_ON_0 and RGB_ON_1) must be cleared to power on the device.
 */
static int veml6046x00_power_on(struct veml6046x00_data *data)
{
	int ret;
	struct device *dev = regmap_get_device(data->regmap);

	ret = regmap_clear_bits(data->regmap, VEML6046X00_REG_CONF0,
				VEML6046X00_CONF0_ON_0);
	if (ret) {
		dev_err(dev, "Failed to set bit for power on %d\n", ret);
		return ret;
	}

	return regmap_clear_bits(data->regmap, VEML6046X00_REG_CONF1,
				 VEML6046X00_CONF1_ON_1);
}

/*
 * Two bits (RGB_ON_0 and RGB_ON_1) must be set to power off the device.
 */
static int veml6046x00_shutdown(struct veml6046x00_data *data)
{
	int ret;
	struct device *dev = regmap_get_device(data->regmap);

	ret = regmap_set_bits(data->regmap, VEML6046X00_REG_CONF0,
			      VEML6046X00_CONF0_ON_0);
	if (ret) {
		dev_err(dev, "Failed to set bit for shutdown %d\n", ret);
		return ret;
	}

	return regmap_set_bits(data->regmap, VEML6046X00_REG_CONF1,
			       VEML6046X00_CONF1_ON_1);
}

static void veml6046x00_shutdown_action(void *data)
{
	veml6046x00_shutdown(data);
}

static const struct iio_chan_spec veml6046x00_channels[] = {
	{
		.type = IIO_INTENSITY,
		.address = VEML6046X00_REG_R,
		.modified = 1,
		.channel2 = IIO_MOD_LIGHT_RED,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
					   BIT(IIO_CHAN_INFO_SCALE),
		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
						     BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = VEML6046X00_SCAN_R,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
	},
	{
		.type = IIO_INTENSITY,
		.address = VEML6046X00_REG_G,
		.modified = 1,
		.channel2 = IIO_MOD_LIGHT_GREEN,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
					   BIT(IIO_CHAN_INFO_SCALE),
		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
						     BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = VEML6046X00_SCAN_G,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
	},
	{
		.type = IIO_INTENSITY,
		.address = VEML6046X00_REG_B,
		.modified = 1,
		.channel2 = IIO_MOD_LIGHT_BLUE,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
					   BIT(IIO_CHAN_INFO_SCALE),
		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
						     BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = VEML6046X00_SCAN_B,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
	},
	{
		.type = IIO_INTENSITY,
		.address = VEML6046X00_REG_IR,
		.modified = 1,
		.channel2 = IIO_MOD_LIGHT_IR,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
					   BIT(IIO_CHAN_INFO_SCALE),
		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
						     BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = VEML6046X00_SCAN_IR,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(VEML6046X00_SCAN_TIMESTAMP),
};

static const struct regmap_config veml6046x00_regmap_config = {
	.name = "veml6046x00_regm",
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = VEML6046X00_REG_INT_H,
};

static const struct reg_field veml6046x00_rf_int_en =
	REG_FIELD(VEML6046X00_REG_CONF0, 1, 1);

static const struct reg_field veml6046x00_rf_trig =
	REG_FIELD(VEML6046X00_REG_CONF0, 2, 2);

static const struct reg_field veml6046x00_rf_mode =
	REG_FIELD(VEML6046X00_REG_CONF0, 3, 3);

static const struct reg_field veml6046x00_rf_it =
	REG_FIELD(VEML6046X00_REG_CONF0, 4, 6);

static const struct reg_field veml6046x00_rf_pers =
	REG_FIELD(VEML6046X00_REG_CONF1, 1, 2);

static int veml6046x00_regfield_init(struct veml6046x00_data *data)
{
	struct regmap *regmap = data->regmap;
	struct device *dev = regmap_get_device(data->regmap);
	struct regmap_field *rm_field;
	struct veml6046x00_rf *rf = &data->rf;

	rm_field = devm_regmap_field_alloc(dev, regmap, veml6046x00_rf_int_en);
	if (IS_ERR(rm_field))
		return PTR_ERR(rm_field);
	rf->int_en = rm_field;

	rm_field = devm_regmap_field_alloc(dev, regmap, veml6046x00_rf_mode);
	if (IS_ERR(rm_field))
		return PTR_ERR(rm_field);
	rf->mode = rm_field;

	rm_field = devm_regmap_field_alloc(dev, regmap, veml6046x00_rf_trig);
	if (IS_ERR(rm_field))
		return PTR_ERR(rm_field);
	rf->trig = rm_field;

	rm_field = devm_regmap_field_alloc(dev, regmap, veml6046x00_rf_it);
	if (IS_ERR(rm_field))
		return PTR_ERR(rm_field);
	rf->it = rm_field;

	rm_field = devm_regmap_field_alloc(dev, regmap, veml6046x00_rf_pers);
	if (IS_ERR(rm_field))
		return PTR_ERR(rm_field);
	rf->pers = rm_field;

	return 0;
}

static int veml6046x00_get_it_index(struct veml6046x00_data *data)
{
	int ret;
	unsigned int reg;

	ret = regmap_field_read(data->rf.it, &reg);
	if (ret)
		return ret;

	/* register value is identical with index of array */
	if (reg >= ARRAY_SIZE(veml6046x00_it))
		return -EINVAL;

	return reg;
}

static int veml6046x00_get_it_usec(struct veml6046x00_data *data, unsigned int *it_usec)
{
	int ret;
	unsigned int reg;

	ret = regmap_field_read(data->rf.it, &reg);
	if (ret)
		return ret;

	if (reg >= ARRAY_SIZE(veml6046x00_it))
		return -EINVAL;

	*it_usec = veml6046x00_it[reg][1];

	return IIO_VAL_INT_PLUS_MICRO;
}

static int veml6046x00_set_it(struct iio_dev *iio, int val, int val2)
{
	struct veml6046x00_data *data = iio_priv(iio);
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(veml6046x00_it); i++) {
		if ((veml6046x00_it[i][0] == val) &&
		    (veml6046x00_it[i][1] == val2))
			return regmap_field_write(data->rf.it, i);
	}

	return -EINVAL;
}

static int veml6046x00_get_val_gain_idx(struct veml6046x00_data *data, int val,
					int val2)
{
	unsigned int i;
	int it_idx;

	it_idx = veml6046x00_get_it_index(data);
	if (it_idx < 0)
		return it_idx;

	for (i = 0; i < ARRAY_SIZE(veml6046x00_it_gains[it_idx]); i++) {
		if ((veml6046x00_it_gains[it_idx][i][0] == val) &&
		    (veml6046x00_it_gains[it_idx][i][1] == val2))
			return i;
	}

	return -EINVAL;
}

static int veml6046x00_get_gain_idx(struct veml6046x00_data *data)
{
	int ret;
	unsigned int i, reg, reg_gain, reg_pd;

	ret = regmap_read(data->regmap, VEML6046X00_REG_CONF1, &reg);
	if (ret)
		return ret;

	reg_gain = FIELD_GET(VEML6046X00_CONF1_GAIN, reg);
	reg_pd = reg & VEML6046X00_CONF1_PD_D2;

	for (i = 0; i < ARRAY_SIZE(veml6046x00_gain_pd); i++) {
		if ((veml6046x00_gain_pd[i].gain_sen == reg_gain) &&
		    (veml6046x00_gain_pd[i].pd == reg_pd))
			return i;
	}

	return -EINVAL;
}

static int veml6046x00_set_scale(struct iio_dev *iio, int val, int val2)
{
	struct veml6046x00_data *data = iio_priv(iio);
	unsigned int new_scale;
	int gain_idx;

	gain_idx = veml6046x00_get_val_gain_idx(data, val, val2);
	if (gain_idx < 0)
		return gain_idx;

	new_scale = FIELD_PREP(VEML6046X00_CONF1_GAIN,
			       veml6046x00_gain_pd[gain_idx].gain_sen) |
			       veml6046x00_gain_pd[gain_idx].pd;

	return regmap_update_bits(data->regmap, VEML6046X00_REG_CONF1,
				  VEML6046X00_CONF1_GAIN |
				  VEML6046X00_CONF1_PD_D2,
				  new_scale);
}

static int veml6046x00_get_scale(struct veml6046x00_data *data,
				 int *val, int *val2)
{
	int gain_idx, it_idx;

	gain_idx = veml6046x00_get_gain_idx(data);
	if (gain_idx < 0)
		return gain_idx;

	it_idx = veml6046x00_get_it_index(data);
	if (it_idx < 0)
		return it_idx;

	*val = veml6046x00_it_gains[it_idx][gain_idx][0];
	*val2 = veml6046x00_it_gains[it_idx][gain_idx][1];

	return IIO_VAL_INT_PLUS_MICRO;
}

/**
 * veml6046x00_read_data_ready() - Read data ready bit
 * @data:	Private data.
 *
 * Helper function for reading data ready bit from interrupt register.
 *
 * Return:
 * * %1		- Data is available (AF_DATA_READY is set)
 * * %0		- No data available
 * * %-EIO	- Error during bulk read
 */
static int veml6046x00_read_data_ready(struct veml6046x00_data *data)
{
	struct device *dev = regmap_get_device(data->regmap);
	int ret;
	u8 reg[2];

	/*
	 * Note from the vendor, but not explicitly in the datasheet: we
	 * should always read both registers together.
	 */
	ret = regmap_bulk_read(data->regmap, VEML6046X00_REG_INT,
			       &reg, sizeof(reg));
	if (ret) {
		dev_err(dev, "Failed to read interrupt register %d\n", ret);
		return -EIO;
	}

	if (reg[1] & VEML6046X00_INT_DRDY)
		return 1;

	return 0;
}

/**
 * veml6046x00_wait_data_available() - Wait until data is available
 * @iio:	Industrial IO.
 * @usecs:	Microseconds to wait for data.
 *
 * This function waits for a certain bit in the interrupt register which signals
 * that there is data to be read available.
 *
 * It tries it two times with a waiting time of usecs in between.
 *
 * Return:
 * * %1		- Data is available (AF_DATA_READY is set)
 * * %0		- Timeout, no data available after usecs timeout
 * * %-EIO	- Error during bulk read
 */
static int veml6046x00_wait_data_available(struct iio_dev *iio, unsigned int usecs)
{
	struct veml6046x00_data *data = iio_priv(iio);
	int ret;

	ret = veml6046x00_read_data_ready(data);
	if (ret)
		return ret;

	fsleep(usecs);
	return veml6046x00_read_data_ready(data);
}

static int veml6046x00_single_read(struct iio_dev *iio,
				   enum iio_modifier modifier, int *val)
{
	struct veml6046x00_data *data = iio_priv(iio);
	struct device *dev = regmap_get_device(data->regmap);
	unsigned int addr, it_usec;
	int ret;
	__le16 reg;

	switch (modifier) {
	case IIO_MOD_LIGHT_RED:
		addr = VEML6046X00_REG_R;
		break;
	case IIO_MOD_LIGHT_GREEN:
		addr = VEML6046X00_REG_G;
		break;
	case IIO_MOD_LIGHT_BLUE:
		addr = VEML6046X00_REG_B;
		break;
	case IIO_MOD_LIGHT_IR:
		addr = VEML6046X00_REG_IR;
		break;
	default:
		return -EINVAL;
	}
	ret = pm_runtime_resume_and_get(dev);
	if (ret)
		return ret;

	ret = veml6046x00_get_it_usec(data, &it_usec);
	if (ret < 0) {
		dev_err(dev, "Failed to get integration time ret: %d", ret);
		goto out;
	}

	ret = regmap_field_write(data->rf.mode, 1);
	if (ret) {
		dev_err(dev, "Failed to write mode ret: %d", ret);
		goto out;
	}

	ret = regmap_field_write(data->rf.trig, 1);
	if (ret) {
		dev_err(dev, "Failed to write trigger ret: %d", ret);
		goto out;
	}

	/* integration time + 12.5 % to ensure completion */
	fsleep(it_usec + it_usec / 8);

	ret = veml6046x00_wait_data_available(iio, it_usec * 4);
	if (ret < 0)
		goto out;
	if (ret == 0) {
		ret = -EAGAIN;
		goto out;
	}

	if (!iio_device_claim_direct(iio)) {
		ret = -EBUSY;
		goto out;
	}

	ret = regmap_bulk_read(data->regmap, addr, &reg, sizeof(reg));
	iio_device_release_direct(iio);
	if (ret)
		goto out;

	*val = le16_to_cpu(reg);

	ret = IIO_VAL_INT;

out:
	pm_runtime_put_autosuspend(dev);

	return ret;
}

static int veml6046x00_read_raw(struct iio_dev *iio,
				struct iio_chan_spec const *chan, int *val,
				int *val2, long mask)
{
	struct veml6046x00_data *data = iio_priv(iio);

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		if (chan->type != IIO_INTENSITY)
			return -EINVAL;
		return veml6046x00_single_read(iio, chan->channel2, val);
	case IIO_CHAN_INFO_INT_TIME:
		*val = 0;
		return veml6046x00_get_it_usec(data, val2);
	case IIO_CHAN_INFO_SCALE:
		return veml6046x00_get_scale(data, val, val2);
	default:
		return -EINVAL;
	}
}

static int veml6046x00_read_avail(struct iio_dev *iio,
				  struct iio_chan_spec const *chan,
				  const int **vals, int *type, int *length,
				  long mask)
{
	struct veml6046x00_data *data = iio_priv(iio);
	int it_idx;

	switch (mask) {
	case IIO_CHAN_INFO_INT_TIME:
		*vals = (int *)&veml6046x00_it;
		*length = 2 * ARRAY_SIZE(veml6046x00_it);
		*type = IIO_VAL_INT_PLUS_MICRO;
		return IIO_AVAIL_LIST;
	case IIO_CHAN_INFO_SCALE:
		it_idx = veml6046x00_get_it_index(data);
		if (it_idx < 0)
			return it_idx;
		*vals = (int *)&veml6046x00_it_gains[it_idx];
		*length = 2 * ARRAY_SIZE(veml6046x00_it_gains[it_idx]);
		*type = IIO_VAL_INT_PLUS_MICRO;
		return IIO_AVAIL_LIST;
	default:
		return -EINVAL;
	}
}

static int veml6046x00_write_raw(struct iio_dev *iio,
				 struct iio_chan_spec const *chan,
				 int val, int val2, long mask)
{
	switch (mask) {
	case IIO_CHAN_INFO_INT_TIME:
		return veml6046x00_set_it(iio, val, val2);
	case IIO_CHAN_INFO_SCALE:
		return veml6046x00_set_scale(iio, val, val2);
	default:
		return -EINVAL;
	}
}

static const struct iio_info veml6046x00_info_no_irq = {
	.read_raw = veml6046x00_read_raw,
	.read_avail = veml6046x00_read_avail,
	.write_raw = veml6046x00_write_raw,
};

static int veml6046x00_buffer_preenable(struct iio_dev *iio)
{
	struct veml6046x00_data *data = iio_priv(iio);
	struct device *dev = regmap_get_device(data->regmap);
	int ret;

	ret = regmap_field_write(data->rf.mode, 0);
	if (ret) {
		dev_err(dev, "Failed to set mode %d\n", ret);
		return ret;
	}

	ret = regmap_field_write(data->rf.trig, 0);
	if (ret) {
		/*
		 * no unrolling of mode as it is set appropriately with next
		 * single read.
		 */
		dev_err(dev, "Failed to set trigger %d\n", ret);
		return ret;
	}

	return pm_runtime_resume_and_get(dev);
}

static int veml6046x00_buffer_postdisable(struct iio_dev *iio)
{
	struct veml6046x00_data *data = iio_priv(iio);
	struct device *dev = regmap_get_device(data->regmap);
	int ret;

	ret = regmap_field_write(data->rf.mode, 1);
	if (ret) {
		dev_err(dev, "Failed to set mode %d\n", ret);
		return ret;
	}

	pm_runtime_put_autosuspend(dev);

	return 0;
}

static const struct iio_buffer_setup_ops veml6046x00_buffer_setup_ops = {
	.preenable = veml6046x00_buffer_preenable,
	.postdisable = veml6046x00_buffer_postdisable,
};

static irqreturn_t veml6046x00_trig_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *iio = pf->indio_dev;
	struct veml6046x00_data *data = iio_priv(iio);
	int ret;
	struct {
		__le16 chans[4];
		aligned_s64 timestamp;
	} scan;

	ret = regmap_bulk_read(data->regmap, VEML6046X00_REG_R,
			       &scan.chans, sizeof(scan.chans));
	if (ret)
		goto done;

	iio_push_to_buffers_with_ts(iio, &scan, sizeof(scan),
				    iio_get_time_ns(iio));

done:
	iio_trigger_notify_done(iio->trig);

	return IRQ_HANDLED;
}

static int veml6046x00_validate_part_id(struct veml6046x00_data *data)
{
	struct device *dev = regmap_get_device(data->regmap);
	unsigned int part_id;
	int ret;
	__le16 reg;

	ret = regmap_bulk_read(data->regmap, VEML6046X00_REG_ID,
			       &reg, sizeof(reg));
	if (ret)
		return dev_err_probe(dev, ret, "Failed to read ID\n");

	part_id = le16_to_cpu(reg);
	if (part_id != 0x01)
		dev_info(dev, "Unknown ID %#04x\n", part_id);

	return 0;
}

static int veml6046x00_setup_device(struct iio_dev *iio)
{
	struct veml6046x00_data *data = iio_priv(iio);
	struct device *dev = regmap_get_device(data->regmap);
	int ret;
	__le16 reg16;

	reg16 = cpu_to_le16(VEML6046X00_CONF0_AF);
	ret = regmap_bulk_write(data->regmap, VEML6046X00_REG_CONF0,
				&reg16, sizeof(reg16));
	if (ret)
		return dev_err_probe(dev, ret, "Failed to set configuration\n");

	reg16 = cpu_to_le16(0);
	ret = regmap_bulk_write(data->regmap, VEML6046X00_REG_THDL,
				&reg16, sizeof(reg16));
	if (ret)
		return dev_err_probe(dev, ret, "Failed to set low threshold\n");

	reg16 = cpu_to_le16(U16_MAX);
	ret = regmap_bulk_write(data->regmap, VEML6046X00_REG_THDH,
				&reg16, sizeof(reg16));
	if (ret)
		return dev_err_probe(dev, ret, "Failed to set high threshold\n");

	ret = regmap_bulk_read(data->regmap, VEML6046X00_REG_INT,
			       &reg16, sizeof(reg16));
	if (ret)
		return dev_err_probe(dev, ret, "Failed to clear interrupts\n");

	return 0;
}

static int veml6046x00_probe(struct i2c_client *i2c)
{
	struct device *dev = &i2c->dev;
	struct veml6046x00_data *data;
	struct iio_dev *iio;
	struct regmap *regmap;
	int ret;

	regmap = devm_regmap_init_i2c(i2c, &veml6046x00_regmap_config);
	if (IS_ERR(regmap))
		return dev_err_probe(dev, PTR_ERR(regmap), "Failed to set regmap\n");

	iio = devm_iio_device_alloc(dev, sizeof(*data));
	if (!iio)
		return -ENOMEM;

	data = iio_priv(iio);
	/* struct iio_dev is retrieved via dev_get_drvdata(). */
	i2c_set_clientdata(i2c, iio);
	data->regmap = regmap;

	ret = veml6046x00_regfield_init(data);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to init regfield\n");

	ret = devm_regulator_get_enable(dev, "vdd");
	if (ret)
		return dev_err_probe(dev, ret, "Failed to enable regulator\n");

	/* bring device in a known state and switch device on */
	ret = veml6046x00_setup_device(iio);
	if (ret < 0)
		return ret;

	ret = devm_add_action_or_reset(dev, veml6046x00_shutdown_action, data);
	if (ret < 0)
		return dev_err_probe(dev, ret, "Failed to add shut down action\n");

	ret = pm_runtime_set_active(dev);
	if (ret < 0)
		return dev_err_probe(dev, ret, "Failed to activate PM runtime\n");

	ret = devm_pm_runtime_enable(dev);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to enable PM runtime\n");

	pm_runtime_get_noresume(dev);
	pm_runtime_set_autosuspend_delay(dev, VEML6046X00_AUTOSUSPEND_MS);
	pm_runtime_use_autosuspend(dev);

	ret = veml6046x00_validate_part_id(data);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to validate device ID\n");

	iio->name = "veml6046x00";
	iio->channels = veml6046x00_channels;
	iio->num_channels = ARRAY_SIZE(veml6046x00_channels);
	iio->modes = INDIO_DIRECT_MODE;

	iio->info = &veml6046x00_info_no_irq;

	ret = devm_iio_triggered_buffer_setup(dev, iio, NULL,
					      veml6046x00_trig_handler,
					      &veml6046x00_buffer_setup_ops);
	if (ret)
		return dev_err_probe(dev, ret,
				     "Failed to register triggered buffer");

	pm_runtime_put_autosuspend(dev);

	ret = devm_iio_device_register(dev, iio);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to register iio device");

	return 0;
}

static int veml6046x00_runtime_suspend(struct device *dev)
{
	struct veml6046x00_data *data = iio_priv(dev_get_drvdata(dev));

	return veml6046x00_shutdown(data);
}

static int veml6046x00_runtime_resume(struct device *dev)
{
	struct veml6046x00_data *data = iio_priv(dev_get_drvdata(dev));

	return veml6046x00_power_on(data);
}

static DEFINE_RUNTIME_DEV_PM_OPS(veml6046x00_pm_ops,
				 veml6046x00_runtime_suspend,
				 veml6046x00_runtime_resume, NULL);

static const struct of_device_id veml6046x00_of_match[] = {
	{ .compatible = "vishay,veml6046x00" },
	{ }
};
MODULE_DEVICE_TABLE(of, veml6046x00_of_match);

static const struct i2c_device_id veml6046x00_id[] = {
	{ "veml6046x00" },
	{ }
};
MODULE_DEVICE_TABLE(i2c, veml6046x00_id);

static struct i2c_driver veml6046x00_driver = {
	.driver = {
		.name = "veml6046x00",
		.of_match_table = veml6046x00_of_match,
		.pm = pm_ptr(&veml6046x00_pm_ops),
	},
	.probe = veml6046x00_probe,
	.id_table = veml6046x00_id,
};
module_i2c_driver(veml6046x00_driver);

MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
MODULE_DESCRIPTION("VEML6046X00 RGBIR Color Sensor");
MODULE_LICENSE("GPL");