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

 /*
  * Copyright 2021 The Chromium OS Authors
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT ti_ina23x

 #include <sys/byteorder.h>
 #include <device.h>
 #include <drivers/gpio.h>
 #include <drivers/i2c.h>
 #include <logging/log.h>
 #include <drivers/sensor.h>

 #include "ina23x.h"

 LOG_MODULE_REGISTER(INA23X, CONFIG_SENSOR_LOG_LEVEL);

 /**
  * @brief Macro used to test if the current's sign bit is set
  */
 #define CURRENT_SIGN_BIT        0x8000

 /**
  * @brief Macro used to check if the current's LSB is 1mA
  */
 #define CURRENT_LSB_1MA         1

 /**
  * @brief Macro for creating the INA23X calibration value
  *        CALIB = (5120 / (current_lsb * rshunt))
  *        NOTE: The 5120 value is a fixed value internal to the
  *              INA23X that is used to ensure scaling is properly
  *              maintained.
  *
  * @param current_lsb Value of the Current register LSB in milliamps
  * @param rshunt Shunt resistor value in milliohms
  */
  #define INA23X_CALIB(current_lsb, rshunt) (5120 / ((current_lsb) * (rshunt)))

 /**
  * @brief Macro to convert raw Bus voltage to millivolts when current_lsb is
  *        set to 1mA.
  *
  * reg value read from bus voltage register
  * clsb value of current_lsb
  */
 #define INA23X_BUS_MV(reg) ((reg) * 125 / 100)

 /**
  * @brief Macro to convert raw power value to milliwatts when current_lsb is
  *        set to 1mA.
  *
  * reg value read from power register
  * clsb value of current_lsb
  */
 #define INA23X_POW_MW(reg) ((reg) * 25)

 static int ina23x_reg_read(const struct device *dev, uint8_t reg, int16_t *val)
 {
 	const struct ina23x_config *const config = dev->config;
 	uint8_t data[2];
 	int ret;

 	ret = i2c_burst_read(config->bus, config->i2c_slv_addr, reg, data, 2);
 	if (ret < 0) {
 		return ret;
 	}

 	*val = sys_get_be16(data);

 	return ret;
 }

 static int ina23x_reg_write(const struct device *dev, uint8_t reg, uint16_t val)
 {
 	const struct ina23x_config *const config = dev->config;
 	uint8_t tx_buf[3];

 	tx_buf[0] = reg;
 	sys_put_be16(val, &tx_buf[1]);

 	return i2c_write(config->bus, tx_buf, sizeof(tx_buf), config->i2c_slv_addr);
 }

 /**
  * @brief sensor value get
  *
  * @return 0 for success
  * @return -ENOTSUP for unsupported channels
  */
 static int ina23x_channel_get(const struct device *dev,
 			      enum sensor_channel chan,
 			      struct sensor_value *val)
 {
 	struct ina23x_data *ina23x = dev->data;
 	const struct ina23x_config *const config = dev->config;

 	switch (chan) {
 	case SENSOR_CHAN_VOLTAGE:
 		if (config->current_lsb == CURRENT_LSB_1MA) {
 			val->val1 = INA23X_BUS_MV(ina23x->bus_voltage) / 1000U;
 			val->val2 = (INA23X_BUS_MV(ina23x->bus_voltage) % 1000) * 1000;
 		} else {
 			val->val1 = ina23x->bus_voltage;
 			val->val2 = 0;
 		}
 		break;

 	case SENSOR_CHAN_CURRENT:
 		if (config->current_lsb == CURRENT_LSB_1MA) {
 			/**
 			 * If current is negative, convert it to a
 			 * magnitude and return the negative of that
 			 * magnitude.
 			 */
 			if (ina23x->current & CURRENT_SIGN_BIT) {
 				uint16_t current_mag = (~ina23x->current + 1);

 				val->val1 = -(current_mag / 1000U);
 				val->val2 = -(current_mag % 1000) * 1000;
 			} else {
 				val->val1 = ina23x->current / 1000U;
 				val->val2 = (ina23x->current % 1000) * 1000;
 			}
 		} else {
 			val->val1 = ina23x->current;
 			val->val2 = 0;
 		}
 		break;

 	case SENSOR_CHAN_POWER:
 		if (config->current_lsb == CURRENT_LSB_1MA) {
 			val->val1 = INA23X_POW_MW(ina23x->power) / 1000U;
 			val->val2 = (INA23X_POW_MW(ina23x->power) % 1000) * 1000;
 		} else {
 			val->val1 = ina23x->power;
 			val->val2 = 0;
 		}
 		break;

 	default:
 		return -ENOTSUP;
 	}

 	return 0;
 }

 /**
  * @brief sensor sample fetch
  *
  * @return 0 for success
  * @return -ENOTSUP for unsupported channels
  */
 static int ina23x_sample_fetch(const struct device *dev,
 			       enum sensor_channel chan)
 {
 	struct ina23x_data *ina23x = dev->data;
 	int ret;

 	switch (chan) {
 	case SENSOR_CHAN_VOLTAGE:
 		ret = ina23x_reg_read(dev, INA23X_REG_BUS_VOLT, &ina23x->bus_voltage);
 		if (ret < 0) {
 			LOG_ERR("Failed to read bus voltage");
 			return ret;
 		}
 		break;

 	case SENSOR_CHAN_CURRENT:
 		ret = ina23x_reg_read(dev, INA23X_REG_CURRENT, &ina23x->current);
 		if (ret < 0) {
 			LOG_ERR("Failed to read current");
 			return ret;
 		}
 		break;

 	case SENSOR_CHAN_POWER:
 		ret = ina23x_reg_read(dev, INA23X_REG_POWER, &ina23x->power);
 		if (ret < 0) {
 			LOG_ERR("Failed to read power");
 			return ret;
 		}
 		break;

 	default:
 		return -ENOTSUP;
 	}

 	return 0;
 }

 /**
  * @brief sensor attribute set
  *
  * @return 0 for success
  * @return -ENOTSUP for unsupported channels
  * @return -EIO for i2c write failure
  */
 static int ina23x_attr_set(const struct device *dev, enum sensor_channel chan,
 			   enum sensor_attribute attr,
 			   const struct sensor_value *val)
 {
 	uint16_t data = val->val1;

 	switch (attr) {
 	case SENSOR_ATTR_CONFIGURATION:
 		return ina23x_reg_write(dev, INA23X_REG_CONFIG, data);
 	case SENSOR_ATTR_CALIBRATION:
 		return ina23x_reg_write(dev, INA23X_REG_CALIB, data);
 	case SENSOR_ATTR_FEATURE_MASK:
 		return ina23x_reg_write(dev, INA23X_REG_MASK, data);
 	case SENSOR_ATTR_ALERT:
 		return ina23x_reg_write(dev, INA23X_REG_ALERT, data);
 	default:
 		LOG_ERR("INA23X attribute not supported.");
 		return -ENOTSUP;
 	}
 }

 /**
  * @brief sensor attribute get
  *
  * @return 0 for success
  * @return -ENOTSUP for unsupported channels
  * @return -EIO for i2c read failure
  */
 static int ina23x_attr_get(const struct device *dev, enum sensor_channel chan,
 			   enum sensor_attribute attr,
 			   struct sensor_value *val)
 {
 	uint16_t data;
 	int ret;

 	switch (attr) {
 	case SENSOR_ATTR_CONFIGURATION:
 		ret = ina23x_reg_read(dev, INA23X_REG_CONFIG, &data);
 		if (ret < 0) {
 			return ret;
 		}
 		break;
 	case SENSOR_ATTR_CALIBRATION:
 		ret = ina23x_reg_read(dev, INA23X_REG_CALIB, &data);
 		if (ret < 0) {
 			return ret;
 		}
 		break;
 	case SENSOR_ATTR_FEATURE_MASK:
 		ret = ina23x_reg_read(dev, INA23X_REG_MASK, &data);
 		if (ret < 0) {
 			return ret;
 		}
 		break;
 	case SENSOR_ATTR_ALERT:
 		ret = ina23x_reg_read(dev, INA23X_REG_ALERT, &data);
 		if (ret < 0) {
 			return ret;
 		}
 		break;
 	default:
 		LOG_ERR("INA23X attribute not supported.");
 		return -ENOTSUP;
 	}

 	val->val1 = data;
 	val->val2 = 0;

 	return 0;
 }

 /**
  * @brief Initialize the INA23x
  *
  * @return 0 for success
  * @return -EINVAL on error
  */
 static int ina23x_init(const struct device *dev)
 {
 	const struct ina23x_config *const config = dev->config;
 	uint16_t cal;
 	int ret;

 	if (!device_is_ready(config->bus)) {
 		LOG_ERR("Device %s is not ready", config->bus->name);
 		return -ENODEV;
 	}

 	ret = ina23x_reg_write(dev, INA23X_REG_CONFIG, config->config);
 	if (ret < 0) {
 		LOG_ERR("Failed to write configuration register!");
 		return ret;
 	}

 	cal = INA23X_CALIB(config->current_lsb, config->rshunt);

 	ret = ina23x_reg_write(dev, INA23X_REG_CALIB, cal);
 	if (ret < 0) {
 		LOG_ERR("Failed to write calibration register!");
 		return ret;
 	}

 #ifdef CONFIG_INA23X_TRIGGER
 	if (config->trig_enabled) {
 		ret = ina23x_trigger_mode_init(dev);
 		if (ret < 0) {
 			LOG_ERR("Failed to init trigger mode\n");
 			return ret;
 		}

 		ret = ina23x_reg_write(dev, INA23X_REG_ALERT,
 				       config->alert_limit);
 		if (ret < 0) {
 			LOG_ERR("Failed to write alert register!");
 			return ret;
 		}

 		ret = ina23x_reg_write(dev, INA23X_REG_MASK, config->mask);
 		if (ret < 0) {
 			LOG_ERR("Failed to write mask register!");
 			return ret;
 		}
 	}
 #endif  /* CONFIG_INA23X_TRIGGER */

 	return 0;
 }

 static const struct sensor_driver_api ina23x_driver_api = {
 	.attr_set = ina23x_attr_set,
 	.attr_get = ina23x_attr_get,
 #ifdef CONFIG_INA23X_TRIGGER
 	.trigger_set = ina23x_trigger_set,
 #endif
 	.sample_fetch = ina23x_sample_fetch,
 	.channel_get = ina23x_channel_get,
 };

 BUILD_ASSERT(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) > 0,
 	     "No compatible ina23x instances found");

 #ifdef CONFIG_INA23X_TRIGGER
 #define INA23X_CFG_IRQ(inst)				\
 	.trig_enabled = true,				\
 	.mask = DT_INST_PROP(inst, mask),		\
 	.alert_limit = DT_INST_PROP(inst, alert_limit),	\
 	.gpio_alert = GPIO_DT_SPEC_INST_GET(inst, irq_gpios)
 #else
 #define INA23X_CFG_IRQ(inst)
 #endif /* CONFIG_INA23X_TRIGGER */

 #define INA23X_DRIVER_INIT(inst)				    \
 	static struct ina23x_data drv_data_##inst;		    \
 	static const struct ina23x_config drv_config_##inst = {	    \
 		.bus = DEVICE_DT_GET(DT_INST_BUS(inst)),	    \
 		.i2c_slv_addr = DT_INST_REG_ADDR(inst),		    \
 		.config = DT_INST_PROP(inst, config),		    \
 		.current_lsb = DT_INST_PROP(inst, current_lsb),	    \
 		.rshunt = DT_INST_PROP(inst, rshunt),		    \
 		COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
 			    (INA23X_CFG_IRQ(inst)), ())		    \
 	};							    \
 	DEVICE_DT_INST_DEFINE(inst,				    \
 			      &ina23x_init,			    \
 			      NULL,				    \
 			      &drv_data_##inst,			    \
 			      &drv_config_##inst,		    \
 			      POST_KERNEL,			    \
 			      CONFIG_SENSOR_INIT_PRIORITY,	    \
 			      &ina23x_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(INA23X_DRIVER_INIT)
	/*
	* Copyright 2021 The Chromium OS Authors
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT ti_ina23x

	#include <sys/byteorder.h>
	#include <device.h>
	#include <drivers/gpio.h>
	#include <drivers/i2c.h>
	#include <logging/log.h>
	#include <drivers/sensor.h>

	#include "ina23x.h"

	LOG_MODULE_REGISTER(INA23X, CONFIG_SENSOR_LOG_LEVEL);

	/**
	* @brief Macro used to test if the current's sign bit is set
	*/
	#define CURRENT_SIGN_BIT 0x8000

	/**
	* @brief Macro used to check if the current's LSB is 1mA
	*/
	#define CURRENT_LSB_1MA 1

	/**
	* @brief Macro for creating the INA23X calibration value
	* CALIB = (5120 / (current_lsb * rshunt))
	* NOTE: The 5120 value is a fixed value internal to the
	* INA23X that is used to ensure scaling is properly
	* maintained.
	*
	* @param current_lsb Value of the Current register LSB in milliamps
	* @param rshunt Shunt resistor value in milliohms
	*/
	#define INA23X_CALIB(current_lsb, rshunt) (5120 / ((current_lsb) * (rshunt)))

	/**
	* @brief Macro to convert raw Bus voltage to millivolts when current_lsb is
	* set to 1mA.
	*
	* reg value read from bus voltage register
	* clsb value of current_lsb
	*/
	#define INA23X_BUS_MV(reg) ((reg) * 125 / 100)

	/**
	* @brief Macro to convert raw power value to milliwatts when current_lsb is
	* set to 1mA.
	*
	* reg value read from power register
	* clsb value of current_lsb
	*/
	#define INA23X_POW_MW(reg) ((reg) * 25)

	static int ina23x_reg_read(const struct device dev, uint8_t reg, int16_t val)
	{
	const struct ina23x_config *const config = dev->config;
	uint8_t data[2];
	int ret;

	ret = i2c_burst_read(config->bus, config->i2c_slv_addr, reg, data, 2);
	if (ret < 0) {
	return ret;
	}

	*val = sys_get_be16(data);

	return ret;
	}

	static int ina23x_reg_write(const struct device *dev, uint8_t reg, uint16_t val)
	{
	const struct ina23x_config *const config = dev->config;
	uint8_t tx_buf[3];

	tx_buf[0] = reg;
	sys_put_be16(val, &tx_buf[1]);

	return i2c_write(config->bus, tx_buf, sizeof(tx_buf), config->i2c_slv_addr);
	}

	/**
	* @brief sensor value get
	*
	* @return 0 for success
	* @return -ENOTSUP for unsupported channels
	*/
	static int ina23x_channel_get(const struct device *dev,
	enum sensor_channel chan,
	struct sensor_value *val)
	{
	struct ina23x_data *ina23x = dev->data;
	const struct ina23x_config *const config = dev->config;

	switch (chan) {
	case SENSOR_CHAN_VOLTAGE:
	if (config->current_lsb == CURRENT_LSB_1MA) {
	val->val1 = INA23X_BUS_MV(ina23x->bus_voltage) / 1000U;
	val->val2 = (INA23X_BUS_MV(ina23x->bus_voltage) % 1000) * 1000;
	} else {
	val->val1 = ina23x->bus_voltage;
	val->val2 = 0;
	}
	break;

	case SENSOR_CHAN_CURRENT:
	if (config->current_lsb == CURRENT_LSB_1MA) {
	/**
	* If current is negative, convert it to a
	* magnitude and return the negative of that
	* magnitude.
	*/
	if (ina23x->current & CURRENT_SIGN_BIT) {
	uint16_t current_mag = (~ina23x->current + 1);

	val->val1 = -(current_mag / 1000U);
	val->val2 = -(current_mag % 1000) * 1000;
	} else {
	val->val1 = ina23x->current / 1000U;
	val->val2 = (ina23x->current % 1000) * 1000;
	}
	} else {
	val->val1 = ina23x->current;
	val->val2 = 0;
	}
	break;

	case SENSOR_CHAN_POWER:
	if (config->current_lsb == CURRENT_LSB_1MA) {
	val->val1 = INA23X_POW_MW(ina23x->power) / 1000U;
	val->val2 = (INA23X_POW_MW(ina23x->power) % 1000) * 1000;
	} else {
	val->val1 = ina23x->power;
	val->val2 = 0;
	}
	break;

	default:
	return -ENOTSUP;
	}

	return 0;
	}

	/**
	* @brief sensor sample fetch
	*
	* @return 0 for success
	* @return -ENOTSUP for unsupported channels
	*/
	static int ina23x_sample_fetch(const struct device *dev,
	enum sensor_channel chan)
	{
	struct ina23x_data *ina23x = dev->data;
	int ret;

	switch (chan) {
	case SENSOR_CHAN_VOLTAGE:
	ret = ina23x_reg_read(dev, INA23X_REG_BUS_VOLT, &ina23x->bus_voltage);
	if (ret < 0) {
	LOG_ERR("Failed to read bus voltage");
	return ret;
	}
	break;

	case SENSOR_CHAN_CURRENT:
	ret = ina23x_reg_read(dev, INA23X_REG_CURRENT, &ina23x->current);
	if (ret < 0) {
	LOG_ERR("Failed to read current");
	return ret;
	}
	break;

	case SENSOR_CHAN_POWER:
	ret = ina23x_reg_read(dev, INA23X_REG_POWER, &ina23x->power);
	if (ret < 0) {
	LOG_ERR("Failed to read power");
	return ret;
	}
	break;

	default:
	return -ENOTSUP;
	}

	return 0;
	}

	/**
	* @brief sensor attribute set
	*
	* @return 0 for success
	* @return -ENOTSUP for unsupported channels
	* @return -EIO for i2c write failure
	*/
	static int ina23x_attr_set(const struct device *dev, enum sensor_channel chan,
	enum sensor_attribute attr,
	const struct sensor_value *val)
	{
	uint16_t data = val->val1;

	switch (attr) {
	case SENSOR_ATTR_CONFIGURATION:
	return ina23x_reg_write(dev, INA23X_REG_CONFIG, data);
	case SENSOR_ATTR_CALIBRATION:
	return ina23x_reg_write(dev, INA23X_REG_CALIB, data);
	case SENSOR_ATTR_FEATURE_MASK:
	return ina23x_reg_write(dev, INA23X_REG_MASK, data);
	case SENSOR_ATTR_ALERT:
	return ina23x_reg_write(dev, INA23X_REG_ALERT, data);
	default:
	LOG_ERR("INA23X attribute not supported.");
	return -ENOTSUP;
	}
	}

	/**
	* @brief sensor attribute get
	*
	* @return 0 for success
	* @return -ENOTSUP for unsupported channels
	* @return -EIO for i2c read failure
	*/
	static int ina23x_attr_get(const struct device *dev, enum sensor_channel chan,
	enum sensor_attribute attr,
	struct sensor_value *val)
	{
	uint16_t data;
	int ret;

	switch (attr) {
	case SENSOR_ATTR_CONFIGURATION:
	ret = ina23x_reg_read(dev, INA23X_REG_CONFIG, &data);
	if (ret < 0) {
	return ret;
	}
	break;
	case SENSOR_ATTR_CALIBRATION:
	ret = ina23x_reg_read(dev, INA23X_REG_CALIB, &data);
	if (ret < 0) {
	return ret;
	}
	break;
	case SENSOR_ATTR_FEATURE_MASK:
	ret = ina23x_reg_read(dev, INA23X_REG_MASK, &data);
	if (ret < 0) {
	return ret;
	}
	break;
	case SENSOR_ATTR_ALERT:
	ret = ina23x_reg_read(dev, INA23X_REG_ALERT, &data);
	if (ret < 0) {
	return ret;
	}
	break;
	default:
	LOG_ERR("INA23X attribute not supported.");
	return -ENOTSUP;
	}

	val->val1 = data;
	val->val2 = 0;

	return 0;
	}

	/**
	* @brief Initialize the INA23x
	*
	* @return 0 for success
	* @return -EINVAL on error
	*/
	static int ina23x_init(const struct device *dev)
	{
	const struct ina23x_config *const config = dev->config;
	uint16_t cal;
	int ret;

	if (!device_is_ready(config->bus)) {
	LOG_ERR("Device %s is not ready", config->bus->name);
	return -ENODEV;
	}

	ret = ina23x_reg_write(dev, INA23X_REG_CONFIG, config->config);
	if (ret < 0) {
	LOG_ERR("Failed to write configuration register!");
	return ret;
	}

	cal = INA23X_CALIB(config->current_lsb, config->rshunt);

	ret = ina23x_reg_write(dev, INA23X_REG_CALIB, cal);
	if (ret < 0) {
	LOG_ERR("Failed to write calibration register!");
	return ret;
	}

	#ifdef CONFIG_INA23X_TRIGGER
	if (config->trig_enabled) {
	ret = ina23x_trigger_mode_init(dev);
	if (ret < 0) {
	LOG_ERR("Failed to init trigger mode\n");
	return ret;
	}

	ret = ina23x_reg_write(dev, INA23X_REG_ALERT,
	config->alert_limit);
	if (ret < 0) {
	LOG_ERR("Failed to write alert register!");
	return ret;
	}

	ret = ina23x_reg_write(dev, INA23X_REG_MASK, config->mask);
	if (ret < 0) {
	LOG_ERR("Failed to write mask register!");
	return ret;
	}
	}
	#endif /* CONFIG_INA23X_TRIGGER */

	return 0;
	}

	static const struct sensor_driver_api ina23x_driver_api = {
	.attr_set = ina23x_attr_set,
	.attr_get = ina23x_attr_get,
	#ifdef CONFIG_INA23X_TRIGGER
	.trigger_set = ina23x_trigger_set,
	#endif
	.sample_fetch = ina23x_sample_fetch,
	.channel_get = ina23x_channel_get,
	};

	BUILD_ASSERT(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) > 0,
	"No compatible ina23x instances found");

	#ifdef CONFIG_INA23X_TRIGGER
	#define INA23X_CFG_IRQ(inst) \
	.trig_enabled = true, \
	.mask = DT_INST_PROP(inst, mask), \
	.alert_limit = DT_INST_PROP(inst, alert_limit), \
	.gpio_alert = GPIO_DT_SPEC_INST_GET(inst, irq_gpios)
	#else
	#define INA23X_CFG_IRQ(inst)
	#endif /* CONFIG_INA23X_TRIGGER */

	#define INA23X_DRIVER_INIT(inst) \
	static struct ina23x_data drv_data_##inst; \
	static const struct ina23x_config drv_config_##inst = { \
	.bus = DEVICE_DT_GET(DT_INST_BUS(inst)), \
	.i2c_slv_addr = DT_INST_REG_ADDR(inst), \
	.config = DT_INST_PROP(inst, config), \
	.current_lsb = DT_INST_PROP(inst, current_lsb), \
	.rshunt = DT_INST_PROP(inst, rshunt), \
	COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
	(INA23X_CFG_IRQ(inst)), ()) \
	}; \
	DEVICE_DT_INST_DEFINE(inst, \
	&ina23x_init, \
	NULL, \
	&drv_data_##inst, \
	&drv_config_##inst, \
	POST_KERNEL, \
	CONFIG_SENSOR_INIT_PRIORITY, \
	&ina23x_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(INA23X_DRIVER_INIT)