drivers/sensor/tsl2561/tsl2561.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2023, Gustavo Silva
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT ams_tsl2561

 #include <zephyr/drivers/sensor.h>
 #include <zephyr/drivers/i2c.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/kernel.h>
 #include <zephyr/devicetree.h>
 #include <zephyr/sys/byteorder.h>
 #include <zephyr/sys/__assert.h>

 LOG_MODULE_REGISTER(TSL2561, CONFIG_SENSOR_LOG_LEVEL);

 #define TSL2561_CHIP_ID 0x05

 #define TSL2561_GAIN_1X  0x00
 #define TSL2561_GAIN_16X 0x01

 #define TSL2561_INTEGRATION_13MS  0x00
 #define TSL2561_INTEGRATION_101MS 0x01
 #define TSL2561_INTEGRATION_402MS 0x02

 /* Register set */
 #define TSL2561_REG_CONTROL        0x00
 #define TSL2561_REG_TIMING         0x01
 #define TSL2561_REG_THRESHLOWLOW   0x02
 #define TSL2561_REG_THRESHLOWHIGH  0x03
 #define TSL2561_REG_THRESHHIGHLOW  0x04
 #define TSL2561_REG_THRESHHIGHHIGH 0x05
 #define TSL2561_REG_INTERRUPT      0x06
 #define TSL2561_REG_ID             0x0A
 #define TSL2561_REG_DATA0LOW       0x0C
 #define TSL2561_REG_DATA0HIGH      0x0D
 #define TSL2561_REG_DATA1LOW       0x0E
 #define TSL2561_REG_DATA1HIGH      0x0F

 /* Command register fields */
 #define TSL2561_COMMAND_CMD  BIT(7)
 #define TSL2561_COMMAND_WORD BIT(5)

 /* Control register fields */
 #define TSL2561_CONTROL_POWER_UP   0x03
 #define TSL2561_CONTROL_POWER_DOWN 0x00

 /* Timing register fields */
 #define TSL2561_TIMING_GAIN  BIT(4)
 #define TSL2561_TIMING_INTEG GENMASK(1, 0)

 /* ID register part number mask */
 #define TSL2561_ID_PARTNO GENMASK(7, 4)

 /* Lux calculation constants */
 #define TSL2561_LUX_SCALE     14U
 #define TSL2561_RATIO_SCALE   9U
 #define TSL2561_CH_SCALE      10U
 #define TSL2561_CHSCALE_TINT0 0x7517
 #define TSL2561_CHSCALE_TINT1 0x0FE7

 #define TSL2561_LUX_K1T 0X0040 /* 0.125   * 2^RATIO_SCALE */
 #define TSL2561_LUX_B1T 0X01F2 /* 0.0304  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M1T 0X01BE /* 0.0272  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K2T 0X0080 /* 0.250   * 2^RATIO_SCALE */
 #define TSL2561_LUX_B2T 0X0214 /* 0.0325  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M2T 0X02D1 /* 0.0440  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K3T 0X00C0 /* 0.375   * 2^RATIO_SCALE */
 #define TSL2561_LUX_B3T 0X023F /* 0.0351  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M3T 0X037B /* 0.0544  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K4T 0X0100 /* 0.50    * 2^RATIO_SCALE */
 #define TSL2561_LUX_B4T 0X0270 /* 0.0381  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M4T 0X03FE /* 0.0624  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K5T 0X0138 /* 0.61    * 2^RATIO_SCALE */
 #define TSL2561_LUX_B5T 0X016F /* 0.0224  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M5T 0X01FC /* 0.0310  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K6T 0X019A /* 0.80    * 2^RATIO_SCALE */
 #define TSL2561_LUX_B6T 0X00D2 /* 0.0128  * 2^LUX_SCALE   */
 #define TSL2561_LUX_M6T 0X00FB /* 0.0153  * 2^LUX_SCALE   */
 #define TSL2561_LUX_K7T 0X029A /* 1.3     * 2^RATIO_SCALE */
 #define TSL2561_LUX_B7T 0X0018 /* 0.00146 * 2^LUX_SCALE   */
 #define TSL2561_LUX_M7T 0X0012 /* 0.00112 * 2^LUX_SCALE   */
 #define TSL2561_LUX_K8T 0X029A /* 1.3     * 2^RATIO_SCALE */
 #define TSL2561_LUX_B8T 0X0000 /* 0.000   * 2^LUX_SCALE   */
 #define TSL2561_LUX_M8T 0X0000 /* 0.000   * 2^LUX_SCALE   */

 struct tsl2561_config {
 	struct i2c_dt_spec i2c;
 	uint16_t integration_time;
 	uint8_t gain;
 };

 struct tsl2561_data {
 	uint16_t ch0;
 	uint16_t ch1;
 	uint32_t ch_scale;
 };

 static int tsl2561_reg_read(const struct device *dev, uint8_t reg, uint8_t *buf, uint8_t size)
 {
 	int ret;
 	const struct tsl2561_config *config = dev->config;
 	uint8_t cmd = (TSL2561_COMMAND_CMD | TSL2561_COMMAND_WORD | reg);

 	ret = i2c_write_read_dt(&config->i2c, &cmd, 1U, buf, size);
 	if (ret < 0) {
 		LOG_ERR("Failed reading register 0x%02x", reg);
 		return ret;
 	}

 	return 0;
 }

 static int tsl2561_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
 {
 	int ret;
 	const struct tsl2561_config *config = dev->config;
 	uint8_t buf[2];

 	buf[0] = (TSL2561_COMMAND_CMD | TSL2561_COMMAND_WORD | reg);
 	buf[1] = val;

 	ret = i2c_write_dt(&config->i2c, buf, 2U);
 	if (ret < 0) {
 		LOG_ERR("Failed writing register 0x%02x", reg);
 		return ret;
 	}

 	return 0;
 }

 static int tsl2561_sample_fetch(const struct device *dev, enum sensor_channel chan)
 {
 	const struct tsl2561_config *config = dev->config;
 	struct tsl2561_data *data = dev->data;
 	uint8_t bytes[2];
 	int ret;

 	if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
 		LOG_ERR("Unsupported sensor channel");
 		return -ENOTSUP;
 	}

 	ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_UP);
 	if (ret < 0) {
 		LOG_ERR("Failed to power up device");
 		return ret;
 	}

 	/* Short sleep after power up. Not in the datasheet, but found by trial and error */
 	k_msleep(5);

 	k_msleep(config->integration_time);

 	/* Read data register's lower and upper bytes consecutively */
 	ret = tsl2561_reg_read(dev, TSL2561_REG_DATA0LOW, bytes, 2U);
 	if (ret < 0) {
 		LOG_ERR("Failed reading channel0 data");
 		return ret;
 	}
 	data->ch0 = bytes[1] << 8 | bytes[0];

 	ret = tsl2561_reg_read(dev, TSL2561_REG_DATA1LOW, bytes, 2U);
 	if (ret < 0) {
 		LOG_ERR("Failed reading channel1 data");
 		return ret;
 	}
 	data->ch1 = bytes[1] << 8 | bytes[0];

 	ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_DOWN);
 	if (ret < 0) {
 		LOG_ERR("Failed to power down device");
 		return ret;
 	}

 	LOG_DBG("channel0: 0x%x; channel1: 0x%x", data->ch0, data->ch1);

 	return 0;
 }

 static int tsl2561_channel_get(const struct device *dev, enum sensor_channel chan,
 			       struct sensor_value *val)
 {
 	struct tsl2561_data *data = dev->data;
 	uint32_t channel0;
 	uint32_t channel1;

 	if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
 		return -ENOTSUP;
 	}

 	channel0 = (data->ch0 * data->ch_scale) >> TSL2561_CH_SCALE;
 	channel1 = (data->ch1 * data->ch_scale) >> TSL2561_CH_SCALE;

 	uint32_t ratio1 = 0;

 	if (channel0 != 0) {
 		ratio1 = (channel1 << (TSL2561_RATIO_SCALE + 1)) / channel0;
 	}

 	/* Round the ratio value */
 	uint32_t ratio = (ratio1 + 1) >> 1;

 	uint32_t b = 0;
 	uint32_t m = 0;

 	if (ratio <= TSL2561_LUX_K1T) {
 		b = TSL2561_LUX_B1T;
 		m = TSL2561_LUX_M1T;
 	} else if (ratio <= TSL2561_LUX_K2T) {
 		b = TSL2561_LUX_B2T;
 		m = TSL2561_LUX_M2T;
 	} else if (ratio <= TSL2561_LUX_K3T) {
 		b = TSL2561_LUX_B3T;
 		m = TSL2561_LUX_M3T;
 	} else if (ratio <= TSL2561_LUX_K4T) {
 		b = TSL2561_LUX_B4T;
 		m = TSL2561_LUX_M4T;
 	} else if (ratio <= TSL2561_LUX_K5T) {
 		b = TSL2561_LUX_B5T;
 		m = TSL2561_LUX_M5T;
 	} else if (ratio <= TSL2561_LUX_K6T) {
 		b = TSL2561_LUX_B6T;
 		m = TSL2561_LUX_M6T;
 	} else if (ratio <= TSL2561_LUX_K7T) {
 		b = TSL2561_LUX_B7T;
 		m = TSL2561_LUX_M7T;
 	} else if (ratio > TSL2561_LUX_K8T) {
 		b = TSL2561_LUX_B8T;
 		m = TSL2561_LUX_M8T;
 	}

 	int32_t tmp = ((channel0 * b) - (channel1 * m));

 	/* Round LSB (2^(LUX_SCALE−1)) */
 	tmp += (1 << (TSL2561_LUX_SCALE - 1));

 	/* Strip off fractional portion */
 	val->val1 = tmp >> TSL2561_LUX_SCALE;

 	val->val2 = 0;

 	return 0;
 }

 static const struct sensor_driver_api tsl2561_driver_api = {
 	.sample_fetch = tsl2561_sample_fetch,
 	.channel_get = tsl2561_channel_get
 };

 static int tsl2561_sensor_setup(const struct device *dev)
 {
 	const struct tsl2561_config *config = dev->config;
 	struct tsl2561_data *data = dev->data;
 	uint8_t timing_reg;
 	uint8_t chip_id;
 	uint8_t tmp;
 	int ret;

 	ret = tsl2561_reg_read(dev, TSL2561_REG_ID, &chip_id, 1U);
 	if (ret < 0) {
 		LOG_ERR("Failed reading chip ID");
 		return ret;
 	}

 	if (FIELD_GET(TSL2561_ID_PARTNO, chip_id) != TSL2561_CHIP_ID) {
 		LOG_ERR("Chip ID is invalid! Device @%02x is not TSL2561!", config->i2c.addr);
 		return -EIO;
 	}

 	switch (config->integration_time) {
 	case 13:
 		tmp = TSL2561_INTEGRATION_13MS;
 		data->ch_scale = TSL2561_CHSCALE_TINT0;
 		break;
 	case 101:
 		tmp = TSL2561_INTEGRATION_101MS;
 		data->ch_scale = TSL2561_CHSCALE_TINT1;
 		break;
 	case 402:
 		tmp = TSL2561_INTEGRATION_402MS;
 		data->ch_scale = (1 << TSL2561_CH_SCALE);
 		break;
 	default:
 		LOG_ERR("Invalid integration time");
 		return -EINVAL;
 	}

 	timing_reg = TSL2561_TIMING_INTEG & tmp;

 	switch (config->gain) {
 	case 1:
 		tmp = TSL2561_GAIN_1X;
 		data->ch_scale = data->ch_scale << 4;
 		break;
 	case 16:
 		tmp = TSL2561_GAIN_16X;
 		break;
 	default:
 		LOG_ERR("Invalid ADC gain");
 		return -EINVAL;
 	}

 	timing_reg |= FIELD_PREP(TSL2561_TIMING_GAIN, tmp);

 	ret = tsl2561_reg_write(dev, TSL2561_REG_TIMING, timing_reg);
 	if (ret < 0) {
 		LOG_ERR("Failed setting timing register");
 		return ret;
 	}

 	return 0;
 }

 static int tsl2561_init(const struct device *dev)
 {
 	const struct tsl2561_config *config = dev->config;
 	int ret;

 	if (!i2c_is_ready_dt(&config->i2c)) {
 		LOG_ERR("I2C dev %s not ready", config->i2c.bus->name);
 		return -ENODEV;
 	}

 	ret = tsl2561_sensor_setup(dev);
 	if (ret < 0) {
 		LOG_ERR("Failed to configure device");
 		return ret;
 	}

 	return 0;
 }

 #define TSL2561_INIT_INST(n)                                                                       \
 	static struct tsl2561_data tsl2561_data_##n;                                               \
 	static const struct tsl2561_config tsl2561_config_##n = {                                  \
 		.i2c = I2C_DT_SPEC_INST_GET(n),                                                    \
 		.integration_time = DT_INST_PROP(n, integration_time),                             \
 		.gain = DT_INST_PROP(n, gain)};                                                    \
 	SENSOR_DEVICE_DT_INST_DEFINE(n, tsl2561_init, NULL, &tsl2561_data_##n,                     \
 				     &tsl2561_config_##n, POST_KERNEL,                             \
 				     CONFIG_SENSOR_INIT_PRIORITY, &tsl2561_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(TSL2561_INIT_INST)
	/*
	* Copyright (c) 2023, Gustavo Silva
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT ams_tsl2561

	#include <zephyr/drivers/sensor.h>
	#include <zephyr/drivers/i2c.h>
	#include <zephyr/logging/log.h>
	#include <zephyr/kernel.h>
	#include <zephyr/devicetree.h>
	#include <zephyr/sys/byteorder.h>
	#include <zephyr/sys/__assert.h>

	LOG_MODULE_REGISTER(TSL2561, CONFIG_SENSOR_LOG_LEVEL);

	#define TSL2561_CHIP_ID 0x05

	#define TSL2561_GAIN_1X 0x00
	#define TSL2561_GAIN_16X 0x01

	#define TSL2561_INTEGRATION_13MS 0x00
	#define TSL2561_INTEGRATION_101MS 0x01
	#define TSL2561_INTEGRATION_402MS 0x02

	/* Register set */
	#define TSL2561_REG_CONTROL 0x00
	#define TSL2561_REG_TIMING 0x01
	#define TSL2561_REG_THRESHLOWLOW 0x02
	#define TSL2561_REG_THRESHLOWHIGH 0x03
	#define TSL2561_REG_THRESHHIGHLOW 0x04
	#define TSL2561_REG_THRESHHIGHHIGH 0x05
	#define TSL2561_REG_INTERRUPT 0x06
	#define TSL2561_REG_ID 0x0A
	#define TSL2561_REG_DATA0LOW 0x0C
	#define TSL2561_REG_DATA0HIGH 0x0D
	#define TSL2561_REG_DATA1LOW 0x0E
	#define TSL2561_REG_DATA1HIGH 0x0F

	/* Command register fields */
	#define TSL2561_COMMAND_CMD BIT(7)
	#define TSL2561_COMMAND_WORD BIT(5)

	/* Control register fields */
	#define TSL2561_CONTROL_POWER_UP 0x03
	#define TSL2561_CONTROL_POWER_DOWN 0x00

	/* Timing register fields */
	#define TSL2561_TIMING_GAIN BIT(4)
	#define TSL2561_TIMING_INTEG GENMASK(1, 0)

	/* ID register part number mask */
	#define TSL2561_ID_PARTNO GENMASK(7, 4)

	/* Lux calculation constants */
	#define TSL2561_LUX_SCALE 14U
	#define TSL2561_RATIO_SCALE 9U
	#define TSL2561_CH_SCALE 10U
	#define TSL2561_CHSCALE_TINT0 0x7517
	#define TSL2561_CHSCALE_TINT1 0x0FE7

	#define TSL2561_LUX_K1T 0X0040 /* 0.125 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B1T 0X01F2 /* 0.0304 * 2^LUX_SCALE */
	#define TSL2561_LUX_M1T 0X01BE /* 0.0272 * 2^LUX_SCALE */
	#define TSL2561_LUX_K2T 0X0080 /* 0.250 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B2T 0X0214 /* 0.0325 * 2^LUX_SCALE */
	#define TSL2561_LUX_M2T 0X02D1 /* 0.0440 * 2^LUX_SCALE */
	#define TSL2561_LUX_K3T 0X00C0 /* 0.375 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B3T 0X023F /* 0.0351 * 2^LUX_SCALE */
	#define TSL2561_LUX_M3T 0X037B /* 0.0544 * 2^LUX_SCALE */
	#define TSL2561_LUX_K4T 0X0100 /* 0.50 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B4T 0X0270 /* 0.0381 * 2^LUX_SCALE */
	#define TSL2561_LUX_M4T 0X03FE /* 0.0624 * 2^LUX_SCALE */
	#define TSL2561_LUX_K5T 0X0138 /* 0.61 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B5T 0X016F /* 0.0224 * 2^LUX_SCALE */
	#define TSL2561_LUX_M5T 0X01FC /* 0.0310 * 2^LUX_SCALE */
	#define TSL2561_LUX_K6T 0X019A /* 0.80 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B6T 0X00D2 /* 0.0128 * 2^LUX_SCALE */
	#define TSL2561_LUX_M6T 0X00FB /* 0.0153 * 2^LUX_SCALE */
	#define TSL2561_LUX_K7T 0X029A /* 1.3 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B7T 0X0018 /* 0.00146 * 2^LUX_SCALE */
	#define TSL2561_LUX_M7T 0X0012 /* 0.00112 * 2^LUX_SCALE */
	#define TSL2561_LUX_K8T 0X029A /* 1.3 * 2^RATIO_SCALE */
	#define TSL2561_LUX_B8T 0X0000 /* 0.000 * 2^LUX_SCALE */
	#define TSL2561_LUX_M8T 0X0000 /* 0.000 * 2^LUX_SCALE */

	struct tsl2561_config {
	struct i2c_dt_spec i2c;
	uint16_t integration_time;
	uint8_t gain;
	};

	struct tsl2561_data {
	uint16_t ch0;
	uint16_t ch1;
	uint32_t ch_scale;
	};

	static int tsl2561_reg_read(const struct device dev, uint8_t reg, uint8_t buf, uint8_t size)
	{
	int ret;
	const struct tsl2561_config *config = dev->config;
	uint8_t cmd = (TSL2561_COMMAND_CMD \| TSL2561_COMMAND_WORD \| reg);

	ret = i2c_write_read_dt(&config->i2c, &cmd, 1U, buf, size);
	if (ret < 0) {
	LOG_ERR("Failed reading register 0x%02x", reg);
	return ret;
	}

	return 0;
	}

	static int tsl2561_reg_write(const struct device *dev, uint8_t reg, uint8_t val)
	{
	int ret;
	const struct tsl2561_config *config = dev->config;
	uint8_t buf[2];

	buf[0] = (TSL2561_COMMAND_CMD \| TSL2561_COMMAND_WORD \| reg);
	buf[1] = val;

	ret = i2c_write_dt(&config->i2c, buf, 2U);
	if (ret < 0) {
	LOG_ERR("Failed writing register 0x%02x", reg);
	return ret;
	}

	return 0;
	}

	static int tsl2561_sample_fetch(const struct device *dev, enum sensor_channel chan)
	{
	const struct tsl2561_config *config = dev->config;
	struct tsl2561_data *data = dev->data;
	uint8_t bytes[2];
	int ret;

	if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
	LOG_ERR("Unsupported sensor channel");
	return -ENOTSUP;
	}

	ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_UP);
	if (ret < 0) {
	LOG_ERR("Failed to power up device");
	return ret;
	}

	/* Short sleep after power up. Not in the datasheet, but found by trial and error */
	k_msleep(5);

	k_msleep(config->integration_time);

	/* Read data register's lower and upper bytes consecutively */
	ret = tsl2561_reg_read(dev, TSL2561_REG_DATA0LOW, bytes, 2U);
	if (ret < 0) {
	LOG_ERR("Failed reading channel0 data");
	return ret;
	}
	data->ch0 = bytes[1] << 8 \| bytes[0];

	ret = tsl2561_reg_read(dev, TSL2561_REG_DATA1LOW, bytes, 2U);
	if (ret < 0) {
	LOG_ERR("Failed reading channel1 data");
	return ret;
	}
	data->ch1 = bytes[1] << 8 \| bytes[0];

	ret = tsl2561_reg_write(dev, TSL2561_REG_CONTROL, TSL2561_CONTROL_POWER_DOWN);
	if (ret < 0) {
	LOG_ERR("Failed to power down device");
	return ret;
	}

	LOG_DBG("channel0: 0x%x; channel1: 0x%x", data->ch0, data->ch1);

	return 0;
	}

	static int tsl2561_channel_get(const struct device *dev, enum sensor_channel chan,
	struct sensor_value *val)
	{
	struct tsl2561_data *data = dev->data;
	uint32_t channel0;
	uint32_t channel1;

	if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_LIGHT) {
	return -ENOTSUP;
	}

	channel0 = (data->ch0 * data->ch_scale) >> TSL2561_CH_SCALE;
	channel1 = (data->ch1 * data->ch_scale) >> TSL2561_CH_SCALE;

	uint32_t ratio1 = 0;

	if (channel0 != 0) {
	ratio1 = (channel1 << (TSL2561_RATIO_SCALE + 1)) / channel0;
	}

	/* Round the ratio value */
	uint32_t ratio = (ratio1 + 1) >> 1;

	uint32_t b = 0;
	uint32_t m = 0;

	if (ratio <= TSL2561_LUX_K1T) {
	b = TSL2561_LUX_B1T;
	m = TSL2561_LUX_M1T;
	} else if (ratio <= TSL2561_LUX_K2T) {
	b = TSL2561_LUX_B2T;
	m = TSL2561_LUX_M2T;
	} else if (ratio <= TSL2561_LUX_K3T) {
	b = TSL2561_LUX_B3T;
	m = TSL2561_LUX_M3T;
	} else if (ratio <= TSL2561_LUX_K4T) {
	b = TSL2561_LUX_B4T;
	m = TSL2561_LUX_M4T;
	} else if (ratio <= TSL2561_LUX_K5T) {
	b = TSL2561_LUX_B5T;
	m = TSL2561_LUX_M5T;
	} else if (ratio <= TSL2561_LUX_K6T) {
	b = TSL2561_LUX_B6T;
	m = TSL2561_LUX_M6T;
	} else if (ratio <= TSL2561_LUX_K7T) {
	b = TSL2561_LUX_B7T;
	m = TSL2561_LUX_M7T;
	} else if (ratio > TSL2561_LUX_K8T) {
	b = TSL2561_LUX_B8T;
	m = TSL2561_LUX_M8T;
	}

	int32_t tmp = ((channel0 * b) - (channel1 * m));

	/* Round LSB (2^(LUX_SCALE−1)) */
	tmp += (1 << (TSL2561_LUX_SCALE - 1));

	/* Strip off fractional portion */
	val->val1 = tmp >> TSL2561_LUX_SCALE;

	val->val2 = 0;

	return 0;
	}

	static const struct sensor_driver_api tsl2561_driver_api = {
	.sample_fetch = tsl2561_sample_fetch,
	.channel_get = tsl2561_channel_get
	};

	static int tsl2561_sensor_setup(const struct device *dev)
	{
	const struct tsl2561_config *config = dev->config;
	struct tsl2561_data *data = dev->data;
	uint8_t timing_reg;
	uint8_t chip_id;
	uint8_t tmp;
	int ret;

	ret = tsl2561_reg_read(dev, TSL2561_REG_ID, &chip_id, 1U);
	if (ret < 0) {
	LOG_ERR("Failed reading chip ID");
	return ret;
	}

	if (FIELD_GET(TSL2561_ID_PARTNO, chip_id) != TSL2561_CHIP_ID) {
	LOG_ERR("Chip ID is invalid! Device @%02x is not TSL2561!", config->i2c.addr);
	return -EIO;
	}

	switch (config->integration_time) {
	case 13:
	tmp = TSL2561_INTEGRATION_13MS;
	data->ch_scale = TSL2561_CHSCALE_TINT0;
	break;
	case 101:
	tmp = TSL2561_INTEGRATION_101MS;
	data->ch_scale = TSL2561_CHSCALE_TINT1;
	break;
	case 402:
	tmp = TSL2561_INTEGRATION_402MS;
	data->ch_scale = (1 << TSL2561_CH_SCALE);
	break;
	default:
	LOG_ERR("Invalid integration time");
	return -EINVAL;
	}

	timing_reg = TSL2561_TIMING_INTEG & tmp;

	switch (config->gain) {
	case 1:
	tmp = TSL2561_GAIN_1X;
	data->ch_scale = data->ch_scale << 4;
	break;
	case 16:
	tmp = TSL2561_GAIN_16X;
	break;
	default:
	LOG_ERR("Invalid ADC gain");
	return -EINVAL;
	}

	timing_reg \|= FIELD_PREP(TSL2561_TIMING_GAIN, tmp);

	ret = tsl2561_reg_write(dev, TSL2561_REG_TIMING, timing_reg);
	if (ret < 0) {
	LOG_ERR("Failed setting timing register");
	return ret;
	}

	return 0;
	}

	static int tsl2561_init(const struct device *dev)
	{
	const struct tsl2561_config *config = dev->config;
	int ret;

	if (!i2c_is_ready_dt(&config->i2c)) {
	LOG_ERR("I2C dev %s not ready", config->i2c.bus->name);
	return -ENODEV;
	}

	ret = tsl2561_sensor_setup(dev);
	if (ret < 0) {
	LOG_ERR("Failed to configure device");
	return ret;
	}

	return 0;
	}

	#define TSL2561_INIT_INST(n) \
	static struct tsl2561_data tsl2561_data_##n; \
	static const struct tsl2561_config tsl2561_config_##n = { \
	.i2c = I2C_DT_SPEC_INST_GET(n), \
	.integration_time = DT_INST_PROP(n, integration_time), \
	.gain = DT_INST_PROP(n, gain)}; \
	SENSOR_DEVICE_DT_INST_DEFINE(n, tsl2561_init, NULL, &tsl2561_data_##n, \
	&tsl2561_config_##n, POST_KERNEL, \
	CONFIG_SENSOR_INIT_PRIORITY, &tsl2561_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(TSL2561_INIT_INST)