diff --git a/firmware/ec/test/Makefile b/firmware/ec/test/Makefile index 66cd4d6efd..f4f15cab38 100644 --- a/firmware/ec/test/Makefile +++ b/firmware/ec/test/Makefile @@ -156,7 +156,7 @@ $(PATHB)Test_PinGroup_driver$(TARGET_EXTENSION): $(STD_FILES) $(TEST_PINGROUP_SR TEST_OCGPIO_SRC=$(OCWARE_ROOT)/src/drivers/OcGpio.c $(OCWARE_ROOT)/src/devices/i2cbus.c fake/fake_I2C.c fake/fake_GPIO.c fake/fake_ThreadedISR.c $(OCWARE_ROOT)/src/helpers/memory.c stub/stub_GateMutex.c $(PATHB)Test_OcGpio$(TARGET_EXTENSION): $(STD_FILES) $(TEST_OCGPIO_SRC) -TEST_OCMP_LTC4015_SRC=$(OCWARE_ROOT)/src/devices/ocmp_wrappers/ocmp_ltc4015.c $(OCWARE_ROOT)/src/devices/ltc4015.c $(OCWARE_ROOT)/src/drivers/GpioSX1509.c $(OCWARE_ROOT)/src/devices/sx1509.c $(OCWARE_ROOT)/src/helpers/memory.c $(OCWARE_ROOT)/src/devices/i2cbus.c fake/fake_GPIO.c fake/fake_I2C.c fake/fake_ThreadedISR.c stub/stub_GateMutex.c $(OCWARE_ROOT)/src/post/post_util.c fake/fake_SX1509_register.c fake/fake_ltc4015_register.c $(OCWARE_ROOT)/platform/oc-sdr/cfg/OC_CONNECT_GBC.c +TEST_OCMP_LTC4015_SRC=$(OCWARE_ROOT)/src/devices/ocmp_wrappers/ocmp_ltc4015.c $(OCWARE_ROOT)/src/devices/ltc4015.c $(OCWARE_ROOT)/src/drivers/GpioSX1509.c $(OCWARE_ROOT)/src/devices/sx1509.c $(OCWARE_ROOT)/src/helpers/memory.c $(OCWARE_ROOT)/src/devices/i2cbus.c fake/fake_GPIO.c fake/fake_I2C.c fake/fake_ThreadedISR.c stub/stub_GateMutex.c stub/stub_GateMutex.c stub/stub_ltc4015.c $(OCWARE_ROOT)/src/post/post_util.c fake/fake_SX1509_register.c fake/fake_ltc4015_register.c $(OCWARE_ROOT)/platform/oc-sdr/cfg/OC_CONNECT_GBC.c $(PATHB)Test_ocmp_ltc4015$(TARGET_EXTENSION): $(STD_FILES) $(TEST_OCMP_LTC4015_SRC) $(INC_M) $(PATHB)%$(TARGET_EXTENSION): diff --git a/firmware/ec/test/fake/fake_GPIO.c b/firmware/ec/test/fake/fake_GPIO.c index 0fd4b3ecc3..c8bf1cec7e 100644 --- a/firmware/ec/test/fake/fake_GPIO.c +++ b/firmware/ec/test/fake/fake_GPIO.c @@ -72,7 +72,7 @@ static int FakeGpio_setCallback(const OcGpio_Pin *pin, if (pin->idx >= FAKE_GPIO_PIN_COUNT) { return OCGPIO_FAILURE; - } + } obj->callback[pin->idx].fn = callback; obj->callback[pin->idx].context = context; diff --git a/firmware/ec/test/fake/fake_SX1509_register.c b/firmware/ec/test/fake/fake_SX1509_register.c index 2c2a411b7f..558a625e75 100644 --- a/firmware/ec/test/fake/fake_SX1509_register.c +++ b/firmware/ec/test/fake/fake_SX1509_register.c @@ -6,118 +6,132 @@ * LICENSE file in the root directory of this source tree. An additional grant * of patent rights can be found in the PATENTS file in the same directory. */ -#include +#include "include/test_sx1509.h" uint8_t SX1509_regs[] = { - [0x00] = 0x00, /* Input buffer disable register B */ - [0x01] = 0x00, /* Input buffer disable register A */ - [0x02] = 0x00, /* Output buffer long slew register B */ - [0x03] = 0x00, /* Output buffer long slew register A */ - [0x04] = 0x00, /* Output buffer low drive register B */ - [0x05] = 0x00, /* Output buffer low drive register A */ - [0x06] = 0x00, /* Pull Up register B */ - [0x07] = 0x00, /* Pull Up register A */ - [0x08] = 0x00, /* Pull Down register B */ - [0x09] = 0x00, /* Pull Down register A */ - [0x0A] = 0x00, /* Open drain register B */ - [0x0B] = 0x00, /* Open drain register A */ - [0x0C] = 0x00, /* Polarity register B */ - [0x0D] = 0x00, /* Polarity register A */ - [0x0E] = 0x00, /* Direction register B */ - [0x0F] = 0x00, /* Direction register A */ - [0x10] = 0x00, /* Data register B */ - [0x11] = 0x00, /* Data register A */ - [0x12] = 0x00, /* Interrupt mask register B */ - [0x13] = 0x00, /* Interrupt mask register A */ - [0x14] = 0x00, /* Sense High register B */ - [0x15] = 0x00, /* Sense Low register B */ - [0x16] = 0x00, /* Sense High register A */ - [0x17] = 0x00, /* Sense Low register A */ - [0x18] = 0x00, /* Interrupt source register B */ - [0x19] = 0x00, /* Interrupt source register A */ - [0x1A] = 0x00, /* Event status register B */ - [0x1B] = 0x00, /* Event status register A */ - [0x1C] = 0x00, /* Level shifter register 1 */ - [0x1D] = 0x00, /* Level shifter register 2 */ - [0x1E] = 0x00, /* Clock management register */ - [0x1F] = 0x00, /* Miscellaneous device settings register */ - [0x20] = 0x00, /* LED driver enable register B */ - [0x21] = 0x00, /* LED driver enable register A */ - [0x22] = 0x00, /* Debounce configuration register */ - [0x23] = 0x00, /* Debounce enable register B */ - [0x24] = 0x00, /* Debounce enable register A */ - [0x25] = 0x00, /* Key scan configuration register 1 */ - [0x26] = 0x00, /* Key scan configuration register 2 */ - [0x27] = 0x00, /* Key value (column) 1 */ - [0x28] = 0x00, /* Key value (row) 2 */ - [0x29] = 0x00, /* ON time register I/O[0] */ - [0x2A] = 0x00, /* ON intensity register I/O[0] */ - [0x2B] = 0x00, /* OFF time/intensity register I/O[0] */ - [0x2C] = 0x00, /* ON time register I/O[1] */ - [0x2D] = 0x00, /* ON intensity register I/O[1] */ - [0x2E] = 0x00, /* OFF time/intensity register I/O[1] */ - [0x2F] = 0x00, /* ON time register I/O[2] */ - [0x30] = 0x00, /* ON intensity register I/O[2] */ - [0x31] = 0x00, /* OFF time/intensity register I/O[2] */ - [0x32] = 0x00, /* ON time register I/O[3] */ - [0x33] = 0x00, /* ON intensity register I/O[3] */ - [0x34] = 0x00, /* OFF time/intensity register I/O[3] */ - [0x35] = 0x00, /* ON time register I/O[4] */ - [0x36] = 0x00, /* ON intensity register I/O[4] */ - [0x37] = 0x00, /* OFF time/intensity register I/O[4] */ - [0x38] = 0x00, /* Fade in register I/O[4] */ - [0x39] = 0x00, /* Fade out register I/O[4] */ - [0x3A] = 0x00, /* ON time register I/O[5] */ - [0x3B] = 0x00, /* ON intensity register I/O[5] */ - [0x3C] = 0x00, /* OFF time/intensity register I/O[5] */ - [0x3D] = 0x00, /* Fade in register I/O[5] */ - [0x3E] = 0x00, /* Fade out register I/O[5] */ - [0x3F] = 0x00, /* ON time register I/O[6] */ - [0x40] = 0x00, /* ON intensity register I/O[6] */ - [0x41] = 0x00, /* OFF time/intensity register I/O[6] */ - [0x42] = 0x00, /* Fade in register I/O[6] */ - [0x43] = 0x00, /* Fade out register I/O[6] */ - [0x44] = 0x00, /* ON time register I/O[6] */ - [0x45] = 0x00, /* ON intensity register I/O[7] */ - [0x46] = 0x00, /* OFF time/intensity register I/O[7] */ - [0x47] = 0x00, /* Fade in register I/O[7] */ - [0x48] = 0x00, /* Fade out register I/O[7] */ - [0x49] = 0x00, /* ON time register I/O[8] */ - [0x4A] = 0x00, /* ON intensity register I/O[8] */ - [0x4B] = 0x00, /* OFF time/intensity register I/O[8] */ - [0x4C] = 0x00, /* ON time register I/O[9] */ - [0x4D] = 0x00, /* ON intensity register I/O[9] */ - [0x4E] = 0x00, /* OFF time/intensity register I/O[9] */ - [0x4F] = 0x00, /* ON time register I/O[10] */ - [0x50] = 0x00, /* ON intensity register I/O[10] */ - [0x51] = 0x00, /* OFF time/intensity register I/O[10] */ - [0x52] = 0x00, /* ON time register I/O[11] */ - [0x53] = 0x00, /* ON intensity register I/O[11] */ - [0x54] = 0x00, /* OFF time/intensity register I/O[11] */ - [0x55] = 0x00, /* ON time register I/O[12] */ - [0x56] = 0x00, /* ON intensity register I/O[12] */ - [0x57] = 0x00, /* OFF time/intensity register I/O[12] */ - [0x58] = 0x00, /* Fade in register I/O[12] */ - [0x59] = 0x00, /* Fade out register I/O[12] */ - [0x5A] = 0x00, /* ON time register I/O[13] */ - [0x5B] = 0x00, /* ON intensity register I/O[13] */ - [0x5C] = 0x00, /* OFF time/intensity register I/O[13] */ - [0x5D] = 0x00, /* Fade in register I/O[13] */ - [0x5E] = 0x00, /* Fade out register I/O[13] */ - [0x5F] = 0x00, /* ON time register I/O[14] */ - [0x60] = 0x00, /* ON intensity register I/O[14] */ - [0x61] = 0x00, /* OFF time/intensity register I/O[14] */ - [0x62] = 0x00, /* Fade in register I/O[14] */ - [0x63] = 0x00, /* Fade out register I/O[14] */ - [0x64] = 0x00, /* ON time register I/O[15] */ - [0x65] = 0x00, /* ON intensity register I/O[15] */ - [0x66] = 0x00, /* OFF time/intensity register I/O[15] */ - [0x67] = 0x00, /* Fade in register I/O[115] */ - [0x68] = 0x00, /* Fade out register I/O[15] */ - [0x69] = 0x00, /* */ - [0x6A] = 0x00, /* */ - [0x7D] = 0x00, /* */ - [0x7E] = 0x00, /* */ - [0x7F] = 0x00, /* */ + [SX1509_REG_INPUT_DISABLE_B] = + 0x00, /* Input buffer disableSX1509_REGister B */ + [SX1509_REG_INPUT_DISABLE_A] = + 0x00, /* Input buffer disableSX1509_REGister A */ + [SX1509_REG_LONG_SLEW_B] = + 0x00, /* Output buffer long slewSX1509_REGister B */ + [SX1509_REG_LONG_SLEW_A] = + 0x00, /* Output buffer long slewSX1509_REGister A */ + [SX1509_REG_LOW_DRIVE_B] = + 0x00, /* Output buffer low driveSX1509_REGister B */ + [SX1509_REG_LOW_DRIVE_A] = + 0x00, /* Output buffer low driveSX1509_REGister A */ + [SX1509_REG_PULL_UP_B] = 0x00, /* Pull UpSX1509_REGister B */ + [SX1509_REG_PULL_UP_A] = 0x00, /* Pull UpSX1509_REGister A */ + [SX1509_REG_PULL_DOWN_B] = 0x00, /* Pull DownSX1509_REGister B */ + [SX1509_REG_PULL_DOWN_A] = 0x00, /* Pull DownSX1509_REGister A */ + [SX1509_REG_OPEN_DRAIN_B] = 0x00, /* Open drainSX1509_REGister B */ + [SX1509_REG_OPEN_DRAIN_A] = 0x00, /* Open drainSX1509_REGister A */ + [SX1509_REG_POLARITY_B] = 0x00, /* PolaritySX1509_REGister B */ + [SX1509_REG_POLARITY_A] = 0x00, /* PolaritySX1509_REGister A */ + [SX1509_REG_DIR_B] = 0x00, /* DirectionSX1509_REGister B */ + [SX1509_REG_DIR_A] = 0x00, /* DirectionSX1509_REGister A */ + [SX1509_REG_DATA_B] = 0x00, /* DataSX1509_REGister B */ + [SX1509_REG_DATA_A] = 0x00, /* DataSX1509_REGister A */ + [SX1509_REG_INTERRUPT_MASK_B] = 0x00, /* Interrupt maskSX1509_REGister B */ + [SX1509_REG_INTERRUPT_MASK_A] = 0x00, /* Interrupt maskSX1509_REGister A */ + [SX1509_REG_SENSE_HIGH_B] = 0x00, /* Sense HighSX1509_REGister B */ + [SX1509_REG_SENSE_LOW_B] = 0x00, /* Sense LowSX1509_REGister B */ + [SX1509_REG_SENSE_HIGH_A] = 0x00, /* Sense HighSX1509_REGister A */ + [SX1509_REG_SENSE_LOW_A] = 0x00, /* Sense LowSX1509_REGister A */ + [SX1509_REG_INTERRUPT_SOURCE_B] = + 0x00, /* Interrupt sourceSX1509_REGister B */ + [SX1509_REG_INTERRUPT_SOURCE_A] = + 0x00, /* Interrupt sourceSX1509_REGister A */ + [SX1509_REG_EVENT_STATUS_B] = 0x00, /* Event statusSX1509_REGister B */ + [SX1509_REG_EVENT_STATUS_A] = 0x00, /* Event statusSX1509_REGister A */ + [SX1509_REG_LEVEL_SHIFTER_1] = 0x00, /* Level shifterSX1509_REGister 1 */ + [SX1509_REG_LEVEL_SHIFTER_2] = 0x00, /* Level shifterSX1509_REGister 2 */ + [SX1509_REG_CLOCK] = 0x00, /* Clock managementSX1509_REGister */ + [SX1509_REG_MISC] = 0x00, /* Miscellaneous device settingsSX1509_REGister */ + [SX1509_REG_LED_DRIVER_ENABLE_B] = + 0x00, /* LED driver enableSX1509_REGister B */ + [SX1509_REG_LED_DRIVER_ENABLE_A] = + 0x00, /* LED driver enableSX1509_REGister A */ + [SX1509_REG_DEBOUNCW_CONFIG] = + 0x00, /* Debounce configurationSX1509_REGister */ + [SX1509_REG_DEBOUNCW_ENABLE_B] = + 0x00, /* Debounce enableSX1509_REGister B */ + [SX1509_REG_DEBOUNCW_ENABLE_A] = + 0x00, /* Debounce enableSX1509_REGister A */ + [SX1509_REG_KEY_CONFIG_1] = + 0x00, /* Key scan configurationSX1509_REGister 1 */ + [SX1509_REG_KEY_CONFIG_2] = + 0x00, /* Key scan configurationSX1509_REGister 2 */ + [SX1509_REG_KEY_DATA_1] = 0x00, /* Key value (column) 1 */ + [SX1509_REG_KEY_DATA_2] = 0x00, /* Key value (row) 2 */ + [SX1509_REG_T_ON_0] = 0x00, /* ON timeSX1509_REGister I/O[0] */ + [SX1509_REG_I_ON_0] = 0x00, /* ON intensitySX1509_REGister I/O[0] */ + [SX1509_REG_OFF_0] = 0x00, /* OFF time/intensitySX1509_REGister I/O[0] */ + [SX1509_REG_T_ON_1] = 0x00, /* ON timeSX1509_REGister I/O[1] */ + [SX1509_REG_I_ON_1] = 0x00, /* ON intensitySX1509_REGister I/O[1] */ + [SX1509_REG_OFF_1] = 0x00, /* OFF time/intensitySX1509_REGister I/O[1] */ + [SX1509_REG_T_ON_2] = 0x00, /* ON timeSX1509_REGister I/O[2] */ + [SX1509_REG_I_ON_2] = 0x00, /* ON intensitySX1509_REGister I/O[2] */ + [SX1509_REG_OFF_2] = 0x00, /* OFF time/intensitySX1509_REGister I/O[2] */ + [SX1509_REG_T_ON_3] = 0x00, /* ON timeSX1509_REGister I/O[3] */ + [SX1509_REG_I_ON_3] = 0x00, /* ON intensitySX1509_REGister I/O[3] */ + [SX1509_REG_OFF_3] = 0x00, /* OFF time/intensitySX1509_REGister I/O[3] */ + [SX1509_REG_T_ON_4] = 0x00, /* ON timeSX1509_REGister I/O[4] */ + [SX1509_REG_I_ON_4] = 0x00, /* ON intensitySX1509_REGister I/O[4] */ + [SX1509_REG_OFF_4] = 0x00, /* OFF time/intensitySX1509_REGister I/O[4] */ + [SX1509_REG_T_RISE_4] = 0x00, /* Fade inSX1509_REGister I/O[4] */ + [SX1509_REG_T_Fall_4] = 0x00, /* Fade outSX1509_REGister I/O[4] */ + [SX1509_REG_T_ON_5] = 0x00, /* ON timeSX1509_REGister I/O[5] */ + [SX1509_REG_I_ON_5] = 0x00, /* ON intensitySX1509_REGister I/O[5] */ + [SX1509_REG_OFF_5] = 0x00, /* OFF time/intensitySX1509_REGister I/O[5] */ + [SX1509_REG_T_RISE_5] = 0x00, /* Fade inSX1509_REGister I/O[5] */ + [SX1509_REG_T_Fall_5] = 0x00, /* Fade outSX1509_REGister I/O[5] */ + [SX1509_REG_T_ON_6] = 0x00, /* ON timeSX1509_REGister I/O[6] */ + [SX1509_REG_I_ON_6] = 0x00, /* ON intensitySX1509_REGister I/O[6] */ + [SX1509_REG_OFF_6] = 0x00, /* OFF time/intensitySX1509_REGister I/O[6] */ + [SX1509_REG_T_RISE_6] = 0x00, /* Fade inSX1509_REGister I/O[6] */ + [SX1509_REG_T_Fall_6] = 0x00, /* Fade outSX1509_REGister I/O[6] */ + [SX1509_REG_T_ON_7] = 0x00, /* ON timeSX1509_REGister I/O[6] */ + [SX1509_REG_I_ON_7] = 0x00, /* ON intensitySX1509_REGister I/O[7] */ + [SX1509_REG_OFF_7] = 0x00, /* OFF time/intensitySX1509_REGister I/O[7] */ + [SX1509_REG_T_RISE_7] = 0x00, /* Fade inSX1509_REGister I/O[7] */ + [SX1509_REG_T_Fall_7] = 0x00, /* Fade outSX1509_REGister I/O[7] */ + [SX1509_REG_T_ON_8] = 0x00, /* ON timeSX1509_REGister I/O[8] */ + [SX1509_REG_I_ON_8] = 0x00, /* ON intensitySX1509_REGister I/O[8] */ + [SX1509_REG_OFF_8] = 0x00, /* OFF time/intensitySX1509_REGister I/O[8] */ + [SX1509_REG_T_ON_9] = 0x00, /* ON timeSX1509_REGister I/O[9] */ + [SX1509_REG_I_ON_9] = 0x00, /* ON intensitySX1509_REGister I/O[9] */ + [SX1509_REG_OFF_9] = 0x00, /* OFF time/intensitySX1509_REGister I/O[9] */ + [SX1509_REG_T_ON_10] = 0x00, /* ON timeSX1509_REGister I/O[10] */ + [SX1509_REG_I_ON_10] = 0x00, /* ON intensitySX1509_REGister I/O[10] */ + [SX1509_REG_OFF_10] = 0x00, /* OFF time/intensitySX1509_REGister I/O[10] */ + [SX1509_REG_T_ON_11] = 0x00, /* ON timeSX1509_REGister I/O[11] */ + [SX1509_REG_I_ON_11] = 0x00, /* ON intensitySX1509_REGister I/O[11] */ + [SX1509_REG_OFF_11] = 0x00, /* OFF time/intensitySX1509_REGister I/O[11] */ + [SX1509_REG_T_ON_12] = 0x00, /* ON timeSX1509_REGister I/O[12] */ + [SX1509_REG_I_ON_12] = 0x00, /* ON intensitySX1509_REGister I/O[12] */ + [SX1509_REG_OFF_12] = 0x00, /* OFF time/intensitySX1509_REGister I/O[12] */ + [SX1509_REG_T_RISE_12] = 0x00, /* Fade inSX1509_REGister I/O[12] */ + [SX1509_REG_T_Fall_12] = 0x00, /* Fade outSX1509_REGister I/O[12] */ + [SX1509_REG_T_ON_13] = 0x00, /* ON timeSX1509_REGister I/O[13] */ + [SX1509_REG_I_ON_13] = 0x00, /* ON intensitySX1509_REGister I/O[13] */ + [SX1509_REG_OFF_13] = 0x00, /* OFF time/intensitySX1509_REGister I/O[13] */ + [SX1509_REG_T_RISE_13] = 0x00, /* Fade inSX1509_REGister I/O[13] */ + [SX1509_REG_T_Fall_13] = 0x00, /* Fade outSX1509_REGister I/O[13] */ + [SX1509_REG_T_ON_14] = 0x00, /* ON timeSX1509_REGister I/O[14] */ + [SX1509_REG_I_ON_14] = 0x00, /* ON intensitySX1509_REGister I/O[14] */ + [SX1509_REG_OFF_14] = 0x00, /* OFF time/intensitySX1509_REGister I/O[14] */ + [SX1509_REG_T_RISE_14] = 0x00, /* Fade inSX1509_REGister I/O[14] */ + [SX1509_REG_T_Fall_14] = 0x00, /* Fade outSX1509_REGister I/O[14] */ + [SX1509_REG_T_ON_15] = 0x00, /* ON timeSX1509_REGister I/O[15] */ + [SX1509_REG_I_ON_15] = 0x00, /* ON intensitySX1509_REGister I/O[15] */ + [SX1509_REG_OFF_15] = 0x00, /* OFF time/intensitySX1509_REGister I/O[15] */ + [SX1509_REG_T_RISE_15] = 0x00, /* Fade inSX1509_REGister I/O[115] */ + [SX1509_REG_T_Fall_15] = 0x00, /* Fade outSX1509_REGister I/O[15] */ + [SX1509_REG_HIGH_INPUT_B] = 0x00, /* */ + [SX1509_REG_HIGH_INPUT_A] = 0x00, /* */ + [SX1509_REG_RESET] = 0x00, /* */ + [SX1509_REG_TEST_1] = 0x00, /* */ + [SX1509_REG_TEST_2] = 0x00, /* */ }; - diff --git a/firmware/ec/test/fake/fake_ltc4015_register.c b/firmware/ec/test/fake/fake_ltc4015_register.c index aef6f13b47..f425c73133 100644 --- a/firmware/ec/test/fake/fake_ltc4015_register.c +++ b/firmware/ec/test/fake/fake_ltc4015_register.c @@ -26,117 +26,137 @@ extern const OcGpio_FnTable GpioSX1509_fnTable; OcGpio_Port gbc_io_1 = { .fn_table = &GpioSX1509_fnTable, - .cfg = &(SX1509_Cfg) { - .i2c_dev = { 0, 0x45 }, - .pin_irq = NULL, - }, + .cfg = + &(SX1509_Cfg){ + .i2c_dev = { 0, 0x45 }, + .pin_irq = NULL, + }, .object_data = &(SX1509_Obj){}, }; /* Invalid Device */ LTC4015_Dev gbc_pwr_invalid_dev = { - .cfg = { - .i2c_dev = { - .bus = 2, - .slave_addr = 0x52, + .cfg = + { + .i2c_dev = + { + .bus = 2, + .slave_addr = 0x52, + }, + .chem = 0, + .r_snsb = 30, + .r_snsi = 7, + .cellcount = 3, + .pin_lt4015_i2c_sel = { &gbc_io_1, 2, 32 }, }, - .chem = 0, - .r_snsb = 30, - .r_snsi = 7, - .cellcount = 3, - .pin_lt4015_i2c_sel = { &gbc_io_1, 2, 32 }, - }, }; /* Invalid Bus */ LTC4015_Dev gbc_pwr_invalid_bus = { - .cfg = { - .i2c_dev = { - .bus = 0xFF, - .slave_addr = 0x52, + .cfg = + { + .i2c_dev = + { + .bus = 0xFF, + .slave_addr = 0x52, + }, + .chem = 0, + .r_snsb = 30, + .r_snsi = 7, + .cellcount = 3, + .pin_lt4015_i2c_sel = { &gbc_io_1, 2, 32 }, + }, +}; +/* Invalid Cfg for _choose_battery_charger*/ +LTC4015_Dev gbc_pwr_invalid_leadAcid_cfg = { + .cfg = + { + .i2c_dev = + { + .bus = 2, + .slave_addr = 0x52, + }, + .chem = 0, + .r_snsb = 30, + .r_snsi = 7, + .cellcount = 3, + .pin_lt4015_i2c_sel = {}, }, - .chem = 0, - .r_snsb = 30, - .r_snsi = 7, - .cellcount = 3, - .pin_lt4015_i2c_sel = { &gbc_io_1, 2, 32 }, - }, }; - /* ======================== Constants & variables =========================== */ uint16_t LTC4015_regs[] = { - [0x01] = 0x00, /* Battery voltage low alert limit */ - [0x02] = 0x00, /* Battery voltage high alert limit */ - [0x03] = 0x00, /* Input voltage low alert limit */ - [0x04] = 0x00, /* Input voltage high alert limit */ - [0x05] = 0x00, /* Output voltage low alert limit */ - [0x06] = 0x00, /* Output voltage high alert limit */ - [0x07] = 0x00, /* Input current high alert limit */ - [0x08] = 0x00, /* Charge current low alert limit */ - [0x09] = 0x00, /* Die temperature high alert limit */ - [0x0A] = 0x00, /* Battery series resistance high alert limit */ - [0x0B] = 0x00, /* Thermistor ratio high(cold battery) alert limit */ - [0x0C] = 0x00, /* Thermistor ratio low(hot battery) alert limit */ - [0x0D] = 0x00, /* Enable limit monitoring and alert notification */ - [0x0E] = 0x00, /* Enable charger state alert notification */ - [0x0F] = 0x00, /* Enable charger status alert notification */ - [0x10] = 0x00, /* Columb counter QCOUNT low alert limit */ - [0x11] = 0x00, /* Columb counter QCOUNT high alert limit */ - [0x12] = 0x00, /* Columb counter prescale factor */ - [0x13] = 0x00, /* Columb counter value */ - [0x14] = 0x00, /* Configuration Settings */ - [0x15] = 0x00, /* Input current limit setting */ - [0x16] = 0x00, /* UVCLFB input buffer limit */ - [0x17] = 0x00, /* Reserved */ - [0x18] = 0x00, /* Reserved */ - [0x19] = 0x00, /* Arm ship mode */ - [0x1A] = 0x00, /* Charge current target */ - [0x1B] = 0x00, /* Charge voltage target */ - [0x1C] = 0x00, /* Low IBAT Threshold for C/x termination */ - [0x1D] = 0x00, /* Time in seconds with battery charger in the CV state before timer termination */ - [0x1E] = 0x00, /* Time in seconds before a max_charge_time fault is declared */ - [0x1F] = 0x00, /* JEITA_T1 */ - [0x20] = 0x00, /* JEITA_T2 */ - [0x21] = 0x00, /* JEITA_T3 */ - [0x22] = 0x00, /* JEITA_T4 */ - [0x23] = 0x00, /* JEITA_T5 */ - [0x24] = 0x00, /* JEITA_T6 */ - [0x25] = 0x00, /* VCHARGE values JEITA_6_5 */ - [0x26] = 0x00, /* VCHARGE values JEITA_4_3_2 */ - [0x27] = 0x00, /* ICHARGE_TARGET values JEITA_6_5 */ - [0x28] = 0x00, /* ICHARGE_TARGET values JEITA_4_3_2 */ - [0x29] = 0x00, /* Battery charger cfguration settings */ - [0x2A] = 0x00, /* LiFePO4/lead-acid absorb voltage adder */ - [0x2B] = 0x00, /* Maximum time for LiFePO4/lead-acid absorb charge */ - [0x2C] = 0x00, /* Lead-acid equalize charge voltage adder */ - [0x2D] = 0x00, /* Lead-acid equalization time */ - [0x2E] = 0x00, /* LiFeP04 recharge threshold */ - [0x2F] = 0x00, /* Reserved */ - [0x30] = 0x00, /* Max Charge Timer for lithium chemistries */ - [0x31] = 0x00, /* Constant-voltage regulation for lithium chemistries */ - [0x32] = 0x00, /* Absorb Timer for LiFePO4 and lead-acid batteries */ - [0x33] = 0x00, /* Eqaulize Timer for lead-acid batteries */ - [0x34] = 0x00, /* Real time battery charger state indicator */ - [0x35] = 0x00, /* Charge status indicator */ - [0x36] = 0x00, /* Limit alert register */ - [0x37] = 0x00, /* Charger state alert register */ - [0x38] = 0x00, /* Charger status alert indicator */ - [0x39] = 0x00, /* Real time system status indicator */ - [0x3A] = 0x00, /* VBAT value(BATSENS) */ - [0x3B] = 0x00, /* VIN */ - [0x3C] = 0x00, /* VSYS */ - [0x3D] = 0x00, /* Battery current(IBAT) */ - [0x3E] = 0x00, /* Input Current(IIN) */ - [0x3F] = 0x00, /* Die temperature */ - [0x40] = 0x00, /* NTC thermistor ratio */ - [0x41] = 0x00, /* Battery series resistance */ - [0x42] = 0x00, /* JEITA temperature region of the NTC thermistor (Li Only) */ - [0x43] = 0x00, /* CHEM and CELLS pin settings */ - [0x44] = 0x00, /* Charge current control DAC control bits */ - [0x45] = 0x00, /* Charge voltage control DAC control bits */ - [0x46] = 0x00, /* Input current limit control DAC control word */ - [0x47] = 0x00, /* Digitally filtered battery voltage */ - [0x48] = 0x00, /* Value of IBAT (0x3D) used in calculating BSR */ - [0x49] = 0x00, /* Reserved */ - [0x4A] = 0x00, /* Measurement valid bit */ + [LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT] = 0x00, + [LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT] = 0x00, + [LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT] = 0x00, + [LTC4015_REG_INPUT_VOLTAGE_HIGH_LIMIT] = 0x00, + [LTC4015_REG_OUTPUT_VOLTAGE_LOW_LIMIT] = 0x00, + [LTC4015_REG_OUTPUT_VOLTAGE_HIGH_LIMIT] = 0x00, + [LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT] = 0x00, + [LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT] = 0x00, + [LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 0x00, + [LTC4015_REG_BATTERY_SERIES_RESISTANCE_HIGH] = 0x00, + [LTC4015_REG_THERMISTOR_RATIO_HIGH] = 0x00, + [LTC4015_REG_THERMISTOR_RATIO_LOW] = 0x00, + [LTC4015_REG_ENABLE_LIMIT_MONITIOR] = 0x00, + [LTC4015_REG_ENABLE_CHARGER_STATE] = 0x00, + [LTC4015_REG_ENABLE_CHARGER_STATUS] = 0x00, + [LTC4015_REG_QCOUNT_LOW_LIMIT] = 0x00, + [LTC4015_REG_QCOUNT_HIGH_LIMIT] = 0x00, + [LTC4015_REG_PRESCALE_FACTOR] = 0x00, + [LTC4015_REG_COLUMB_COUNTER_VALUE] = 0x00, + [LTC4015_REG_CONFIGURATION_SETTING] = 0x00, + [LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING] = 0x00, + [LTC4015_REG_UVCLFB_INPUT_BUFFER] = 0x00, + [LTC4015_REG_RESERVE_1] = 0x00, + [LTC4015_REG_RESERVE_2] = 0x00, + [LTC4015_REG_ARM_SHIP_MODE] = 0x00, + [LTC4015_REG_CHARGE_CURRENT_TARGET] = 0x00, + [LTC4015_REG_VCHARGE_SETTING] = 0x00, + [LTC4015_REG_LOW_BAT_THRESHOLD] = 0x00, + [LTC4015_REG_CV_STATE_BATTER_CHARGER_TIME] = 0x00, + [LTC4015_REG_MAX_CHARGE_TIME] = 0x00, + [LTC4015_REG_JEITA_T1] = 0x00, + [LTC4015_REG_JEITA_T2] = 0x00, + [LTC4015_REG_JEITA_T3] = 0x00, + [LTC4015_REG_JEITA_T4] = 0x00, + [LTC4015_REG_JEITA_T5] = 0x00, + [LTC4015_REG_JEITA_T6] = 0x00, + [LTC4015_REG_VCHARGE_JEITA_6_5] = 0x00, + [LTC4015_REG_VCHARGE_JEITA_4_3_2] = 0x00, + [LTC4015_REG_ICHARGE_TARGET_JEITA_6_5] = 0x00, + [LTC4015_REG_ICHARGE_TARGET_JEITA_4_3_2] = 0x00, + [LTC4015_REG_BATTERY_CHARGER_CFGURATION] = 0x00, + [LTC4015_REG_ABSORB_VOLTAGE] = 0x00, + [LTC4015_REG_ABSORB_CHARGE_MAX_TIME] = 0x00, + [LTC4015_REG_LEADACID_EQUALIZE_CHARGE_VOLTAGE] = 0x00, + [LTC4015_REG_LEADACID_EQUALIZATION_TIME] = 0x00, + [LTC4015_REG_P04_RECHARGE_THRESHOLD] = 0x00, + [LTC4015_REG_RESERVE_3] = 0x00, + [LTC4015_REG_LITHIUM_MAX_CHARGE_TIME] = 0x00, + [LTC4015_REG_LITIUM_CONST_VOLTAGE_REGULATION] = 0x00, + [LTC4015_REG_LEADACID_P04_ABSORB_TIME] = 0x00, + [LTC4015_REG_LEADACID_EQUALIZE_TIME] = 0x00, + [LTC4015_REG_BATTERY_CHARGE_STATE] = 0x00, + [LTC4015_REG_CHARGE_STATUS_INDICATOR] = 0x00, + [LTC4015_REG_LIMIT_ALERT_REGISTER] = 0x00, + [LTC4015_REG_CHARGER_STATE_ALERT_REGISTER] = 0x00, + [LTC4015_REG_CHARGE_STATUS_ALERT_INDICATOR] = 0x00, + [LTC4015_REG_SYSTEM_STATUS_INDICATOR] = 0x00, + [LTC4015_REG_VBAT_VALUE] = 0x00, + [LTC4015_REG_VIN] = 0x00, + [LTC4015_REG_VSYS] = 0x00, + [LTC4015_REG_BATTEY_CURRENT] = 0x00, + [LTC4015_REG_INPUT_CURRENT] = 0x00, + [LTC4015_REG_DIE_TEMPERATURE] = 0x00, + [LTC4015_REG_NTC_THERMISTOR_RATIO] = 0x00, + [LTC4015_REG_BATTERY_SERIES_RESISTANCE] = 0x00, + [LTC4015_REG_NTC_THERMISTOR_JITA_TEMP] = 0x00, + [LTC4015_REG_CHEM_CELLS_PIN] = 0x00, + [LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 0x00, + [LTC4015_REG_CHARGE_VOLTAGE_DAC_CONTROL] = 0x00, + [LTC4015_REG_INPUT_CUEERNT_DAC_CONTROL] = 0x00, + [LTC4015_REG_DIGITALLY_BATTERY_VOLTAGE] = 0x00, + [LTC4015_REG_BSR_IBAT_VALUE] = 0x00, + [LTC4015_REG_RESERVE_4] = 0x00, + [LTC4015_REG_VAILD_BIT_MESURMENT] = 0x00, }; diff --git a/firmware/ec/test/include/test_ltc4015.h b/firmware/ec/test/include/test_ltc4015.h index a3f5e7e1bb..dd73037854 100644 --- a/firmware/ec/test/include/test_ltc4015.h +++ b/firmware/ec/test/include/test_ltc4015.h @@ -24,6 +24,12 @@ #include #include "unity.h" +#define LTC4015_INIT_BATTERY_VOLTAGE_LOW_LIMIT 16470 +#define LTC4015_INIT_BATTERY_VOLTAGE_HIGH_LIMIT 21844 +#define LTC4015_INIT_CHARGE_CURRENT_LOW_LIMIT 2047 +#define LTC4015_INIT_INPUT_VOLTAGE_LOW_LIMIT 9830 +#define LTC4015_INIT_INPUT_CURRENT_HIGH_LIMIT 23892 +#define LTC4015_INIT_INPUT_CURRENT_LIMIT_SETTING 76 /* ======================== Constants & variables =========================== */ extern const OcGpio_FnTable GpioSX1509_fnTable; @@ -50,23 +56,130 @@ typedef enum LTC4015Config { LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, } LTC4015Config; -static const LTC4015_Config fact_lithiumIon_cfg = { - .batteryVoltageLow = 9500, - .batteryVoltageHigh = 12600, - .batteryCurrentLow = 100, - .inputVoltageLow = 16200, - .inputCurrentHigh = 5000, - .inputCurrentLimit = 5570, -}; +/*Enumes are defined as per the LTC4015 datasheet*/ +typedef enum LTC4015Regs { + LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT = 0x01, + LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT, + LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT, + LTC4015_REG_INPUT_VOLTAGE_HIGH_LIMIT, + LTC4015_REG_OUTPUT_VOLTAGE_LOW_LIMIT, + LTC4015_REG_OUTPUT_VOLTAGE_HIGH_LIMIT, + LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT, + LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT, + LTC4015_REG_DIE_TEMP_HIGH_LIMIT, + LTC4015_REG_BATTERY_SERIES_RESISTANCE_HIGH, + LTC4015_REG_THERMISTOR_RATIO_HIGH, + LTC4015_REG_THERMISTOR_RATIO_LOW, + LTC4015_REG_ENABLE_LIMIT_MONITIOR, + LTC4015_REG_ENABLE_CHARGER_STATE, + LTC4015_REG_ENABLE_CHARGER_STATUS, + LTC4015_REG_QCOUNT_LOW_LIMIT, + LTC4015_REG_QCOUNT_HIGH_LIMIT, + LTC4015_REG_PRESCALE_FACTOR, + LTC4015_REG_COLUMB_COUNTER_VALUE, + LTC4015_REG_CONFIGURATION_SETTING, + LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING, + LTC4015_REG_UVCLFB_INPUT_BUFFER, + LTC4015_REG_RESERVE_1, + LTC4015_REG_RESERVE_2, + LTC4015_REG_ARM_SHIP_MODE, + LTC4015_REG_CHARGE_CURRENT_TARGET, + LTC4015_REG_VCHARGE_SETTING, + LTC4015_REG_LOW_BAT_THRESHOLD, + LTC4015_REG_CV_STATE_BATTER_CHARGER_TIME, + LTC4015_REG_MAX_CHARGE_TIME, + LTC4015_REG_JEITA_T1, + LTC4015_REG_JEITA_T2, + LTC4015_REG_JEITA_T3, + LTC4015_REG_JEITA_T4, + LTC4015_REG_JEITA_T5, + LTC4015_REG_JEITA_T6, + LTC4015_REG_VCHARGE_JEITA_6_5, + LTC4015_REG_VCHARGE_JEITA_4_3_2, + LTC4015_REG_ICHARGE_TARGET_JEITA_6_5, + LTC4015_REG_ICHARGE_TARGET_JEITA_4_3_2, + LTC4015_REG_BATTERY_CHARGER_CFGURATION, + LTC4015_REG_ABSORB_VOLTAGE, + LTC4015_REG_ABSORB_CHARGE_MAX_TIME, + LTC4015_REG_LEADACID_EQUALIZE_CHARGE_VOLTAGE, + LTC4015_REG_LEADACID_EQUALIZATION_TIME, + LTC4015_REG_P04_RECHARGE_THRESHOLD, + LTC4015_REG_RESERVE_3, + LTC4015_REG_LITHIUM_MAX_CHARGE_TIME, + LTC4015_REG_LITIUM_CONST_VOLTAGE_REGULATION, + LTC4015_REG_LEADACID_P04_ABSORB_TIME, + LTC4015_REG_LEADACID_EQUALIZE_TIME, + LTC4015_REG_BATTERY_CHARGE_STATE, + LTC4015_REG_CHARGE_STATUS_INDICATOR, + LTC4015_REG_LIMIT_ALERT_REGISTER, + LTC4015_REG_CHARGER_STATE_ALERT_REGISTER, + LTC4015_REG_CHARGE_STATUS_ALERT_INDICATOR, + LTC4015_REG_SYSTEM_STATUS_INDICATOR, + LTC4015_REG_VBAT_VALUE, + LTC4015_REG_VIN, + LTC4015_REG_VSYS, + LTC4015_REG_BATTEY_CURRENT, + LTC4015_REG_INPUT_CURRENT, + LTC4015_REG_DIE_TEMPERATURE, + LTC4015_REG_NTC_THERMISTOR_RATIO, + LTC4015_REG_BATTERY_SERIES_RESISTANCE, + LTC4015_REG_NTC_THERMISTOR_JITA_TEMP, + LTC4015_REG_CHEM_CELLS_PIN, + LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL, + LTC4015_REG_CHARGE_VOLTAGE_DAC_CONTROL, + LTC4015_REG_INPUT_CUEERNT_DAC_CONTROL, + LTC4015_REG_DIGITALLY_BATTERY_VOLTAGE, + LTC4015_REG_BSR_IBAT_VALUE, + LTC4015_REG_RESERVE_4, + LTC4015_REG_VAILD_BIT_MESURMENT, +} LTC4015Regs; -static const LTC4015_Config fact_leadAcid_cfg = { - .batteryVoltageLow = 9500, - .batteryVoltageHigh = 13800, - .batteryCurrentLow = 100, - .inputVoltageLow = 16200, - .inputCurrentHigh = 17000, - .inputCurrentLimit = 16500, - .icharge = 10660, - .vcharge = 12000, -}; +int16_t ocmp_ltc4015_get_battery_current(LTC4015_Dev *dev, int16_t value); + +int16_t ocmp_ltc4015_get_battery_voltage(LTC4015_Dev *dev, int16_t value); + +int16_t ocmp_ltc4015_get_system_voltage(int16_t value); + +int16_t ocmp_ltc4015_get_input_voltage(int16_t value); + +int16_t ocmp_ltc4015_get_input_current(LTC4015_Dev *dev, int16_t value); + +int16_t ocmp_ltc4015_get_dia_temperature(int16_t value); + +int16_t ocmp_ltc4015_get_icharge_dac(LTC4015_Dev *dev, int16_t value); + +int16_t ocmp_ltc4015_get_cfg_battery_current_low(LTC4015_Dev *dev, + int16_t value); + +int16_t ocmp_ltc4015_get_cfg_input_voltage_low(int16_t value); + +int16_t ocmp_ltc4015_get_cfg_input_current_high(LTC4015_Dev *dev, + int16_t value); + +uint16_t ocmp_ltc4015_get_cfg_input_current_limit(LTC4015_Dev *dev, + uint16_t value); + +uint16_t ocmp_ltc4015_get_cfg_icharge(LTC4015_Dev *dev, uint16_t value); + +uint16_t ocmp_ltc4015_get_cfg_vcharge(LTC4015_Dev *dev, uint16_t value); + +int16_t ocmp_ltc4015_get_cfg_die_temperature_high(int16_t value); + +uint16_t ocmp_ltc4015_set_cfg_battery_current_low(LTC4015_Dev *dev, + int16_t value); + +uint16_t ocmp_ltc4015_set_cfg_input_voltage_low(int16_t value); + +uint16_t ocmp_ltc4015_set_cfg_input_current_high(LTC4015_Dev *dev, + int16_t value); + +uint16_t ocmp_ltc4015_set_cfg_input_current_limit(LTC4015_Dev *dev, + int16_t value); +int ocmp_ltc4015_set_cfg_icharge(LTC4015_Dev *dev, uint16_t value); + +double ocmp_ltc4015_set_cfg_vcharge(LTC4015_Dev *dev, int16_t value); + +uint16_t ocmp_ltc4015_set_cfg_die_temperature_high(int16_t value); + +int16_t ocmp_ltc4015_set_cfg_battery_voltage(LTC4015_Dev *dev, int16_t value); #endif diff --git a/firmware/ec/test/include/test_sx1509.h b/firmware/ec/test/include/test_sx1509.h new file mode 100644 index 0000000000..31757667ef --- /dev/null +++ b/firmware/ec/test/include/test_sx1509.h @@ -0,0 +1,127 @@ +/** + * Copyright (c) 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +#ifndef _TEST_SX1509_H +#define _TEST_SX1509_H + +#include + +/*Enumes are defined as per the SX1509 datasheet*/ +typedef enum SX1509Regs { + SX1509_REG_INPUT_DISABLE_B = 0x00, + SX1509_REG_INPUT_DISABLE_A, + SX1509_REG_LONG_SLEW_B, + SX1509_REG_LONG_SLEW_A, + SX1509_REG_LOW_DRIVE_B, + SX1509_REG_LOW_DRIVE_A, + SX1509_REG_PULL_UP_B, + SX1509_REG_PULL_UP_A, + SX1509_REG_PULL_DOWN_B, + SX1509_REG_PULL_DOWN_A, + SX1509_REG_OPEN_DRAIN_B, + SX1509_REG_OPEN_DRAIN_A, + SX1509_REG_POLARITY_B, + SX1509_REG_POLARITY_A, + SX1509_REG_DIR_B, + SX1509_REG_DIR_A, + SX1509_REG_DATA_B, + SX1509_REG_DATA_A, + SX1509_REG_INTERRUPT_MASK_B, + SX1509_REG_INTERRUPT_MASK_A, + SX1509_REG_SENSE_HIGH_B, + SX1509_REG_SENSE_LOW_B, + SX1509_REG_SENSE_HIGH_A, + SX1509_REG_SENSE_LOW_A, + SX1509_REG_INTERRUPT_SOURCE_B, + SX1509_REG_INTERRUPT_SOURCE_A, + SX1509_REG_EVENT_STATUS_B, + SX1509_REG_EVENT_STATUS_A, + SX1509_REG_LEVEL_SHIFTER_1, + SX1509_REG_LEVEL_SHIFTER_2, + SX1509_REG_CLOCK, + SX1509_REG_MISC, + SX1509_REG_LED_DRIVER_ENABLE_B, + SX1509_REG_LED_DRIVER_ENABLE_A, + SX1509_REG_DEBOUNCW_CONFIG, + SX1509_REG_DEBOUNCW_ENABLE_B, + SX1509_REG_DEBOUNCW_ENABLE_A, + SX1509_REG_KEY_CONFIG_1, + SX1509_REG_KEY_CONFIG_2, + SX1509_REG_KEY_DATA_1, + SX1509_REG_KEY_DATA_2, + SX1509_REG_T_ON_0, + SX1509_REG_I_ON_0, + SX1509_REG_OFF_0, + SX1509_REG_T_ON_1, + SX1509_REG_I_ON_1, + SX1509_REG_OFF_1, + SX1509_REG_T_ON_2, + SX1509_REG_I_ON_2, + SX1509_REG_OFF_2, + SX1509_REG_T_ON_3, + SX1509_REG_I_ON_3, + SX1509_REG_OFF_3, + SX1509_REG_T_ON_4, + SX1509_REG_I_ON_4, + SX1509_REG_OFF_4, + SX1509_REG_T_RISE_4, + SX1509_REG_T_Fall_4, + SX1509_REG_T_ON_5, + SX1509_REG_I_ON_5, + SX1509_REG_OFF_5, + SX1509_REG_T_RISE_5, + SX1509_REG_T_Fall_5, + SX1509_REG_T_ON_6, + SX1509_REG_I_ON_6, + SX1509_REG_OFF_6, + SX1509_REG_T_RISE_6, + SX1509_REG_T_Fall_6, + SX1509_REG_T_ON_7, + SX1509_REG_I_ON_7, + SX1509_REG_OFF_7, + SX1509_REG_T_RISE_7, + SX1509_REG_T_Fall_7, + SX1509_REG_T_ON_8, + SX1509_REG_I_ON_8, + SX1509_REG_OFF_8, + SX1509_REG_T_ON_9, + SX1509_REG_I_ON_9, + SX1509_REG_OFF_9, + SX1509_REG_T_ON_10, + SX1509_REG_I_ON_10, + SX1509_REG_OFF_10, + SX1509_REG_T_ON_11, + SX1509_REG_I_ON_11, + SX1509_REG_OFF_11, + SX1509_REG_T_ON_12, + SX1509_REG_I_ON_12, + SX1509_REG_OFF_12, + SX1509_REG_T_RISE_12, + SX1509_REG_T_Fall_12, + SX1509_REG_T_ON_13, + SX1509_REG_I_ON_13, + SX1509_REG_OFF_13, + SX1509_REG_T_RISE_13, + SX1509_REG_T_Fall_13, + SX1509_REG_T_ON_14, + SX1509_REG_I_ON_14, + SX1509_REG_OFF_14, + SX1509_REG_T_RISE_14, + SX1509_REG_T_Fall_14, + SX1509_REG_T_ON_15, + SX1509_REG_I_ON_15, + SX1509_REG_OFF_15, + SX1509_REG_T_RISE_15, + SX1509_REG_T_Fall_15, + SX1509_REG_HIGH_INPUT_B, + SX1509_REG_HIGH_INPUT_A, + SX1509_REG_RESET = 0x7D, + SX1509_REG_TEST_1, + SX1509_REG_TEST_2 +} SX1509Regs; +#endif diff --git a/firmware/ec/test/stub/stub_ltc4015.c b/firmware/ec/test/stub/stub_ltc4015.c new file mode 100644 index 0000000000..93e827590f --- /dev/null +++ b/firmware/ec/test/stub/stub_ltc4015.c @@ -0,0 +1,214 @@ +/** + * Copyright (c) 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +#include +#include "include/test_ltc4015.h" + +#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y)) + +int16_t ocmp_ltc4015_get_battery_voltage(LTC4015_Dev *dev, int16_t value) +{ + switch (dev->cfg.chem) { + case LTC4015_CHEM_LEAD_ACID: + return ((int16_t)value / 1000.0) * (128.176 * dev->cfg.cellcount); + case LTC4015_CHEM_LI_FE_PO4: + case LTC4015_CHEM_LI_ION: + return ((int16_t)value / 1000.0) * (192.264 * dev->cfg.cellcount); + default: + break; + } + return 0; +} + +int16_t ocmp_ltc4015_get_battery_current(LTC4015_Dev *dev, int16_t value) +{ + int16_t expBatteryCurrent = 0; + expBatteryCurrent = ((float)((int16_t)value * 1.46487)) / (dev->cfg.r_snsb); + return expBatteryCurrent; +} + +int16_t ocmp_ltc4015_get_system_voltage(int16_t value) +{ + int16_t expSystemVoltage = 0; + expSystemVoltage = (int16_t)value * 1.648; + return expSystemVoltage; +} + +int16_t ocmp_ltc4015_get_input_voltage(int16_t value) +{ + int16_t expInputVoltage = 0; + expInputVoltage = (int16_t)value * 1.648; + return expInputVoltage; +} + +int16_t ocmp_ltc4015_get_input_current(LTC4015_Dev *dev, int16_t value) +{ + int16_t expInputCurrent = 0; + expInputCurrent = ((float)((int16_t)value * 1.46487)) / (dev->cfg.r_snsi); + return expInputCurrent; +} + +int16_t ocmp_ltc4015_get_dia_temperature(int16_t value) +{ + int16_t expDieTemperature = 0; + expDieTemperature = (((int16_t)value - 12010) / 45.6); + return expDieTemperature; +} + +int16_t ocmp_ltc4015_get_icharge_dac(LTC4015_Dev *dev, int16_t value) +{ + int16_t expICharge = 0; + expICharge = (int16_t)((value + 1) / dev->cfg.r_snsb); + return expICharge; +} + +int16_t ocmp_ltc4015_get_cfg_battery_current_low(LTC4015_Dev *dev, + int16_t value) +{ + int16_t expBatteryCurrentLow = 0; + expBatteryCurrentLow = ((int16_t)value * 1.46487) / dev->cfg.r_snsb; + return expBatteryCurrentLow; +} + +int16_t ocmp_ltc4015_get_cfg_input_voltage_low(int16_t value) +{ + int16_t expInputVoltageLow = 0; + expInputVoltageLow = (int16_t)value * 1.648; + return expInputVoltageLow; +} + +int16_t ocmp_ltc4015_get_cfg_input_current_high(LTC4015_Dev *dev, int16_t value) +{ + int16_t expInputCurrentHigh = 0; + expInputCurrentHigh = ((int16_t)value * 1.46487) / dev->cfg.r_snsi; + return expInputCurrentHigh; +} + +uint16_t ocmp_ltc4015_get_cfg_input_current_limit(LTC4015_Dev *dev, + uint16_t value) +{ + uint16_t expInputCurrentLimit = 0; + expInputCurrentLimit = ((value + 1) * 500.0) / dev->cfg.r_snsi; + return expInputCurrentLimit; +} + +uint16_t ocmp_ltc4015_get_cfg_icharge(LTC4015_Dev *dev, uint16_t value) +{ + uint16_t expIcharge = 0; + expIcharge = (value + 1) * 1000 / dev->cfg.r_snsb; + return expIcharge; +} + +uint16_t ocmp_ltc4015_get_cfg_vcharge(LTC4015_Dev *dev, uint16_t value) +{ + uint16_t vcharge = 0; + switch (dev->cfg.chem) { + case LTC4015_CHEM_LEAD_ACID: + vcharge = + round(((value / 105.0) + 2.0) * dev->cfg.cellcount * 1000.0); + break; + case LTC4015_CHEM_LI_FE_PO4: + vcharge = + round(((value / 80.0) + 3.4125) * dev->cfg.cellcount * 1000.0); + break; + case LTC4015_CHEM_LI_ION: + vcharge = + round(((value / 80.0) + 3.8125) * dev->cfg.cellcount * 1000.0); + break; + default: + break; + } + return vcharge; +} + +int16_t ocmp_ltc4015_get_cfg_die_temperature_high(int16_t value) +{ + int16_t expDieTempHigh = 0; + expDieTempHigh = (((int16_t)value - 12010) / 45.6); + return expDieTempHigh; +} + +int16_t ocmp_ltc4015_set_cfg_battery_voltage(LTC4015_Dev *dev, int16_t value) +{ + switch (dev->cfg.chem) { + case LTC4015_CHEM_LEAD_ACID: + return (value / (dev->cfg.cellcount * 128.176)) * 1000.0; + case LTC4015_CHEM_LI_FE_PO4: + case LTC4015_CHEM_LI_ION: + return (value / (dev->cfg.cellcount * 192.264)) * 1000.0; + default: + break; + } + return 0; +} + +uint16_t ocmp_ltc4015_set_cfg_battery_current_low(LTC4015_Dev *dev, + int16_t value) +{ + uint16_t expBatteryCurrentLow = 0; + expBatteryCurrentLow = (value * dev->cfg.r_snsb) / (1.46487); + return expBatteryCurrentLow; +} + +uint16_t ocmp_ltc4015_set_cfg_input_voltage_low(int16_t value) +{ + uint16_t expInputVoltageLow = 0; + expInputVoltageLow = (value / (1.648)); + return expInputVoltageLow; +} +uint16_t ocmp_ltc4015_set_cfg_input_current_high(LTC4015_Dev *dev, + int16_t value) +{ + uint16_t expInputCurrentHigh = 0; + expInputCurrentHigh = ((value * dev->cfg.r_snsi) / 1.46487); + return expInputCurrentHigh; +} + +uint16_t ocmp_ltc4015_set_cfg_input_current_limit(LTC4015_Dev *dev, + int16_t value) +{ + uint16_t expInputCurrentLimit = 0; + expInputCurrentLimit = ((value * dev->cfg.r_snsi) / 500) - 1; + return expInputCurrentLimit; +} + +int ocmp_ltc4015_set_cfg_icharge(LTC4015_Dev *dev, uint16_t value) +{ + int expIcharge = 0; + expIcharge = round((value * dev->cfg.r_snsb) / 1000.0) - 1; + expIcharge = MAX(0, expIcharge); + return expIcharge; +} + +double ocmp_ltc4015_set_cfg_vcharge(LTC4015_Dev *dev, int16_t value) +{ + double targetV = value / (1000.0 * dev->cfg.cellcount); + double expVChargeSetting = 0; + switch (dev->cfg.chem) { + case LTC4015_CHEM_LEAD_ACID: + expVChargeSetting = round((targetV - 2.0) * 105.0); + break; + case LTC4015_CHEM_LI_FE_PO4: + expVChargeSetting = round((targetV - 3.4125) * 80.0); + break; + case LTC4015_CHEM_LI_ION: + expVChargeSetting = round((targetV - 3.8125) * 80.0); + break; + default: + break; + } + expVChargeSetting = MAX(0, expVChargeSetting); + return expVChargeSetting; +} + +uint16_t ocmp_ltc4015_set_cfg_die_temperature_high(int16_t value) +{ + uint16_t expdieTempAlertLimit = 0; + expdieTempAlertLimit = (value * 45.6) + 12010; + return expdieTempAlertLimit; +} diff --git a/firmware/ec/test/suites/Test_ocmp_ltc4015.c b/firmware/ec/test/suites/Test_ocmp_ltc4015.c index 9945305d14..86b78a7b5b 100644 --- a/firmware/ec/test/suites/Test_ocmp_ltc4015.c +++ b/firmware/ec/test/suites/Test_ocmp_ltc4015.c @@ -8,16 +8,21 @@ */ #include "include/test_ltc4015.h" -extern const I2C_Dev I2C_DEV; +#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y)) + extern bool LTC4015_GpioPins[1]; -extern uint32_t LTC4015_GpioConfig[1]; -extern OcGpio_Port gbc_io_1; -extern OcGpio_Port ec_io; -extern LTC4015_Dev gbc_pwr_int_bat_charger ; -extern LTC4015_Dev gbc_pwr_invalid_dev; -extern LTC4015_Dev gbc_pwr_invalid_bus; +extern const I2C_Dev I2C_DEV; +extern const LTC4015_Config fact_leadAcid_cfg; +extern const LTC4015_Config fact_lithiumIon_cfg; extern LTC4015_Dev gbc_pwr_ext_bat_charger; -extern uint16_t LTC4015_regs[0x4A]; +extern LTC4015_Dev gbc_pwr_int_bat_charger; +extern LTC4015_Dev gbc_pwr_invalid_bus; +extern LTC4015_Dev gbc_pwr_invalid_dev; +extern LTC4015_Dev gbc_pwr_invalid_leadAcid_cfg; +extern OcGpio_Port ec_io; +extern OcGpio_Port gbc_io_1; +extern uint32_t LTC4015_GpioConfig[1]; +extern uint16_t LTC4015_regs[LTC4015_REG_VAILD_BIT_MESURMENT]; extern uint8_t SX1509_regs[0x7F]; /* ============================= Boilerplate ================================ */ @@ -27,14 +32,14 @@ void suite_setUp(void) fake_I2C_init(); fake_I2C_registerDevSimple(gbc_pwr_int_bat_charger.cfg.i2c_dev.bus, - gbc_pwr_int_bat_charger.cfg.i2c_dev.slave_addr, - LTC4015_regs, - sizeof(LTC4015_regs), sizeof(LTC4015_regs[0]), - sizeof(uint8_t), FAKE_I2C_DEV_LITTLE_ENDIAN); + gbc_pwr_int_bat_charger.cfg.i2c_dev.slave_addr, + LTC4015_regs, sizeof(LTC4015_regs), + sizeof(LTC4015_regs[0]), sizeof(uint8_t), + FAKE_I2C_DEV_LITTLE_ENDIAN); - fake_I2C_registerDevSimple(0, 0x45, SX1509_regs, - sizeof(SX1509_regs), sizeof(SX1509_regs[0]), - sizeof(uint8_t), FAKE_I2C_DEV_LITTLE_ENDIAN); + fake_I2C_registerDevSimple(0, 0x45, SX1509_regs, sizeof(SX1509_regs), + sizeof(SX1509_regs[0]), sizeof(uint8_t), + FAKE_I2C_DEV_LITTLE_ENDIAN); } void setUp(void) @@ -54,40 +59,41 @@ void suite_tearDown(void) { fake_I2C_deinit(); /* This will automatically unregister devices */ } -// Parameters are not used as this is just used to test assigning the -// alert_handler right now. +/* Parameters are not used as this is just used to test assigning the + alert_handler right now.*/ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" -void OCMP_GenerateAlert(const AlertData *alert_data, - unsigned int alert_id, +void OCMP_GenerateAlert(const AlertData *alert_data, unsigned int alert_id, const void *data) { - } #pragma GCC diagnostic pop /* ================================ Tests =================================== */ +/* Values are used in the below function are taken as per the datasheet*/ void test_ocmp_ltc4015_probe(void) { POSTData postData; LTC4015_GpioConfig[0x05] = 0; /* Test with the actual value */ - LTC4015_regs[0x39] = LTC4015_CHARGER_ENABLED; + LTC4015_regs[LTC4015_REG_SYSTEM_STATUS_INDICATOR] = LTC4015_CHARGER_ENABLED; TEST_ASSERT_EQUAL(POST_DEV_FOUND, LTC4015_fxnTable.cb_probe( - &gbc_pwr_int_bat_charger, &postData)); + &gbc_pwr_int_bat_charger, &postData)); TEST_ASSERT_EQUAL(OCGPIO_CFG_OUTPUT, LTC4015_GpioConfig[0x05]); - /* Test with an incorrect value */ - LTC4015_regs[0x39] = ~LTC4015_CHARGER_ENABLED; - TEST_ASSERT_EQUAL(POST_DEV_MISSING, LTC4015_fxnTable.cb_probe( - &gbc_pwr_int_bat_charger, &postData)); + /* Test with an incorrect value */ + LTC4015_regs[LTC4015_REG_SYSTEM_STATUS_INDICATOR] = + ~LTC4015_CHARGER_ENABLED; + TEST_ASSERT_EQUAL( + POST_DEV_MISSING, + LTC4015_fxnTable.cb_probe(&gbc_pwr_int_bat_charger, &postData)); /* Test with a missing device */ TEST_ASSERT_EQUAL(POST_DEV_MISSING, LTC4015_fxnTable.cb_probe( - &gbc_pwr_invalid_dev, &postData)); + &gbc_pwr_invalid_dev, &postData)); /* Test with a missing bus */ TEST_ASSERT_EQUAL(POST_DEV_MISSING, LTC4015_fxnTable.cb_probe( - &gbc_pwr_invalid_bus, &postData)); + &gbc_pwr_invalid_bus, &postData)); } void test_ocmp_ltc4015_init(void) @@ -100,734 +106,1204 @@ void test_ocmp_ltc4015_init(void) }; AlertData *alert_data_cp = malloc(sizeof(AlertData)); *alert_data_cp = alert_data; - TEST_ASSERT_EQUAL(POST_DEV_CFG_DONE, LTC4015_fxnTable.cb_init( - &gbc_pwr_int_bat_charger, - &fact_lithiumIon_cfg, alert_data_cp)); - TEST_ASSERT_EQUAL(16470, LTC4015_regs[0x01]); - TEST_ASSERT_EQUAL(21844, LTC4015_regs[0x02]); - TEST_ASSERT_EQUAL(2047, LTC4015_regs[0x08]); - TEST_ASSERT_EQUAL(9830, LTC4015_regs[0x03]); - TEST_ASSERT_EQUAL(23892, LTC4015_regs[0x07]); - TEST_ASSERT_EQUAL(76, LTC4015_regs[0x15]); + TEST_ASSERT_EQUAL(POST_DEV_CFG_DONE, + LTC4015_fxnTable.cb_init(&gbc_pwr_int_bat_charger, + &fact_lithiumIon_cfg, + alert_data_cp)); + TEST_ASSERT_EQUAL(LTC4015_INIT_BATTERY_VOLTAGE_LOW_LIMIT, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(LTC4015_INIT_BATTERY_VOLTAGE_HIGH_LIMIT, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(LTC4015_INIT_CHARGE_CURRENT_LOW_LIMIT, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); + TEST_ASSERT_EQUAL(LTC4015_INIT_INPUT_VOLTAGE_LOW_LIMIT, + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(LTC4015_INIT_INPUT_CURRENT_HIGH_LIMIT, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(LTC4015_INIT_INPUT_CURRENT_LIMIT_SETTING, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); TEST_ASSERT_EQUAL_HEX16(LTC4015_EVT_BVL | LTC4015_EVT_BVH | - LTC4015_EVT_IVL | LTC4015_EVT_ICH | LTC4015_EVT_BCL, - LTC4015_regs[0x0D]); + LTC4015_EVT_IVL | LTC4015_EVT_ICH | + LTC4015_EVT_BCL, + LTC4015_regs[LTC4015_REG_ENABLE_LIMIT_MONITIOR]); /* Test with a missing device */ - TEST_ASSERT_EQUAL(POST_DEV_CFG_FAIL, LTC4015_fxnTable.cb_init( - &gbc_pwr_invalid_dev, - &fact_lithiumIon_cfg, alert_data_cp)); + TEST_ASSERT_EQUAL(POST_DEV_CFG_FAIL, + LTC4015_fxnTable.cb_init(&gbc_pwr_invalid_dev, + &fact_lithiumIon_cfg, + alert_data_cp)); /* Test with a missing bus */ - TEST_ASSERT_EQUAL(POST_DEV_CFG_FAIL, LTC4015_fxnTable.cb_init( - &gbc_pwr_invalid_bus, - &fact_lithiumIon_cfg, alert_data_cp)); + TEST_ASSERT_EQUAL(POST_DEV_CFG_FAIL, + LTC4015_fxnTable.cb_init(&gbc_pwr_invalid_bus, + &fact_lithiumIon_cfg, + alert_data_cp)); + + /* Test for _choose_battery_charge false */ + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_init(&gbc_pwr_invalid_leadAcid_cfg, + &fact_lithiumIon_cfg, alert_data_cp)); } -void test_ocmp_ltc4015_get_status(void) +void test_ocmp_ltc4015_battery_voltage_get_status(void) { int16_t batteryVoltage = 0; - int16_t batteryCurrent = 0; - int16_t systemVoltage = 0; - int16_t inputVoltage = 0; - int16_t inputCurrent = 0; - uint16_t dieTemperature = 0; - int16_t iCharge = 0; - int16_t buffer = 0; + int16_t expectedValue = 0; - /* Test lithium ion chemistry */ /* Battery Voltage(VBATSENS/cellcount) = [VBAT] <95> 192.264(uV) */ - LTC4015_regs[0x3A] = 15603; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_BATTERY_VOLTAGE, &batteryVoltage)); - TEST_ASSERT_EQUAL(8999, batteryVoltage); + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_VBAT_VALUE] = 15603; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_int_bat_charger, + LTC4015_STATUS_BATTERY_VOLTAGE, + &batteryVoltage)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_int_bat_charger, LTC4015_regs[LTC4015_REG_VBAT_VALUE]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltage); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_VBAT_VALUE] = 17945; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_ext_bat_charger, + LTC4015_STATUS_BATTERY_VOLTAGE, + &batteryVoltage)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_ext_bat_charger, LTC4015_regs[LTC4015_REG_VBAT_VALUE]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltage); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_VBAT_VALUE] = 15603; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_dev, + LTC4015_STATUS_BATTERY_VOLTAGE, + &batteryVoltage)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_VBAT_VALUE] = 15603; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_bus, + LTC4015_STATUS_BATTERY_VOLTAGE, + &batteryVoltage)); +} + +void test_ocmp_ltc4015_battery_current_get_status(void) +{ + int16_t batteryCurrent = 0; + int16_t expectedValue = 0; /* IBAT_LO_ALERT_LIMIT = (limit*RSNSB)/1.46487uV */ - LTC4015_regs[0x3D] = 2048; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_BATTERY_CURRENT, &batteryCurrent)); - TEST_ASSERT_EQUAL(100, batteryCurrent); + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_BATTEY_CURRENT] = 2048; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_int_bat_charger, + LTC4015_STATUS_BATTERY_CURRENT, + &batteryCurrent)); + expectedValue = ocmp_ltc4015_get_battery_current( + &gbc_pwr_int_bat_charger, LTC4015_regs[LTC4015_REG_BATTEY_CURRENT]); + TEST_ASSERT_EQUAL(expectedValue, batteryCurrent); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_BATTEY_CURRENT] = 8276; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_ext_bat_charger, + LTC4015_STATUS_BATTERY_CURRENT, + &batteryCurrent)); + expectedValue = ocmp_ltc4015_get_battery_current( + &gbc_pwr_ext_bat_charger, LTC4015_regs[LTC4015_REG_BATTEY_CURRENT]); + TEST_ASSERT_EQUAL(expectedValue, batteryCurrent); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_BATTEY_CURRENT] = 2048; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_dev, + LTC4015_STATUS_BATTERY_CURRENT, + &batteryCurrent)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_BATTEY_CURRENT] = 2048; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_bus, + LTC4015_STATUS_BATTERY_CURRENT, + &batteryCurrent)); +} + +void test_ocmp_ltc4015_system_voltage_get_status(void) +{ + int16_t systemVoltage = 0; + int16_t expectedValue = 0; /* System voltage = [VSYS] <95> 1.648mV */ - LTC4015_regs[0x3C] = 7000; + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_VSYS] = 7000; TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_SYSTEM_VOLTAGE, &systemVoltage)); - TEST_ASSERT_EQUAL(11536, systemVoltage); + &gbc_pwr_int_bat_charger, + LTC4015_STATUS_SYSTEM_VOLTAGE, &systemVoltage)); + expectedValue = + ocmp_ltc4015_get_system_voltage(LTC4015_regs[LTC4015_REG_VSYS]); + TEST_ASSERT_EQUAL(expectedValue, systemVoltage); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_VSYS] = 12500; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_ext_bat_charger, + LTC4015_STATUS_SYSTEM_VOLTAGE, &systemVoltage)); + expectedValue = + ocmp_ltc4015_get_system_voltage(LTC4015_regs[LTC4015_REG_VSYS]); + TEST_ASSERT_EQUAL(expectedValue, systemVoltage); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_VSYS] = 12500; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_dev, + LTC4015_STATUS_SYSTEM_VOLTAGE, + &systemVoltage)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_VSYS] = 7000; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_bus, + LTC4015_STATUS_SYSTEM_VOLTAGE, + &systemVoltage)); +} + +void test_ocmp_ltc4015_input_voltage_get_status(void) +{ + int16_t inputVoltage = 0; + int16_t expectedValue = 0; /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x3B] = 3034; + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_VIN] = 3034; TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); - TEST_ASSERT_EQUAL(5000, inputVoltage); + &gbc_pwr_int_bat_charger, + LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); + expectedValue = + ocmp_ltc4015_get_input_voltage(LTC4015_regs[LTC4015_REG_VIN]); + TEST_ASSERT_EQUAL(expectedValue, inputVoltage); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_VIN] = 60; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_ext_bat_charger, + LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); + expectedValue = + ocmp_ltc4015_get_input_voltage(LTC4015_regs[LTC4015_REG_VIN]); + TEST_ASSERT_EQUAL(expectedValue, inputVoltage); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_VIN] = 60; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_dev, + LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_VIN] = 3034; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_bus, + LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); +} + +void test_ocmp_ltc4015_input_current_get_status(void) +{ + int16_t inputCurrent = 0; + int16_t expectedValue = 0; + + /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ + /* Test lithium ion chemistry */ + /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT] = 23892; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_int_bat_charger, + LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); + + expectedValue = ocmp_ltc4015_get_input_current( + &gbc_pwr_int_bat_charger, LTC4015_regs[LTC4015_REG_INPUT_CURRENT]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrent); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT] = 23211; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_ext_bat_charger, + LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); + expectedValue = ocmp_ltc4015_get_input_current( + &gbc_pwr_ext_bat_charger, LTC4015_regs[LTC4015_REG_INPUT_CURRENT]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrent); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT] = 23892; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_dev, + LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT] = 23892; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_bus, + LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); +} + +void test_ocmp_ltc4015_dia_temperature_get_status(void) +{ + int16_t dieTemperature = 0; + int16_t expectedValue = 0; /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x3E] = 23892; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); - TEST_ASSERT_EQUAL(4999, inputCurrent); + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE] = 13606; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_int_bat_charger, + LTC4015_STATUS_DIE_TEMPERATURE, + &dieTemperature)); + expectedValue = ocmp_ltc4015_get_dia_temperature( + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE]); + TEST_ASSERT_EQUAL(expectedValue, dieTemperature); - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP <96> 12010)/45.6°C */ - LTC4015_regs[0x3F] = 13606; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_DIE_TEMPERATURE, &dieTemperature)); - TEST_ASSERT_EQUAL(35, dieTemperature); + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE] = 15666; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_status(&gbc_pwr_int_bat_charger, + LTC4015_STATUS_DIE_TEMPERATURE, + &dieTemperature)); + expectedValue = ocmp_ltc4015_get_dia_temperature( + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE]); + TEST_ASSERT_EQUAL(expectedValue, dieTemperature); - /* Charger Current servo level = (ICHARGE_DAC + 1) <95> 1mV/RSNSB */ - LTC4015_regs[0x44] = 0x1F; + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE] = 15666; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_dev, + LTC4015_STATUS_DIE_TEMPERATURE, + &dieTemperature)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_DIE_TEMPERATURE] = 13606; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status(&gbc_pwr_invalid_bus, + LTC4015_STATUS_DIE_TEMPERATURE, + &dieTemperature)); +} + +void test_ocmp_ltc4015_icharge_dac_get_status(void) +{ + int16_t iCharge = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 31; TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, - LTC4015_STATUS_ICHARGE_DAC, &iCharge)); - TEST_ASSERT_EQUAL(1, iCharge); + &gbc_pwr_int_bat_charger, + LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + expectedValue = ocmp_ltc4015_get_icharge_dac( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL]); + TEST_ASSERT_EQUAL(expectedValue, iCharge); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 31; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_ext_bat_charger, + LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + expectedValue = ocmp_ltc4015_get_icharge_dac( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL]); + TEST_ASSERT_EQUAL(expectedValue, iCharge); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 31; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_dev, LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 31; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_invalid_bus, LTC4015_STATUS_ICHARGE_DAC, &iCharge)); +} + +void test_ocmp_ltc4015_invalid_param_get_status(void) +{ + int16_t buffer = 0; /*Test with invalid paramId*/ - LTC4015_regs[0x44] = 0x1F; + LTC4015_regs[LTC4015_REG_CHARGE_CUEERNT_DAC_CONTROL] = 31; buffer = 0; TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_int_bat_charger, 7, &buffer)); + &gbc_pwr_int_bat_charger, 7, &buffer)); TEST_ASSERT_EQUAL(0, buffer); } -void test_ocmp_ltc4015_get_config(void) +void test_ocmp_ltc4015_get_cfg_battery_voltage_low(void) +{ + int16_t batteryVoltageLow = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT] = 15603; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVoltageLow)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltageLow); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT] = 13458; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVoltageLow)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltageLow); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT] = 13458; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVoltageLow)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT] = 13458; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVoltageLow)); +} + +void test_ocmp_ltc4015_get_cfg_battery_voltage_high(void) +{ + int16_t batteryVoltageHigh = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT] = 21845; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVoltageHigh)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltageHigh); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT] = 17945; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVoltageHigh)); + expectedValue = ocmp_ltc4015_get_battery_voltage( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryVoltageHigh); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT] = 17945; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVoltageHigh)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT] = 17945; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVoltageHigh)); +} + +void test_ocmp_ltc4015_get_cfg_battery_current_low(void) +{ + int16_t batteryCurrentLow = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT] = 2048; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + expectedValue = ocmp_ltc4015_get_cfg_battery_current_low( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryCurrentLow); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT] = 8276; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + expectedValue = ocmp_ltc4015_get_cfg_battery_current_low( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, batteryCurrentLow); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT] = 8276; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT] = 8276; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); +} + +void test_ocmp_ltc4015_get_cfg_input_voltage_low(void) +{ + int16_t inputVoltageLow = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT] = 60; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + expectedValue = ocmp_ltc4015_get_cfg_input_voltage_low( + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, inputVoltageLow); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT] = 60; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + expectedValue = ocmp_ltc4015_get_cfg_input_voltage_low( + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, inputVoltageLow); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT] = 60; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config(&gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT] = 60; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config(&gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); +} + +void test_ocmp_ltc4015_get_cfg_input_current_high(void) +{ + int16_t inputCurrentHigh = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT] = 23211; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + expectedValue = ocmp_ltc4015_get_cfg_input_current_high( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrentHigh); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT] = 23211; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + expectedValue = ocmp_ltc4015_get_cfg_input_current_high( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrentHigh); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT] = 23211; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config(&gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT] = 23211; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config(&gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); +} + +void test_ocmp_ltc4015_get_cfg_input_current_limit(void) +{ + uint16_t inputCurrentLimit = 0; + uint16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING] = 76; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + expectedValue = ocmp_ltc4015_get_cfg_input_current_limit( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrentLimit); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING] = 200; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + expectedValue = ocmp_ltc4015_get_cfg_input_current_limit( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); + TEST_ASSERT_EQUAL(expectedValue, inputCurrentLimit); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING] = 200; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING] = 200; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); +} + +void test_ocmp_ltc4015_get_cfg_icharge(void) +{ + uint16_t icharge = 0; + uint16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET] = 8; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_ICHARGE, &icharge)); + expectedValue = ocmp_ltc4015_get_cfg_icharge( + &gbc_pwr_int_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET]); + TEST_ASSERT_EQUAL(expectedValue, icharge); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET] = 11; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_ICHARGE, &icharge)); + expectedValue = ocmp_ltc4015_get_cfg_icharge( + &gbc_pwr_ext_bat_charger, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET]); + TEST_ASSERT_EQUAL(expectedValue, icharge); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET] = 12; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, LTC4015_CONFIG_ICHARGE, &icharge)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET] = 12; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, LTC4015_CONFIG_ICHARGE, &icharge)); +} + +void test_ocmp_ltc4015_get_cfg_vcharge(void) +{ + uint16_t vcharge = 0; + uint16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_VCHARGE_SETTING] = 31; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_VCHARGE, &vcharge)); + expectedValue = ocmp_ltc4015_get_cfg_vcharge( + &gbc_pwr_int_bat_charger, LTC4015_regs[LTC4015_REG_VCHARGE_SETTING]); + TEST_ASSERT_EQUAL(expectedValue, vcharge); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_VCHARGE_SETTING] = 60; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_get_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_VCHARGE, &vcharge)); + expectedValue = ocmp_ltc4015_get_cfg_vcharge( + &gbc_pwr_ext_bat_charger, LTC4015_regs[LTC4015_REG_VCHARGE_SETTING]); + TEST_ASSERT_EQUAL(expectedValue, vcharge); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_VCHARGE_SETTING] = 11; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, LTC4015_CONFIG_VCHARGE, &vcharge)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_VCHARGE_SETTING] = 11; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, LTC4015_CONFIG_VCHARGE, &vcharge)); +} + +void test_ocmp_ltc4015_get_cfg_die_temperature_high(void) +{ + int16_t dieTempHigh = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 15658; + TEST_ASSERT_EQUAL(true, + LTC4015_fxnTable.cb_get_config( + &gbc_pwr_int_bat_charger, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &dieTempHigh)); + expectedValue = ocmp_ltc4015_get_cfg_die_temperature_high( + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, dieTempHigh); + + /* Test lead acid chemistry */ + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 11554; + TEST_ASSERT_EQUAL(true, + LTC4015_fxnTable.cb_get_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &dieTempHigh)); + expectedValue = ocmp_ltc4015_get_cfg_die_temperature_high( + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT]); + TEST_ASSERT_EQUAL(expectedValue, dieTempHigh); + + /* Test with a missing device */ + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 15658; + TEST_ASSERT_EQUAL(false, + LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &dieTempHigh)); + + /* Test with a missing bus */ + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 15658; + TEST_ASSERT_EQUAL(false, + LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &dieTempHigh)); +} + +void test_ocmp_ltc4015_get_cfg_invalid_param(void) { int16_t buffer = 0; - uint16_t inputCurrent = 0; - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x01] = 13458; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(10349, buffer); - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x02] = 17945; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(13800, buffer); - - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - LTC4015_regs[0x08] = 8276; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); - TEST_ASSERT_EQUAL(4041, buffer); - - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x03] = 60; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(98, buffer); - - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x07] = 23211; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - TEST_ASSERT_EQUAL(17000, buffer); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - LTC4015_regs[0x15] = 200; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - TEST_ASSERT_EQUAL(50250, inputCurrent); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - LTC4015_regs[0x1A] = 12; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_ICHARGE, &buffer)); - TEST_ASSERT_EQUAL(4333, buffer); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - LTC4015_regs[0x1B] = 11; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_VCHARGE, &buffer)); - TEST_ASSERT_EQUAL(12629, buffer); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - LTC4015_regs[0x09] = 15658; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(80, buffer); /*Test with invalid paramId*/ - LTC4015_regs[0x09] = 15658; - buffer = 0; + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 15658; TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_ext_bat_charger, 9, &buffer)); + &gbc_pwr_ext_bat_charger, 9, &buffer)); TEST_ASSERT_EQUAL(0, buffer); } -void test_ocmp_ltc4015_set_config(void) +void test_ocmp_ltc4015_set_cfg_battery_voltage_low(void) { - int16_t buffer = 0; - uint32_t inputCurrent = 0; - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - buffer = 10350; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(13458, LTC4015_regs[0x01]); - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 128.176(uV) */ - buffer = 13800; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(17944, LTC4015_regs[0x02]); - - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - buffer = 4041; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); - TEST_ASSERT_EQUAL(8275, LTC4015_regs[0x08]); - - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - buffer = 98; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(59, LTC4015_regs[0x03]); - - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - buffer = 17000; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - TEST_ASSERT_EQUAL(23210, LTC4015_regs[0x07]); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - inputCurrent = 50250; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - TEST_ASSERT_EQUAL(200, LTC4015_regs[0x15]); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - buffer = 4333; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_ICHARGE, &buffer)); - TEST_ASSERT_EQUAL(12, LTC4015_regs[0x1A]); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - buffer = 12629; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_VCHARGE, &buffer)); - TEST_ASSERT_EQUAL(11, LTC4015_regs[0x1B]); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - buffer = 80; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(15658, LTC4015_regs[0x09]); - - /*Test with invalid paramId*/ - buffer = 80; - LTC4015_regs[0x09] = 0; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, 9, &buffer)); - TEST_ASSERT_EQUAL(0, LTC4015_regs[0x09]); -} - -void test_ocmp_ltc4015_upper_boundary_value(void) -{ - uint32_t buffer = 0; - uint32_t inputCurrent = 0; - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(1304, LTC4015_regs[0x01]); - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 128.176(uV) */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(1304, LTC4015_regs[0x02]); - - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); - TEST_ASSERT_EQUAL(2054, LTC4015_regs[0x08]); - - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(608, LTC4015_regs[0x03]); - - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - TEST_ASSERT_EQUAL(1369, LTC4015_regs[0x07]); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - inputCurrent = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - TEST_ASSERT_EQUAL(3, LTC4015_regs[0x15]); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_ICHARGE, &buffer)); - TEST_ASSERT_EQUAL(2, LTC4015_regs[0x1A]); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_VCHARGE, &buffer)); - TEST_ASSERT_EQUAL(0, LTC4015_regs[0x1B]); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - buffer = 66539; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(57746, LTC4015_regs[0x09]); -} - -void test_ocmp_ltc4015_lower_boundary_value(void) -{ - int16_t buffer = 0; - int16_t inputCurrent = 0; - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(65088, LTC4015_regs[0x01]); - - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 128.176(uV) */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(65088, LTC4015_regs[0x02]); - - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); - TEST_ASSERT_EQUAL(64830, LTC4015_regs[0x08]); - - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); - TEST_ASSERT_EQUAL(65327, LTC4015_regs[0x03]); - - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - TEST_ASSERT_EQUAL(65065, LTC4015_regs[0x07]); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - inputCurrent = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - TEST_ASSERT_EQUAL(259, LTC4015_regs[0x15]); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_ICHARGE, &buffer)); - TEST_ASSERT_EQUAL(195, LTC4015_regs[0x1A]); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_VCHARGE, &buffer)); - TEST_ASSERT_EQUAL(931, LTC4015_regs[0x1B]); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - buffer = -345; - TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_ext_bat_charger, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); - TEST_ASSERT_EQUAL(61814, LTC4015_regs[0x09]); -} - -void test_ocmp_ltc4015_get_status_for_invalid_device(void) -{ - int16_t batteryVoltage = 0; - int16_t batteryCurrent = 0; - int16_t systemVoltage = 0; - int16_t inputVoltage = 0; - int16_t inputCurrent = 0; - uint16_t dieTemperature = 0; - int16_t iCharge = 0; + int16_t batteryVolLow = 0; + uint16_t expectedValue = 0; /* Test lithium ion chemistry */ - /* Battery Voltage(VBATSENS/cellcount) = [VBAT] <95> 192.264(uV) */ - LTC4015_regs[0x3A] = 15603; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_BATTERY_VOLTAGE, &batteryVoltage)); + batteryVolLow = 9000; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVolLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_int_bat_charger, batteryVolLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); - /* IBAT_LO_ALERT_LIMIT = (limit*RSNSB)/1.46487uV */ - LTC4015_regs[0x3D] = 2048; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_BATTERY_CURRENT, &batteryCurrent)); + /* Test lead acid chemistry */ + batteryVolLow = 10350; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVolLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_ext_bat_charger, batteryVolLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); - /* System voltage = [VSYS] <95> 1.648mV */ - LTC4015_regs[0x3C] = 7000; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_SYSTEM_VOLTAGE, &systemVoltage)); + /* Make sure too-low values don't do anything bad */ + batteryVolLow = 100; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, + &batteryVolLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_ext_bat_charger, batteryVolLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_LOW_LIMIT]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x3B] = 3034; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); + /* Test with a missing device */ + batteryVolLow = 10350; + TEST_ASSERT_EQUAL(false, + LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &batteryVolLow)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x3E] = 23892; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP <96> 12010)/45.6°C */ - LTC4015_regs[0x3F] = 13606; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_DIE_TEMPERATURE, &dieTemperature)); - - /* Charger Current servo level = (ICHARGE_DAC + 1) <95> 1mV/RSNSB */ - LTC4015_regs[0x44] = 0x1F; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_dev, - LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + /* Test with a missing bus */ + batteryVolLow = 10350; + TEST_ASSERT_EQUAL(false, + LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &batteryVolLow)); } -void test_ocmp_ltc4015_get_status_for_invalid_bus(void) +void test_ocmp_ltc4015_set_cfg_battery_voltage_high(void) { - int16_t batteryVoltage = 0; - int16_t batteryCurrent = 0; - int16_t systemVoltage = 0; - int16_t inputVoltage = 0; - int16_t inputCurrent = 0; - uint16_t dieTemperature = 0; - int16_t iCharge = 0; + int16_t batteryVolHigh = 0; + int16_t expectedValue = 0; /* Test lithium ion chemistry */ - /* Battery Voltage(VBATSENS/cellcount) = [VBAT] <95> 192.264(uV) */ - LTC4015_regs[0x3A] = 15603; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_BATTERY_VOLTAGE, &batteryVoltage)); + batteryVolHigh = 12600; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVolHigh)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_int_bat_charger, batteryVolHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); - /* IBAT_LO_ALERT_LIMIT = (limit*RSNSB)/1.46487uV */ - LTC4015_regs[0x3D] = 2048; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_BATTERY_CURRENT, &batteryCurrent)); + /* Test lead acid chemistry */ + batteryVolHigh = 13800; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVolHigh)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_ext_bat_charger, batteryVolHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); - /* System voltage = [VSYS] <95> 1.648mV */ - LTC4015_regs[0x3C] = 7000; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_SYSTEM_VOLTAGE, &systemVoltage)); + /* Make sure too-high values don't do anything bad */ + batteryVolHigh = 35500; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVolHigh)); + expectedValue = ocmp_ltc4015_set_cfg_battery_voltage( + &gbc_pwr_ext_bat_charger, batteryVolHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_BATTERY_VOLTAGE_HIGH_LIMIT]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x3B] = 3034; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_INPUT_VOLATGE, &inputVoltage)); + /* Test with a missing device */ + batteryVolHigh = 13800; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVolHigh)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x3E] = 23892; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_INPUT_CURRENT, &inputCurrent)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP <96> 12010)/45.6°C */ - LTC4015_regs[0x3F] = 13606; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_DIE_TEMPERATURE, &dieTemperature)); - - /* Charger Current servo level = (ICHARGE_DAC + 1) <95> 1mV/RSNSB */ - LTC4015_regs[0x44] = 0x1F; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( - &gbc_pwr_invalid_bus, - LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + /* Test with a missing bus */ + batteryVolHigh = 13800; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + &batteryVolHigh)); } -void test_ocmp_ltc4015_get_config_for_invalid_device(void) +void test_ocmp_ltc4015_set_cfg_battery_current_low(void) { - int16_t buffer = 0; - uint16_t inputCurrent = 0; + int16_t batteryCurrentLow = 0; + int16_t expectedValue = 0; - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x01] = 13458; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + /* Test lithium ion chemistry */ + batteryCurrentLow = 100; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_current_low( + &gbc_pwr_int_bat_charger, batteryCurrentLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x02] = 17945; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); + /* Test lead acid chemistry */ + batteryCurrentLow = 2000; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_current_low( + &gbc_pwr_ext_bat_charger, batteryCurrentLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - LTC4015_regs[0x08] = 8276; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); + /* Make sure too-low values don't do anything bad */ + batteryCurrentLow = 20; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); + expectedValue = ocmp_ltc4015_set_cfg_battery_current_low( + &gbc_pwr_ext_bat_charger, batteryCurrentLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_LOW_LIMIT]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x03] = 60; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); + /* Test with a missing device */ + batteryCurrentLow = 4041; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x07] = 23211; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - LTC4015_regs[0x15] = 200; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - LTC4015_regs[0x1A] = 12; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_ICHARGE, &buffer)); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - LTC4015_regs[0x1B] = 11; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_VCHARGE, &buffer)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - LTC4015_regs[0x09] = 15658; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); + /* Test with a missing bus */ + batteryCurrentLow = 4041; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + &batteryCurrentLow)); } - -void test_ocmp_ltc4015_get_config_for_invalid_bus(void) +void test_ocmp_ltc4015_set_cfg_input_voltage_low(void) { - int16_t buffer = 0; - uint16_t inputCurrent = 0; + int16_t inputVoltageLow = 0; + int16_t expectedValue = 0; - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x01] = 13458; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + /* Test lithium ion chemistry */ + inputVoltageLow = 16200; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + expectedValue = ocmp_ltc4015_set_cfg_input_voltage_low(inputVoltageLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - LTC4015_regs[0x02] = 17945; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); + /* Test lead acid chemistry */ + inputVoltageLow = 16200; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + expectedValue = ocmp_ltc4015_set_cfg_input_voltage_low(inputVoltageLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - LTC4015_regs[0x08] = 8276; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); + /* Make sure too-low values don't do anything bad */ + inputVoltageLow = 100; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); + expectedValue = ocmp_ltc4015_set_cfg_input_voltage_low(inputVoltageLow); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_VOLTAGE_LOW_LIMIT]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - LTC4015_regs[0x03] = 60; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); + /* Test with a missing device */ + inputVoltageLow = 16200; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config(&gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - LTC4015_regs[0x07] = 23211; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - LTC4015_regs[0x15] = 200; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - LTC4015_regs[0x1A] = 12; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_ICHARGE, &buffer)); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - LTC4015_regs[0x1B] = 11; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_VCHARGE, &buffer)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - LTC4015_regs[0x09] = 15658; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); + /* Test with a missing bus */ + inputVoltageLow = 16200; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config(&gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + &inputVoltageLow)); } -void test_ocmp_ltc4015_set_config_for_invalid_device(void) +void test_ocmp_ltc4015_set_input_current_high(void) { - int16_t buffer = 0; - uint32_t inputCurrent = 0; + int16_t inputCurrentHigh = 0; + int16_t expectedValue = 0; - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - buffer = 10350; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + /* Test lithium ion chemistry */ + inputCurrentHigh = 17000; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_high( + &gbc_pwr_int_bat_charger, inputCurrentHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 128.176(uV) */ - buffer = 13800; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); + /* Test lead acid chemistry */ + inputCurrentHigh = 17000; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_high( + &gbc_pwr_ext_bat_charger, inputCurrentHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - buffer = 4041; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); + /* Make sure too-low values don't do anything bad */ + inputCurrentHigh = 100; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_high( + &gbc_pwr_ext_bat_charger, inputCurrentHigh); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_HIGH_LIMIT]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - buffer = 98; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); + /* Test with a missing device */ + inputCurrentHigh = 17000; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config(&gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - buffer = 17000; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - inputCurrent = 50250; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - buffer = 4333; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_ICHARGE, &buffer)); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - buffer = 12629; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_VCHARGE, &buffer)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - buffer = 80; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_dev, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); + /* Test with a missing bus */ + inputCurrentHigh = 17000; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config(&gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + &inputCurrentHigh)); } -void test_ocmp_ltc4015_set_config_for_invalid_bus(void) +void test_ocmp_ltc4015_set_input_current_limit(void) { - int16_t buffer = 0; - uint32_t inputCurrent = 0; + int16_t inputCurrentLimit = 0; + int16_t expectedValue = 0; - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 192.264(uV) */ - buffer = 10350; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + /* Test lithium ion chemistry */ + inputCurrentLimit = 16500; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_limit( + &gbc_pwr_int_bat_charger, inputCurrentLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); - /* under voltage limit = [VBAT_LO_ALERT_LIMIT] • 128.176(uV) */ - buffer = 13800; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, &buffer)); + /* Test lead acid chemistry */ + inputCurrentLimit = 16500; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_limit( + &gbc_pwr_ext_bat_charger, inputCurrentLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); - /* IBAT_LO_ALERT_LIMIT = (limit*1.46487uV )/RSNSB*/ - buffer = 4041; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_BATTERY_CURRENT_LOW, &buffer)); + /* Make sure too-low values don't do anything bad */ + inputCurrentLimit = 400; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); + expectedValue = ocmp_ltc4015_set_cfg_input_current_limit( + &gbc_pwr_ext_bat_charger, inputCurrentLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_INPUT_CURRENT_LIMIT_SETTING]); - /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ - buffer = 98; + /* Test with a missing device */ + inputCurrentLimit = 16500; TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); - /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ - buffer = 17000; + /* Test with a missing bus */ + inputCurrentLimit = 16500; TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_CURRENT_HIGH, &buffer)); - - /* IIN_LIMIT_SETTING = (limit * RSNSI / 500uV) - 1 */ - inputCurrent = 50250; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_INPUT_CURRENT_LIMIT, &inputCurrent)); - - /* Maximum charge current target = (ICHARGE_TARGET + 1) • 1mV/RSNSB */ - buffer = 4333; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_ICHARGE, &buffer)); - - /* vcharge = (VCHARGE_SETTING/105.0 + 2.0)V/cell w/o temp comp.*/ - buffer = 12629; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_VCHARGE, &buffer)); - - /* DIE_TEMP_HI_ALERT_LIMIT = (DIE_TEMP – 12010)/45.6°C */ - buffer = 80; - TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( - &gbc_pwr_invalid_bus, - LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, &buffer)); + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + &inputCurrentLimit)); +} + +void test_ocmp_ltc4015_set_cfg_icharge(void) +{ + uint16_t icharge = 0; + uint16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + icharge = 4321; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_int_bat_charger, + LTC4015_CONFIG_ICHARGE, &icharge)); + expectedValue = + ocmp_ltc4015_set_cfg_icharge(&gbc_pwr_int_bat_charger, icharge); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET]); + + /* Test lead acid chemistry */ + icharge = 5000; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_ICHARGE, &icharge)); + expectedValue = + ocmp_ltc4015_set_cfg_icharge(&gbc_pwr_ext_bat_charger, icharge); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET]); + + /* Make sure low values are handled properly (iCharge * Rsnsb < 1000) */ + icharge = 100; + TEST_ASSERT_EQUAL( + true, LTC4015_fxnTable.cb_set_config(&gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_ICHARGE, &icharge)); + expectedValue = + ocmp_ltc4015_set_cfg_icharge(&gbc_pwr_ext_bat_charger, icharge); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_CHARGE_CURRENT_TARGET]); + + /* Test with a missing device */ + icharge = 5000; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, LTC4015_CONFIG_ICHARGE, &icharge)); + + /* Test with a missing bus */ + icharge = 5000; + TEST_ASSERT_EQUAL( + false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, LTC4015_CONFIG_ICHARGE, &icharge)); +} + +void test_ocmp_ltc4015_set_vcharge(void) +{ + int16_t vChargeSetting = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + vChargeSetting = 12300; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_int_bat_charger, + LTC4015_CONFIG_VCHARGE, &vChargeSetting)); + expectedValue = + ocmp_ltc4015_set_cfg_vcharge(&gbc_pwr_int_bat_charger, vChargeSetting); + TEST_ASSERT_EQUAL(expectedValue, LTC4015_regs[LTC4015_REG_VCHARGE_SETTING]); + + /* Test lead acid chemistry */ + vChargeSetting = 12600; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_VCHARGE, &vChargeSetting)); + expectedValue = + ocmp_ltc4015_set_cfg_vcharge(&gbc_pwr_ext_bat_charger, vChargeSetting); + TEST_ASSERT_EQUAL(expectedValue, LTC4015_regs[LTC4015_REG_VCHARGE_SETTING]); + + /* Make sure too-low values don't do anything bad */ + vChargeSetting = 6000; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_VCHARGE, &vChargeSetting)); + expectedValue = + ocmp_ltc4015_set_cfg_vcharge(&gbc_pwr_ext_bat_charger, vChargeSetting); + TEST_ASSERT_EQUAL(expectedValue, LTC4015_regs[LTC4015_REG_VCHARGE_SETTING]); + + /* Test with a missing device */ + vChargeSetting = 12629; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, LTC4015_CONFIG_VCHARGE, + &vChargeSetting)); + + /* Test with a missing bus */ + vChargeSetting = 12629; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, LTC4015_CONFIG_VCHARGE, + &vChargeSetting)); +} + +void test_ocmp_ltc4015_set_die_temperature_high(void) +{ + int16_t dieTempAlertLimit = 0; + int16_t expectedValue = 0; + + /* Test lithium ion chemistry */ + dieTempAlertLimit = 80; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_int_bat_charger, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, + &dieTempAlertLimit)); + expectedValue = + ocmp_ltc4015_set_cfg_die_temperature_high(dieTempAlertLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT]); + + /* Test lead acid chemistry */ + dieTempAlertLimit = -10; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, + &dieTempAlertLimit)); + expectedValue = + ocmp_ltc4015_set_cfg_die_temperature_high(dieTempAlertLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT]); + + /* Make sure too-low values don't do anything bad */ + dieTempAlertLimit = 0; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, + &dieTempAlertLimit)); + expectedValue = + ocmp_ltc4015_set_cfg_die_temperature_high(dieTempAlertLimit); + TEST_ASSERT_EQUAL(expectedValue, + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT]); + + /* Test with a missing device */ + dieTempAlertLimit = 80; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_DIE_TEMPERATURE_HIGH, + &dieTempAlertLimit)); + + /* Test with a missing bus */ + dieTempAlertLimit = 80; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, LTC4015_CONFIG_VCHARGE, + &dieTempAlertLimit)); +} + +void test_ocmp_ltc4015_set_cfg_invalid_param(void) +{ + int16_t buffer = 80; + + /* Invalid param test */ + LTC4015_regs[LTC4015_REG_DIE_TEMP_HIGH_LIMIT] = 0; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_ext_bat_charger, 9, &buffer)); +} + +void test_ocmp_ltc4015_alert_handler(void) +{ + int16_t value = 0x0800; + AlertData alert_data = { + .subsystem = 1, + .componentId = 4, + .deviceId = 1, + }; + AlertData *alert_data_cp = malloc(sizeof(AlertData)); + *alert_data_cp = alert_data; + TEST_ASSERT_EQUAL(POST_DEV_CFG_DONE, + LTC4015_fxnTable.cb_init(&gbc_pwr_int_bat_charger, + &fact_lithiumIon_cfg, + alert_data_cp)); + + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_BVL, value, alert_data_cp); + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_BVH, value, alert_data_cp); + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_BCL, value, alert_data_cp); + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_IVL, value, alert_data_cp); + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_ICH, value, alert_data_cp); + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_DTH, value, alert_data_cp); + + /* Test for memory check */ + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_BVL, value, NULL); + + /* Default case test */ + gbc_pwr_int_bat_charger.obj.alert_cb(LTC4015_EVT_BMFA, value, + alert_data_cp); }