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

 /*
  * Copyright (c) 2022 Badgerd Technologies B.V.
  * Copyright (c) 2023 Metratec GmbH
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include "bmp581.h"

 #include <math.h>

 #include <zephyr/device.h>
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/i2c.h>
 #include <zephyr/drivers/sensor.h>
 #include <zephyr/init.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/sys/check.h>

 LOG_MODULE_REGISTER(bmp581, CONFIG_SENSOR_LOG_LEVEL);

 #if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
 #warning "BMP581 driver enabled without any devices"
 #endif

 static int power_up_check(const struct device *dev);
 static int get_nvm_status(uint8_t *nvm_status, const struct device *dev);
 static int get_interrupt_status(uint8_t *int_status, const struct device *dev);
 static int validate_chip_id(struct bmp581_data *drv);
 static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
 				    const struct device *dev);
 static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
 			  const struct device *dev);
 static int set_odr_config(const struct sensor_value *odr, const struct device *dev);
 static int soft_reset(const struct device *dev);
 static int set_iir_config(const struct sensor_value *iir, const struct device *dev);
 static int get_power_mode(enum bmp5_powermode *powermode, const struct device *dev);
 static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev);

 static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = BMP5_OK;
 	uint8_t odr = 0;
 	enum bmp5_powermode current_powermode;

 	CHECKIF(dev == NULL) {
 		return -EINVAL;
 	}

 	ret = get_power_mode(&current_powermode, dev);
 	if (ret != BMP5_OK) {
 		LOG_ERR("Couldnt set the power mode because something went wrong when getting the "
 			"current power mode.");
 		return ret;
 	}

 	if (current_powermode != BMP5_POWERMODE_STANDBY) {
 		/*
 		 * Device should be set to standby before transitioning to forced mode or normal
 		 * mode or continuous mode.
 		 */

 		ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr);
 		if (ret == BMP5_OK) {
 			/* Setting deep_dis = 1(BMP5_DEEP_DISABLED) disables the deep standby mode
 			 */
 			odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
 			odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, BMP5_POWERMODE_STANDBY);
 			ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);

 			if (ret != BMP5_OK) {
 				LOG_DBG("Failed to set power mode to BMP5_POWERMODE_STANDBY.");
 				return ret;
 			}
 		}
 	}

 	/* lets update the power mode */
 	switch (powermode) {
 	case BMP5_POWERMODE_STANDBY:
 		/* this change is already done so we can just return */
 		ret = BMP5_OK;
 		break;
 	case BMP5_POWERMODE_DEEP_STANDBY:
 		LOG_DBG("Setting power mode to DEEP STANDBY is not supported, current power mode "
 			"is BMP5_POWERMODE_STANDBY.");
 		ret = -ENOTSUP;
 		break;
 	case BMP5_POWERMODE_NORMAL:
 	case BMP5_POWERMODE_FORCED:
 	case BMP5_POWERMODE_CONTINUOUS:
 		odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
 		odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, powermode);
 		ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);
 		break;
 	default:
 		/* invalid power mode */
 		ret = -EINVAL;
 		break;
 	}

 	return ret;
 }

 static int get_power_mode(enum bmp5_powermode *powermode, const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = BMP5_OK;

 	CHECKIF(powermode == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	uint8_t reg = 0;
 	uint8_t raw_power_mode = 0;

 	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &reg);
 	if (ret != BMP5_OK) {
 		LOG_DBG("Failed to read odr config to get power mode!");
 		return ret;
 	}

 	raw_power_mode = BMP5_GET_BITS_POS_0(reg, BMP5_POWERMODE);

 	switch (raw_power_mode) {
 	case BMP5_POWERMODE_STANDBY: {
 		/* Getting deep disable status */
 		uint8_t deep_dis = BMP5_GET_BITSLICE(reg, BMP5_DEEP_DISABLE);

 		/* Checking deepstandby status only when powermode is in standby mode */

 		/* If deep_dis = 0(BMP5_DEEP_ENABLED) then deepstandby mode is enabled.
 		 * If deep_dis = 1(BMP5_DEEP_DISABLED) then deepstandby mode is disabled
 		 */
 		if (deep_dis == BMP5_DEEP_ENABLED) {
 			/* TODO: check if it is really deep standby */
 			*powermode = BMP5_POWERMODE_DEEP_STANDBY;
 		} else {
 			*powermode = BMP5_POWERMODE_STANDBY;
 		}

 		break;
 	}
 	case BMP5_POWERMODE_NORMAL:
 		*powermode = BMP5_POWERMODE_NORMAL;
 		break;
 	case BMP5_POWERMODE_FORCED:
 		*powermode = BMP5_POWERMODE_FORCED;
 		break;
 	case BMP5_POWERMODE_CONTINUOUS:
 		*powermode = BMP5_POWERMODE_CONTINUOUS;
 		break;
 	default:
 		/* invalid power mode */
 		ret = -EINVAL;
 		LOG_DBG("Something went wrong invalid powermode!");
 		break;
 	}

 	return ret;
 }

 static int power_up_check(const struct device *dev)
 {
 	int8_t rslt = 0;
 	uint8_t nvm_status = 0;

 	CHECKIF(dev == NULL) {
 		return -EINVAL;
 	}

 	rslt = get_nvm_status(&nvm_status, dev);

 	if (rslt == BMP5_OK) {
 		/* Check if nvm_rdy status = 1 and nvm_err status = 0 to proceed */
 		if ((nvm_status & BMP5_INT_NVM_RDY) && (!(nvm_status & BMP5_INT_NVM_ERR))) {
 			rslt = BMP5_OK;
 		} else {
 			rslt = -EFAULT;
 		}
 	}

 	return rslt;
 }

 static int get_interrupt_status(uint8_t *int_status, const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;

 	CHECKIF(int_status == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_INT_STATUS, int_status);
 }

 static int get_nvm_status(uint8_t *nvm_status, const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;

 	CHECKIF(nvm_status == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_STATUS, nvm_status);
 }

 static int validate_chip_id(struct bmp581_data *drv)
 {
 	int8_t rslt = 0;

 	CHECKIF(drv == NULL) {
 		return -EINVAL;
 	}

 	if ((drv->chip_id == BMP5_CHIP_ID_PRIM) || (drv->chip_id == BMP5_CHIP_ID_SEC)) {
 		rslt = BMP5_OK;
 	} else {
 		drv->chip_id = 0;
 		rslt = -ENODEV;
 	}

 	return rslt;
 }

 /*!
  *  This API gets the configuration for oversampling of temperature, oversampling of
  *  pressure and ODR configuration along with pressure enable.
  */
 static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
 				    const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;

 	/* Variable to store the function result */
 	int8_t rslt = 0;

 	/* Variable to store OSR and ODR config */
 	uint8_t reg_data[2] = {0};

 	CHECKIF(osr_odr_press_cfg == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	/* Get OSR and ODR configuration in burst read */
 	rslt = i2c_burst_read_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, reg_data, 2);

 	if (rslt == BMP5_OK) {
 		osr_odr_press_cfg->osr_t = BMP5_GET_BITS_POS_0(reg_data[0], BMP5_TEMP_OS);
 		osr_odr_press_cfg->osr_p = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_OS);
 		osr_odr_press_cfg->press_en = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_EN);
 		osr_odr_press_cfg->odr = BMP5_GET_BITSLICE(reg_data[1], BMP5_ODR);
 	}

 	return rslt;
 }

 static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
 			  const struct device *dev)
 {
 	CHECKIF(osr == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	struct bmp581_data *drv = (struct bmp581_data *)dev->data;
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = 0;

 	uint8_t oversampling = osr->val1;
 	uint8_t press_en = osr->val2 != 0; /* if it is not 0 then pressure is enabled */
 	uint8_t osr_val = 0;

 	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, &osr_val);
 	if (ret == BMP5_OK) {
 		switch (chan) {
 		case SENSOR_CHAN_ALL:
 			osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
 			osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
 			osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
 			break;
 		case SENSOR_CHAN_PRESS:
 			osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
 			osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
 			break;
 		case SENSOR_CHAN_AMBIENT_TEMP:
 			osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
 			break;
 		default:
 			ret = -ENOTSUP;
 			break;
 		}

 		if (ret == BMP5_OK) {
 			ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, osr_val);
 			get_osr_odr_press_config(&drv->osr_odr_press_config, dev);
 		}
 	}

 	return ret;
 }

 static int set_odr_config(const struct sensor_value *odr, const struct device *dev)
 {
 	CHECKIF(odr == NULL || dev == NULL) {
 		return -EINVAL;
 	}

 	struct bmp581_data *drv = (struct bmp581_data *)dev->data;
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = 0;
 	uint8_t odr_val = 0;

 	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr_val);
 	if (ret != BMP5_OK) {
 		return ret;
 	}
 	odr_val = BMP5_SET_BITSLICE(odr_val, BMP5_ODR, odr->val1);
 	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr_val);
 	get_osr_odr_press_config(&drv->osr_odr_press_config, dev);

 	return ret;
 }

 static int soft_reset(const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = 0;
 	const uint8_t reset_cmd = BMP5_SOFT_RESET_CMD;
 	uint8_t int_status = 0;

 	CHECKIF(dev == NULL) {
 		return -EINVAL;
 	}

 	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_CMD, reset_cmd);

 	if (ret == BMP5_OK) {
 		k_usleep(BMP5_DELAY_US_SOFT_RESET);
 		ret = get_interrupt_status(&int_status, dev);
 		if (ret == BMP5_OK) {
 			if (int_status & BMP5_INT_ASSERTED_POR_SOFTRESET_COMPLETE) {
 				ret = BMP5_OK;
 			} else {
 				ret = -EFAULT;
 			}
 		}
 	} else {
 		LOG_DBG("Failed perform soft-reset.");
 	}

 	return ret;
 }

 static int bmp581_sample_fetch(const struct device *dev, enum sensor_channel chan)
 {
 	CHECKIF(dev == NULL) {
 		return -EINVAL;
 	}

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

 	struct bmp581_data *drv = (struct bmp581_data *)dev->data;
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	uint8_t data[6];
 	int ret = 0;

 	ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_TEMP_DATA_XLSB, data, 6);
 	if (ret == BMP5_OK) {
 		/* convert raw sensor data to sensor_value. Shift the decimal part by 1 decimal
 		 * place to compensate for the conversion in sensor_value_to_double()
 		 */
 		drv->last_sample.temperature.val1 = data[2];
 		drv->last_sample.temperature.val2 = (data[1] << 8 | data[0]) * 10;

 		if (drv->osr_odr_press_config.press_en == BMP5_ENABLE) {
 			uint32_t raw_pressure = (uint32_t)((uint32_t)(data[5] << 16) |
 							   (uint16_t)(data[4] << 8) | data[3]);
 			/* convert raw sensor data to sensor_value. Shift the decimal part by
 			 * 4 decimal places to compensate for the conversion in
 			 * sensor_value_to_double()
 			 */
 			drv->last_sample.pressure.val1 = raw_pressure >> 6;
 			drv->last_sample.pressure.val2 = (raw_pressure & BIT_MASK(6)) * 10000;
 		} else {
 			drv->last_sample.pressure.val1 = 0;
 			drv->last_sample.pressure.val2 = 0;
 		}
 	}

 	return ret;
 }

 static int bmp581_channel_get(const struct device *dev, enum sensor_channel chan,
 			      struct sensor_value *val)
 {
 	CHECKIF(dev == NULL || val == NULL) {
 		return -EINVAL;
 	}

 	struct bmp581_data *drv = (struct bmp581_data *)dev->data;

 	switch (chan) {
 	case SENSOR_CHAN_PRESS:
 		/* returns pressure in Pa */
 		*val = drv->last_sample.pressure;
 		return BMP5_OK;
 	case SENSOR_CHAN_AMBIENT_TEMP:
 		/* returns temperature in Celcius */
 		*val = drv->last_sample.temperature;
 		return BMP5_OK;
 	default:
 		return -ENOTSUP;
 	}
 }

 static int set_iir_config(const struct sensor_value *iir, const struct device *dev)
 {
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = BMP5_OK;

 	CHECKIF((iir == NULL) | (dev == NULL)) {
 		return -EINVAL;
 	}

 	/* Variable to store existing powermode */
 	enum bmp5_powermode prev_powermode;

 	ret = get_power_mode(&prev_powermode, dev);
 	if (ret != BMP5_OK) {
 		LOG_DBG("Not able to get current power mode.");
 		return ret;
 	}
 	/* IIR configuration is writable only during STANDBY mode(as per datasheet) */
 	set_power_mode(BMP5_POWERMODE_STANDBY, dev);

 	/* update IIR config */
 	uint8_t dsp_config[2];

 	ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);
 	if (ret != BMP5_OK) {
 		LOG_DBG("Failed to read dsp config register.");
 		return ret;
 	}
 	/* Put IIR filtered values in data registers */
 	dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_TEMP, BMP5_ENABLE);
 	dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_PRESS, BMP5_ENABLE);

 	/* Configure IIR filter */
 	dsp_config[1] = iir->val1;
 	dsp_config[1] = BMP5_SET_BITSLICE(dsp_config[1], BMP5_SET_IIR_PRESS, iir->val2);

 	/* Set IIR configuration */
 	ret = i2c_burst_write_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);

 	if (ret != BMP5_OK) {
 		LOG_DBG("Failed to configure IIR filter.");
 		return ret;
 	}

 	/* Restore previous power mode if it is not standby already */
 	if (prev_powermode != BMP5_POWERMODE_STANDBY) {
 		ret = set_power_mode(prev_powermode, dev);
 	}

 	return ret;
 }

 static int bmp581_attr_set(const struct device *dev, enum sensor_channel chan,
 			   enum sensor_attribute attr, const struct sensor_value *val)
 {
 	CHECKIF(dev == NULL || val == NULL) {
 		return -EINVAL;
 	}

 	int ret;

 	switch ((int)attr) {
 	case SENSOR_ATTR_SAMPLING_FREQUENCY:
 		ret = set_odr_config(val, dev);
 		break;
 	case SENSOR_ATTR_OVERSAMPLING:
 		ret = set_osr_config(val, chan, dev);
 		break;
 	case BMP5_ATTR_POWER_MODE: {
 		enum bmp5_powermode powermode = (enum bmp5_powermode)val->val1;

 		ret = set_power_mode(powermode, dev);
 		break;
 	}
 	case BMP5_ATTR_IIR_CONFIG:
 		ret = set_iir_config(val, dev);
 		break;
 	default:
 		ret = -ENOTSUP;
 		break;
 	}
 	return ret;
 }

 static int bmp581_init(const struct device *dev)
 {
 	CHECKIF(dev == NULL) {
 		return -EINVAL;
 	}

 	struct bmp581_data *drv = (struct bmp581_data *)dev->data;
 	struct bmp581_config *conf = (struct bmp581_config *)dev->config;
 	int ret = -1;

 	/* Reset the chip id. */
 	drv->chip_id = 0;
 	memset(&drv->osr_odr_press_config, 0, sizeof(drv->osr_odr_press_config));
 	memset(&drv->last_sample, 0, sizeof(drv->last_sample));

 	soft_reset(dev);

 	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_CHIP_ID, &drv->chip_id);
 	if (ret != BMP5_OK) {
 		return ret;
 	}

 	if (drv->chip_id != 0) {
 		ret = power_up_check(dev);
 		if (ret == BMP5_OK) {
 			ret = validate_chip_id(drv);
 			if (ret != BMP5_OK) {
 				LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)",
 					drv->chip_id, BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
 			}
 		}
 	} else {
 		/* that means something went wrong */
 		LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)", drv->chip_id,
 			BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
 		return -EINVAL;
 	}
 	return ret;
 }

 static const struct sensor_driver_api bmp581_driver_api = {.sample_fetch = bmp581_sample_fetch,
 							   .channel_get = bmp581_channel_get,
 							   .attr_set = bmp581_attr_set};

 #define BMP581_CONFIG(i)                                                                           \
 	static const struct bmp581_config bmp581_config_##i = {                                    \
 		.i2c = I2C_DT_SPEC_INST_GET(i),                                                    \
 	}

 #define BMP581_INIT(i)                                                                             \
 	static struct bmp581_data bmp581_data_##i;                                                 \
 	BMP581_CONFIG(i);                                                                          \
                                                                                                    \
 	SENSOR_DEVICE_DT_INST_DEFINE(i, bmp581_init, NULL, &bmp581_data_##i, &bmp581_config_##i,   \
 				     POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY,                     \
 				     &bmp581_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(BMP581_INIT)
	/*
	* Copyright (c) 2022 Badgerd Technologies B.V.
	* Copyright (c) 2023 Metratec GmbH
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include "bmp581.h"

	#include <math.h>

	#include <zephyr/device.h>
	#include <zephyr/drivers/gpio.h>
	#include <zephyr/drivers/i2c.h>
	#include <zephyr/drivers/sensor.h>
	#include <zephyr/init.h>
	#include <zephyr/logging/log.h>
	#include <zephyr/sys/check.h>

	LOG_MODULE_REGISTER(bmp581, CONFIG_SENSOR_LOG_LEVEL);

	#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
	#warning "BMP581 driver enabled without any devices"
	#endif

	static int power_up_check(const struct device *dev);
	static int get_nvm_status(uint8_t nvm_status, const struct device dev);
	static int get_interrupt_status(uint8_t int_status, const struct device dev);
	static int validate_chip_id(struct bmp581_data *drv);
	static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
	const struct device *dev);
	static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
	const struct device *dev);
	static int set_odr_config(const struct sensor_value odr, const struct device dev);
	static int soft_reset(const struct device *dev);
	static int set_iir_config(const struct sensor_value iir, const struct device dev);
	static int get_power_mode(enum bmp5_powermode powermode, const struct device dev);
	static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev);

	static int set_power_mode(enum bmp5_powermode powermode, const struct device *dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = BMP5_OK;
	uint8_t odr = 0;
	enum bmp5_powermode current_powermode;

	CHECKIF(dev == NULL) {
	return -EINVAL;
	}

	ret = get_power_mode(&current_powermode, dev);
	if (ret != BMP5_OK) {
	LOG_ERR("Couldnt set the power mode because something went wrong when getting the "
	"current power mode.");
	return ret;
	}

	if (current_powermode != BMP5_POWERMODE_STANDBY) {
	/*
	* Device should be set to standby before transitioning to forced mode or normal
	* mode or continuous mode.
	*/

	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr);
	if (ret == BMP5_OK) {
	/* Setting deep_dis = 1(BMP5_DEEP_DISABLED) disables the deep standby mode
	*/
	odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
	odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, BMP5_POWERMODE_STANDBY);
	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);

	if (ret != BMP5_OK) {
	LOG_DBG("Failed to set power mode to BMP5_POWERMODE_STANDBY.");
	return ret;
	}
	}
	}

	/* lets update the power mode */
	switch (powermode) {
	case BMP5_POWERMODE_STANDBY:
	/* this change is already done so we can just return */
	ret = BMP5_OK;
	break;
	case BMP5_POWERMODE_DEEP_STANDBY:
	LOG_DBG("Setting power mode to DEEP STANDBY is not supported, current power mode "
	"is BMP5_POWERMODE_STANDBY.");
	ret = -ENOTSUP;
	break;
	case BMP5_POWERMODE_NORMAL:
	case BMP5_POWERMODE_FORCED:
	case BMP5_POWERMODE_CONTINUOUS:
	odr = BMP5_SET_BITSLICE(odr, BMP5_DEEP_DISABLE, BMP5_DEEP_DISABLED);
	odr = BMP5_SET_BITS_POS_0(odr, BMP5_POWERMODE, powermode);
	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr);
	break;
	default:
	/* invalid power mode */
	ret = -EINVAL;
	break;
	}

	return ret;
	}

	static int get_power_mode(enum bmp5_powermode powermode, const struct device dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = BMP5_OK;

	CHECKIF(powermode == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	uint8_t reg = 0;
	uint8_t raw_power_mode = 0;

	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &reg);
	if (ret != BMP5_OK) {
	LOG_DBG("Failed to read odr config to get power mode!");
	return ret;
	}

	raw_power_mode = BMP5_GET_BITS_POS_0(reg, BMP5_POWERMODE);

	switch (raw_power_mode) {
	case BMP5_POWERMODE_STANDBY: {
	/* Getting deep disable status */
	uint8_t deep_dis = BMP5_GET_BITSLICE(reg, BMP5_DEEP_DISABLE);

	/* Checking deepstandby status only when powermode is in standby mode */

	/* If deep_dis = 0(BMP5_DEEP_ENABLED) then deepstandby mode is enabled.
	* If deep_dis = 1(BMP5_DEEP_DISABLED) then deepstandby mode is disabled
	*/
	if (deep_dis == BMP5_DEEP_ENABLED) {
	/* TODO: check if it is really deep standby */
	*powermode = BMP5_POWERMODE_DEEP_STANDBY;
	} else {
	*powermode = BMP5_POWERMODE_STANDBY;
	}

	break;
	}
	case BMP5_POWERMODE_NORMAL:
	*powermode = BMP5_POWERMODE_NORMAL;
	break;
	case BMP5_POWERMODE_FORCED:
	*powermode = BMP5_POWERMODE_FORCED;
	break;
	case BMP5_POWERMODE_CONTINUOUS:
	*powermode = BMP5_POWERMODE_CONTINUOUS;
	break;
	default:
	/* invalid power mode */
	ret = -EINVAL;
	LOG_DBG("Something went wrong invalid powermode!");
	break;
	}

	return ret;
	}

	static int power_up_check(const struct device *dev)
	{
	int8_t rslt = 0;
	uint8_t nvm_status = 0;

	CHECKIF(dev == NULL) {
	return -EINVAL;
	}

	rslt = get_nvm_status(&nvm_status, dev);

	if (rslt == BMP5_OK) {
	/* Check if nvm_rdy status = 1 and nvm_err status = 0 to proceed */
	if ((nvm_status & BMP5_INT_NVM_RDY) && (!(nvm_status & BMP5_INT_NVM_ERR))) {
	rslt = BMP5_OK;
	} else {
	rslt = -EFAULT;
	}
	}

	return rslt;
	}

	static int get_interrupt_status(uint8_t int_status, const struct device dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;

	CHECKIF(int_status == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_INT_STATUS, int_status);
	}

	static int get_nvm_status(uint8_t nvm_status, const struct device dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;

	CHECKIF(nvm_status == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	return i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_STATUS, nvm_status);
	}

	static int validate_chip_id(struct bmp581_data *drv)
	{
	int8_t rslt = 0;

	CHECKIF(drv == NULL) {
	return -EINVAL;
	}

	if ((drv->chip_id == BMP5_CHIP_ID_PRIM) \|\| (drv->chip_id == BMP5_CHIP_ID_SEC)) {
	rslt = BMP5_OK;
	} else {
	drv->chip_id = 0;
	rslt = -ENODEV;
	}

	return rslt;
	}

	/*!
	* This API gets the configuration for oversampling of temperature, oversampling of
	* pressure and ODR configuration along with pressure enable.
	*/
	static int get_osr_odr_press_config(struct bmp581_osr_odr_press_config *osr_odr_press_cfg,
	const struct device *dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;

	/* Variable to store the function result */
	int8_t rslt = 0;

	/* Variable to store OSR and ODR config */
	uint8_t reg_data[2] = {0};

	CHECKIF(osr_odr_press_cfg == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	/* Get OSR and ODR configuration in burst read */
	rslt = i2c_burst_read_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, reg_data, 2);

	if (rslt == BMP5_OK) {
	osr_odr_press_cfg->osr_t = BMP5_GET_BITS_POS_0(reg_data[0], BMP5_TEMP_OS);
	osr_odr_press_cfg->osr_p = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_OS);
	osr_odr_press_cfg->press_en = BMP5_GET_BITSLICE(reg_data[0], BMP5_PRESS_EN);
	osr_odr_press_cfg->odr = BMP5_GET_BITSLICE(reg_data[1], BMP5_ODR);
	}

	return rslt;
	}

	static int set_osr_config(const struct sensor_value *osr, enum sensor_channel chan,
	const struct device *dev)
	{
	CHECKIF(osr == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	struct bmp581_data drv = (struct bmp581_data )dev->data;
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = 0;

	uint8_t oversampling = osr->val1;
	uint8_t press_en = osr->val2 != 0; /* if it is not 0 then pressure is enabled */
	uint8_t osr_val = 0;

	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, &osr_val);
	if (ret == BMP5_OK) {
	switch (chan) {
	case SENSOR_CHAN_ALL:
	osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
	osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
	osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
	break;
	case SENSOR_CHAN_PRESS:
	osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_OS, oversampling);
	osr_val = BMP5_SET_BITSLICE(osr_val, BMP5_PRESS_EN, press_en);
	break;
	case SENSOR_CHAN_AMBIENT_TEMP:
	osr_val = BMP5_SET_BITS_POS_0(osr_val, BMP5_TEMP_OS, oversampling);
	break;
	default:
	ret = -ENOTSUP;
	break;
	}

	if (ret == BMP5_OK) {
	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_OSR_CONFIG, osr_val);
	get_osr_odr_press_config(&drv->osr_odr_press_config, dev);
	}
	}

	return ret;
	}

	static int set_odr_config(const struct sensor_value odr, const struct device dev)
	{
	CHECKIF(odr == NULL \|\| dev == NULL) {
	return -EINVAL;
	}

	struct bmp581_data drv = (struct bmp581_data )dev->data;
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = 0;
	uint8_t odr_val = 0;

	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, &odr_val);
	if (ret != BMP5_OK) {
	return ret;
	}
	odr_val = BMP5_SET_BITSLICE(odr_val, BMP5_ODR, odr->val1);
	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_ODR_CONFIG, odr_val);
	get_osr_odr_press_config(&drv->osr_odr_press_config, dev);

	return ret;
	}

	static int soft_reset(const struct device *dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = 0;
	const uint8_t reset_cmd = BMP5_SOFT_RESET_CMD;
	uint8_t int_status = 0;

	CHECKIF(dev == NULL) {
	return -EINVAL;
	}

	ret = i2c_reg_write_byte_dt(&conf->i2c, BMP5_REG_CMD, reset_cmd);

	if (ret == BMP5_OK) {
	k_usleep(BMP5_DELAY_US_SOFT_RESET);
	ret = get_interrupt_status(&int_status, dev);
	if (ret == BMP5_OK) {
	if (int_status & BMP5_INT_ASSERTED_POR_SOFTRESET_COMPLETE) {
	ret = BMP5_OK;
	} else {
	ret = -EFAULT;
	}
	}
	} else {
	LOG_DBG("Failed perform soft-reset.");
	}

	return ret;
	}

	static int bmp581_sample_fetch(const struct device *dev, enum sensor_channel chan)
	{
	CHECKIF(dev == NULL) {
	return -EINVAL;
	}

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

	struct bmp581_data drv = (struct bmp581_data )dev->data;
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	uint8_t data[6];
	int ret = 0;

	ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_TEMP_DATA_XLSB, data, 6);
	if (ret == BMP5_OK) {
	/* convert raw sensor data to sensor_value. Shift the decimal part by 1 decimal
	* place to compensate for the conversion in sensor_value_to_double()
	*/
	drv->last_sample.temperature.val1 = data[2];
	drv->last_sample.temperature.val2 = (data[1] << 8 \| data[0]) * 10;

	if (drv->osr_odr_press_config.press_en == BMP5_ENABLE) {
	uint32_t raw_pressure = (uint32_t)((uint32_t)(data[5] << 16) \|
	(uint16_t)(data[4] << 8) \| data[3]);
	/* convert raw sensor data to sensor_value. Shift the decimal part by
	* 4 decimal places to compensate for the conversion in
	* sensor_value_to_double()
	*/
	drv->last_sample.pressure.val1 = raw_pressure >> 6;
	drv->last_sample.pressure.val2 = (raw_pressure & BIT_MASK(6)) * 10000;
	} else {
	drv->last_sample.pressure.val1 = 0;
	drv->last_sample.pressure.val2 = 0;
	}
	}

	return ret;
	}

	static int bmp581_channel_get(const struct device *dev, enum sensor_channel chan,
	struct sensor_value *val)
	{
	CHECKIF(dev == NULL \|\| val == NULL) {
	return -EINVAL;
	}

	struct bmp581_data drv = (struct bmp581_data )dev->data;

	switch (chan) {
	case SENSOR_CHAN_PRESS:
	/* returns pressure in Pa */
	*val = drv->last_sample.pressure;
	return BMP5_OK;
	case SENSOR_CHAN_AMBIENT_TEMP:
	/* returns temperature in Celcius */
	*val = drv->last_sample.temperature;
	return BMP5_OK;
	default:
	return -ENOTSUP;
	}
	}

	static int set_iir_config(const struct sensor_value iir, const struct device dev)
	{
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = BMP5_OK;

	CHECKIF((iir == NULL) \| (dev == NULL)) {
	return -EINVAL;
	}

	/* Variable to store existing powermode */
	enum bmp5_powermode prev_powermode;

	ret = get_power_mode(&prev_powermode, dev);
	if (ret != BMP5_OK) {
	LOG_DBG("Not able to get current power mode.");
	return ret;
	}
	/* IIR configuration is writable only during STANDBY mode(as per datasheet) */
	set_power_mode(BMP5_POWERMODE_STANDBY, dev);

	/* update IIR config */
	uint8_t dsp_config[2];

	ret = i2c_burst_read_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);
	if (ret != BMP5_OK) {
	LOG_DBG("Failed to read dsp config register.");
	return ret;
	}
	/* Put IIR filtered values in data registers */
	dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_TEMP, BMP5_ENABLE);
	dsp_config[0] = BMP5_SET_BITSLICE(dsp_config[0], BMP5_SHDW_SET_IIR_PRESS, BMP5_ENABLE);

	/* Configure IIR filter */
	dsp_config[1] = iir->val1;
	dsp_config[1] = BMP5_SET_BITSLICE(dsp_config[1], BMP5_SET_IIR_PRESS, iir->val2);

	/* Set IIR configuration */
	ret = i2c_burst_write_dt(&conf->i2c, BMP5_REG_DSP_CONFIG, dsp_config, 2);

	if (ret != BMP5_OK) {
	LOG_DBG("Failed to configure IIR filter.");
	return ret;
	}

	/* Restore previous power mode if it is not standby already */
	if (prev_powermode != BMP5_POWERMODE_STANDBY) {
	ret = set_power_mode(prev_powermode, dev);
	}

	return ret;
	}

	static int bmp581_attr_set(const struct device *dev, enum sensor_channel chan,
	enum sensor_attribute attr, const struct sensor_value *val)
	{
	CHECKIF(dev == NULL \|\| val == NULL) {
	return -EINVAL;
	}

	int ret;

	switch ((int)attr) {
	case SENSOR_ATTR_SAMPLING_FREQUENCY:
	ret = set_odr_config(val, dev);
	break;
	case SENSOR_ATTR_OVERSAMPLING:
	ret = set_osr_config(val, chan, dev);
	break;
	case BMP5_ATTR_POWER_MODE: {
	enum bmp5_powermode powermode = (enum bmp5_powermode)val->val1;

	ret = set_power_mode(powermode, dev);
	break;
	}
	case BMP5_ATTR_IIR_CONFIG:
	ret = set_iir_config(val, dev);
	break;
	default:
	ret = -ENOTSUP;
	break;
	}
	return ret;
	}

	static int bmp581_init(const struct device *dev)
	{
	CHECKIF(dev == NULL) {
	return -EINVAL;
	}

	struct bmp581_data drv = (struct bmp581_data )dev->data;
	struct bmp581_config conf = (struct bmp581_config )dev->config;
	int ret = -1;

	/* Reset the chip id. */
	drv->chip_id = 0;
	memset(&drv->osr_odr_press_config, 0, sizeof(drv->osr_odr_press_config));
	memset(&drv->last_sample, 0, sizeof(drv->last_sample));

	soft_reset(dev);

	ret = i2c_reg_read_byte_dt(&conf->i2c, BMP5_REG_CHIP_ID, &drv->chip_id);
	if (ret != BMP5_OK) {
	return ret;
	}

	if (drv->chip_id != 0) {
	ret = power_up_check(dev);
	if (ret == BMP5_OK) {
	ret = validate_chip_id(drv);
	if (ret != BMP5_OK) {
	LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)",
	drv->chip_id, BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
	}
	}
	} else {
	/* that means something went wrong */
	LOG_ERR("Unexpected chip id (%x). Expected (%x or %x)", drv->chip_id,
	BMP5_CHIP_ID_PRIM, BMP5_CHIP_ID_SEC);
	return -EINVAL;
	}
	return ret;
	}

	static const struct sensor_driver_api bmp581_driver_api = {.sample_fetch = bmp581_sample_fetch,
	.channel_get = bmp581_channel_get,
	.attr_set = bmp581_attr_set};

	#define BMP581_CONFIG(i) \
	static const struct bmp581_config bmp581_config_##i = { \
	.i2c = I2C_DT_SPEC_INST_GET(i), \
	}

	#define BMP581_INIT(i) \
	static struct bmp581_data bmp581_data_##i; \
	BMP581_CONFIG(i); \
	\
	SENSOR_DEVICE_DT_INST_DEFINE(i, bmp581_init, NULL, &bmp581_data_##i, &bmp581_config_##i, \
	POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
	&bmp581_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(BMP581_INIT)