drivers/fuel_gauge/sbs_gauge/emul_sbs_gauge.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright 2022 Google LLC
  * Copyright 2023 Microsoft Corporation
  *
  * SPDX-License-Identifier: Apache-2.0
  *
  * Emulator for SBS 1.1 compliant smart battery fuel gauge.
  */

 #ifdef CONFIG_FUEL_GAUGE
 #define DT_DRV_COMPAT sbs_sbs_gauge_new_api
 #else
 #define DT_DRV_COMPAT sbs_sbs_gauge
 #endif /* CONFIG_FUEL_GAUGE */

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(sbs_sbs_gauge);

 #include <stdbool.h>
 #include <stdint.h>
 #include <zephyr/device.h>
 #include <zephyr/devicetree.h>
 #include <zephyr/drivers/emul.h>
 #include <zephyr/drivers/i2c.h>
 #include <zephyr/drivers/i2c_emul.h>
 #include <zephyr/sys/byteorder.h>
 #include <zephyr/drivers/emul_fuel_gauge.h>
 #include <zephyr/drivers/fuel_gauge.h>
 #include <zephyr/sys/util.h>

 #include "sbs_gauge.h"

 /** Run-time data used by the emulator */
 struct sbs_gauge_emul_data {
 	uint16_t mfr_acc;
 	uint16_t remaining_capacity_alarm;
 	uint16_t remaining_time_alarm;
 	uint16_t mode;
 	int16_t at_rate;
 	/* Whether the battery cutoff or not */
 	bool is_cutoff;
 	/*
 	 * Counts the number of times the cutoff payload has been sent to the designated
 	 * register
 	 */
 	uint8_t cutoff_writes;
 	struct {
 		/* Non-register values associated with the state of the battery */
 		/* Battery terminal voltage */
 		uint32_t uV;
 		/* Battery terminal current - Pos is charging, Neg is discharging */
 		int uA;
 	} batt_state;
 };

 /** Static configuration for the emulator */
 struct sbs_gauge_emul_cfg {
 	/** I2C address of emulator */
 	uint16_t addr;
 	bool cutoff_support;
 	uint32_t cutoff_reg_addr;
 	uint16_t cutoff_payload[SBS_GAUGE_CUTOFF_PAYLOAD_MAX_SIZE];
 };

 static void emul_sbs_gauge_maybe_do_battery_cutoff(const struct emul *target, int reg, int val)
 {
 	struct sbs_gauge_emul_data *data = target->data;
 	const struct sbs_gauge_emul_cfg *cfg = target->cfg;

 	/* Check if this is a cutoff write */
 	if (cfg->cutoff_support && reg == cfg->cutoff_reg_addr) {
 		__ASSERT_NO_MSG(ARRAY_SIZE(cfg->cutoff_payload) > 0);
 		/*
 		 * Calculate the next payload element value for a battery cutoff.
 		 *
 		 * We thoroughly check bounds elsewhere, so we can be confident we're not indexing
 		 * past the end of the array.
 		 */
 		uint16_t target_payload_elem_val = cfg->cutoff_payload[data->cutoff_writes];

 		if (target_payload_elem_val == val) {
 			data->cutoff_writes++;
 			__ASSERT_NO_MSG(data->cutoff_writes <= ARRAY_SIZE(cfg->cutoff_payload));
 		} else {
 			/* Wrong payload target value, reset cutoff sequence detection. */
 			data->cutoff_writes = 0;
 		}

 		if (data->cutoff_writes == ARRAY_SIZE(cfg->cutoff_payload)) {
 			data->is_cutoff = true;
 			data->cutoff_writes = 0;
 		}
 	}
 	/* Not a cutoff write, reset payload counter  */
 	else {
 		data->cutoff_writes = 0;
 	}
 }

 static int emul_sbs_gauge_reg_write(const struct emul *target, int reg, int val)
 {
 	struct sbs_gauge_emul_data *data = target->data;

 	LOG_INF("write %x = %x", reg, val);
 	switch (reg) {
 	case SBS_GAUGE_CMD_MANUFACTURER_ACCESS:
 		data->mfr_acc = val;
 		break;
 	case SBS_GAUGE_CMD_REM_CAPACITY_ALARM:
 		data->remaining_capacity_alarm = val;
 		break;
 	case SBS_GAUGE_CMD_REM_TIME_ALARM:
 		data->remaining_time_alarm = val;
 		break;
 	case SBS_GAUGE_CMD_BATTERY_MODE:
 		data->mode = val;
 		break;
 	case SBS_GAUGE_CMD_AR:
 		data->at_rate = val;
 		break;
 	default:
 		LOG_INF("Unknown write %x", reg);
 		return -EIO;
 	}

 	/*
 	 * One of the above registers is always designated as a "cutoff" register, usually it's
 	 * MANUFACTURER ACCESS, but not always.
 	 */
 	emul_sbs_gauge_maybe_do_battery_cutoff(target, reg, val);

 	return 0;
 }

 static int emul_sbs_gauge_reg_read(const struct emul *target, int reg, int *val)
 {
 	struct sbs_gauge_emul_data *data = target->data;

 	switch (reg) {
 	case SBS_GAUGE_CMD_MANUFACTURER_ACCESS:
 		*val = data->mfr_acc;
 		break;
 	case SBS_GAUGE_CMD_REM_CAPACITY_ALARM:
 		*val = data->remaining_capacity_alarm;
 		break;
 	case SBS_GAUGE_CMD_REM_TIME_ALARM:
 		*val = data->remaining_time_alarm;
 		break;
 	case SBS_GAUGE_CMD_BATTERY_MODE:
 		*val = data->mode;
 		break;
 	case SBS_GAUGE_CMD_AR:
 		*val = data->at_rate;
 		break;
 	case SBS_GAUGE_CMD_VOLTAGE:
 		*val = data->batt_state.uV / 1000;
 		break;
 	case SBS_GAUGE_CMD_CURRENT:
 		*val = data->batt_state.uA / 1000;
 		break;
 	case SBS_GAUGE_CMD_AVG_CURRENT:
 	case SBS_GAUGE_CMD_TEMP:
 	case SBS_GAUGE_CMD_ASOC:
 	case SBS_GAUGE_CMD_RSOC:
 	case SBS_GAUGE_CMD_FULL_CAPACITY:
 	case SBS_GAUGE_CMD_REM_CAPACITY:
 	case SBS_GAUGE_CMD_NOM_CAPACITY:
 	case SBS_GAUGE_CMD_AVG_TIME2EMPTY:
 	case SBS_GAUGE_CMD_AVG_TIME2FULL:
 	case SBS_GAUGE_CMD_RUNTIME2EMPTY:
 	case SBS_GAUGE_CMD_CYCLE_COUNT:
 	case SBS_GAUGE_CMD_DESIGN_VOLTAGE:
 	case SBS_GAUGE_CMD_CHG_CURRENT:
 	case SBS_GAUGE_CMD_CHG_VOLTAGE:
 	case SBS_GAUGE_CMD_FLAGS:
 	case SBS_GAUGE_CMD_ARTTF:
 	case SBS_GAUGE_CMD_ARTTE:
 	case SBS_GAUGE_CMD_AROK:
 		/* Arbitrary stub value. */
 		*val = 1;
 		break;
 	default:
 		LOG_ERR("Unknown register 0x%x read", reg);
 		return -EIO;
 	}
 	LOG_INF("read 0x%x = 0x%x", reg, *val);

 	return 0;
 }

 static int emul_sbs_gauge_buffer_read(const struct emul *target, int reg, char *val)
 {
 	char mfg[] = "ACME";
 	char dev[] = "B123456";
 	char chem[] = "LiPO";
 	struct sbs_gauge_manufacturer_name *mfg_name = (struct sbs_gauge_manufacturer_name *)val;
 	struct sbs_gauge_device_name *dev_name = (struct sbs_gauge_device_name *)val;
 	struct sbs_gauge_device_chemistry *dev_chem = (struct sbs_gauge_device_chemistry *)val;

 	switch (reg) {
 	case SBS_GAUGE_CMD_MANUFACTURER_NAME:
 		mfg_name->manufacturer_name_length = sizeof(mfg);
 		memcpy(mfg_name->manufacturer_name, mfg, mfg_name->manufacturer_name_length);
 		break;
 	case SBS_GAUGE_CMD_DEVICE_NAME:
 		dev_name->device_name_length = sizeof(dev);
 		memcpy(dev_name->device_name, dev, dev_name->device_name_length);
 		break;

 	case SBS_GAUGE_CMD_DEVICE_CHEMISTRY:
 		dev_chem->device_chemistry_length = MIN(sizeof(chem),
 							sizeof(dev_chem->device_chemistry));
 		memcpy(dev_chem->device_chemistry, chem, dev_chem->device_chemistry_length);
 		break;
 	default:
 		LOG_ERR("Unknown register 0x%x read", reg);
 		return -EIO;
 	}

 	return 0;
 }

 static int sbs_gauge_emul_transfer_i2c(const struct emul *target, struct i2c_msg *msgs,
 				       int num_msgs, int addr)
 {
 	/* Largely copied from emul_bmi160.c */
 	struct sbs_gauge_emul_data *data;
 	unsigned int val;
 	int reg;
 	int rc;

 	data = target->data;

 	__ASSERT_NO_MSG(msgs && num_msgs);

 	i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
 	switch (num_msgs) {
 	case 2:
 		if (msgs->flags & I2C_MSG_READ) {
 			LOG_ERR("Unexpected read");
 			return -EIO;
 		}
 		if (msgs->len != 1) {
 			LOG_ERR("Unexpected msg0 length %d", msgs->len);
 			return -EIO;
 		}
 		reg = msgs->buf[0];

 		/* Now process the 'read' part of the message */
 		msgs++;
 		if (msgs->flags & I2C_MSG_READ) {
 			switch (msgs->len) {
 			case 2:
 				rc = emul_sbs_gauge_reg_read(target, reg, &val);
 				if (rc) {
 					/* Return before writing bad value to message buffer */
 					return rc;
 				}

 				/* SBS uses SMBus, which sends data in little-endian format. */
 				sys_put_le16(val, msgs->buf);
 				break;
 					/* buffer properties */
 			case (sizeof(struct sbs_gauge_manufacturer_name)):
 			case (sizeof(struct sbs_gauge_device_chemistry)):
 				rc = emul_sbs_gauge_buffer_read(target, reg, (char *)msgs->buf);
 				break;
 			default:
 				LOG_ERR("Unexpected msg1 length %d", msgs->len);
 				return -EIO;
 			}
 		} else {
 			/* We write a word (2 bytes by the SBS spec) */
 			if (msgs->len != 2) {
 				LOG_ERR("Unexpected msg1 length %d", msgs->len);
 			}
 			uint16_t value = sys_get_le16(msgs->buf);

 			rc = emul_sbs_gauge_reg_write(target, reg, value);
 		}
 		break;
 	default:
 		LOG_ERR("Invalid number of messages: %d", num_msgs);
 		return -EIO;
 	}

 	return rc;
 }

 static int emul_sbs_fuel_gauge_set_battery_charging(const struct emul *target, uint32_t uV, int uA)
 {
 	struct sbs_gauge_emul_data *data = target->data;

 	if (uV == 0 || uA == 0)
 		return -EINVAL;

 	data->batt_state.uA = uA;
 	data->batt_state.uV = uV;

 	return 0;
 }

 static int emul_sbs_fuel_gauge_is_battery_cutoff(const struct emul *target, bool *cutoff)
 {
 	struct sbs_gauge_emul_data *data = target->data;

 	__ASSERT_NO_MSG(cutoff != NULL);

 	*cutoff = data->is_cutoff;

 	return 0;
 }

 static const struct fuel_gauge_emul_driver_api sbs_gauge_backend_api = {
 	.set_battery_charging = emul_sbs_fuel_gauge_set_battery_charging,
 	.is_battery_cutoff = emul_sbs_fuel_gauge_is_battery_cutoff,
 };

 static const struct i2c_emul_api sbs_gauge_emul_api_i2c = {
 	.transfer = sbs_gauge_emul_transfer_i2c,
 };

 static void sbs_gauge_emul_reset(const struct emul *target)
 {
 	struct sbs_gauge_emul_data *data = target->data;

 	memset(data, 0, sizeof(*data));
 }

 #ifdef CONFIG_ZTEST
 #include <zephyr/ztest.h>

 /* Add test reset handlers in when using emulators with tests */
 #define SBS_GAUGE_EMUL_RESET_RULE_BEFORE(inst)                                                     \
 	sbs_gauge_emul_reset(EMUL_DT_GET(DT_DRV_INST(inst)));

 static void emul_sbs_gauge_reset_rule_after(const struct ztest_unit_test *test, void *data)
 {
 	ARG_UNUSED(test);
 	ARG_UNUSED(data);

 	DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_EMUL_RESET_RULE_BEFORE)
 }
 ZTEST_RULE(emul_sbs_gauge_reset, NULL, emul_sbs_gauge_reset_rule_after);
 #endif /* CONFIG_ZTEST */

 /**
  * Set up a new SBS_GAUGE emulator (I2C)
  *
  * @param emul Emulation information
  * @param parent Device to emulate (must use sbs_gauge driver)
  * @return 0 indicating success (always)
  */
 static int emul_sbs_sbs_gauge_init(const struct emul *target, const struct device *parent)
 {
 	ARG_UNUSED(parent);

 	sbs_gauge_emul_reset(target);

 	return 0;
 }

 /*
  * Main instantiation macro. SBS Gauge Emulator only implemented for I2C
  */
 #define SBS_GAUGE_EMUL(n)                                                                          \
 	static struct sbs_gauge_emul_data sbs_gauge_emul_data_##n;                                 \
 	static const struct sbs_gauge_emul_cfg sbs_gauge_emul_cfg_##n = {                          \
 		.addr = DT_INST_REG_ADDR(n),                                                       \
 		.cutoff_support = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_support, false),       \
 		.cutoff_reg_addr = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_reg_addr, 0),         \
 		.cutoff_payload = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_payload, {}),          \
 	};                                                                                         \
 	EMUL_DT_INST_DEFINE(n, emul_sbs_sbs_gauge_init, &sbs_gauge_emul_data_##n,                  \
 			    &sbs_gauge_emul_cfg_##n, &sbs_gauge_emul_api_i2c,                      \
 			    &sbs_gauge_backend_api)

 DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_EMUL)
	/*
	* Copyright 2022 Google LLC
	* Copyright 2023 Microsoft Corporation
	*
	* SPDX-License-Identifier: Apache-2.0
	*
	* Emulator for SBS 1.1 compliant smart battery fuel gauge.
	*/

	#ifdef CONFIG_FUEL_GAUGE
	#define DT_DRV_COMPAT sbs_sbs_gauge_new_api
	#else
	#define DT_DRV_COMPAT sbs_sbs_gauge
	#endif /* CONFIG_FUEL_GAUGE */

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(sbs_sbs_gauge);

	#include <stdbool.h>
	#include <stdint.h>
	#include <zephyr/device.h>
	#include <zephyr/devicetree.h>
	#include <zephyr/drivers/emul.h>
	#include <zephyr/drivers/i2c.h>
	#include <zephyr/drivers/i2c_emul.h>
	#include <zephyr/sys/byteorder.h>
	#include <zephyr/drivers/emul_fuel_gauge.h>
	#include <zephyr/drivers/fuel_gauge.h>
	#include <zephyr/sys/util.h>

	#include "sbs_gauge.h"

	/** Run-time data used by the emulator */
	struct sbs_gauge_emul_data {
	uint16_t mfr_acc;
	uint16_t remaining_capacity_alarm;
	uint16_t remaining_time_alarm;
	uint16_t mode;
	int16_t at_rate;
	/* Whether the battery cutoff or not */
	bool is_cutoff;
	/*
	* Counts the number of times the cutoff payload has been sent to the designated
	* register
	*/
	uint8_t cutoff_writes;
	struct {
	/* Non-register values associated with the state of the battery */
	/* Battery terminal voltage */
	uint32_t uV;
	/* Battery terminal current - Pos is charging, Neg is discharging */
	int uA;
	} batt_state;
	};

	/** Static configuration for the emulator */
	struct sbs_gauge_emul_cfg {
	/** I2C address of emulator */
	uint16_t addr;
	bool cutoff_support;
	uint32_t cutoff_reg_addr;
	uint16_t cutoff_payload[SBS_GAUGE_CUTOFF_PAYLOAD_MAX_SIZE];
	};

	static void emul_sbs_gauge_maybe_do_battery_cutoff(const struct emul *target, int reg, int val)
	{
	struct sbs_gauge_emul_data *data = target->data;
	const struct sbs_gauge_emul_cfg *cfg = target->cfg;

	/* Check if this is a cutoff write */
	if (cfg->cutoff_support && reg == cfg->cutoff_reg_addr) {
	__ASSERT_NO_MSG(ARRAY_SIZE(cfg->cutoff_payload) > 0);
	/*
	* Calculate the next payload element value for a battery cutoff.
	*
	* We thoroughly check bounds elsewhere, so we can be confident we're not indexing
	* past the end of the array.
	*/
	uint16_t target_payload_elem_val = cfg->cutoff_payload[data->cutoff_writes];

	if (target_payload_elem_val == val) {
	data->cutoff_writes++;
	__ASSERT_NO_MSG(data->cutoff_writes <= ARRAY_SIZE(cfg->cutoff_payload));
	} else {
	/* Wrong payload target value, reset cutoff sequence detection. */
	data->cutoff_writes = 0;
	}

	if (data->cutoff_writes == ARRAY_SIZE(cfg->cutoff_payload)) {
	data->is_cutoff = true;
	data->cutoff_writes = 0;
	}
	}
	/* Not a cutoff write, reset payload counter */
	else {
	data->cutoff_writes = 0;
	}
	}

	static int emul_sbs_gauge_reg_write(const struct emul *target, int reg, int val)
	{
	struct sbs_gauge_emul_data *data = target->data;

	LOG_INF("write %x = %x", reg, val);
	switch (reg) {
	case SBS_GAUGE_CMD_MANUFACTURER_ACCESS:
	data->mfr_acc = val;
	break;
	case SBS_GAUGE_CMD_REM_CAPACITY_ALARM:
	data->remaining_capacity_alarm = val;
	break;
	case SBS_GAUGE_CMD_REM_TIME_ALARM:
	data->remaining_time_alarm = val;
	break;
	case SBS_GAUGE_CMD_BATTERY_MODE:
	data->mode = val;
	break;
	case SBS_GAUGE_CMD_AR:
	data->at_rate = val;
	break;
	default:
	LOG_INF("Unknown write %x", reg);
	return -EIO;
	}

	/*
	* One of the above registers is always designated as a "cutoff" register, usually it's
	* MANUFACTURER ACCESS, but not always.
	*/
	emul_sbs_gauge_maybe_do_battery_cutoff(target, reg, val);

	return 0;
	}

	static int emul_sbs_gauge_reg_read(const struct emul target, int reg, int val)
	{
	struct sbs_gauge_emul_data *data = target->data;

	switch (reg) {
	case SBS_GAUGE_CMD_MANUFACTURER_ACCESS:
	*val = data->mfr_acc;
	break;
	case SBS_GAUGE_CMD_REM_CAPACITY_ALARM:
	*val = data->remaining_capacity_alarm;
	break;
	case SBS_GAUGE_CMD_REM_TIME_ALARM:
	*val = data->remaining_time_alarm;
	break;
	case SBS_GAUGE_CMD_BATTERY_MODE:
	*val = data->mode;
	break;
	case SBS_GAUGE_CMD_AR:
	*val = data->at_rate;
	break;
	case SBS_GAUGE_CMD_VOLTAGE:
	*val = data->batt_state.uV / 1000;
	break;
	case SBS_GAUGE_CMD_CURRENT:
	*val = data->batt_state.uA / 1000;
	break;
	case SBS_GAUGE_CMD_AVG_CURRENT:
	case SBS_GAUGE_CMD_TEMP:
	case SBS_GAUGE_CMD_ASOC:
	case SBS_GAUGE_CMD_RSOC:
	case SBS_GAUGE_CMD_FULL_CAPACITY:
	case SBS_GAUGE_CMD_REM_CAPACITY:
	case SBS_GAUGE_CMD_NOM_CAPACITY:
	case SBS_GAUGE_CMD_AVG_TIME2EMPTY:
	case SBS_GAUGE_CMD_AVG_TIME2FULL:
	case SBS_GAUGE_CMD_RUNTIME2EMPTY:
	case SBS_GAUGE_CMD_CYCLE_COUNT:
	case SBS_GAUGE_CMD_DESIGN_VOLTAGE:
	case SBS_GAUGE_CMD_CHG_CURRENT:
	case SBS_GAUGE_CMD_CHG_VOLTAGE:
	case SBS_GAUGE_CMD_FLAGS:
	case SBS_GAUGE_CMD_ARTTF:
	case SBS_GAUGE_CMD_ARTTE:
	case SBS_GAUGE_CMD_AROK:
	/* Arbitrary stub value. */
	*val = 1;
	break;
	default:
	LOG_ERR("Unknown register 0x%x read", reg);
	return -EIO;
	}
	LOG_INF("read 0x%x = 0x%x", reg, *val);

	return 0;
	}

	static int emul_sbs_gauge_buffer_read(const struct emul target, int reg, char val)
	{
	char mfg[] = "ACME";
	char dev[] = "B123456";
	char chem[] = "LiPO";
	struct sbs_gauge_manufacturer_name mfg_name = (struct sbs_gauge_manufacturer_name )val;
	struct sbs_gauge_device_name dev_name = (struct sbs_gauge_device_name )val;
	struct sbs_gauge_device_chemistry dev_chem = (struct sbs_gauge_device_chemistry )val;

	switch (reg) {
	case SBS_GAUGE_CMD_MANUFACTURER_NAME:
	mfg_name->manufacturer_name_length = sizeof(mfg);
	memcpy(mfg_name->manufacturer_name, mfg, mfg_name->manufacturer_name_length);
	break;
	case SBS_GAUGE_CMD_DEVICE_NAME:
	dev_name->device_name_length = sizeof(dev);
	memcpy(dev_name->device_name, dev, dev_name->device_name_length);
	break;

	case SBS_GAUGE_CMD_DEVICE_CHEMISTRY:
	dev_chem->device_chemistry_length = MIN(sizeof(chem),
	sizeof(dev_chem->device_chemistry));
	memcpy(dev_chem->device_chemistry, chem, dev_chem->device_chemistry_length);
	break;
	default:
	LOG_ERR("Unknown register 0x%x read", reg);
	return -EIO;
	}

	return 0;
	}

	static int sbs_gauge_emul_transfer_i2c(const struct emul target, struct i2c_msg msgs,
	int num_msgs, int addr)
	{
	/* Largely copied from emul_bmi160.c */
	struct sbs_gauge_emul_data *data;
	unsigned int val;
	int reg;
	int rc;

	data = target->data;

	__ASSERT_NO_MSG(msgs && num_msgs);

	i2c_dump_msgs_rw(target->dev, msgs, num_msgs, addr, false);
	switch (num_msgs) {
	case 2:
	if (msgs->flags & I2C_MSG_READ) {
	LOG_ERR("Unexpected read");
	return -EIO;
	}
	if (msgs->len != 1) {
	LOG_ERR("Unexpected msg0 length %d", msgs->len);
	return -EIO;
	}
	reg = msgs->buf[0];

	/* Now process the 'read' part of the message */
	msgs++;
	if (msgs->flags & I2C_MSG_READ) {
	switch (msgs->len) {
	case 2:
	rc = emul_sbs_gauge_reg_read(target, reg, &val);
	if (rc) {
	/* Return before writing bad value to message buffer */
	return rc;
	}

	/* SBS uses SMBus, which sends data in little-endian format. */
	sys_put_le16(val, msgs->buf);
	break;
	/* buffer properties */
	case (sizeof(struct sbs_gauge_manufacturer_name)):
	case (sizeof(struct sbs_gauge_device_chemistry)):
	rc = emul_sbs_gauge_buffer_read(target, reg, (char *)msgs->buf);
	break;
	default:
	LOG_ERR("Unexpected msg1 length %d", msgs->len);
	return -EIO;
	}
	} else {
	/* We write a word (2 bytes by the SBS spec) */
	if (msgs->len != 2) {
	LOG_ERR("Unexpected msg1 length %d", msgs->len);
	}
	uint16_t value = sys_get_le16(msgs->buf);

	rc = emul_sbs_gauge_reg_write(target, reg, value);
	}
	break;
	default:
	LOG_ERR("Invalid number of messages: %d", num_msgs);
	return -EIO;
	}

	return rc;
	}

	static int emul_sbs_fuel_gauge_set_battery_charging(const struct emul *target, uint32_t uV, int uA)
	{
	struct sbs_gauge_emul_data *data = target->data;

	if (uV == 0 \|\| uA == 0)
	return -EINVAL;

	data->batt_state.uA = uA;
	data->batt_state.uV = uV;

	return 0;
	}

	static int emul_sbs_fuel_gauge_is_battery_cutoff(const struct emul target, bool cutoff)
	{
	struct sbs_gauge_emul_data *data = target->data;

	__ASSERT_NO_MSG(cutoff != NULL);

	*cutoff = data->is_cutoff;

	return 0;
	}

	static const struct fuel_gauge_emul_driver_api sbs_gauge_backend_api = {
	.set_battery_charging = emul_sbs_fuel_gauge_set_battery_charging,
	.is_battery_cutoff = emul_sbs_fuel_gauge_is_battery_cutoff,
	};

	static const struct i2c_emul_api sbs_gauge_emul_api_i2c = {
	.transfer = sbs_gauge_emul_transfer_i2c,
	};

	static void sbs_gauge_emul_reset(const struct emul *target)
	{
	struct sbs_gauge_emul_data *data = target->data;

	memset(data, 0, sizeof(*data));
	}

	#ifdef CONFIG_ZTEST
	#include <zephyr/ztest.h>

	/* Add test reset handlers in when using emulators with tests */
	#define SBS_GAUGE_EMUL_RESET_RULE_BEFORE(inst) \
	sbs_gauge_emul_reset(EMUL_DT_GET(DT_DRV_INST(inst)));

	static void emul_sbs_gauge_reset_rule_after(const struct ztest_unit_test test, void data)
	{
	ARG_UNUSED(test);
	ARG_UNUSED(data);

	DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_EMUL_RESET_RULE_BEFORE)
	}
	ZTEST_RULE(emul_sbs_gauge_reset, NULL, emul_sbs_gauge_reset_rule_after);
	#endif /* CONFIG_ZTEST */

	/**
	* Set up a new SBS_GAUGE emulator (I2C)
	*
	* @param emul Emulation information
	* @param parent Device to emulate (must use sbs_gauge driver)
	* @return 0 indicating success (always)
	*/
	static int emul_sbs_sbs_gauge_init(const struct emul target, const struct device parent)
	{
	ARG_UNUSED(parent);

	sbs_gauge_emul_reset(target);

	return 0;
	}

	/*
	* Main instantiation macro. SBS Gauge Emulator only implemented for I2C
	*/
	#define SBS_GAUGE_EMUL(n) \
	static struct sbs_gauge_emul_data sbs_gauge_emul_data_##n; \
	static const struct sbs_gauge_emul_cfg sbs_gauge_emul_cfg_##n = { \
	.addr = DT_INST_REG_ADDR(n), \
	.cutoff_support = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_support, false), \
	.cutoff_reg_addr = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_reg_addr, 0), \
	.cutoff_payload = DT_PROP_OR(DT_DRV_INST(n), battery_cutoff_payload, {}), \
	}; \
	EMUL_DT_INST_DEFINE(n, emul_sbs_sbs_gauge_init, &sbs_gauge_emul_data_##n, \
	&sbs_gauge_emul_cfg_##n, &sbs_gauge_emul_api_i2c, \
	&sbs_gauge_backend_api)

	DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_EMUL)