diff --git a/firmware/ec/inc/devices/eth_sw.h b/firmware/ec/inc/devices/eth_sw.h index 49e341ffae..dd73f8a0b7 100644 --- a/firmware/ec/inc/devices/eth_sw.h +++ b/firmware/ec/inc/devices/eth_sw.h @@ -147,9 +147,9 @@ typedef struct Eth_TcpClient_Params { uint8_t repeat; } Eth_TcpClient_Params; -ePostCode eth_sw_probe(); -ePostCode eth_sw_init(); -void eth_enable_interrupt(); +ePostCode eth_sw_probe(POSTData *postData); +ePostCode eth_sw_init(Eth_cfg *ethCfg); +void eth_enable_interrupt(void); ReturnStatus get_interrupt(uint8_t port); ReturnStatus eth_sw_get_status_speed(uint8_t port, port_speed *speed); ReturnStatus eth_sw_get_status_duplex(uint8_t port, port_duplex *duplex); diff --git a/firmware/ec/inc/devices/ltc4015.h b/firmware/ec/inc/devices/ltc4015.h index f0f22dbeba..b96f06830e 100644 --- a/firmware/ec/inc/devices/ltc4015.h +++ b/firmware/ec/inc/devices/ltc4015.h @@ -191,4 +191,5 @@ ReturnStatus LTC4015_enableChargerStateAlerts(LTC4015_Dev *dev, ePostCode LTC4015_probe(LTC4015_Dev *dev, POSTData *postData); +void LTC4015_configure(LTC4015_Dev *dev); #endif /* LTC4015_H_ */ diff --git a/firmware/ec/test/Makefile b/firmware/ec/test/Makefile index d7a36beac9..66cd4d6efd 100644 --- a/firmware/ec/test/Makefile +++ b/firmware/ec/test/Makefile @@ -156,6 +156,9 @@ $(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 +$(PATHB)Test_ocmp_ltc4015$(TARGET_EXTENSION): $(STD_FILES) $(TEST_OCMP_LTC4015_SRC) $(INC_M) + $(PATHB)%$(TARGET_EXTENSION): $(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $^ -o $@ $(COV_CMDS) diff --git a/firmware/ec/test/fake/fake_SX1509_register.c b/firmware/ec/test/fake/fake_SX1509_register.c new file mode 100644 index 0000000000..0efb5b36a5 --- /dev/null +++ b/firmware/ec/test/fake/fake_SX1509_register.c @@ -0,0 +1,123 @@ +/** + * 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 + +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, /* */ +}; + diff --git a/firmware/ec/test/fake/fake_ltc4015_register.c b/firmware/ec/test/fake/fake_ltc4015_register.c new file mode 100644 index 0000000000..aef6f13b47 --- /dev/null +++ b/firmware/ec/test/fake/fake_ltc4015_register.c @@ -0,0 +1,142 @@ +/** + * 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/test_ltc4015.h" +#include + +OcGpio_Port ec_io = { + .fn_table = &FakeGpio_fnTable, + .object_data = &(FakeGpio_Obj){}, +}; + +bool LTC4015_GpioPins[] = { + [0x05] = 0x1, +}; + +uint32_t LTC4015_GpioConfig[] = { + [0x05] = OCGPIO_CFG_INPUT, +}; + +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, + }, + .object_data = &(SX1509_Obj){}, +}; + +/* Invalid Device */ +LTC4015_Dev gbc_pwr_invalid_dev = { + .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 }, + }, +}; + +/* Invalid Bus */ +LTC4015_Dev gbc_pwr_invalid_bus = { + .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 }, + }, +}; + +/* ======================== 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 */ +}; diff --git a/firmware/ec/test/include/test_ltc4015.h b/firmware/ec/test/include/test_ltc4015.h new file mode 100644 index 0000000000..a3f5e7e1bb --- /dev/null +++ b/firmware/ec/test/include/test_ltc4015.h @@ -0,0 +1,72 @@ +/** + * 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_LTC4015_H +#define _TEST_LTC4015_H + +#include "common/inc/global/Framework.h" +#include "common/inc/ocmp_wrappers/ocmp_ltc4015.h" +#include "drivers/GpioSX1509.h" +#include "drivers/OcGpio.h" +#include "fake/fake_GPIO.h" +#include "fake/fake_I2C.h" +#include "fake/fake_ThreadedISR.h" +#include "helpers/array.h" +#include "helpers/attribute.h" +#include "helpers/memory.h" +#include "inc/devices/ltc4015.h" +#include +#include +#include "unity.h" + +/* ======================== Constants & variables =========================== */ + +extern const OcGpio_FnTable GpioSX1509_fnTable; + +typedef enum LTC4015Status { + LTC4015_STATUS_BATTERY_VOLTAGE = 0, + LTC4015_STATUS_BATTERY_CURRENT, + LTC4015_STATUS_SYSTEM_VOLTAGE, + LTC4015_STATUS_INPUT_VOLATGE, + LTC4015_STATUS_INPUT_CURRENT, + LTC4015_STATUS_DIE_TEMPERATURE, + LTC4015_STATUS_ICHARGE_DAC +} LTC4015Status; + +typedef enum LTC4015Config { + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW = 0, + LTC4015_CONFIG_BATTERY_VOLTAGE_HIGH, + LTC4015_CONFIG_BATTERY_CURRENT_LOW, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, + LTC4015_CONFIG_INPUT_CURRENT_HIGH, + LTC4015_CONFIG_INPUT_CURRENT_LIMIT, + LTC4015_CONFIG_ICHARGE, + LTC4015_CONFIG_VCHARGE, + 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, +}; + +static const LTC4015_Config fact_leadAcid_cfg = { + .batteryVoltageLow = 9500, + .batteryVoltageHigh = 13800, + .batteryCurrentLow = 100, + .inputVoltageLow = 16200, + .inputCurrentHigh = 17000, + .inputCurrentLimit = 16500, + .icharge = 10660, + .vcharge = 12000, +}; +#endif diff --git a/firmware/ec/test/suites/Test_ocmp_ltc4015.c b/firmware/ec/test/suites/Test_ocmp_ltc4015.c new file mode 100644 index 0000000000..9945305d14 --- /dev/null +++ b/firmware/ec/test/suites/Test_ocmp_ltc4015.c @@ -0,0 +1,833 @@ +/** + * 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/test_ltc4015.h" + +extern const I2C_Dev I2C_DEV; +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 LTC4015_Dev gbc_pwr_ext_bat_charger; +extern uint16_t LTC4015_regs[0x4A]; +extern uint8_t SX1509_regs[0x7F]; + +/* ============================= Boilerplate ================================ */ +void suite_setUp(void) +{ + FakeGpio_registerDevSimple(LTC4015_GpioPins, LTC4015_GpioConfig); + 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); + + 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) +{ + memset(LTC4015_regs, 0, sizeof(LTC4015_regs)); + + OcGpio_init(&gbc_io_1); + + LTC4015_init(&gbc_pwr_int_bat_charger); +} + +void tearDown(void) +{ +} + +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. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +void OCMP_GenerateAlert(const AlertData *alert_data, + unsigned int alert_id, + const void *data) +{ + +} +#pragma GCC diagnostic pop +/* ================================ Tests =================================== */ +void test_ocmp_ltc4015_probe(void) +{ + POSTData postData; + LTC4015_GpioConfig[0x05] = 0; + + /* Test with the actual value */ + LTC4015_regs[0x39] = LTC4015_CHARGER_ENABLED; + TEST_ASSERT_EQUAL(POST_DEV_FOUND, LTC4015_fxnTable.cb_probe( + &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 a missing device */ + TEST_ASSERT_EQUAL(POST_DEV_MISSING, LTC4015_fxnTable.cb_probe( + &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)); +} + +void test_ocmp_ltc4015_init(void) +{ + /* Now try to init with a pin associated */ + 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)); + 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_HEX16(LTC4015_EVT_BVL | LTC4015_EVT_BVH | + LTC4015_EVT_IVL | LTC4015_EVT_ICH | LTC4015_EVT_BCL, + LTC4015_regs[0x0D]); + + /* 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 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)); +} + +void test_ocmp_ltc4015_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; + + /* 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); + + /* 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); + + /* System voltage = [VSYS] <95> 1.648mV */ + LTC4015_regs[0x3C] = 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); + + /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ + LTC4015_regs[0x3B] = 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); + + /* 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); + + /* 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); + + /* Charger Current servo level = (ICHARGE_DAC + 1) <95> 1mV/RSNSB */ + LTC4015_regs[0x44] = 0x1F; + TEST_ASSERT_EQUAL(true, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_int_bat_charger, + LTC4015_STATUS_ICHARGE_DAC, &iCharge)); + TEST_ASSERT_EQUAL(1, iCharge); + + /*Test with invalid paramId*/ + LTC4015_regs[0x44] = 0x1F; + buffer = 0; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_status( + &gbc_pwr_int_bat_charger, 7, &buffer)); + TEST_ASSERT_EQUAL(0, buffer); +} + +void test_ocmp_ltc4015_get_config(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; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_ext_bat_charger, 9, &buffer)); + TEST_ASSERT_EQUAL(0, buffer); +} + +void test_ocmp_ltc4015_set_config(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; + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); +} + +void test_ocmp_ltc4015_get_status_for_invalid_bus(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; + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); +} + +void test_ocmp_ltc4015_get_config_for_invalid_device(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(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_dev, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); +} + + +void test_ocmp_ltc4015_get_config_for_invalid_bus(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(false, LTC4015_fxnTable.cb_get_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_BATTERY_VOLTAGE_LOW, &buffer)); + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); +} + +void test_ocmp_ltc4015_set_config_for_invalid_device(void) +{ + int16_t buffer = 0; + uint32_t inputCurrent = 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)); + + /* 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)); + + /* 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)); + + /* 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)); + + /* 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)); +} + +void test_ocmp_ltc4015_set_config_for_invalid_bus(void) +{ + int16_t buffer = 0; + uint32_t inputCurrent = 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)); + + /* 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)); + + /* 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)); + + /* VIN_LO_ALERT_LIMIT = limit/1.648mV */ + buffer = 98; + TEST_ASSERT_EQUAL(false, LTC4015_fxnTable.cb_set_config( + &gbc_pwr_invalid_bus, + LTC4015_CONFIG_INPUT_VOLTAGE_LOW, &buffer)); + + /* IIN_HI_ALERT_LIMIT = (limit*RSNSI)/1.46487uV */ + buffer = 17000; + 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)); +}