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

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

 #define DT_DRV_COMPAT sciosense_ens160

 #include <zephyr/drivers/sensor/ens160.h>
 #include <zephyr/init.h>
 #include <zephyr/kernel.h>
 #include <zephyr/pm/pm.h>
 #include <zephyr/pm/device.h>
 #include <zephyr/sys/byteorder.h>
 #include <zephyr/sys/__assert.h>

 #include "ens160.h"

 LOG_MODULE_REGISTER(ENS160, CONFIG_SENSOR_LOG_LEVEL);

 static int ens160_set_temperature(const struct device *dev, const struct sensor_value *val)
 {
 	struct ens160_data *data = dev->data;
 	uint8_t buf[2];
 	int64_t temp;
 	int ret;

 	/* Recommended operation: -5 to 60 degrees Celsius */
 	if (!IN_RANGE(val->val1, -5, 60)) {
 		LOG_ERR("Invalid temperature value");
 		return -EINVAL;
 	}

 	/* Convert temperature from Celsius to Kelvin */
 	temp = sensor_value_to_micro(val) + 273150000U;
 	/* Temperature is stored in 64 * Kelvin */
 	temp *= 64;
 	sys_put_le16(DIV_ROUND_CLOSEST(temp, 1000000U), buf);

 	ret = data->tf->write_data(dev, ENS160_REG_TEMP_IN, buf, 2U);
 	if (ret < 0) {
 		LOG_ERR("Failed to write temperature");
 		return ret;
 	}

 	return 0;
 }

 static int ens160_set_humidity(const struct device *dev, const struct sensor_value *val)
 {
 	struct ens160_data *data = dev->data;
 	uint8_t buf[2];
 	uint64_t rh;
 	int ret;

 	/* Recommended operation: 20 to 80% RH */
 	if (!IN_RANGE(val->val1, 20, 80)) {
 		LOG_ERR("Invalid RH value");
 		return -EINVAL;
 	}

 	rh = sensor_value_to_micro(val);
 	/* RH value is stored in 512 * %RH */
 	rh *= 512;
 	sys_put_le16(DIV_ROUND_CLOSEST(rh, 1000000U), buf);

 	ret = data->tf->write_data(dev, ENS160_REG_RH_IN, buf, 2U);
 	if (ret < 0) {
 		LOG_ERR("Failed to write RH");
 		return ret;
 	}

 	return 0;
 }

 static bool ens160_new_data(const struct device *dev)
 {
 	struct ens160_data *data = dev->data;
 	uint8_t status;
 	int ret;

 	ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
 	if (ret < 0) {
 		return ret;
 	}

 	return FIELD_GET(ENS160_STATUS_NEWDAT, status) != 0;
 }

 static int ens160_sample_fetch(const struct device *dev, enum sensor_channel chan)
 {
 	struct ens160_data *data = dev->data;
 	uint16_t le16_buffer;
 	uint8_t buffer;
 	int ret;

 	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_CO2 ||
 			chan == SENSOR_CHAN_VOC ||
 			chan == (enum sensor_channel)SENSOR_CHAN_ENS160_AQI);

 	if (!IS_ENABLED(CONFIG_ENS160_TRIGGER)) {
 		WAIT_FOR(ens160_new_data(dev), ENS160_TIMEOUT_US, k_msleep(10));
 	}

 	ret = data->tf->read_data(dev, ENS160_REG_DATA_ECO2, (uint8_t *)&le16_buffer,
 				  sizeof(le16_buffer));
 	if (ret < 0) {
 		LOG_ERR("Failed to fetch CO2");
 		return ret;
 	}

 	data->eco2 = sys_le16_to_cpu(le16_buffer);

 	ret = data->tf->read_data(dev, ENS160_REG_DATA_TVOC, (uint8_t *)&le16_buffer,
 				  sizeof(le16_buffer));
 	if (ret < 0) {
 		LOG_ERR("Failed to fetch VOC");
 		return ret;
 	}

 	data->tvoc = sys_le16_to_cpu(le16_buffer);

 	ret = data->tf->read_reg(dev, ENS160_REG_DATA_AQI, &buffer);
 	if (ret < 0) {
 		LOG_ERR("Failed to fetch AQI");
 		return ret;
 	}

 	data->aqi = FIELD_GET(ENS160_DATA_AQI_UBA, buffer);

 	return 0;
 }

 static int ens160_channel_get(const struct device *dev, enum sensor_channel chan,
 			      struct sensor_value *val)
 {
 	struct ens160_data *data = dev->data;

 	switch (chan) {
 	case SENSOR_CHAN_CO2:
 		val->val1 = data->eco2;
 		val->val2 = 0;
 		break;
 	case SENSOR_CHAN_VOC:
 		val->val1 = data->tvoc;
 		val->val2 = 0;
 		break;
 	case SENSOR_CHAN_ENS160_AQI:
 		val->val1 = data->aqi;
 		val->val2 = 0;
 	default:
 		return -ENOTSUP;
 	}

 	return 0;
 }

 static int ens160_attr_set(const struct device *dev, enum sensor_channel chan,
 			   enum sensor_attribute attr, const struct sensor_value *val)
 {
 	int ret = 0;

 	switch ((uint32_t)attr) {
 	case SENSOR_ATTR_ENS160_TEMP:
 		ret = ens160_set_temperature(dev, val);
 		break;
 	case SENSOR_ATTR_ENS160_RH:
 		ret = ens160_set_humidity(dev, val);
 		break;
 	default:
 		return -ENOTSUP;
 	}

 	return ret;
 }

 static const struct sensor_driver_api ens160_driver_api = {
 	.sample_fetch = ens160_sample_fetch,
 	.channel_get = ens160_channel_get,
 	.attr_set = ens160_attr_set,
 #ifdef CONFIG_ENS160_TRIGGER
 	.trigger_set = ens160_trigger_set,
 #endif
 };

 static int ens160_init(const struct device *dev)
 {
 	const struct ens160_config *config = dev->config;
 	struct ens160_data *data = dev->data;
 	uint8_t fw_version[3];
 	uint16_t part_id;
 	uint8_t status;
 	int ret;

 	ret = config->bus_init(dev);
 	if (ret < 0) {
 		return ret;
 	}

 	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_RESET);
 	if (ret < 0) {
 		LOG_ERR("Failed to reset the device");
 		return ret;
 	}

 	k_msleep(ENS160_BOOTING_TIME_MS);

 	ret = data->tf->read_data(dev, ENS160_REG_PART_ID, (uint8_t *)&part_id, sizeof(part_id));
 	if (ret < 0) {
 		LOG_ERR("Failed to read Part ID");
 		return -EIO;
 	}

 	if (sys_le16_to_cpu(part_id) != ENS160_PART_ID) {
 		LOG_ERR("Part ID is invalid. Expected: 0x%x; read: 0x%x", ENS160_PART_ID, part_id);
 		return -EIO;
 	}

 	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
 	if (ret < 0) {
 		LOG_ERR("Failed to set operation mode");
 		return ret;
 	}

 	k_msleep(ENS160_BOOTING_TIME_MS);

 	ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_CLRGPR);
 	if (ret < 0) {
 		LOG_ERR("Failed to clear GPR registers");
 		return ret;
 	}

 	ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER);
 	if (ret < 0) {
 		LOG_ERR("Failed to write GET_APPVER command");
 		return ret;
 	}

 	k_msleep(ENS160_BOOTING_TIME_MS);

 	ret = data->tf->read_data(dev, ENS160_REG_GPR_READ4, fw_version, sizeof(fw_version));
 	if (ret < 0) {
 		LOG_ERR("Failed to read firmware version");
 		return ret;
 	}
 	LOG_INF("Firmware version: %u.%u.%u", fw_version[2], fw_version[1], fw_version[0]);

 #ifdef CONFIG_ENS160_TRIGGER
 	ret = ens160_init_interrupt(dev);
 	if (ret < 0) {
 		LOG_ERR("Failed to initialize interrupt");
 		return ret;
 	}
 #endif /* CONFIG_ENS160_TRIGGER */

 	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
 	if (ret < 0) {
 		LOG_ERR("Failed to set operation mode");
 		return ret;
 	}

 	k_msleep(ENS160_BOOTING_TIME_MS);

 	ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
 	if (ret < 0) {
 		LOG_ERR("Failed to read device status");
 		return ret;
 	}

 	if (FIELD_GET(ENS160_STATUS_VALIDITY_FLAG, status) != ENS160_STATUS_NORMAL) {
 		LOG_ERR("Status 0x%02x is invalid", status);
 		return -EINVAL;
 	}

 	return 0;
 }

 #ifdef CONFIG_PM_DEVICE
 static int ens160_pm_action(const struct device *dev, enum pm_device_action action)
 {
 	struct ens160_data *data = dev->data;
 	int ret = 0;

 	switch (action) {
 	case PM_DEVICE_ACTION_RESUME:
 		ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
 		k_msleep(ENS160_BOOTING_TIME_MS);
 		ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
 		break;
 	case PM_DEVICE_ACTION_SUSPEND:
 		ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_DEEP_SLEEP);
 		break;
 	default:
 		return -ENOTSUP;
 	}

 	k_msleep(ENS160_BOOTING_TIME_MS);

 	return ret;
 }
 #endif

 #define ENS160_SPI_OPERATION                                                                       \
 	(SPI_OP_MODE_MASTER | SPI_WORD_SET(8) | SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_TRANSFER_MSB)

 #define ENS160_CONFIG_SPI(inst)                                                                    \
 	.bus_init = &ens160_spi_init,                                                              \
 	.spi = SPI_DT_SPEC_INST_GET(inst, ENS160_SPI_OPERATION, 0),

 #define ENS160_CONFIG_I2C(inst)                                                                    \
 	.bus_init = &ens160_i2c_init,                                                              \
 	.i2c = I2C_DT_SPEC_INST_GET(inst),

 #define ENS160_DEFINE(inst)                                                                        \
 	static struct ens160_data ens160_data_##inst;                                              \
 	static const struct ens160_config ens160_config_##inst = {                                 \
 		IF_ENABLED(CONFIG_ENS160_TRIGGER,                                                  \
 			  (.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios),))                   \
 		COND_CODE_1(DT_INST_ON_BUS(inst, spi),                                             \
 			   (ENS160_CONFIG_SPI(inst)),                                              \
 			   (ENS160_CONFIG_I2C(inst)))                                              \
 	};                                                                                         \
                                                                                                    \
 	PM_DEVICE_DT_INST_DEFINE(inst, ens160_pm_action);                                          \
 	SENSOR_DEVICE_DT_INST_DEFINE(inst, ens160_init, PM_DEVICE_DT_INST_GET(inst),               \
 				     &ens160_data_##inst, &ens160_config_##inst, POST_KERNEL,      \
 				     CONFIG_SENSOR_INIT_PRIORITY, &ens160_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(ENS160_DEFINE)
	/*
	* Copyright (c) 2024 Gustavo Silva
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT sciosense_ens160

	#include <zephyr/drivers/sensor/ens160.h>
	#include <zephyr/init.h>
	#include <zephyr/kernel.h>
	#include <zephyr/pm/pm.h>
	#include <zephyr/pm/device.h>
	#include <zephyr/sys/byteorder.h>
	#include <zephyr/sys/__assert.h>

	#include "ens160.h"

	LOG_MODULE_REGISTER(ENS160, CONFIG_SENSOR_LOG_LEVEL);

	static int ens160_set_temperature(const struct device dev, const struct sensor_value val)
	{
	struct ens160_data *data = dev->data;
	uint8_t buf[2];
	int64_t temp;
	int ret;

	/* Recommended operation: -5 to 60 degrees Celsius */
	if (!IN_RANGE(val->val1, -5, 60)) {
	LOG_ERR("Invalid temperature value");
	return -EINVAL;
	}

	/* Convert temperature from Celsius to Kelvin */
	temp = sensor_value_to_micro(val) + 273150000U;
	/* Temperature is stored in 64 * Kelvin */
	temp *= 64;
	sys_put_le16(DIV_ROUND_CLOSEST(temp, 1000000U), buf);

	ret = data->tf->write_data(dev, ENS160_REG_TEMP_IN, buf, 2U);
	if (ret < 0) {
	LOG_ERR("Failed to write temperature");
	return ret;
	}

	return 0;
	}

	static int ens160_set_humidity(const struct device dev, const struct sensor_value val)
	{
	struct ens160_data *data = dev->data;
	uint8_t buf[2];
	uint64_t rh;
	int ret;

	/* Recommended operation: 20 to 80% RH */
	if (!IN_RANGE(val->val1, 20, 80)) {
	LOG_ERR("Invalid RH value");
	return -EINVAL;
	}

	rh = sensor_value_to_micro(val);
	/* RH value is stored in 512 * %RH */
	rh *= 512;
	sys_put_le16(DIV_ROUND_CLOSEST(rh, 1000000U), buf);

	ret = data->tf->write_data(dev, ENS160_REG_RH_IN, buf, 2U);
	if (ret < 0) {
	LOG_ERR("Failed to write RH");
	return ret;
	}

	return 0;
	}

	static bool ens160_new_data(const struct device *dev)
	{
	struct ens160_data *data = dev->data;
	uint8_t status;
	int ret;

	ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
	if (ret < 0) {
	return ret;
	}

	return FIELD_GET(ENS160_STATUS_NEWDAT, status) != 0;
	}

	static int ens160_sample_fetch(const struct device *dev, enum sensor_channel chan)
	{
	struct ens160_data *data = dev->data;
	uint16_t le16_buffer;
	uint8_t buffer;
	int ret;

	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL \|\| chan == SENSOR_CHAN_CO2 \|\|
	chan == SENSOR_CHAN_VOC \|\|
	chan == (enum sensor_channel)SENSOR_CHAN_ENS160_AQI);

	if (!IS_ENABLED(CONFIG_ENS160_TRIGGER)) {
	WAIT_FOR(ens160_new_data(dev), ENS160_TIMEOUT_US, k_msleep(10));
	}

	ret = data->tf->read_data(dev, ENS160_REG_DATA_ECO2, (uint8_t *)&le16_buffer,
	sizeof(le16_buffer));
	if (ret < 0) {
	LOG_ERR("Failed to fetch CO2");
	return ret;
	}

	data->eco2 = sys_le16_to_cpu(le16_buffer);

	ret = data->tf->read_data(dev, ENS160_REG_DATA_TVOC, (uint8_t *)&le16_buffer,
	sizeof(le16_buffer));
	if (ret < 0) {
	LOG_ERR("Failed to fetch VOC");
	return ret;
	}

	data->tvoc = sys_le16_to_cpu(le16_buffer);

	ret = data->tf->read_reg(dev, ENS160_REG_DATA_AQI, &buffer);
	if (ret < 0) {
	LOG_ERR("Failed to fetch AQI");
	return ret;
	}

	data->aqi = FIELD_GET(ENS160_DATA_AQI_UBA, buffer);

	return 0;
	}

	static int ens160_channel_get(const struct device *dev, enum sensor_channel chan,
	struct sensor_value *val)
	{
	struct ens160_data *data = dev->data;

	switch (chan) {
	case SENSOR_CHAN_CO2:
	val->val1 = data->eco2;
	val->val2 = 0;
	break;
	case SENSOR_CHAN_VOC:
	val->val1 = data->tvoc;
	val->val2 = 0;
	break;
	case SENSOR_CHAN_ENS160_AQI:
	val->val1 = data->aqi;
	val->val2 = 0;
	default:
	return -ENOTSUP;
	}

	return 0;
	}

	static int ens160_attr_set(const struct device *dev, enum sensor_channel chan,
	enum sensor_attribute attr, const struct sensor_value *val)
	{
	int ret = 0;

	switch ((uint32_t)attr) {
	case SENSOR_ATTR_ENS160_TEMP:
	ret = ens160_set_temperature(dev, val);
	break;
	case SENSOR_ATTR_ENS160_RH:
	ret = ens160_set_humidity(dev, val);
	break;
	default:
	return -ENOTSUP;
	}

	return ret;
	}

	static const struct sensor_driver_api ens160_driver_api = {
	.sample_fetch = ens160_sample_fetch,
	.channel_get = ens160_channel_get,
	.attr_set = ens160_attr_set,
	#ifdef CONFIG_ENS160_TRIGGER
	.trigger_set = ens160_trigger_set,
	#endif
	};

	static int ens160_init(const struct device *dev)
	{
	const struct ens160_config *config = dev->config;
	struct ens160_data *data = dev->data;
	uint8_t fw_version[3];
	uint16_t part_id;
	uint8_t status;
	int ret;

	ret = config->bus_init(dev);
	if (ret < 0) {
	return ret;
	}

	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_RESET);
	if (ret < 0) {
	LOG_ERR("Failed to reset the device");
	return ret;
	}

	k_msleep(ENS160_BOOTING_TIME_MS);

	ret = data->tf->read_data(dev, ENS160_REG_PART_ID, (uint8_t *)&part_id, sizeof(part_id));
	if (ret < 0) {
	LOG_ERR("Failed to read Part ID");
	return -EIO;
	}

	if (sys_le16_to_cpu(part_id) != ENS160_PART_ID) {
	LOG_ERR("Part ID is invalid. Expected: 0x%x; read: 0x%x", ENS160_PART_ID, part_id);
	return -EIO;
	}

	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
	if (ret < 0) {
	LOG_ERR("Failed to set operation mode");
	return ret;
	}

	k_msleep(ENS160_BOOTING_TIME_MS);

	ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_CLRGPR);
	if (ret < 0) {
	LOG_ERR("Failed to clear GPR registers");
	return ret;
	}

	ret = data->tf->write_reg(dev, ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER);
	if (ret < 0) {
	LOG_ERR("Failed to write GET_APPVER command");
	return ret;
	}

	k_msleep(ENS160_BOOTING_TIME_MS);

	ret = data->tf->read_data(dev, ENS160_REG_GPR_READ4, fw_version, sizeof(fw_version));
	if (ret < 0) {
	LOG_ERR("Failed to read firmware version");
	return ret;
	}
	LOG_INF("Firmware version: %u.%u.%u", fw_version[2], fw_version[1], fw_version[0]);

	#ifdef CONFIG_ENS160_TRIGGER
	ret = ens160_init_interrupt(dev);
	if (ret < 0) {
	LOG_ERR("Failed to initialize interrupt");
	return ret;
	}
	#endif /* CONFIG_ENS160_TRIGGER */

	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
	if (ret < 0) {
	LOG_ERR("Failed to set operation mode");
	return ret;
	}

	k_msleep(ENS160_BOOTING_TIME_MS);

	ret = data->tf->read_reg(dev, ENS160_REG_DEVICE_STATUS, &status);
	if (ret < 0) {
	LOG_ERR("Failed to read device status");
	return ret;
	}

	if (FIELD_GET(ENS160_STATUS_VALIDITY_FLAG, status) != ENS160_STATUS_NORMAL) {
	LOG_ERR("Status 0x%02x is invalid", status);
	return -EINVAL;
	}

	return 0;
	}

	#ifdef CONFIG_PM_DEVICE
	static int ens160_pm_action(const struct device *dev, enum pm_device_action action)
	{
	struct ens160_data *data = dev->data;
	int ret = 0;

	switch (action) {
	case PM_DEVICE_ACTION_RESUME:
	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_IDLE);
	k_msleep(ENS160_BOOTING_TIME_MS);
	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_STANDARD);
	break;
	case PM_DEVICE_ACTION_SUSPEND:
	ret = data->tf->write_reg(dev, ENS160_REG_OPMODE, ENS160_OPMODE_DEEP_SLEEP);
	break;
	default:
	return -ENOTSUP;
	}

	k_msleep(ENS160_BOOTING_TIME_MS);

	return ret;
	}
	#endif

	#define ENS160_SPI_OPERATION \
	(SPI_OP_MODE_MASTER \| SPI_WORD_SET(8) \| SPI_MODE_CPOL \| SPI_MODE_CPHA \| SPI_TRANSFER_MSB)

	#define ENS160_CONFIG_SPI(inst) \
	.bus_init = &ens160_spi_init, \
	.spi = SPI_DT_SPEC_INST_GET(inst, ENS160_SPI_OPERATION, 0),

	#define ENS160_CONFIG_I2C(inst) \
	.bus_init = &ens160_i2c_init, \
	.i2c = I2C_DT_SPEC_INST_GET(inst),

	#define ENS160_DEFINE(inst) \
	static struct ens160_data ens160_data_##inst; \
	static const struct ens160_config ens160_config_##inst = { \
	IF_ENABLED(CONFIG_ENS160_TRIGGER, \
	(.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios),)) \
	COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
	(ENS160_CONFIG_SPI(inst)), \
	(ENS160_CONFIG_I2C(inst))) \
	}; \
	\
	PM_DEVICE_DT_INST_DEFINE(inst, ens160_pm_action); \
	SENSOR_DEVICE_DT_INST_DEFINE(inst, ens160_init, PM_DEVICE_DT_INST_GET(inst), \
	&ens160_data_##inst, &ens160_config_##inst, POST_KERNEL, \
	CONFIG_SENSOR_INIT_PRIORITY, &ens160_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(ENS160_DEFINE)