From 4dbc3e4e75d6b45ad7e75cf813722b50f4ebdd11 Mon Sep 17 00:00:00 2001 From: 1624952103 Date: Wed, 4 Mar 2026 17:40:48 +0800 Subject: [PATCH] =?utf8?q?=E6=9B=B4=E6=96=B0hp4750=E9=A9=B1=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../sdk/zhihui/drivers/charge/hp4570/hp4570.c | 981 +++++++++--------- .../sdk/zhihui/drivers/charge/hp4570/hp4570.h | 903 ++++++++-------- .../drivers/charge/service/charge_at_cmd.c | 2 +- .../battery/service/battery_service.cpp | 8 +- .../factorytest_protocol.c | 10 +- 5 files changed, 980 insertions(+), 924 deletions(-) diff --git a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c index f4068ff33..1efa5fdc9 100644 --- a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c +++ b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c @@ -1,6 +1,6 @@ /** - * @file HP4570.c - * @brief This is the source file containing the HP4570 APIs. + * @file HP4570N.c + * @brief This is the source file containing the HP4570N APIs. * @author Hypower Applications * @date June 26, 2023 * @@ -28,9 +28,9 @@ struct CHIP_STATE{ bool safety_mode; bool ntc_hot; bool ntc_cold; -}hp4570_chip_state; +}hp4570n_chip_state; -uint8_t hp4570_i2c_addr = HP4570_I2C_ADDR; +uint8_t hp4570n_i2c_addr = HP4570N_I2C_ADDR; #define SUCCESS 0 #define FAIL 1 @@ -38,20 +38,16 @@ uint8_t hp4570_i2c_addr = HP4570_I2C_ADDR; #define INVALID_INPUT 1 #if defined(BOARD_L22) || defined(BOARD_FD272) -#define HP4570_I2C_BUS I2C_BUS_0 +#define HP4570N_I2C_BUS I2C_BUS_0 #elif defined BOARD_U8 -#define HP4570_I2C_BUS I2C_BUS_3 +#define HP4570N_I2C_BUS I2C_BUS_3 #endif - -bool hp4570_write_reg(uint8_t reg, uint8_t value) -{ - return custom_i2c_write_reg(hp4570_i2c_addr, reg, 1, &value, 1, HP4570_I2C_BUS); - +static bool hp4570n_write_reg(uint8_t reg, uint8_t value){ + return custom_i2c_write_reg(hp4570n_i2c_addr, reg, 1, &value, 1, HP4570N_I2C_BUS); } -bool hp4570_read_reg(uint8_t reg, uint8_t *value) -{ - return custom_i2c_read_regs(hp4570_i2c_addr, reg, 1, value, 1, HP4570_I2C_BUS); +static bool hp4570n_read_reg(uint8_t reg, uint8_t *value){ + return custom_i2c_read_regs(hp4570n_i2c_addr, reg, 1, value, 1, HP4570N_I2C_BUS); } #define INPUT_PARA_FAIL_RETURN(value, min, max) \ @@ -84,169 +80,187 @@ bool hp4570_read_reg(uint8_t reg, uint8_t *value) SET_BIT(value, mask, !en_code, shift); \ } while (0) -// Initialize HP4570 chip -bool hp4570_init(uint8_t chip_ver){ - custom_i2c_init(HP4570_I2C_BUS); - switch (chip_ver){ - case HP4570K: - hp4570_i2c_addr = HP4570_I2C_ADDR; - break; - default: - hp4570_i2c_addr = HP4570_I2C_ADDR; - break; - } - if(hp4570_identify(chip_ver) != SUCCESS) +// Initialize HP4570N chip +bool hp4570n_init(uint8_t chip_ver){ + custom_i2c_init(HP4570N_I2C_BUS); + // switch (chip_ver){ + // case HP4570NK: + // hp4570n_i2c_addr = HP4570NK_I2C_ADDR; + // break; + // default: + // hp4570n_i2c_addr = HP4570N_I2C_ADDR; + // break; + // } + + hp4570n_i2c_addr = HP4570N_I2C_ADDR; + + if(hp4570n_identify(chip_ver) != SUCCESS) { - printf("hp4570_identify(chip_ver) failed !!!! \n"); + printf("hp4570n_identify(chip_ver) failed !!!! \n"); return FAIL; } - printf("hp4570_identify(chip_ver) succed !!!! \n"); - // hp4570_reg_rst(); + printf("hp4570n_identify(chip_ver) succed !!!! \n"); + // hp4570n_reg_rst(); // Add initialization code here, such as configuring registers - hp4570_set_ceb_en(true); + hp4570n_set_ceb_en(true); + + // int ret = hp4570n_set_chrg_vbat_mV(4700.0); + int ret = hp4570n_set_chrg_vbat_mV(4440.0); + printf("hp4570n_set_chrg_vbat_mV ret:%d\n",ret); + + ret = hp4570n_set_high_chrg_ipre_mA(30); + printf("hp4570n_set_high_chrg_ipre_mA(30) ret:%d\n",ret); + ret = hp4570n_set_low_chrg_ipre_mA(30); + printf("hp4570n_set_low_chrg_ipre_mA(30) ret:%d\n",ret); - // int ret = hp4570_set_chrg_vbat_mV(4700.0); - int ret = hp4570_set_chrg_vbat_mV(4440.0); - printf("hp4570_set_chrg_vbat_mV ret:%d\n",ret); + ret = hp4570n_set_chrg_ichg_mA(260); + printf("hp4570n_set_chrg_ichg_mA(400) ret:%d\n",ret); - ret = hp4570_set_chrg_ipre_mA(30); - printf("hp4570_set_chrg_ipre_mA(30) ret:%d\n",ret); + ret = hp4570n_set_chrg_iterm_mA(30); + printf("hp4570n_set_chrg_iterm_mA(30) ret:%d\n",ret); - ret = hp4570_set_chrg_ichg_mA(260); - printf("hp4570_set_chrg_ichg_mA(400) ret:%d\n",ret); + ret = hp4570n_set_iindpm_mA(1000); + printf("hp4570n_set_iindpm_mA(1000) ret:%d\n",ret); - ret = hp4570_set_chrg_iterm_mA(30); - printf("hp4570_set_chrg_iterm_mA(30) ret:%d\n",ret); + ret = hp4570n_set_high_chrg_idead_mA(29); + printf("hp4570n_set_high_chrg_idead_mA(29) ret:%d\n",ret); - ret = hp4570_set_iindpm_mA(1000); - printf("hp4570_set_iindpm_mA(1000) ret:%d\n",ret); + ret = hp4570n_set_low_chrg_idead_mA(29); + printf("hp4570n_set_low_chrg_idead_mA(29) ret:%d\n",ret); + + hp4570n_set_rst_vsys_wvbus_en(false); - ret = hp4570_set_chrg_idead_mA(29); - printf("hp4570_set_chrg_idead_mA(29) ret:%d\n",ret); - #if 0 uint8_t value = 0; - hp4570_read_reg(HP4570_REG_DPM_SET, &value); - printf("HP4570_REG_DPM_SET : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_DPM_SET, &value); + printf("hp4570n_REG_DPM_SET : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL1, &value); - printf("HP4570_REG_SYS_CTRL1 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL1, &value); + printf("hp4570n_REG_SYS_CTRL1 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - printf("HP4570_REG_SYS_CTRL0 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL0, &value); + printf("hp4570n_REG_SYS_CTRL0 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_IDSG_ITERM_SET, &value); - printf("HP4570_REG_IDSG_ITERM_SET : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_IDSG_ITERM_SET, &value); + printf("hp4570n_REG_IDSG_ITERM_SET : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_BAT_VOL_SET, &value); - printf("HP4570_REG_BAT_VOL_SET : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_BAT_VOL_SET, &value); + printf("hp4570n_REG_BAT_VOL_SET : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - printf("HP4570_REG_SYS_CTRL3 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL3, &value); + printf("hp4570n_REG_SYS_CTRL3 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL4, &value); - printf("HP4570_REG_SYS_CTRL4 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL4, &value); + printf("hp4570n_REG_SYS_CTRL4 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - printf("HP4570_REG_CHIP_STAT0 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_CHIP_STAT0, &value); + printf("hp4570n_REG_CHIP_STAT0 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_CHIP_STAT1, &value); - printf("HP4570_REG_CHIP_STAT1 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_CHIP_STAT1, &value); + printf("hp4570n_REG_CHIP_STAT1 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_CHIP_STAT2, &value); - printf("HP4570_REG_CHIP_STAT2 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_CHIP_STAT2, &value); + printf("hp4570n_REG_CHIP_STAT2 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_VIPRE, &value); - printf("HP4570_REG_VIPRE : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_VIPRE, &value); + printf("hp4570n_REG_VIPRE : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_EXT_CTRL, &value); - printf("HP4570_REG_EXT_CTRL : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_EXT_CTRL, &value); + printf("hp4570n_REG_EXT_CTRL : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL5, &value); - printf("HP4570_REG_SYS_CTRL5 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL5, &value); + printf("hp4570n_REG_SYS_CTRL5 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - printf("HP4570_REG_SYS_CTRL6 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL6, &value); + printf("hp4570n_REG_SYS_CTRL6 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - printf("HP4570_REG_SYS_CTRL7 : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_CTRL7, &value); + printf("hp4570n_REG_SYS_CTRL7 : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - printf("HP4570_REG_SYS_WAKE_UP_SRC : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_SYS_WAKE_UP_SRC, &value); + printf("hp4570n_REG_SYS_WAKE_UP_SRC : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_INT0_ENABLE, &value); - printf("HP4570_REG_INT0_ENABLE : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_INT0_ENABLE, &value); + printf("hp4570n_REG_INT0_ENABLE : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_INT0_STAT, &value); - printf("HP4570_REG_INT0_STAT : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_INT0_STAT, &value); + printf("hp4570n_REG_INT0_STAT : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_VID_LSB, &value); - printf("HP4570_REG_VID_LSB : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_VID_LSB, &value); + printf("hp4570n_REG_VID_LSB : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_VID_MSB, &value); - printf("HP4570_REG_VID_MSB : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_VID_MSB, &value); + printf("hp4570n_REG_VID_MSB : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_PID_LSB, &value); - printf("HP4570_REG_PID_LSB : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_PID_LSB, &value); + printf("hp4570n_REG_PID_LSB : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_PID_MSB, &value); - printf("HP4570_REG_PID_MSB : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_PID_MSB, &value); + printf("hp4570n_REG_PID_MSB : 0x%x\n",value); value = 0; - hp4570_read_reg(HP4570_REG_CHIP_VER, &value); - printf("HP4570_REG_CHIP_VER : 0x%x\n",value); + hp4570n_read_reg(hp4570n_REG_CHIP_VER, &value); + printf("hp4570n_REG_CHIP_VER : 0x%x\n",value); #endif - // if( hp4570_set_chrg_vbat_mV(4012.5) && - // hp4570_set_chrg_ipre_mA(34) && - // hp4570_set_chrg_ichg_mA(200) && - // hp4570_set_chrg_iterm_mA(34) && - // hp4570_set_iindpm_mA(1000) && - // hp4570_set_vin_min_mV(3800)) + // if( hp4570n_set_chrg_vbat_mV(4012.5) && + // hp4570n_set_chrg_ipre_mA(34) && + // hp4570n_set_chrg_ichg_mA(200) && + // hp4570n_set_chrg_iterm_mA(34) && + // hp4570n_set_iindpm_mA(1000) && + // hp4570n_set_vin_min_mV(3800)) return SUCCESS; // return FAIL; + // if( hp4570n_set_chrg_vbat_mV(4012.5) && + // // hp4570n_set_chrg_ipre_mA(34) && + // // hp4570n_set_chrg_ichg_mA(200) && + // // hp4570n_set_chrg_iterm_mA(34) && + // // hp4570n_set_iindpm_mA(1000) && + // hp4570n_set_vin_min_mV(3800)) + // return SUCCESS; + // return FAIL; } -bool hp4570_identify(uint8_t chip_ver){ +bool hp4570n_identify(uint8_t chip_ver){ uint8_t vid_value[2]; uint8_t pid_value[2]; uint8_t chip_ver_value; - hp4570_read_reg(HP4570_REG_VID_LSB, &vid_value[0]); - hp4570_read_reg(HP4570_REG_VID_MSB, &vid_value[1]); - hp4570_read_reg(HP4570_REG_PID_LSB, &pid_value[0]); - hp4570_read_reg(HP4570_REG_PID_MSB, &pid_value[1]); - hp4570_read_reg(HP4570_REG_CHIP_VER, &chip_ver_value); + hp4570n_read_reg(HP4570N_REG_VID_LSB, &vid_value[0]); + hp4570n_read_reg(HP4570N_REG_VID_MSB, &vid_value[1]); + hp4570n_read_reg(HP4570N_REG_PID_LSB, &pid_value[0]); + hp4570n_read_reg(HP4570N_REG_PID_MSB, &pid_value[1]); + hp4570n_read_reg(HP4570N_REG_CHIP_VER, &chip_ver_value); - // printf("vid_value[0] : 0x%x , vid_value[1] : 0x%x , pid_value[0] : 0x%x,pid_value[1] : 0x%x chip_ver_value : 0x%x\n",vid_value[0],vid_value[1],pid_value[0],pid_value[1],chip_ver_value); + printf("vid_value[0] : 0x%x , vid_value[1] : 0x%x , pid_value[0] : 0x%x,pid_value[1] : 0x%x chip_ver_value : 0x%x\n",vid_value[0],vid_value[1],pid_value[0],pid_value[1],chip_ver_value); - if((vid_value[0] != HP4570_REG_VID_LSB_DEF) || - (vid_value[1] != HP4570_REG_VID_MSB_DEF) || - (pid_value[0] != HP4570_REG_PID_LSB_DEF)) { + if((vid_value[0] != HP4570N_REG_VID_LSB_DEF) || + (vid_value[1] != HP4570N_REG_VID_MSB_DEF) || + (pid_value[0] != HP4570N_REG_PID_LSB_DEF)) { return FAIL; } @@ -261,679 +275,718 @@ bool hp4570_identify(uint8_t chip_ver){ return SUCCESS; } -void hp4570_entry_shipmode(void){ - hp4570_set_batfet_dis(true); +void hp4570n_entry_shipmode(void){ + hp4570n_set_batfet_dis(true); } -void hp4570_reg_rst(void){ +void hp4570n_reg_rst(void){ // Write 1 will auto be 0 - hp4570_write_reg(HP4570_REG_SYS_CTRL1, HP4570_REG_RST_RESET << HP4570_REG_RST_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL1, HP4570N_REG_RST_RESET << HP4570N_REG_RST_BIT_SHIFT); } -void hp4570_wdt_rst(void){ +void hp4570n_wdt_rst(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL1, &value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL1, &value); // Write 1 will auto be 0 and timer will reset,after watchdog fault,Only write 1 will restart timer - SET_BIT(value, HP4570_WDT_RST_MASK, HP4570_WDT_RST_RESET, HP4570_WDT_RST_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL1,value); + SET_BIT(value, HP4570N_WDT_RST_MASK, HP4570N_WDT_RST_RESET, HP4570N_WDT_RST_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL1,value); } -void hp4570_vsys_rst(void){ +void hp4570n_vsys_rst(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL5, &value); - SET_BIT(value, HP4570_VSYS_RST_MASK, HP4570_VSYS_RST_RESET, HP4570_VSYS_RST_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL5,value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL5, &value); + SET_BIT(value, HP4570N_VSYS_RST_MASK, HP4570N_VSYS_RST_RESET, HP4570N_VSYS_RST_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL5,value); } -bool hp4570_set_vindpm_mV(uint16_t voltage){ +bool hp4570n_set_vindpm_mV(uint16_t voltage){ uint8_t value; uint8_t vin_min_code; - INPUT_PARA_FAIL_RETURN(voltage,HP4570_VIN_MIN_MIN_mV,HP4570_VIN_MIN_MAX_mV); - hp4570_read_reg(HP4570_REG_DPM_SET, &value); - vin_min_code = (uint8_t)((voltage - HP4570_VIN_MIN_OFFSET_mV)/HP4570_VIN_MIN_STEP_mV); - SET_BIT(value, HP4570_VIN_MIN_MASK, vin_min_code, HP4570_VIN_MIN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_DPM_SET, value); + INPUT_PARA_FAIL_RETURN(voltage,HP4570N_VIN_MIN_MIN_mV,HP4570N_VIN_MIN_MAX_mV); + hp4570n_read_reg(HP4570N_REG_DPM_SET, &value); + vin_min_code = (uint8_t)((voltage - HP4570N_VIN_MIN_OFFSET_mV)/HP4570N_VIN_MIN_STEP_mV); + SET_BIT(value, HP4570N_VIN_MIN_MASK, vin_min_code, HP4570N_VIN_MIN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_DPM_SET, value); return SUCCESS; } -bool hp4570_set_iindpm_mA(uint16_t current){ +bool hp4570n_set_iindpm_mA(uint16_t current){ uint8_t value; uint8_t iindpm_code; - INPUT_PARA_FAIL_RETURN(current,HP4570_IINDPM_MIN_mA,HP4570_IINDPM_MAX_mA); - hp4570_read_reg(HP4570_REG_DPM_SET, &value); - iindpm_code = (uint8_t)((current - HP4570_IINDPM_OFFSET_mA)/HP4570_IINDPM_STEP_mA); - SET_BIT(value, HP4570_IINDPM_MASK, iindpm_code, HP4570_IINDPM_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_DPM_SET, value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IINDPM_MIN_mA,HP4570N_IINDPM_MAX_mA); + hp4570n_read_reg(HP4570N_REG_DPM_SET, &value); + iindpm_code = (uint8_t)((current - HP4570N_IINDPM_OFFSET_mA)/HP4570N_IINDPM_STEP_mA); + SET_BIT(value, HP4570N_IINDPM_MASK, iindpm_code, HP4570N_IINDPM_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_DPM_SET, value); return SUCCESS; } -bool hp4570_set_trst_dgl_mS(uint32_t time){ +bool hp4570n_set_trst_dgl_mS(uint32_t time){ uint8_t value; uint8_t trst_dgl_code; - INVALID_INPUT_RETURN(time, trst_dgl_code, HP4570_trst_dgl_time, HP4570_NUM_TRST_DGL_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - SET_BIT(value, HP4570_TRST_DGL_MASK, trst_dgl_code, HP4570_TRST_DGL_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL0, value); + INVALID_INPUT_RETURN(time, trst_dgl_code, HP4570N_trst_dgl_time, HP4570N_NUM_TRST_DGL_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL0, &value); + SET_BIT(value, HP4570N_TRST_DGL_MASK, trst_dgl_code, HP4570N_TRST_DGL_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL0, value); return SUCCESS; } -bool hp4570_set_trst_dur_mS(uint16_t time){ +bool hp4570n_set_trst_dur_mS(uint16_t time){ uint8_t value; uint8_t trst_dur_code; - INVALID_INPUT_RETURN(time, trst_dur_code, HP4570_trst_dur_time, HP4570_NUM_TRST_DUR_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - SET_BIT(value, HP4570_TRST_DUR_MASK, trst_dur_code, HP4570_TRST_DUR_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL0,value); + INVALID_INPUT_RETURN(time, trst_dur_code, HP4570N_trst_dur_time, HP4570N_NUM_TRST_DUR_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL0, &value); + SET_BIT(value, HP4570N_TRST_DUR_MASK, trst_dur_code, HP4570N_TRST_DUR_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL0,value); return SUCCESS; } -void hp4570_set_hiz_en(bool en){ +void hp4570n_set_hiz_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - SET_ENABLE(en, value, HP4570_EN_HIZ_MASK, HP4570_EN_HIZ_ENABLE, HP4570_EN_HIZ_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL0,value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL0, &value); + SET_ENABLE(en, value, HP4570N_EN_HIZ_MASK, HP4570N_EN_HIZ_ENABLE, HP4570N_EN_HIZ_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL0,value); } -void hp4570_set_ceb_en(bool en){ +void hp4570n_set_ceb_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - SET_ENABLE(en, value, HP4570_CEB_MASK, HP4570_CEB_ENABLE, HP4570_CEB_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL0, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL0, &value); + SET_ENABLE(en, value, HP4570N_CEB_MASK, HP4570N_CEB_ENABLE, HP4570N_CEB_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL0, value); } -bool hp4570_set_vbat_uvlo_mV(uint16_t voltage){ +bool hp4570n_set_vbat_uvlo_mV(uint16_t voltage){ uint8_t value; uint8_t vbat_uvlo_code; - hp4570_read_reg(HP4570_REG_SYS_CTRL0, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP4570_VBAT_UVLO_MIN_mV,HP4570_VBAT_UVLO_MAX_mV); - vbat_uvlo_code = (uint8_t)((voltage - HP4570_VBAT_UVLO_OFFSET_mV)/HP4570_VBAT_UVLO_STEP_mV); - SET_BIT(value, HP4570_VBAT_UVLO_MASK, vbat_uvlo_code, HP4570_VBAT_UVLO_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL0, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL0, &value); + INPUT_PARA_FAIL_RETURN(voltage,HP4570N_VBAT_UVLO_MIN_mV,HP4570N_VBAT_UVLO_MAX_mV); + vbat_uvlo_code = (uint8_t)((voltage - HP4570N_VBAT_UVLO_OFFSET_mV)/HP4570N_VBAT_UVLO_STEP_mV); + SET_BIT(value, HP4570N_VBAT_UVLO_MASK, vbat_uvlo_code, HP4570N_VBAT_UVLO_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL0, value); return SUCCESS; } -bool hp4570_set_chrg_ichg_mA(uint16_t current){ +bool hp4570n_set_chrg_ichg_mA(uint16_t current){ uint8_t value; uint8_t ichg_code; - hp4570_read_reg(HP4570_REG_SYS_CTRL1, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570_ICHG_MIN_mA,HP4570_ICHG_MAX_mA); - ichg_code = (uint8_t)((current - HP4570_ICHG_OFFSET_mA)/HP4570_ICHG_STEP_mA); - SET_BIT(value, HP4570_ICHG_MASK, ichg_code, HP4570_ICHG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL1, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL1, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_ICHG_MIN_mA,HP4570N_ICHG_MAX_mA); + ichg_code = (uint8_t)((current - HP4570N_ICHG_OFFSET_mA)/HP4570N_ICHG_STEP_mA); + SET_BIT(value, HP4570N_ICHG_MASK, ichg_code, HP4570N_ICHG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL1, value); return SUCCESS; } -bool hp4570i_set_chrg_ichg_mA(uint16_t current){ +bool hp4570ni_set_chrg_ichg_mA(uint16_t current){ uint8_t value; uint8_t ichg_code; - hp4570_read_reg(HP4570_REG_SYS_CTRL1, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570I_ICHG_MIN_mA,HP4570I_ICHG_MAX_mA); - ichg_code = (uint8_t)((current - HP4570I_ICHG_OFFSET_mA)/HP4570I_ICHG_STEP_mA); - SET_BIT(value, HP4570_ICHG_MASK, ichg_code, HP4570_ICHG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL1, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL1, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570NI_ICHG_MIN_mA,HP4570NI_ICHG_MAX_mA); + ichg_code = (uint8_t)((current - HP4570NI_ICHG_OFFSET_mA)/HP4570NI_ICHG_STEP_mA); + SET_BIT(value, HP4570N_ICHG_MASK, ichg_code, HP4570N_ICHG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL1, value); return SUCCESS; } -bool hp4570_set_ibatfet_ocp_mA(uint16_t current){ +bool hp4570n_set_high_ibatfet_ocp_mA(uint16_t current){ uint8_t value; uint8_t ibatfet_ocp_code; - hp4570_read_reg(HP4570_REG_IDSG_ITERM_SET, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570_IBATFET_OCP_MIN_mA,HP4570_IBATFET_OCP_MAX_mA); - ibatfet_ocp_code = (uint8_t)((current - HP4570_IBATFET_OCP_OFFSET_mA)/HP4570_IBATFET_OCP_STEP_mA); - SET_BIT(value, HP4570_IBATFET_OCP_MASK, ibatfet_ocp_code, HP4570_IBATFET_OCP_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_IDSG_ITERM_SET,value); + hp4570n_set_iterm_2x_en(HP4570N_EN_ITERM_2X_ENABLE); + hp4570n_read_reg(HP4570N_REG_IDSG_ITERM_SET, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IBATFET_OCP_MIN_mA,HP4570N_IBATFET_OCP_MAX_mA); + ibatfet_ocp_code = (uint8_t)((current/2 - HP4570N_IBATFET_OCP_OFFSET_mA)/HP4570N_IBATFET_OCP_STEP_mA); + SET_BIT(value, HP4570N_IBATFET_OCP_MASK, ibatfet_ocp_code, HP4570N_IBATFET_OCP_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_IDSG_ITERM_SET,value); return SUCCESS; } -bool hp4570_set_chrg_iterm_mA(uint8_t current){ +bool hp4570n_set_low_ibatfet_ocp_mA(uint16_t current){ + uint8_t value; + uint8_t ibatfet_ocp_code; + hp4570n_set_iterm_2x_en(!HP4570N_EN_ITERM_2X_ENABLE); + hp4570n_read_reg(HP4570N_REG_IDSG_ITERM_SET, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IBATFET_OCP_MIN_mA,HP4570N_IBATFET_OCP_MAX_mA); + ibatfet_ocp_code = (uint8_t)((current - HP4570N_IBATFET_OCP_OFFSET_mA)/HP4570N_IBATFET_OCP_STEP_mA); + SET_BIT(value, HP4570N_IBATFET_OCP_MASK, ibatfet_ocp_code, HP4570N_IBATFET_OCP_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_IDSG_ITERM_SET,value); + return SUCCESS; +} + +bool hp4570n_set_chrg_iterm_mA(uint8_t current){ uint8_t value; uint8_t iterm_code; - hp4570_read_reg(HP4570_REG_IDSG_ITERM_SET, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570_ITERM_MIN_mA,HP4570_ITERM_MAX_mA); - iterm_code = (uint8_t)((current - HP4570_ITERM_OFFSET_mA)/HP4570_ITERM_STEP_mA); - SET_BIT(value, HP4570_ITERM_MASK, iterm_code, HP4570_ITERM_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_IDSG_ITERM_SET,value); + hp4570n_read_reg(HP4570N_REG_IDSG_ITERM_SET, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_ITERM_MIN_mA,HP4570N_ITERM_MAX_mA); + iterm_code = (uint8_t)((current - HP4570N_ITERM_OFFSET_mA)/HP4570N_ITERM_STEP_mA); + SET_BIT(value, HP4570N_ITERM_MASK, iterm_code, HP4570N_ITERM_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_IDSG_ITERM_SET,value); return SUCCESS; } -bool hp4570_set_chrg_vbat_mV(float voltage){ +bool hp4570n_set_chrg_vbat_mV(float voltage){ uint8_t value; uint8_t vbatreg_code; - hp4570_read_reg(HP4570_REG_BAT_VOL_SET, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP4570_VBATREG_MIN_mV,HP4570_VBATREG_MAX_mV); - vbatreg_code = (uint8_t)((voltage - HP4570_VBATREG_OFFSET_mV)/HP4570_VBATREG_STEP_mV); - SET_BIT(value, HP4570_VBATREG_MASK, vbatreg_code, HP4570_VBATREG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_BAT_VOL_SET,value); + hp4570n_read_reg(HP4570N_REG_BAT_VOL_SET, &value); + INPUT_PARA_FAIL_RETURN(voltage,HP4570N_VBATREG_MIN_mV,HP4570N_VBATREG_MAX_mV); + vbatreg_code = (uint8_t)((voltage - HP4570N_VBATREG_OFFSET_mV)/HP4570N_VBATREG_STEP_mV); + SET_BIT(value, HP4570N_VBATREG_MASK, vbatreg_code, HP4570N_VBATREG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_BAT_VOL_SET,value); return SUCCESS; } -bool hp4570_set_chrg_vpre_mV(uint8_t voltage){ +bool hp4570n_set_chrg_vpre_mV(uint8_t voltage){ uint8_t value0; uint8_t value1; uint8_t vbat_pre_code; - INVALID_INPUT_RETURN(voltage, vbat_pre_code, HP4570_vbat_pre_voltage, HP4570_NUM_VBAT_PRE_VAL); - hp4570_read_reg(HP4570_REG_BAT_VOL_SET, value0); - hp4570_read_reg(HP4570_REG_VIPRE, value1); - SET_BIT(value0, HP4570_VBAT_PRE_0_MASK, (vbat_pre_code & 0x1), HP4570_VBAT_PRE_0_BIT_SHIFT); - SET_BIT(value1, HP4570_VBAT_PRE_1_MASK, (vbat_pre_code & 0x2)>>1, HP4570_VBAT_PRE_1_BIT_SHIFT); - (hp4570_write_reg(HP4570_REG_BAT_VOL_SET,value0) & hp4570_write_reg(HP4570_REG_VIPRE,value1)); + INVALID_INPUT_RETURN(voltage, vbat_pre_code, HP4570N_vbat_pre_voltage, HP4570N_NUM_VBAT_PRE_VAL); + hp4570n_read_reg(HP4570N_REG_BAT_VOL_SET, value0); + hp4570n_read_reg(HP4570N_REG_VIPRE, value1); + SET_BIT(value0, HP4570N_VBAT_PRE_0_MASK, (vbat_pre_code & 0x1), HP4570N_VBAT_PRE_0_BIT_SHIFT); + SET_BIT(value1, HP4570N_VBAT_PRE_1_MASK, (vbat_pre_code & 0x2)>>1, HP4570N_VBAT_PRE_1_BIT_SHIFT); + (hp4570n_write_reg(HP4570N_REG_BAT_VOL_SET,value0) & hp4570n_write_reg(HP4570N_REG_VIPRE,value1)); return SUCCESS; } -bool hp4570_set_chrg_vre_mV(uint8_t voltage){ +bool hp4570n_set_chrg_vre_mV(uint8_t voltage){ uint8_t value; uint8_t vre_chg_code; - INVALID_INPUT_RETURN(voltage, vre_chg_code, HP4570_vre_chg_voltage, HP4570_NUM_VRE_CHG_VAL); - hp4570_read_reg(HP4570_REG_BAT_VOL_SET, &value); - SET_BIT(value, HP4570_VRE_CHG_MASK, vre_chg_code, HP4570_VRE_CHG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_BAT_VOL_SET,value); + INVALID_INPUT_RETURN(voltage, vre_chg_code, HP4570N_vre_chg_voltage, HP4570N_NUM_VRE_CHG_VAL); + hp4570n_read_reg(HP4570N_REG_BAT_VOL_SET, &value); + SET_BIT(value, HP4570N_VRE_CHG_MASK, vre_chg_code, HP4570N_VRE_CHG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_BAT_VOL_SET,value); return SUCCESS; } -void hp4570_set_wdt_dsg_en(bool en){ +void hp4570n_set_wdt_dsg_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP4570_EN_WDT_DSG_MASK, HP4570_EN_WDT_DSG_ENABLE, HP4570_EN_WDT_DSG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_ENABLE(en, value, HP4570N_EN_WDT_DSG_MASK, HP4570N_EN_WDT_DSG_ENABLE, HP4570N_EN_WDT_DSG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2, value); } -void hp4570_set_wdt_timer_en(bool en){ +void hp4570n_set_wdt_timer_en(bool en){ uint8_t value; uint32_t wdt_timer_code; if(!en) - hp4570_set_wdt_timer_mS(HP4570_WDT_TIMER_DIS); - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - value &= HP4570_WDT_TIMER_MASK; - if(value >> HP4570_WDT_TIMER_BIT_SHIFT == HP4570_WDT_TIMER_DIS) + hp4570n_set_wdt_timer_mS(HP4570N_WDT_TIMER_DIS); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + value &= HP4570N_WDT_TIMER_MASK; + if(value >> HP4570N_WDT_TIMER_BIT_SHIFT == HP4570N_WDT_TIMER_DIS) // do nothing return; - wdt_timer_code = (HP4570_REG_SYS_CTRL2_DEF & HP4570_WDT_TIMER_MASK) >> HP4570_WDT_TIMER_BIT_SHIFT; - SET_BIT(value, HP4570_WDT_TIMER_MASK, wdt_timer_code, HP4570_WDT_TIMER_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2,value); + wdt_timer_code = (HP4570N_REG_SYS_CTRL2_DEF & HP4570N_WDT_TIMER_MASK) >> HP4570N_WDT_TIMER_BIT_SHIFT; + SET_BIT(value, HP4570N_WDT_TIMER_MASK, wdt_timer_code, HP4570N_WDT_TIMER_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2,value); } -bool hp4570_set_wdt_timer_mS(uint32_t time){ +bool hp4570n_set_wdt_timer_mS(uint32_t time){ uint8_t value; uint8_t wdt_timer_code; - INVALID_INPUT_RETURN(time, wdt_timer_code, HP4570_watchdog_time, HP4570_NUM_WDT_TIMER_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_BIT(value, HP4570_WDT_TIMER_MASK, wdt_timer_code, HP4570_WDT_TIMER_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2,value); + INVALID_INPUT_RETURN(time, wdt_timer_code, HP4570N_watchdog_time, HP4570N_NUM_WDT_TIMER_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_BIT(value, HP4570N_WDT_TIMER_MASK, wdt_timer_code, HP4570N_WDT_TIMER_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2,value); return SUCCESS; } -void hp4570_set_chrg_term_en(bool en){ +void hp4570n_set_chrg_term_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP4570_EN_TERM_MASK, HP4570_EN_TERM_ENABLE, HP4570_EN_TERM_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_ENABLE(en, value, HP4570N_EN_TERM_MASK, HP4570N_EN_TERM_ENABLE, HP4570N_EN_TERM_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2, value); } -void hp4570_set_chrg_timer_en(bool en){ +void hp4570n_set_chrg_timer_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP4570_EN_TIMER_MASK, HP4570_EN_TIMER_ENABLE, HP4570_EN_TIMER_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_ENABLE(en, value, HP4570N_EN_TIMER_MASK, HP4570N_EN_TIMER_ENABLE, HP4570N_EN_TIMER_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2, value); } -bool hp4570_set_chrg_timer_hour(uint8_t time){ +bool hp4570n_set_chrg_timer_hour(uint8_t time){ uint8_t value; uint8_t chg_timer_code; - INVALID_INPUT_RETURN(time, chg_timer_code, HP4570_fast_chg_time, HP4570_NUM_CHG_TIMER_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_BIT(value, HP4570_CHG_TIMER_MASK, chg_timer_code, HP4570_CHG_TIMER_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2,value); + INVALID_INPUT_RETURN(time, chg_timer_code, HP4570N_fast_chg_time, HP4570N_NUM_CHG_TIMER_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_BIT(value, HP4570N_CHG_TIMER_MASK, chg_timer_code, HP4570N_CHG_TIMER_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2,value); return SUCCESS; } // when TERM_TMR is enabled, the IC will not suspend the charge current after the charge termination -void hp4570_set_chrg_term_tmr(bool en){ +void hp4570n_set_chrg_term_tmr(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP4570_TERM_TMR_MASK, HP4570_TERM_TMR_ENABLE, HP4570_TERM_TMR_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL2, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL2, &value); + SET_ENABLE(en, value, HP4570N_TERM_TMR_MASK, HP4570N_TERM_TMR_ENABLE, HP4570N_TERM_TMR_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL2, value); } -void hp4570_set_ntc_en(bool en){ +void hp4570n_set_ntc_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_NTC_EN_MASK, HP4570_NTC_EN_ENABLE, HP4570_NTC_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_NTC_EN_MASK, HP4570N_NTC_EN_ENABLE, HP4570N_NTC_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } -void hp4570_set_chrg_tmr2x_en(bool en){ +void hp4570n_set_chrg_tmr2x_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_TMR2X_EN_MASK, HP4570_TMR2X_EN_ENABLE, HP4570_TMR2X_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_TMR2X_EN_MASK, HP4570N_TMR2X_EN_ENABLE, HP4570N_TMR2X_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } // when set 1, enter ship mode w/o vbus, the bit will be set to 0 after exiting ship mode -bool hp4570_set_batfet_dis(bool en){ +bool hp4570n_set_batfet_dis(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_BATFET_DIS_MASK, HP4570_BATFET_DIS_ENABLE, HP4570_BATFET_DIS_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_BATFET_DIS_MASK, HP4570N_BATFET_DIS_ENABLE, HP4570N_BATFET_DIS_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); return SUCCESS; } -void hp4570_set_int_pg_en(bool en){ +void hp4570n_set_int_pg_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_PG_INT_CONTROL_MASK, HP4570_PG_INT_CONTROL_ENABLE, HP4570_PG_INT_CONTROL_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_PG_INT_CONTROL_MASK, HP4570N_PG_INT_CONTROL_ENABLE, HP4570N_PG_INT_CONTROL_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } -void hp4570_set_int_chrg_done_en(bool en){ +void hp4570n_set_int_chrg_done_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_CHG_DONE_INT_EN_MASK, HP4570_CHG_DONE_INT_EN_ENABLE, HP4570_CHG_DONE_INT_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_CHG_DONE_INT_EN_MASK, HP4570N_CHG_DONE_INT_EN_ENABLE, HP4570N_CHG_DONE_INT_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } // Include: not charge to CC, Pre into CC ,CC into CV, not charge into CC(Auto recharge) -void hp4570_set_int_chrg_stat_en(bool en){ +void hp4570n_set_int_chrg_stat_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_CHG_STAT_INT_EN_MASK, HP4570_CHG_STAT_INT_EN_ENABLE, HP4570_CHG_STAT_INT_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_CHG_STAT_INT_EN_MASK, HP4570N_CHG_STAT_INT_EN_ENABLE, HP4570N_CHG_STAT_INT_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } -void hp4570_set_int_ntc_transition_en(bool en){ +void hp4570n_set_int_ntc_transition_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_NTC_TRANSITION_EN_MASK, HP4570_NTC_TRANSITION_EN_ENABLE, HP4570_NTC_TRANSITION_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_NTC_TRANSITION_EN_MASK, HP4570N_NTC_TRANSITION_EN_ENABLE, HP4570N_NTC_TRANSITION_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } -void hp4570_set_int_batovp_en(bool en){ +void hp4570n_set_int_batovp_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP4570_BATOVP_INT_EN_MASK, HP4570_BATOVP_INT_EN_ENABLE, HP4570_BATOVP_INT_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL3, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL3, &value); + SET_ENABLE(en, value, HP4570N_BATOVP_INT_EN_MASK, HP4570N_BATOVP_INT_EN_ENABLE, HP4570N_BATOVP_INT_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL3, value); } -void hp4570_set_pcb_otp_en(bool en){ +void hp4570n_set_pcb_otp_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL4, &value); - SET_ENABLE(en, value, HP4570_EN_PCB_OTP_MASK, HP4570_EN_PCB_OTP_ENABLE, HP4570_EN_PCB_OTP_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL4, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL4, &value); + SET_ENABLE(en, value, HP4570N_EN_PCB_OTP_MASK, HP4570N_EN_PCB_OTP_ENABLE, HP4570N_EN_PCB_OTP_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL4, value); } -void hp4570_set_vindpm_en(bool en){ +void hp4570n_set_vindpm_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL4, &value); - SET_ENABLE(en, value, HP4570_VINDPM_EN_MASK, HP4570_VINDPM_EN_ENABLE, HP4570_VINDPM_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL4, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL4, &value); + SET_ENABLE(en, value, HP4570N_VINDPM_EN_MASK, HP4570N_VINDPM_EN_ENABLE, HP4570N_VINDPM_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL4, value); } -bool hp4570_set_thermal_reg_degree(uint8_t degree){ +bool hp4570n_set_thermal_reg_degree(uint8_t degree){ uint8_t value; uint8_t thermal_reg_code; - INVALID_INPUT_RETURN(degree, thermal_reg_code, HP4570_thermal_reg_degree, HP4570_NUM_THERMAL_REG_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL4, &value); - SET_BIT(value, HP4570_THERMAL_REG_MASK, thermal_reg_code, HP4570_THERMAL_REG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL4, value); + INVALID_INPUT_RETURN(degree, thermal_reg_code, HP4570N_thermal_reg_degree, HP4570N_NUM_THERMAL_REG_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL4, &value); + SET_BIT(value, HP4570N_THERMAL_REG_MASK, thermal_reg_code, HP4570N_THERMAL_REG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL4, value); return SUCCESS; } -bool hp4570_set_vsys_reg_mV(float voltage){ +bool hp4570n_set_vsys_reg_mV(float voltage){ uint8_t value; uint8_t vsys_reg_code; - hp4570_read_reg(HP4570_REG_SYS_CTRL4, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP4570_VSYS_REG_MIN_mV,HP4570_VSYS_REG_MAX_mV); - vsys_reg_code = (uint8_t)((voltage - HP4570_VSYS_REG_OFFSET_mV)/HP4570_VSYS_REG_STEP_mV); - SET_BIT(value, HP4570_VSYS_REG_MASK, vsys_reg_code, HP4570_VSYS_REG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL4,value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL4, &value); + INPUT_PARA_FAIL_RETURN(voltage,HP4570N_VSYS_REG_MIN_mV,HP4570N_VSYS_REG_MAX_mV); + vsys_reg_code = (uint8_t)((voltage - HP4570N_VSYS_REG_OFFSET_mV)/HP4570N_VSYS_REG_STEP_mV); + SET_BIT(value, HP4570N_VSYS_REG_MASK, vsys_reg_code, HP4570N_VSYS_REG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL4,value); return SUCCESS; } -bool hp4570_set_ship_dgl_mS(uint16_t time){ +bool hp4570n_set_ship_dgl_mS(uint16_t time){ uint8_t value; uint8_t ship_dgl_code; - INVALID_INPUT_RETURN(time, ship_dgl_code, HP4570_ship_dgl_time, HP4570_NUM_SHIP_DGL_VAL); - SET_BIT(value, HP4570_SHIP_DGL_MASK, ship_dgl_code, HP4570_SHIP_DGL_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_CHIP_STAT1, value); + INVALID_INPUT_RETURN(time, ship_dgl_code, HP4570N_ship_dgl_time, HP4570N_NUM_SHIP_DGL_VAL); + SET_BIT(value, HP4570N_SHIP_DGL_MASK, ship_dgl_code, HP4570N_SHIP_DGL_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_CHIP_STAT1, value); return SUCCESS; } -bool hp4570_set_vin_exit_ship_tset_mS(uint16_t time){ +bool hp4570n_set_vin_exit_ship_tset_mS(uint16_t time){ uint8_t value; uint8_t in_exit_ship_tset_code; - INVALID_INPUT_RETURN(time, in_exit_ship_tset_code, HP4570_ship_dgl_time, HP4570_NUM_IN_EXIT_SHIP_TSET_VAL); - hp4570_read_reg(HP4570_REG_VIPRE, &value); - SET_BIT(value, HP4570_IN_EXIT_SHIP_TSET_MASK, in_exit_ship_tset_code, HP4570_IN_EXIT_SHIP_TSET_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_VIPRE, value); + INVALID_INPUT_RETURN(time, in_exit_ship_tset_code, HP4570N_ship_dgl_time, HP4570N_NUM_IN_EXIT_SHIP_TSET_VAL); + hp4570n_read_reg(HP4570N_REG_VIPRE, &value); + SET_BIT(value, HP4570N_IN_EXIT_SHIP_TSET_MASK, in_exit_ship_tset_code, HP4570N_IN_EXIT_SHIP_TSET_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_VIPRE, value); + return SUCCESS; +} + +bool hp4570n_set_low_chrg_ipre_mA(uint16_t current){ + uint8_t value; + uint8_t ipre_code; + hp4570n_set_ipre_4x_en(!HP4570N_EN_IPRE_4X_ENABLE); + hp4570n_read_reg(HP4570N_REG_VIPRE, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IPRE_MIN_mA,HP4570N_IPRE_MAX_mA); + ipre_code = (uint8_t)((current - HP4570N_IPRE_OFFSET_mA)/HP4570N_IPRE_STEP_mA); + SET_BIT(value, HP4570N_IPRE_MASK, ipre_code, HP4570N_IPRE_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_VIPRE,value); return SUCCESS; } -bool hp4570_set_chrg_ipre_mA(uint16_t current){ +bool hp4570n_set_high_chrg_ipre_mA(uint16_t current){ uint8_t value; uint8_t ipre_code; - hp4570_read_reg(HP4570_REG_VIPRE, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570_IPRE_MIN_mA,HP4570_IPRE_MAX_mA); - ipre_code = (uint8_t)((current - HP4570_IPRE_OFFSET_mA)/HP4570_IPRE_STEP_mA); - SET_BIT(value, HP4570_IPRE_MASK, ipre_code, HP4570_IPRE_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_VIPRE,value); + hp4570n_set_ipre_4x_en(HP4570N_EN_IPRE_4X_ENABLE); + hp4570n_read_reg(HP4570N_REG_VIPRE, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IPRE_MIN_mA,HP4570N_IPRE_MAX_mA); + ipre_code = (uint8_t)((current/4 - HP4570N_IPRE_OFFSET_mA)/HP4570N_IPRE_STEP_mA); + SET_BIT(value, HP4570N_IPRE_MASK, ipre_code, HP4570N_IPRE_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_VIPRE,value); return SUCCESS; } -void hp4570_set_rst_vin_entry_en(bool en){ +void hp4570n_set_rst_vin_entry_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_EXT_CTRL, &value); - SET_ENABLE(en, value, HP4570_VINDPM_EN_MASK, HP4570_VIN_ENTRY_RST_EN_ENABLE, HP4570_VIN_ENTRY_RST_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_EXT_CTRL, value); + hp4570n_read_reg(HP4570N_REG_EXT_CTRL, &value); + SET_ENABLE(en, value, HP4570N_VINDPM_EN_MASK, HP4570N_VIN_ENTRY_RST_EN_ENABLE, HP4570N_VIN_ENTRY_RST_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_EXT_CTRL, value); +} + +bool hp4570n_set_high_chrg_idead_mA(uint16_t current){ + uint8_t value; + uint8_t ideadbat_code; + hp4570n_set_ideadbat_4x_en(HP4570N_EN_IDEADBAT_4X_ENABLE); + hp4570n_read_reg(HP4570N_REG_EXT_CTRL, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IDEADBAT_MIN_mA,HP4570N_IDEADBAT_MAX_mA); + ideadbat_code = (uint8_t)((current/4 - HP4570N_IDEADBAT_OFFSET_mA)/HP4570N_IDEADBAT_STEP_mA); + SET_BIT(value, HP4570N_IDEADBAT_MASK, ideadbat_code, HP4570N_IDEADBAT_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_EXT_CTRL,value); + return SUCCESS; } -bool hp4570_set_chrg_idead_mA(uint16_t current){ +bool hp4570n_set_low_chrg_idead_mA(uint16_t current){ uint8_t value; uint8_t ideadbat_code; - hp4570_read_reg(HP4570_REG_EXT_CTRL, &value); - INPUT_PARA_FAIL_RETURN(current,HP4570_IDEADBAT_MIN_mA,HP4570_IDEADBAT_MAX_mA); - ideadbat_code = (uint8_t)((current - HP4570_IDEADBAT_OFFSET_mA)/HP4570_IDEADBAT_STEP_mA); - SET_BIT(value, HP4570_IDEADBAT_MASK, ideadbat_code, HP4570_IDEADBAT_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_EXT_CTRL,value); + hp4570n_set_ideadbat_4x_en(!HP4570N_EN_IDEADBAT_4X_ENABLE); + hp4570n_read_reg(HP4570N_REG_EXT_CTRL, &value); + INPUT_PARA_FAIL_RETURN(current,HP4570N_IDEADBAT_MIN_mA,HP4570N_IDEADBAT_MAX_mA); + ideadbat_code = (uint8_t)((current - HP4570N_IDEADBAT_OFFSET_mA)/HP4570N_IDEADBAT_STEP_mA); + SET_BIT(value, HP4570N_IDEADBAT_MASK, ideadbat_code, HP4570N_IDEADBAT_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_EXT_CTRL,value); return SUCCESS; } -bool hp4570_set_en_iindpm_en(bool en){ +bool hp4570n_set_en_iindpm_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_EXT_CTRL, &value); - SET_ENABLE(en, value, HP4570_EN_IINDPM_MASK, HP4570_EN_IINDPM_ENABLE, HP4570_EN_IINDPM_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL5, value); + hp4570n_read_reg(HP4570N_REG_EXT_CTRL, &value); + SET_ENABLE(en, value, HP4570N_EN_IINDPM_MASK, HP4570N_EN_IINDPM_ENABLE, HP4570N_EN_IINDPM_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL5, value); return SUCCESS; } -bool hp4570_set_key_wk_time_mS(uint16_t time){ +bool hp4570n_set_key_wk_time_mS(uint16_t time){ uint8_t value; uint8_t key_wk_set_code; - INVALID_INPUT_RETURN(time, key_wk_set_code, HP4570_key_wk_set_time, HP4570_NUM_KEY_WK_SET_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL5, &value); - SET_BIT(value, HP4570_KEY_WK_SET_MASK, key_wk_set_code, HP4570_KEY_WK_SET_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL5, value); + INVALID_INPUT_RETURN(time, key_wk_set_code, HP4570N_key_wk_set_time, HP4570N_NUM_KEY_WK_SET_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL5, &value); + SET_BIT(value, HP4570N_KEY_WK_SET_MASK, key_wk_set_code, HP4570N_KEY_WK_SET_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL5, value); return SUCCESS; } -bool hp4570_set_t_hiccup_mS(uint16_t time){ +bool hp4570n_set_t_hiccup_mS(uint16_t time){ uint8_t value; uint8_t t_hiccup_code; - INVALID_INPUT_RETURN(time, t_hiccup_code, HP4570_key_wk_set_time, HP4570_NUM_T_HICCUP_VAL); - hp4570_read_reg(HP4570_REG_SYS_CTRL5, &value); - SET_BIT(value, HP4570_T_HICCUP_MASK, t_hiccup_code, HP4570_T_HICCUP_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL5, value); + INVALID_INPUT_RETURN(time, t_hiccup_code, HP4570N_key_wk_set_time, HP4570N_NUM_T_HICCUP_VAL); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL5, &value); + SET_BIT(value, HP4570N_T_HICCUP_MASK, t_hiccup_code, HP4570N_T_HICCUP_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL5, value); return SUCCESS; } -void hp4570_set_wdt_vsys_rst_en(bool en){ +void hp4570n_set_wdt_vsys_rst_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP4570_WDT_VSYS_RST_MASK, HP4570_WDT_VSYS_RST_ENABLE, HP4570_WDT_VSYS_RST_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL6, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL6, &value); + SET_ENABLE(en, value, HP4570N_WDT_VSYS_RST_MASK, HP4570N_WDT_VSYS_RST_ENABLE, HP4570N_WDT_VSYS_RST_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL6, value); } -void hp4570_set_ship_dgl_en(bool en){ +void hp4570n_set_ship_dgl_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP4570_EN_SHIP_DGL_MASK, HP4570_EN_SHIP_DGL_ENABLE, HP4570_EN_SHIP_DGL_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL6, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL6, &value); + SET_ENABLE(en, value, HP4570N_EN_SHIP_DGL_MASK, HP4570N_EN_SHIP_DGL_ENABLE, HP4570N_EN_SHIP_DGL_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL6, value); } -void hp4570_set_wdt_chg_en(bool en){ +void hp4570n_set_wdt_chg_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP4570_EN_WDT_CHG_MASK, HP4570_EN_WDT_CHG_ENABLE, HP4570_EN_WDT_CHG_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); + SET_ENABLE(en, value, HP4570N_EN_WDT_CHG_MASK, HP4570N_EN_WDT_CHG_ENABLE, HP4570N_EN_WDT_CHG_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -void hp4570_set_rst_pwrkey_en(bool en){ +void hp4570n_set_rst_pwrkey_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP4570_EN_PWRKEY_RST_MASK, HP4570_EN_PWRKEY_RST_ENABLE, HP4570_EN_PWRKEY_RST_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); + SET_ENABLE(en, value, HP4570N_EN_PWRKEY_RST_MASK, HP4570N_EN_PWRKEY_RST_ENABLE, HP4570N_EN_PWRKEY_RST_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -void hp4570_set_rst_vsys_wvbus_en(bool en){ +void hp4570n_set_rst_vsys_wvbus_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP4570_VSYS_RST_WVBUS_MASK, HP4570_VSYS_RST_WVBUS_ENABLE, HP4570_VSYS_RST_WVBUS_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); + SET_ENABLE(en, value, HP4570N_VSYS_RST_WVBUS_MASK, HP4570N_VSYS_RST_WVBUS_ENABLE, HP4570N_VSYS_RST_WVBUS_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -void hp4570_set_pwrkey_en(bool en){ +void hp4570n_set_pwrkey_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP4570_PWRKEY_EN_MASK, HP4570_PWRKEY_EN_ENABLE, HP4570_PWRKEY_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); + SET_ENABLE(en, value, HP4570N_PWRKEY_EN_MASK, HP4570N_PWRKEY_EN_ENABLE, HP4570N_PWRKEY_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -void hp4570_set_vbus_wk_en(bool en){ +void hp4570n_set_vbus_wk_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP4570_VBUS_WK_EN_MASK, HP4570_VBUS_WK_EN_ENABLE, HP4570_VBUS_WK_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); + SET_ENABLE(en, value, HP4570N_VBUS_WK_EN_MASK, HP4570N_VBUS_WK_EN_ENABLE, HP4570N_VBUS_WK_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -void hp4570_set_pwrkey_wk_en(bool en){ +void hp4570n_set_pwrkey_wk_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL7, &value); if(en){ - SET_BIT(value, HP4570_PWRKEY_WK_EN_MASK, HP4570_PWRKEY_WK_EN_ENABLE, HP4570_PWRKEY_WK_EN_BIT_SHIFT); + SET_BIT(value, HP4570N_PWRKEY_WK_EN_MASK, HP4570N_PWRKEY_WK_EN_ENABLE, HP4570N_PWRKEY_WK_EN_BIT_SHIFT); // Note: bit 2 must be 1 - value |= (HP4570_PWRKEY_EN_ENABLE << HP4570_PWRKEY_EN_BIT_SHIFT); + value |= (HP4570N_PWRKEY_EN_ENABLE << HP4570N_PWRKEY_EN_BIT_SHIFT); }else - SET_BIT(value, HP4570_PWRKEY_WK_EN_MASK, !HP4570_PWRKEY_WK_EN_ENABLE, HP4570_PWRKEY_WK_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL7, value); + SET_BIT(value, HP4570N_PWRKEY_WK_EN_MASK, !HP4570N_PWRKEY_WK_EN_ENABLE, HP4570N_PWRKEY_WK_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL7, value); } -bool hp4570_set_watchdog_int_enable(bool en){ +bool hp4570n_set_watchdog_int_enable(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_INT0_ENABLE, &value); - SET_ENABLE(en, value, HP4570_WATCHDOG_INT_EN_MASK, HP4570_WATCHDOG_INT_EN_ENABLE, HP4570_WATCHDOG_INT_EN_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_INT0_ENABLE, value); + hp4570n_read_reg(HP4570N_REG_INT0_ENABLE, &value); + SET_ENABLE(en, value, HP4570N_WATCHDOG_INT_EN_MASK, HP4570N_WATCHDOG_INT_EN_ENABLE, HP4570N_WATCHDOG_INT_EN_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_INT0_ENABLE, value); return SUCCESS; } -bool hp4570_set_chg_safety_expired_enable(bool en){ +bool hp4570n_set_chg_safety_expired_enable(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_INT0_ENABLE, &value); - SET_ENABLE(en, value, HP4570_CHG_SAFETY_EXPIRED_MASK, HP4570_CHG_SAFETY_EXPIRED_ENABLE, HP4570_CHG_SAFETY_EXPIRED_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_INT0_ENABLE, value); + hp4570n_read_reg(HP4570N_REG_INT0_ENABLE, &value); + SET_ENABLE(en, value, HP4570N_CHG_SAFETY_EXPIRED_MASK, HP4570N_CHG_SAFETY_EXPIRED_ENABLE, HP4570N_CHG_SAFETY_EXPIRED_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_INT0_ENABLE, value); return SUCCESS; } -bool hp4570_read_status_wdt_fault(void){ +bool hp4570n_read_status_wdt_fault(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return (value & HP4570_WDT_FAULT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return (value & HP4570N_WDT_FAULT_MASK) ? true : false; } -bool hp4570_read_chrg_stat_not_chrg(void){ +bool hp4570n_read_chrg_stat_not_chrg(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_NOT_CHRG) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return ((value & HP4570N_CHRG_STAT_MASK) == HP4570N_CHRG_STAT_NOT_CHRG) ? true : false; } -bool hp4570_read_chrg_stat_dead_chrg(void){ +bool hp4570n_read_chrg_stat_dead_chrg(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_DEAD_CHRG) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return ((value & HP4570N_CHRG_STAT_MASK) == HP4570N_CHRG_STAT_DEAD_CHRG) ? true : false; } -bool hp4570_read_chrg_stat_pre_chrg(void){ +bool hp4570n_read_chrg_stat_pre_chrg(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_PRE_CHRG) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return ((value & HP4570N_CHRG_STAT_MASK) == HP4570N_CHRG_STAT_PRE_CHRG) ? true : false; } -bool hp4570_read_chrg_stat_fast_chrg(void){ +bool hp4570n_read_chrg_stat_fast_chrg(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_FAST_CHRG) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return ((value & HP4570N_CHRG_STAT_MASK) == HP4570N_CHRG_STAT_FAST_CHRG) ? true : false; } -bool hp4570_read_chrg_stat_chrg_done(void){ +bool hp4570n_read_chrg_stat_chrg_done(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_CHRG_DONE) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return ((value & HP4570N_CHRG_STAT_MASK) == HP4570N_CHRG_STAT_CHRG_DONE) ? true : false; } -bool hp4570_read_status_vindpm(void){ +bool hp4570n_read_status_vindpm(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return (value & HP4570_VIN_DPM_STAT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return (value & HP4570N_VIN_DPM_STAT_MASK) ? true : false; } -bool hp4570_read_status_vbus_pg(void){ +bool hp4570n_read_status_vbus_pg(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return (value & HP4570_VBUS_PG_STAT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return (value & HP4570N_VBUS_PG_STAT_MASK) ? true : false; } -bool hp4570_read_status_thermal(void){ +bool hp4570n_read_status_thermal(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); - return (value & HP4570_THERM_STAT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT0, &value); + return (value & HP4570N_THERM_STAT_MASK) ? true : false; } -void hp4570_update_status_chip_stat1(void){ +void hp4570n_update_status_chip_stat1(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT1, &value); - if(value & HP4570_VIN_FAULT_MASK) - hp4570_chip_state.vin_fault |= true; - if(value & HP4570_TSHUT_MASK) - hp4570_chip_state.tshut |= true; - if(value & HP4570_VBAT_OVP_MASK) - hp4570_chip_state.vbat_ovp |= true; - if(value & HP4570_SAFETY_MODE_MASK) - hp4570_chip_state.safety_mode |= true; - hp4570_chip_state.ntc_hot = (value & HP4570_NTC_HOT_MASK) ? true : false; - hp4570_chip_state.ntc_cold = (value & HP4570_NTC_COLD_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT1, &value); + if(value & HP4570N_VIN_FAULT_MASK) + hp4570n_chip_state.vin_fault |= true; + if(value & HP4570N_TSHUT_MASK) + hp4570n_chip_state.tshut |= true; + if(value & HP4570N_VBAT_OVP_MASK) + hp4570n_chip_state.vbat_ovp |= true; + if(value & HP4570N_SAFETY_MODE_MASK) + hp4570n_chip_state.safety_mode |= true; + hp4570n_chip_state.ntc_hot = (value & HP4570N_NTC_HOT_MASK) ? true : false; + hp4570n_chip_state.ntc_cold = (value & HP4570N_NTC_COLD_MASK) ? true : false; } -void hp4570_clear_status_chip_stat1(void){ - hp4570_chip_state.vin_fault = false; - hp4570_chip_state.tshut = false; - hp4570_chip_state.vbat_ovp = false; - hp4570_chip_state.safety_mode = false; +void hp4570n_clear_status_chip_stat1(void){ + hp4570n_chip_state.vin_fault = false; + hp4570n_chip_state.tshut = false; + hp4570n_chip_state.vbat_ovp = false; + hp4570n_chip_state.safety_mode = false; } -bool hp4570_read_status_vin_fault(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.vin_fault; +bool hp4570n_read_status_vin_fault(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.vin_fault; } -bool hp4570_read_status_tshut(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.tshut; +bool hp4570n_read_status_tshut(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.tshut; } -bool hp4570_read_status_vbat_ovp(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.vbat_ovp; +bool hp4570n_read_status_vbat_ovp(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.vbat_ovp; } -bool hp4570_read_status_safety_mode(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.safety_mode; +bool hp4570n_read_status_safety_mode(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.safety_mode; } -bool hp4570_read_status_ntc_hot(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.ntc_hot; +bool hp4570n_read_status_ntc_hot(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.ntc_hot; } -bool hp4570_read_status_ntc_cold(void){ - hp4570_update_status_chip_stat1(); - return hp4570_chip_state.ntc_cold; +bool hp4570n_read_status_ntc_cold(void){ + hp4570n_update_status_chip_stat1(); + return hp4570n_chip_state.ntc_cold; } -bool hp4570_read_status_iindpm(void){ +bool hp4570n_read_status_iindpm(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_CHIP_STAT2, &value); - return (value & HP4570_IIN_DPM_STAT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_CHIP_STAT2, &value); + return (value & HP4570N_IIN_DPM_STAT_MASK) ? true : false; } -bool hp4570_read_status_vin_entry_rst(void){ +bool hp4570n_read_status_vin_entry_rst(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP4570_ENTRY_RST_STAT_MASK){ - hp4570_write_reg(HP4570_REG_SYS_WAKE_UP_SRC,HP4570_ENTRY_RST_STAT_MASK); + hp4570n_read_reg(HP4570N_REG_SYS_WAKE_UP_SRC, &value); + if(value & HP4570N_ENTRY_RST_STAT_MASK){ + hp4570n_write_reg(HP4570N_REG_SYS_WAKE_UP_SRC,HP4570N_ENTRY_RST_STAT_MASK); return true; } return false; } -bool hp4570_read_status_pwrkey_rst(void){ +bool hp4570n_read_status_pwrkey_rst(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP4570_PWRKEY_RST_STAT_MASK){ - hp4570_write_reg(HP4570_REG_SYS_WAKE_UP_SRC,HP4570_PWRKEY_RST_STAT_MASK); + hp4570n_read_reg(HP4570N_REG_SYS_WAKE_UP_SRC, &value); + if(value & HP4570N_PWRKEY_RST_STAT_MASK){ + hp4570n_write_reg(HP4570N_REG_SYS_WAKE_UP_SRC,HP4570N_PWRKEY_RST_STAT_MASK); return true; } return false; } -bool hp4570_read_status_hiccup_latch(void){ +bool hp4570n_read_status_hiccup_latch(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP4570_HICCUP_LATCH_STAT_MASK){ - hp4570_write_reg(HP4570_REG_SYS_WAKE_UP_SRC,HP4570_HICCUP_LATCH_STAT_MASK); + hp4570n_read_reg(HP4570N_REG_SYS_WAKE_UP_SRC, &value); + if(value & HP4570N_HICCUP_LATCH_STAT_MASK){ + hp4570n_write_reg(HP4570N_REG_SYS_WAKE_UP_SRC,HP4570N_HICCUP_LATCH_STAT_MASK); return true; } return false; } -bool hp4570_read_status_pwrkey_wk(void){ +bool hp4570n_read_status_pwrkey_wk(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP4570_PWRKEY_WK_MASK){ - hp4570_write_reg(HP4570_REG_SYS_WAKE_UP_SRC,HP4570_PWRKEY_WK_MASK); + hp4570n_read_reg(HP4570N_REG_SYS_WAKE_UP_SRC, &value); + if(value & HP4570N_PWRKEY_WK_MASK){ + hp4570n_write_reg(HP4570N_REG_SYS_WAKE_UP_SRC,HP4570N_PWRKEY_WK_MASK); return true; } return false; } -bool hp4570_read_status_vbus_wk(void){ +bool hp4570n_read_status_vbus_wk(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP4570_VBUS_WK_MASK){ - hp4570_write_reg(HP4570_REG_SYS_WAKE_UP_SRC,HP4570_VBUS_WK_MASK); + hp4570n_read_reg(HP4570N_REG_SYS_WAKE_UP_SRC, &value); + if(value & HP4570N_VBUS_WK_MASK){ + hp4570n_write_reg(HP4570N_REG_SYS_WAKE_UP_SRC,HP4570N_VBUS_WK_MASK); return true; } return false; } -bool hp4570_read_status_watchdog_int(void){ +bool hp4570n_read_status_watchdog_int(void){ uint8_t value; - hp4570_read_reg(HP4570_REG_INT0_STAT, &value); - return (value & HP4570_WATCHDOG_INT_MASK) ? true : false; + hp4570n_read_reg(HP4570N_REG_INT0_STAT, &value); + return (value & HP4570N_WATCHDOG_INT_MASK) ? true : false; } -void hp4570_set_iterm_2x_en(bool en){ +void hp4570n_set_iterm_2x_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP4570_EN_ITERM_2X_MASK,HP4570_EN_ITERM_2X_ENABLE,HP4570_EN_ITERM_2X_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL6, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL6, &value); + SET_ENABLE(en, value, HP4570N_EN_ITERM_2X_MASK,HP4570N_EN_ITERM_2X_ENABLE,HP4570N_EN_ITERM_2X_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL6, value); } -void hp4570_set_ipre_4x_en(bool en){ +void hp4570n_set_ipre_4x_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP4570_EN_IPRE_4X_MASK,HP4570_EN_IPRE_4X_ENABLE,HP4570_EN_IPRE_4X_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL6, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL6, &value); + SET_ENABLE(en, value, HP4570N_EN_IPRE_4X_MASK,HP4570N_EN_IPRE_4X_ENABLE,HP4570N_EN_IPRE_4X_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL6, value); } -void hp4570_set_ideadbat_4x_en(bool en){ +void hp4570n_set_ideadbat_4x_en(bool en){ uint8_t value; - hp4570_read_reg(HP4570_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP4570_EN_IDEADBAT_4X_MASK,HP4570_EN_IDEADBAT_4X_ENABLE,HP4570_EN_IDEADBAT_4X_BIT_SHIFT); - hp4570_write_reg(HP4570_REG_SYS_CTRL6, value); + hp4570n_read_reg(HP4570N_REG_SYS_CTRL6, &value); + SET_ENABLE(en, value, HP4570N_EN_IDEADBAT_4X_MASK,HP4570N_EN_IDEADBAT_4X_ENABLE,HP4570N_EN_IDEADBAT_4X_BIT_SHIFT); + hp4570n_write_reg(HP4570N_REG_SYS_CTRL6, value); } -uint8_t hp4570_get_id(void) +uint8_t hp4570n_get_id(void) { uint8_t id = 0; - if(hp4570_identify(HP4570N) == SUCCESS) + if(hp4570n_identify(HP4570N) == SUCCESS) id = 0x2; return id; } \ No newline at end of file diff --git a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h index 78beef1d7..9858a2f9f 100644 --- a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h +++ b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h @@ -1,8 +1,8 @@ /** - * @file HP4570-H.h - * @brief This is the header file containing the HP4570 I2C Settings and Control. - Includes API for computations related to configuring HP4570 Registers - and Functions to Control the HP4570 Family IC. + * @file HP4570N-H.h + * @brief This is the header file containing the HP4570N I2C Settings and Control. + Includes API for computations related to configuring HP4570N Registers + and Functions to Control the HP4570N Family IC. * @author Hypower Applications * @date October 14, 2024 * @@ -20,8 +20,8 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef HP4570_CHARGER_H -#define HP4570_CHARGER_H +#ifndef HP4570N_CHARGER_H +#define HP4570N_CHARGER_H #include #include @@ -29,7 +29,7 @@ // for example // Avoid using "X", x stands for General Condition -enum HP4570_chip_ver { +enum hp4570n_chip_ver { HP4570A,// all default, package typeA HP4570B,// all default, package typeB HP4570I = 0x0A,// different ichg range and step @@ -40,481 +40,484 @@ enum HP4570_chip_ver { }; // 7-bit Slave Address -#define HP4570_I2C_ADDR 0x07 +#define HP4570N_I2C_ADDR 0x07 // Register address definitions -#define HP4570_REG_DPM_SET 0x00 -#define HP4570_REG_SYS_CTRL0 0x01 -#define HP4570_REG_SYS_CTRL1 0x02 -#define HP4570_REG_IDSG_ITERM_SET 0x03 -#define HP4570_REG_BAT_VOL_SET 0x04 -#define HP4570_REG_SYS_CTRL2 0x05 -#define HP4570_REG_SYS_CTRL3 0x06 -#define HP4570_REG_SYS_CTRL4 0x07 -#define HP4570_REG_CHIP_STAT0 0x08 -#define HP4570_REG_CHIP_STAT1 0x09 -#define HP4570_REG_CHIP_STAT2 0x0B -#define HP4570_REG_VIPRE 0x0C -#define HP4570_REG_EXT_CTRL 0x0D -#define HP4570_REG_SYS_CTRL5 0x15 -#define HP4570_REG_SYS_CTRL6 0x19 -#define HP4570_REG_SYS_CTRL7 0x1B -#define HP4570_REG_SYS_WAKE_UP_SRC 0x1E -#define HP4570_REG_INT0_ENABLE 0x50 -#define HP4570_REG_INT0_STAT 0x58 -#define HP4570_REG_VID_LSB 0x60 -#define HP4570_REG_VID_MSB 0x61 -#define HP4570_REG_PID_LSB 0x62 -#define HP4570_REG_PID_MSB 0x63 -#define HP4570_REG_CHIP_VER 0x64 +#define HP4570N_REG_DPM_SET 0x00 +#define HP4570N_REG_SYS_CTRL0 0x01 +#define HP4570N_REG_SYS_CTRL1 0x02 +#define HP4570N_REG_IDSG_ITERM_SET 0x03 +#define HP4570N_REG_BAT_VOL_SET 0x04 +#define HP4570N_REG_SYS_CTRL2 0x05 +#define HP4570N_REG_SYS_CTRL3 0x06 +#define HP4570N_REG_SYS_CTRL4 0x07 +#define HP4570N_REG_CHIP_STAT0 0x08 +#define HP4570N_REG_CHIP_STAT1 0x09 +#define HP4570N_REG_CHIP_STAT2 0x0B +#define HP4570N_REG_VIPRE 0x0C +#define HP4570N_REG_EXT_CTRL 0x0D +#define HP4570N_REG_SYS_CTRL5 0x15 +#define HP4570N_REG_SYS_CTRL6 0x19 +#define HP4570N_REG_SYS_CTRL7 0x1B +#define HP4570N_REG_SYS_WAKE_UP_SRC 0x1E +#define HP4570N_REG_INT0_ENABLE 0x50 +#define HP4570N_REG_INT0_STAT 0x58 +#define HP4570N_REG_VID_LSB 0x60 +#define HP4570N_REG_VID_MSB 0x61 +#define HP4570N_REG_PID_LSB 0x62 +#define HP4570N_REG_PID_MSB 0x63 +#define HP4570N_REG_CHIP_VER 0x64 #ifndef GENMASK #define GENMASK(h, l) (((uint8_t) -1 >> (7 - (h))) & ~((1U << (l)) - 1)) #endif -#define HP4570_VIN_MIN_MASK GENMASK(7, 4) -#define HP4570_VIN_MIN_STEP_mV 100 -#define HP4570_VIN_MIN_OFFSET_mV 3800 -#define HP4570_VIN_MIN_MIN_mV 3800 -#define HP4570_VIN_MIN_MAX_mV 4700 -#define HP4570_VIN_MIN_BIT_SHIFT 4 - -#define HP4570_IINDPM_MASK GENMASK(2, 0) -#define HP4570_IINDPM_STEP_mA 100 -#define HP4570_IINDPM_OFFSET_mA 300 -#define HP4570_IINDPM_MIN_mA 300 -#define HP4570_IINDPM_MAX_mA 1000 -#define HP4570_IINDPM_BIT_SHIFT 0 - -#define HP4570_NUM_TRST_DGL_VAL 4 -#define HP4570_TRST_DGL_MASK GENMASK(7, 6) -#define HP4570_TRST_DGL_BIT_SHIFT 6 - -#define HP4570_NUM_TRST_DUR_VAL 2 -#define HP4570_TRST_DUR_MASK BIT(5) -#define HP4570_TRST_DUR_BIT_SHIFT 5 - -#define HP4570_EN_HIZ_MASK BIT(4) -#define HP4570_EN_HIZ_ENABLE 1 -#define HP4570_EN_HIZ_BIT_SHIFT 4 - -#define HP4570_CEB_MASK BIT(3) -#define HP4570_CEB_ENABLE 0 -#define HP4570_CEB_BIT_SHIFT 3 - -#define HP4570_VBAT_UVLO_MASK GENMASK(2, 0) -#define HP4570_VBAT_UVLO_STEP_mV 100 -#define HP4570_VBAT_UVLO_OFFSET_mV 2400 -#define HP4570_VBAT_UVLO_MIN_mV 2400 -#define HP4570_VBAT_UVLO_MAX_mV 3100 -#define HP4570_VBAT_UVLO_DEF_mV 2800 -#define HP4570_VBAT_UVLO_BIT_SHIFT 0 - -#define HP4570_REG_RST_MASK BIT(7) -#define HP4570_REG_RST_RESET 1 -#define HP4570_REG_RST_BIT_SHIFT 7 - -#define HP4570_WDT_RST_MASK BIT(6) -#define HP4570_WDT_RST_RESET 1 -#define HP4570_WDT_RST_BIT_SHIFT 6 - -#define HP4570_ICHG_MASK GENMASK(5, 0) -#define HP4570_ICHG_STEP_mA 8 -#define HP4570_ICHG_OFFSET_mA 8 -#define HP4570_ICHG_MIN_mA 8 -#define HP4570_ICHG_MAX_mA 512 -#define HP4570I_ICHG_STEP_mA 8 -#define HP4570I_ICHG_OFFSET_mA 8 -#define HP4570I_ICHG_MIN_mA 8 -#define HP4570I_ICHG_MAX_mA 512 -#define HP4570_ICHG_BIT_SHIFT 0 - -#define HP4570_IBATFET_OCP_MASK GENMASK(7, 4) -#define HP4570_IBATFET_OCP_STEP_mA 200 -#define HP4570_IBATFET_OCP_OFFSET_mA 200 -#define HP4570_IBATFET_OCP_MIN_mA 200 -#define HP4570_IBATFET_OCP_MAX_mA 3200 -#define HP4570_IBATFET_OCP_BIT_SHIFT 4 - -#define HP4570_ITERM_MASK GENMASK(3, 0) -#define HP4570_ITERM_STEP_mA 2 -#define HP4570_ITERM_OFFSET_mA 1 -#define HP4570_ITERM_MIN_mA 1 -#define HP4570_ITERM_MAX_mA 31 -#define HP4570_ITERM_BIT_SHIFT 0 - -#define HP4570_VBATREG_MASK GENMASK(7, 2) -#define HP4570_VBATREG_STEP_mV 10 -#define HP4570_VBATREG_OFFSET_mV 4040 -#define HP4570_VBATREG_MIN_mV 4040 -#define HP4570_VBATREG_MAX_mV 4670 -#define HP4570_VBATREG_BIT_SHIFT 2 - -#define HP4570_NUM_VBAT_PRE_VAL 4 -#define HP4570_VBAT_PRE_0_MASK BIT(1) -#define HP4570_VBAT_PRE_1_MASK BIT(4) -#define HP4570_VBAT_PRE_0_BIT_SHIFT 1 -#define HP4570_VBAT_PRE_1_BIT_SHIFT 4 - -#define HP4570_NUM_VRE_CHG_VAL 2 -#define HP4570_VRE_CHG_MASK BIT(0) -#define HP4570_VRE_CHG_BIT_SHIFT 0 - -#define HP4570_EN_WDT_DSG_MASK BIT(7) -#define HP4570_EN_WDT_DSG_ENABLE 1 -#define HP4570_EN_WDT_DSG_BIT_SHIFT 7 - -#define HP4570_NUM_WDT_TIMER_VAL 4 -#define HP4570_WDT_TIMER_MASK GENMASK(6, 5) -#define HP4570_WDT_TIMER_DIS 0 -#define HP4570_WDT_TIMER_BIT_SHIFT 5 - -#define HP4570_EN_TERM_MASK BIT(4) -#define HP4570_EN_TERM_ENABLE 1 -#define HP4570_EN_TERM_BIT_SHIFT 4 - -#define HP4570_EN_TIMER_MASK BIT(3) -#define HP4570_EN_TIMER_ENABLE 1 -#define HP4570_EN_TIMER_BIT_SHIFT 3 - -#define HP4570_NUM_CHG_TIMER_VAL 4 -#define HP4570_CHG_TIMER_MASK GENMASK(2, 1) -#define HP4570_CHG_TIMER_BIT_SHIFT 1 - -#define HP4570_TERM_TMR_MASK BIT(0) -#define HP4570_TERM_TMR_ENABLE 1 -#define HP4570_TERM_TMR_BIT_SHIFT 0 - -#define HP4570_NTC_EN_MASK BIT(7) -#define HP4570_NTC_EN_ENABLE 1 -#define HP4570_NTC_EN_BIT_SHIFT 7 - -#define HP4570_TMR2X_EN_MASK BIT(6) -#define HP4570_TMR2X_EN_ENABLE 1 -#define HP4570_TMR2X_EN_BIT_SHIFT 6 - -#define HP4570_BATFET_DIS_MASK BIT(5) -#define HP4570_BATFET_DIS_ENABLE 1 -#define HP4570_BATFET_DIS_BIT_SHIFT 5 - -#define HP4570_PG_INT_CONTROL_MASK BIT(4) -#define HP4570_PG_INT_CONTROL_ENABLE 0 -#define HP4570_PG_INT_CONTROL_BIT_SHIFT 4 - -#define HP4570_CHG_DONE_INT_EN_MASK BIT(3) -#define HP4570_CHG_DONE_INT_EN_ENABLE 0 -#define HP4570_CHG_DONE_INT_EN_BIT_SHIFT 3 - -#define HP4570_CHG_STAT_INT_EN_MASK BIT(2) -#define HP4570_CHG_STAT_INT_EN_ENABLE 0 -#define HP4570_CHG_STAT_INT_EN_BIT_SHIFT 2 - -#define HP4570_NTC_TRANSITION_EN_MASK BIT(1) -#define HP4570_NTC_TRANSITION_EN_ENABLE 0 -#define HP4570_NTC_TRANSITION_EN_BIT_SHIFT 1 - -#define HP4570_BATOVP_INT_EN_MASK BIT(0) -#define HP4570_BATOVP_INT_EN_ENABLE 0 -#define HP4570_BATOVP_INT_EN_BIT_SHIFT 0 - -#define HP4570_EN_PCB_OTP_MASK BIT(7) -#define HP4570_EN_PCB_OTP_ENABLE 0 -#define HP4570_EN_PCB_OTP_BIT_SHIFT 7 - -#define HP4570_VINDPM_EN_MASK BIT(6) -#define HP4570_VINDPM_EN_ENABLE 1 -#define HP4570_VINDPM_EN_BIT_SHIFT 6 - -#define HP4570_NUM_THERMAL_REG_VAL 4 -#define HP4570_THERMAL_REG_MASK GENMASK(5, 4) -#define HP4570_THERMAL_REG_BIT_SHIFT 4 - -#define HP4570_VSYS_REG_MASK GENMASK(2, 0) -#define HP4570_VSYS_REG_STEP_mV 100 -#define HP4570_VSYS_REG_OFFSET_mV 4250 -#define HP4570_VSYS_REG_MIN_mV 4250 -#define HP4570_VSYS_REG_MAX_mV 4950 -#define HP4570_VSYS_REG_BIT_SHIFT 0 - -#define HP4570_CHRG_STAT_MASK GENMASK(5, 3) -#define HP4570_CHRG_STAT_BIT_SHIFT 3 -#define HP4570_CHRG_STAT_NOT_CHRG 0 -#define HP4570_CHRG_STAT_DEAD_CHRG (BIT(5) | BIT(3)) -#define HP4570_CHRG_STAT_PRE_CHRG BIT(3) -#define HP4570_CHRG_STAT_FAST_CHRG BIT(4) -#define HP4570_CHRG_STAT_CHRG_DONE (BIT(4) | BIT(3)) - -#define HP4570_WDT_FAULT_MASK BIT(7) -#define HP4570_VIN_DPM_STAT_MASK BIT(2) -#define HP4570_VBUS_PG_STAT_MASK BIT(1) -#define HP4570_THERM_STAT_MASK BIT(0) - -#define HP4570_NUM_SHIP_DGL_VAL 4 -#define HP4570_SHIP_DGL_MASK GENMASK(7, 6) -#define HP4570_SHIP_DGL_BIT_SHIFT 6 - -#define HP4570_VIN_FAULT_MASK BIT(5) -#define HP4570_TSHUT_MASK BIT(4) -#define HP4570_VBAT_OVP_MASK BIT(3) -#define HP4570_SAFETY_MODE_MASK BIT(2) -#define HP4570_NTC_HOT_MASK BIT(1) -#define HP4570_NTC_COLD_MASK BIT(0) - -#define HP4570_IIN_DPM_STAT_MASK BIT(6) - -#define HP4570_NUM_IN_EXIT_SHIP_TSET_VAL 2 -#define HP4570_IN_EXIT_SHIP_TSET_MASK BIT(5) -#define HP4570_IN_EXIT_SHIP_TSET_BIT_SHIFT 5 - -#define HP4570_IPRE_MASK GENMASK(3, 0) -#define HP4570_IPRE_STEP_mA 2 -#define HP4570_IPRE_OFFSET_mA 1 -#define HP4570_IPRE_MIN_mA 1 -#define HP4570_IPRE_MAX_mA 31 -#define HP4570_IPRE_BIT_SHIFT 0 - -#define HP4570_VIN_ENTRY_RST_EN_MASK BIT(4) -#define HP4570_VIN_ENTRY_RST_EN_ENABLE 1 -#define HP4570_VIN_ENTRY_RST_EN_BIT_SHIFT 4 - -#define HP4570_IDEADBAT_MASK GENMASK(3, 0) -#define HP4570_IDEADBAT_STEP_mA 2 -#define HP4570_IDEADBAT_OFFSET_mA 1 -#define HP4570_IDEADBAT_MIN_mA 1 -#define HP4570_IDEADBAT_MAX_mA 31 -#define HP4570_IDEADBAT_BIT_SHIFT 0 - -#define HP4570_VSYS_RST_MASK BIT(7) -#define HP4570_VSYS_RST_RESET 1 -#define HP4570_VSYS_RST_BIT_SHIFT 7 - -#define HP4570_EN_IINDPM_MASK BIT(5) -#define HP4570_EN_IINDPM_ENABLE 1 -#define HP4570_EN_IINDPM_BIT_SHIFT 5 - -#define HP4570_NUM_KEY_WK_SET_VAL 2 -#define HP4570_KEY_WK_SET_MASK BIT(2) -#define HP4570_KEY_WK_SET_BIT_SHIFT 2 - -#define HP4570_NUM_T_HICCUP_VAL 2 -#define HP4570_T_HICCUP_MASK BIT(0) -#define HP4570_T_HICCUP_BIT_SHIFT 0 - -#define HP4570_EN_ITERM_2X_MASK BIT(6) -#define HP4570_EN_ITERM_2X_ENABLE 1 -#define HP4570_EN_ITERM_2X_BIT_SHIFT 6 - -#define HP4570_EN_IPRE_4X_MASK BIT(5) -#define HP4570_EN_IPRE_4X_ENABLE 1 -#define HP4570_EN_IPRE_4X_BIT_SHIFT 5 - -#define HP4570_EN_IDEADBAT_4X_MASK BIT(4) -#define HP4570_EN_IDEADBAT_4X_ENABLE 1 -#define HP4570_EN_IDEADBAT_4X_BIT_SHIFT 4 - -#define HP4570_WDT_VSYS_RST_MASK BIT(3) -#define HP4570_WDT_VSYS_RST_ENABLE 1 -#define HP4570_WDT_VSYS_RST_BIT_SHIFT 3 - -#define HP4570_EN_SHIP_DGL_MASK BIT(2) -#define HP4570_EN_SHIP_DGL_ENABLE 1 -#define HP4570_EN_SHIP_DGL_BIT_SHIFT 2 - -#define HP4570_EN_WDT_CHG_MASK BIT(7) -#define HP4570_EN_WDT_CHG_ENABLE 1 -#define HP4570_EN_WDT_CHG_BIT_SHIFT 7 - -#define HP4570_EN_PWRKEY_RST_MASK BIT(5) -#define HP4570_EN_PWRKEY_RST_ENABLE 1 -#define HP4570_EN_PWRKEY_RST_BIT_SHIFT 5 - -#define HP4570_VSYS_RST_WVBUS_MASK BIT(4) -#define HP4570_VSYS_RST_WVBUS_ENABLE 1 -#define HP4570_VSYS_RST_WVBUS_BIT_SHIFT 4 - -#define HP4570_PWRKEY_EN_MASK BIT(2) -#define HP4570_PWRKEY_EN_ENABLE 1 -#define HP4570_PWRKEY_EN_BIT_SHIFT 2 - -#define HP4570_VBUS_WK_EN_MASK BIT(1) -#define HP4570_VBUS_WK_EN_ENABLE 1 -#define HP4570_VBUS_WK_EN_BIT_SHIFT 1 - -#define HP4570_PWRKEY_WK_EN_MASK BIT(0) -#define HP4570_PWRKEY_WK_EN_ENABLE 1 -#define HP4570_PWRKEY_WK_EN_BIT_SHIFT 0 - -#define HP4570_ENTRY_RST_STAT_MASK BIT(7) -#define HP4570_PWRKEY_RST_STAT_MASK BIT(5) -#define HP4570_HICCUP_LATCH_STAT_MASK BIT(4) -#define HP4570_PWRKEY_WK_MASK BIT(1) -#define HP4570_VBUS_WK_MASK BIT(0) - -#define HP4570_WATCHDOG_INT_EN_MASK BIT(7) -#define HP4570_WATCHDOG_INT_EN_ENABLE 0 -#define HP4570_WATCHDOG_INT_EN_BIT_SHIFT 7 - -#define HP4570_CHG_SAFETY_EXPIRED_MASK BIT(1) -#define HP4570_CHG_SAFETY_EXPIRED_ENABLE 0 -#define HP4570_CHG_SAFETY_EXPIRED_BIT_SHIFT 1 - -#define HP4570_WATCHDOG_INT_MASK BIT(7) +#define HP4570N_VIN_MIN_MASK GENMASK(7, 4) +#define HP4570N_VIN_MIN_STEP_mV 100 +#define HP4570N_VIN_MIN_OFFSET_mV 3800 +#define HP4570N_VIN_MIN_MIN_mV 3800 +#define HP4570N_VIN_MIN_MAX_mV 4700 +#define HP4570N_VIN_MIN_BIT_SHIFT 4 + +#define HP4570N_IINDPM_MASK GENMASK(2, 0) +#define HP4570N_IINDPM_STEP_mA 100 +#define HP4570N_IINDPM_OFFSET_mA 300 +#define HP4570N_IINDPM_MIN_mA 300 +#define HP4570N_IINDPM_MAX_mA 1000 +#define HP4570N_IINDPM_BIT_SHIFT 0 + +#define HP4570N_NUM_TRST_DGL_VAL 4 +#define HP4570N_TRST_DGL_MASK GENMASK(7, 6) +#define HP4570N_TRST_DGL_BIT_SHIFT 6 + +#define HP4570N_NUM_TRST_DUR_VAL 2 +#define HP4570N_TRST_DUR_MASK BIT(5) +#define HP4570N_TRST_DUR_BIT_SHIFT 5 + +#define HP4570N_EN_HIZ_MASK BIT(4) +#define HP4570N_EN_HIZ_ENABLE 1 +#define HP4570N_EN_HIZ_BIT_SHIFT 4 + +#define HP4570N_CEB_MASK BIT(3) +#define HP4570N_CEB_ENABLE 0 +#define HP4570N_CEB_BIT_SHIFT 3 + +#define HP4570N_VBAT_UVLO_MASK GENMASK(2, 0) +#define HP4570N_VBAT_UVLO_STEP_mV 100 +#define HP4570N_VBAT_UVLO_OFFSET_mV 2400 +#define HP4570N_VBAT_UVLO_MIN_mV 2400 +#define HP4570N_VBAT_UVLO_MAX_mV 3100 +#define HP4570N_VBAT_UVLO_DEF_mV 2800 +#define HP4570N_VBAT_UVLO_BIT_SHIFT 0 + +#define HP4570N_REG_RST_MASK BIT(7) +#define HP4570N_REG_RST_RESET 1 +#define HP4570N_REG_RST_BIT_SHIFT 7 + +#define HP4570N_WDT_RST_MASK BIT(6) +#define HP4570N_WDT_RST_RESET 1 +#define HP4570N_WDT_RST_BIT_SHIFT 6 + +#define HP4570N_ICHG_MASK GENMASK(5, 0) +#define HP4570N_ICHG_STEP_mA 8 +#define HP4570N_ICHG_OFFSET_mA 8 +#define HP4570N_ICHG_MIN_mA 8 +#define HP4570N_ICHG_MAX_mA 512 +#define HP4570NI_ICHG_STEP_mA 8 +#define HP4570NI_ICHG_OFFSET_mA 8 +#define HP4570NI_ICHG_MIN_mA 8 +#define HP4570NI_ICHG_MAX_mA 512 +#define HP4570N_ICHG_BIT_SHIFT 0 + +#define HP4570N_IBATFET_OCP_MASK GENMASK(7, 4) +#define HP4570N_IBATFET_OCP_STEP_mA 200 +#define HP4570N_IBATFET_OCP_OFFSET_mA 200 +#define HP4570N_IBATFET_OCP_MIN_mA 200 +#define HP4570N_IBATFET_OCP_MAX_mA 3200 +#define HP4570N_IBATFET_OCP_BIT_SHIFT 4 + +#define HP4570N_ITERM_MASK GENMASK(3, 0) +#define HP4570N_ITERM_STEP_mA 2 +#define HP4570N_ITERM_OFFSET_mA 1 +#define HP4570N_ITERM_MIN_mA 1 +#define HP4570N_ITERM_MAX_mA 31 +#define HP4570N_ITERM_BIT_SHIFT 0 + +#define HP4570N_VBATREG_MASK GENMASK(7, 2) +#define HP4570N_VBATREG_STEP_mV 10 +#define HP4570N_VBATREG_OFFSET_mV 4040 +#define HP4570N_VBATREG_MIN_mV 4040 +#define HP4570N_VBATREG_MAX_mV 4670 +#define HP4570N_VBATREG_BIT_SHIFT 2 + +#define HP4570N_NUM_VBAT_PRE_VAL 4 +#define HP4570N_VBAT_PRE_0_MASK BIT(1) +#define HP4570N_VBAT_PRE_1_MASK BIT(4) +#define HP4570N_VBAT_PRE_0_BIT_SHIFT 1 +#define HP4570N_VBAT_PRE_1_BIT_SHIFT 4 + +#define HP4570N_NUM_VRE_CHG_VAL 2 +#define HP4570N_VRE_CHG_MASK BIT(0) +#define HP4570N_VRE_CHG_BIT_SHIFT 0 + +#define HP4570N_EN_WDT_DSG_MASK BIT(7) +#define HP4570N_EN_WDT_DSG_ENABLE 1 +#define HP4570N_EN_WDT_DSG_BIT_SHIFT 7 + +#define HP4570N_NUM_WDT_TIMER_VAL 4 +#define HP4570N_WDT_TIMER_MASK GENMASK(6, 5) +#define HP4570N_WDT_TIMER_DIS 0 +#define HP4570N_WDT_TIMER_BIT_SHIFT 5 + +#define HP4570N_EN_TERM_MASK BIT(4) +#define HP4570N_EN_TERM_ENABLE 1 +#define HP4570N_EN_TERM_BIT_SHIFT 4 + +#define HP4570N_EN_TIMER_MASK BIT(3) +#define HP4570N_EN_TIMER_ENABLE 1 +#define HP4570N_EN_TIMER_BIT_SHIFT 3 + +#define HP4570N_NUM_CHG_TIMER_VAL 4 +#define HP4570N_CHG_TIMER_MASK GENMASK(2, 1) +#define HP4570N_CHG_TIMER_BIT_SHIFT 1 + +#define HP4570N_TERM_TMR_MASK BIT(0) +#define HP4570N_TERM_TMR_ENABLE 1 +#define HP4570N_TERM_TMR_BIT_SHIFT 0 + +#define HP4570N_NTC_EN_MASK BIT(7) +#define HP4570N_NTC_EN_ENABLE 1 +#define HP4570N_NTC_EN_BIT_SHIFT 7 + +#define HP4570N_TMR2X_EN_MASK BIT(6) +#define HP4570N_TMR2X_EN_ENABLE 1 +#define HP4570N_TMR2X_EN_BIT_SHIFT 6 + +#define HP4570N_BATFET_DIS_MASK BIT(5) +#define HP4570N_BATFET_DIS_ENABLE 1 +#define HP4570N_BATFET_DIS_BIT_SHIFT 5 + +#define HP4570N_PG_INT_CONTROL_MASK BIT(4) +#define HP4570N_PG_INT_CONTROL_ENABLE 0 +#define HP4570N_PG_INT_CONTROL_BIT_SHIFT 4 + +#define HP4570N_CHG_DONE_INT_EN_MASK BIT(3) +#define HP4570N_CHG_DONE_INT_EN_ENABLE 0 +#define HP4570N_CHG_DONE_INT_EN_BIT_SHIFT 3 + +#define HP4570N_CHG_STAT_INT_EN_MASK BIT(2) +#define HP4570N_CHG_STAT_INT_EN_ENABLE 0 +#define HP4570N_CHG_STAT_INT_EN_BIT_SHIFT 2 + +#define HP4570N_NTC_TRANSITION_EN_MASK BIT(1) +#define HP4570N_NTC_TRANSITION_EN_ENABLE 0 +#define HP4570N_NTC_TRANSITION_EN_BIT_SHIFT 1 + +#define HP4570N_BATOVP_INT_EN_MASK BIT(0) +#define HP4570N_BATOVP_INT_EN_ENABLE 0 +#define HP4570N_BATOVP_INT_EN_BIT_SHIFT 0 + +#define HP4570N_EN_PCB_OTP_MASK BIT(7) +#define HP4570N_EN_PCB_OTP_ENABLE 0 +#define HP4570N_EN_PCB_OTP_BIT_SHIFT 7 + +#define HP4570N_VINDPM_EN_MASK BIT(6) +#define HP4570N_VINDPM_EN_ENABLE 1 +#define HP4570N_VINDPM_EN_BIT_SHIFT 6 + +#define HP4570N_NUM_THERMAL_REG_VAL 4 +#define HP4570N_THERMAL_REG_MASK GENMASK(5, 4) +#define HP4570N_THERMAL_REG_BIT_SHIFT 4 + +#define HP4570N_VSYS_REG_MASK GENMASK(2, 0) +#define HP4570N_VSYS_REG_STEP_mV 100 +#define HP4570N_VSYS_REG_OFFSET_mV 4250 +#define HP4570N_VSYS_REG_MIN_mV 4250 +#define HP4570N_VSYS_REG_MAX_mV 4950 +#define HP4570N_VSYS_REG_BIT_SHIFT 0 + +#define HP4570N_CHRG_STAT_MASK GENMASK(5, 3) +#define HP4570N_CHRG_STAT_BIT_SHIFT 3 +#define HP4570N_CHRG_STAT_NOT_CHRG 0 +#define HP4570N_CHRG_STAT_DEAD_CHRG (BIT(5) | BIT(3)) +#define HP4570N_CHRG_STAT_PRE_CHRG BIT(3) +#define HP4570N_CHRG_STAT_FAST_CHRG BIT(4) +#define HP4570N_CHRG_STAT_CHRG_DONE (BIT(4) | BIT(3)) + +#define HP4570N_WDT_FAULT_MASK BIT(7) +#define HP4570N_VIN_DPM_STAT_MASK BIT(2) +#define HP4570N_VBUS_PG_STAT_MASK BIT(1) +#define HP4570N_THERM_STAT_MASK BIT(0) + +#define HP4570N_NUM_SHIP_DGL_VAL 4 +#define HP4570N_SHIP_DGL_MASK GENMASK(7, 6) +#define HP4570N_SHIP_DGL_BIT_SHIFT 6 + +#define HP4570N_VIN_FAULT_MASK BIT(5) +#define HP4570N_TSHUT_MASK BIT(4) +#define HP4570N_VBAT_OVP_MASK BIT(3) +#define HP4570N_SAFETY_MODE_MASK BIT(2) +#define HP4570N_NTC_HOT_MASK BIT(1) +#define HP4570N_NTC_COLD_MASK BIT(0) + +#define HP4570N_IIN_DPM_STAT_MASK BIT(6) + +#define HP4570N_NUM_IN_EXIT_SHIP_TSET_VAL 2 +#define HP4570N_IN_EXIT_SHIP_TSET_MASK BIT(5) +#define HP4570N_IN_EXIT_SHIP_TSET_BIT_SHIFT 5 + +#define HP4570N_IPRE_MASK GENMASK(3, 0) +#define HP4570N_IPRE_STEP_mA 2 +#define HP4570N_IPRE_OFFSET_mA 1 +#define HP4570N_IPRE_MIN_mA 1 +#define HP4570N_IPRE_MAX_mA 31 +#define HP4570N_IPRE_BIT_SHIFT 0 + +#define HP4570N_VIN_ENTRY_RST_EN_MASK BIT(4) +#define HP4570N_VIN_ENTRY_RST_EN_ENABLE 1 +#define HP4570N_VIN_ENTRY_RST_EN_BIT_SHIFT 4 + +#define HP4570N_IDEADBAT_MASK GENMASK(3, 0) +#define HP4570N_IDEADBAT_STEP_mA 2 +#define HP4570N_IDEADBAT_OFFSET_mA 1 +#define HP4570N_IDEADBAT_MIN_mA 1 +#define HP4570N_IDEADBAT_MAX_mA 31 +#define HP4570N_IDEADBAT_BIT_SHIFT 0 + +#define HP4570N_VSYS_RST_MASK BIT(7) +#define HP4570N_VSYS_RST_RESET 1 +#define HP4570N_VSYS_RST_BIT_SHIFT 7 + +#define HP4570N_EN_IINDPM_MASK BIT(5) +#define HP4570N_EN_IINDPM_ENABLE 1 +#define HP4570N_EN_IINDPM_BIT_SHIFT 5 + +#define HP4570N_NUM_KEY_WK_SET_VAL 2 +#define HP4570N_KEY_WK_SET_MASK BIT(2) +#define HP4570N_KEY_WK_SET_BIT_SHIFT 2 + +#define HP4570N_NUM_T_HICCUP_VAL 2 +#define HP4570N_T_HICCUP_MASK BIT(0) +#define HP4570N_T_HICCUP_BIT_SHIFT 0 + +#define HP4570N_EN_ITERM_2X_MASK BIT(6) +#define HP4570N_EN_ITERM_2X_ENABLE 1 +#define HP4570N_EN_ITERM_2X_BIT_SHIFT 6 + +#define HP4570N_EN_IPRE_4X_MASK BIT(5) +#define HP4570N_EN_IPRE_4X_ENABLE 1 +#define HP4570N_EN_IPRE_4X_BIT_SHIFT 5 + +#define HP4570N_EN_IDEADBAT_4X_MASK BIT(4) +#define HP4570N_EN_IDEADBAT_4X_ENABLE 1 +#define HP4570N_EN_IDEADBAT_4X_BIT_SHIFT 4 + +#define HP4570N_WDT_VSYS_RST_MASK BIT(3) +#define HP4570N_WDT_VSYS_RST_ENABLE 1 +#define HP4570N_WDT_VSYS_RST_BIT_SHIFT 3 + +#define HP4570N_EN_SHIP_DGL_MASK BIT(2) +#define HP4570N_EN_SHIP_DGL_ENABLE 1 +#define HP4570N_EN_SHIP_DGL_BIT_SHIFT 2 + +#define HP4570N_EN_WDT_CHG_MASK BIT(7) +#define HP4570N_EN_WDT_CHG_ENABLE 1 +#define HP4570N_EN_WDT_CHG_BIT_SHIFT 7 + +#define HP4570N_EN_PWRKEY_RST_MASK BIT(5) +#define HP4570N_EN_PWRKEY_RST_ENABLE 1 +#define HP4570N_EN_PWRKEY_RST_BIT_SHIFT 5 + +#define HP4570N_VSYS_RST_WVBUS_MASK BIT(4) +#define HP4570N_VSYS_RST_WVBUS_ENABLE 1 +#define HP4570N_VSYS_RST_WVBUS_BIT_SHIFT 4 + +#define HP4570N_PWRKEY_EN_MASK BIT(2) +#define HP4570N_PWRKEY_EN_ENABLE 1 +#define HP4570N_PWRKEY_EN_BIT_SHIFT 2 + +#define HP4570N_VBUS_WK_EN_MASK BIT(1) +#define HP4570N_VBUS_WK_EN_ENABLE 1 +#define HP4570N_VBUS_WK_EN_BIT_SHIFT 1 + +#define HP4570N_PWRKEY_WK_EN_MASK BIT(0) +#define HP4570N_PWRKEY_WK_EN_ENABLE 1 +#define HP4570N_PWRKEY_WK_EN_BIT_SHIFT 0 + +#define HP4570N_ENTRY_RST_STAT_MASK BIT(7) +#define HP4570N_PWRKEY_RST_STAT_MASK BIT(5) +#define HP4570N_HICCUP_LATCH_STAT_MASK BIT(4) +#define HP4570N_PWRKEY_WK_MASK BIT(1) +#define HP4570N_VBUS_WK_MASK BIT(0) + +#define HP4570N_WATCHDOG_INT_EN_MASK BIT(7) +#define HP4570N_WATCHDOG_INT_EN_ENABLE 0 +#define HP4570N_WATCHDOG_INT_EN_BIT_SHIFT 7 + +#define HP4570N_CHG_SAFETY_EXPIRED_MASK BIT(1) +#define HP4570N_CHG_SAFETY_EXPIRED_ENABLE 0 +#define HP4570N_CHG_SAFETY_EXPIRED_BIT_SHIFT 1 + +#define HP4570N_WATCHDOG_INT_MASK BIT(7) -static const uint32_t HP4570_trst_dgl_time[HP4570_NUM_TRST_DGL_VAL] = { +static const uint32_t HP4570N_trst_dgl_time[HP4570N_NUM_TRST_DGL_VAL] = { 80000, 120000, 160000, 200000 }; -static const uint16_t HP4570_trst_dur_time[HP4570_NUM_TRST_DUR_VAL] = { +static const uint16_t HP4570N_trst_dur_time[HP4570N_NUM_TRST_DUR_VAL] = { 2000, 4000 }; -static const uint16_t HP4570_vbat_pre_voltage[HP4570_NUM_VBAT_PRE_VAL] = { +static const uint16_t HP4570N_vbat_pre_voltage[HP4570N_NUM_VBAT_PRE_VAL] = { 2800, 3000, 3200, 3300 }; -static const uint8_t HP4570_vre_chg_voltage[HP4570_NUM_VRE_CHG_VAL] = { +static const uint8_t HP4570N_vre_chg_voltage[HP4570N_NUM_VRE_CHG_VAL] = { 100, 200 }; -static const uint32_t HP4570_watchdog_time[HP4570_NUM_WDT_TIMER_VAL] = { +static const uint32_t HP4570N_watchdog_time[HP4570N_NUM_WDT_TIMER_VAL] = { 0, 40000, 80000, 160000 }; -static const uint8_t HP4570_fast_chg_time[HP4570_NUM_CHG_TIMER_VAL] = { +static const uint8_t HP4570N_fast_chg_time[HP4570N_NUM_CHG_TIMER_VAL] = { 3, 5, 8, 12 }; -static const uint8_t HP4570_thermal_reg_degree[HP4570_NUM_THERMAL_REG_VAL] = { +static const uint8_t HP4570N_thermal_reg_degree[HP4570N_NUM_THERMAL_REG_VAL] = { 80, 100, 120, 130 }; -static const uint16_t HP4570_ship_dgl_time[HP4570_NUM_SHIP_DGL_VAL] = { +static const uint16_t HP4570N_ship_dgl_time[HP4570N_NUM_SHIP_DGL_VAL] = { 1000, 2000, 4000, 8000 }; -static const uint16_t HP4570_in_exit_ship_tset_time[HP4570_NUM_IN_EXIT_SHIP_TSET_VAL] = { +static const uint16_t HP4570N_in_exit_ship_tset_time[HP4570N_NUM_IN_EXIT_SHIP_TSET_VAL] = { 50, 2000 }; -static const uint16_t HP4570_key_wk_set_time[HP4570_NUM_KEY_WK_SET_VAL] = { +static const uint16_t HP4570N_key_wk_set_time[HP4570N_NUM_KEY_WK_SET_VAL] = { 2000, 200 }; -static const uint16_t HP4570_t_hiccup_time[HP4570_NUM_T_HICCUP_VAL] = { +static const uint16_t HP4570N_t_hiccup_time[HP4570N_NUM_T_HICCUP_VAL] = { 256, 512 }; //Default value for a register. -#define HP4570_REG_DPM_SET_DEF 0x84 -#define HP4570_REG_SYS_CTRL0_DEF 0xA4 -#define HP4570_REG_SYS_CTRL1_DEF 0x00 -#define HP4570_REG_IDSG_ITERM_SET_DEF 0x91 -#define HP4570_REG_BAT_VOL_SET_DEF 0x43 -#define HP4570_REG_SYS_CTRL2_DEF 0x3A -#define HP4570_REG_SYS_CTRL3_DEF 0x40 -#define HP4570_REG_SYS_CTRL4_DEF 0x24 -#define HP4570_REG_CHIP_STAT1_DEF 0x00 -#define HP4570_REG_VIPRE_DEF 0x01 -#define HP4570_REG_EXT_CTRL_DEF 0x11 -#define HP4570_REG_SYS_CTRL5_DEF 0x21 -#define HP4570_REG_SYS_CTRL6_DEF 0x0C -#define HP4570_REG_SYS_CTRL7_DEF 0xB6 -#define HP4570_REG_INT0_ENABLE_DEF 0x00 -#define HP4570_REG_INT0_STAT_DEF 0x00 -#define HP4570_REG_VID_LSB_DEF 0xC6 -#define HP4570_REG_VID_MSB_DEF 0x34 -#define HP4570_REG_PID_LSB_DEF 0x81 -#define HP4570_REG_PID_MSB_DEF 0x00 - -#define HP4570J_REG_SYS_CTRL0_DEF 0xAC +#define HP4570N_REG_DPM_SET_DEF 0x84 +#define HP4570N_REG_SYS_CTRL0_DEF 0xA4 +#define HP4570N_REG_SYS_CTRL1_DEF 0x00 +#define HP4570N_REG_IDSG_ITERM_SET_DEF 0x91 +#define HP4570N_REG_BAT_VOL_SET_DEF 0x43 +#define HP4570N_REG_SYS_CTRL2_DEF 0x3A +#define HP4570N_REG_SYS_CTRL3_DEF 0x40 +#define HP4570N_REG_SYS_CTRL4_DEF 0x24 +#define HP4570N_REG_CHIP_STAT1_DEF 0x00 +#define HP4570N_REG_VIPRE_DEF 0x01 +#define HP4570N_REG_EXT_CTRL_DEF 0x11 +#define HP4570N_REG_SYS_CTRL5_DEF 0x21 +#define HP4570N_REG_SYS_CTRL6_DEF 0x0C +#define HP4570N_REG_SYS_CTRL7_DEF 0xB6 +#define HP4570N_REG_INT0_ENABLE_DEF 0x00 +#define HP4570N_REG_INT0_STAT_DEF 0x00 +#define HP4570N_REG_VID_LSB_DEF 0xC6 +#define HP4570N_REG_VID_MSB_DEF 0x34 +#define HP4570N_REG_PID_LSB_DEF 0x81 +#define HP4570N_REG_PID_MSB_DEF 0x03 + +#define HP4570NJ_REG_SYS_CTRL0_DEF 0xAC // Function Declarations -bool hp4570_init(uint8_t chip_ver); -bool hp4570_identify(uint8_t chip_ver); - -void hp4570_set_pwrkey_en(bool en);// PWRKEY function enable control -bool hp4570_set_trst_dgl_mS(uint32_t time);// Pull INT low to disconnect the battery then auto on - -void hp4570_reg_rst(void);// Register reset -void hp4570_wdt_rst(void);// Watchdog timer reset -void hp4570_vsys_rst(void);// VSYS reset -void hp4570_set_rst_vin_entry_en(bool en);// VIN 4 pulse Reset Enable -void hp4570_set_rst_pwrkey_en(bool en);// VSYS reset enable PWRKEY operation Enable -void hp4570_set_rst_vsys_wvbus_en(bool en);// VSYS reset operation when VBUS is present - -void hp4570_entry_shipmode(void); -bool hp4570_set_batfet_dis(bool en);// BATFET force off -void hp4570_set_vbus_wk_en(bool en);// VBUS plug in to exit ship mode -void hp4570_set_pwrkey_wk_en(bool en);// PWRKEY be low to exit ship mode -bool hp4570_set_vin_exit_ship_tset_mS(uint16_t time);// IN Port Power Good Time Setting for Exit Shipmode -bool hp4570_set_key_wk_time_mS(uint16_t time);// KEY wake up time set -void hp4570_set_ship_dgl_en(bool en);// Enter ship mode deglitch enable control -bool hp4570_set_ship_dgl_mS(uint16_t time);// Enter ship mode deglitch time - - -void hp4570_set_hiz_en(bool en);// VBUS power path Hi-Z mode enable -void hp4570_set_ceb_en(bool en);// Enable or disable charging function - -bool hp4570_set_vsys_reg_mV(float voltage);// VSYS regulation -bool hp4570_set_trst_dur_mS(uint16_t time);// VSYS off time before auto on -void hp4570_set_vindpm_en(bool en); -void hp4570_set_iindpm_en(bool en); -bool hp4570_set_vindpm_mV(uint16_t voltage); -bool hp4570_set_iindpm_mA(uint16_t current); - -bool hp4570_set_chrg_vpre_mV(uint8_t voltage);// Battery pre-charge voltage set -bool hp4570_set_chrg_vbat_mV(float voltage); -bool hp4570_set_chrg_vre_mV(uint8_t voltage);// Battery re-charge voltage set -bool hp4570_set_chrg_idead_mA(uint16_t current); -bool hp4570_set_chrg_ipre_mA(uint16_t current);// Battery pre-charge current set -bool hp4570_set_chrg_ichg_mA(uint16_t current); -bool hp4570i_set_chrg_ichg_mA(uint16_t current); -bool hp4570_set_chrg_iterm_mA(uint8_t current); -void hp4570_set_chrg_term_en(bool en);// Termination is allowed or not -void hp4570_set_chrg_term_tmr(bool en);// Termination timer control -void hp4570_set_chrg_timer_en(bool en);// Safety timer set during charging -bool hp4570_set_chrg_timer_hour(uint8_t time);// Fast charging mode timer set -void hp4570_set_chrg_tmr2x_en(bool en);// Safety timer double during DPM/Thermal - -bool hp4570_set_ibatfet_ocp_mA(uint16_t current); -bool hp4570_set_vbat_uvlo_mV(uint16_t voltage);// Battery UVLO falling threshold,hys is about =150mV -bool hp4570_set_t_hiccup_mS(uint16_t time);// Hiccup timer set - -void hp4570_set_wdt_timer_en(bool en);// If watchdog timer already enable, function will do noting, otherwise will set as default -bool hp4570_set_wdt_timer_mS(uint32_t time); -void hp4570_set_wdt_chg_en(bool en);// Watchdog timer function enable control during charging -void hp4570_set_wdt_dsg_en(bool en);// Watchdog timer function enable control during discharging -void hp4570_set_wdt_vsys_rst_en(bool en);// Watch dog fault VSYS reset enable control - -void hp4570_set_ntc_en(bool en);// NTC enable during charging -void hp4570_set_pcb_otp_en(bool en);// PCB_OTP enable -bool hp4570_set_thermal_reg_degree(uint8_t degree);// Die temp control by Thermal loop - -void hp4570_set_int_pg_en(bool en);// Power good int enable control -void hp4570_set_int_chrg_done_en(bool en);// Charge complete int enable control -void hp4570_set_int_chrg_stat_en(bool en);// Charging status dynamic change int enable control -void hp4570_set_int_ntc_transition_en(bool en);// Battery temp region change int enable control -void hp4570_set_int_batovp_en(bool en);// Battery OVP int enable control -void hp4570_set_int_wdt_en(bool en);// Watch dog time expire int enable control -void hp4570_set_int_chg_safety_expired_en(bool en);// Charger enter safety int enable control - -bool hp4570_read_chrg_stat_not_chrg(void); -bool hp4570_read_chrg_stat_dead_chrg(void); -bool hp4570_read_chrg_stat_pre_chrg(void); -bool hp4570_read_chrg_stat_fast_chrg(void); -bool hp4570_read_chrg_stat_chrg_done(void); - -bool hp4570_read_status_wdt_fault(void);// Watchdog timer expired 1: Expired; 0: Not Expired -bool hp4570_read_status_vindpm(void);// 1: In DPM; 0: Not DPM -bool hp4570_read_status_vbus_pg(void);// 1: Power Good; 0: Not Good -bool hp4570_read_status_thermal(void);// 1: In thermal; 0: Not thermal -bool hp4570_read_status_vin_fault(void);// 1: Input fault ovp or bad source plug out; 0: normal -bool hp4570_read_status_tshut(void);// 1: Thermal shutdown; 0: Normal -bool hp4570_read_status_vbat_ovp(void);// 1: BAT_OVP; 0: Not BAT_OVP -bool hp4570_read_status_safety_mode(void);// Charger safety timer expired 1: Expired; 0: Not Expired -bool hp4570_read_status_ntc_hot(void);// 1: Hot; 0: Not hot -bool hp4570_read_status_ntc_cold(void);// 1: Cold; 0: Not cold -bool hp4570_read_status_iindpm(void);// 1: In DPM; 0: Not DPM -bool hp4570_read_status_vin_entry_rst(void);// VIN_ENTRY_RST once happenned -bool hp4570_read_status_pwrkey_rst(void);// PWRKEY reset once happened -bool hp4570_read_status_hiccup_latch(void);// Hiccup once happened -bool hp4570_read_status_pwrkey_wk(void);// PWRKEY 2S low time wake up from ship mode -bool hp4570_read_status_vbus_wk(void);// VBUS plug in wake up from ship mode -bool hp4570_read_status_watchdog_int(void);// Watch dog time expire IRQ - -void hp4570_set_iterm_2x_en(bool en);//Terminate charge current X2 enable control -void hp4570_set_ipre_4x_en(bool en);//Pre-charge current X4 enable control -void hp4570_set_ideadbat_4x_en(bool en);//dead battary charge current X4 enable control -uint8_t hp4570_get_id(void); -#endif // HP4570_CHARGER_H \ No newline at end of file +bool hp4570n_init(uint8_t chip_ver); +bool hp4570n_identify(uint8_t chip_ver); + +void hp4570n_set_pwrkey_en(bool en);// PWRKEY function enable control +bool hp4570n_set_trst_dgl_mS(uint32_t time);// Pull INT low to disconnect the battery then auto on + +void hp4570n_reg_rst(void);// Register reset +void hp4570n_wdt_rst(void);// Watchdog timer reset +void hp4570n_vsys_rst(void);// VSYS reset +void hp4570n_set_rst_vin_entry_en(bool en);// VIN 4 pulse Reset Enable +void hp4570n_set_rst_pwrkey_en(bool en);// VSYS reset enable PWRKEY operation Enable +void hp4570n_set_rst_vsys_wvbus_en(bool en);// VSYS reset operation when VBUS is present + +void hp4570n_entry_shipmode(void); +bool hp4570n_set_batfet_dis(bool en);// BATFET force off +void hp4570n_set_vbus_wk_en(bool en);// VBUS plug in to exit ship mode +void hp4570n_set_pwrkey_wk_en(bool en);// PWRKEY be low to exit ship mode +bool hp4570n_set_vin_exit_ship_tset_mS(uint16_t time);// IN Port Power Good Time Setting for Exit Shipmode +bool hp4570n_set_key_wk_time_mS(uint16_t time);// KEY wake up time set +void hp4570n_set_ship_dgl_en(bool en);// Enter ship mode deglitch enable control +bool hp4570n_set_ship_dgl_mS(uint16_t time);// Enter ship mode deglitch time + + +void hp4570n_set_hiz_en(bool en);// VBUS power path Hi-Z mode enable +void hp4570n_set_ceb_en(bool en);// Enable or disable charging function + +bool hp4570n_set_vsys_reg_mV(float voltage);// VSYS regulation +bool hp4570n_set_trst_dur_mS(uint16_t time);// VSYS off time before auto on +void hp4570n_set_vindpm_en(bool en); +void hp4570n_set_iindpm_en(bool en); +bool hp4570n_set_vindpm_mV(uint16_t voltage); +bool hp4570n_set_iindpm_mA(uint16_t current); + +bool hp4570n_set_chrg_vpre_mV(uint8_t voltage);// Battery pre-charge voltage set +bool hp4570n_set_chrg_vbat_mV(float voltage); +bool hp4570n_set_chrg_vre_mV(uint8_t voltage);// Battery re-charge voltage set +bool hp4570n_set_high_chrg_idead_mA(uint16_t current); +bool hp4570n_set_low_chrg_idead_mA(uint16_t current); +bool hp4570n_set_high_chrg_ipre_mA(uint16_t current);// Battery pre-charge current set +bool hp4570n_set_low_chrg_ipre_mA(uint16_t current); +bool hp4570n_set_chrg_ichg_mA(uint16_t current); +bool hp4570ni_set_chrg_ichg_mA(uint16_t current); +bool hp4570n_set_chrg_iterm_mA(uint8_t current); +void hp4570n_set_chrg_term_en(bool en);// Termination is allowed or not +void hp4570n_set_chrg_term_tmr(bool en);// Termination timer control +void hp4570n_set_chrg_timer_en(bool en);// Safety timer set during charging +bool hp4570n_set_chrg_timer_hour(uint8_t time);// Fast charging mode timer set +void hp4570n_set_chrg_tmr2x_en(bool en);// Safety timer double during DPM/Thermal + +bool hp4570n_set_high_ibatfet_ocp_mA(uint16_t current); +bool hp4570n_set_low_ibatfet_ocp_mA(uint16_t current); +bool hp4570n_set_vbat_uvlo_mV(uint16_t voltage);// Battery UVLO falling threshold,hys is about =150mV +bool hp4570n_set_t_hiccup_mS(uint16_t time);// Hiccup timer set + +void hp4570n_set_wdt_timer_en(bool en);// If watchdog timer already enable, function will do noting, otherwise will set as default +bool hp4570n_set_wdt_timer_mS(uint32_t time); +void hp4570n_set_wdt_chg_en(bool en);// Watchdog timer function enable control during charging +void hp4570n_set_wdt_dsg_en(bool en);// Watchdog timer function enable control during discharging +void hp4570n_set_wdt_vsys_rst_en(bool en);// Watch dog fault VSYS reset enable control + +void hp4570n_set_ntc_en(bool en);// NTC enable during charging +void hp4570n_set_pcb_otp_en(bool en);// PCB_OTP enable +bool hp4570n_set_thermal_reg_degree(uint8_t degree);// Die temp control by Thermal loop + +void hp4570n_set_int_pg_en(bool en);// Power good int enable control +void hp4570n_set_int_chrg_done_en(bool en);// Charge complete int enable control +void hp4570n_set_int_chrg_stat_en(bool en);// Charging status dynamic change int enable control +void hp4570n_set_int_ntc_transition_en(bool en);// Battery temp region change int enable control +void hp4570n_set_int_batovp_en(bool en);// Battery OVP int enable control +void hp4570n_set_int_wdt_en(bool en);// Watch dog time expire int enable control +void hp4570n_set_int_chg_safety_expired_en(bool en);// Charger enter safety int enable control + +bool hp4570n_read_chrg_stat_not_chrg(void); +bool hp4570n_read_chrg_stat_dead_chrg(void); +bool hp4570n_read_chrg_stat_pre_chrg(void); +bool hp4570n_read_chrg_stat_fast_chrg(void); +bool hp4570n_read_chrg_stat_chrg_done(void); + +bool hp4570n_read_status_wdt_fault(void);// Watchdog timer expired 1: Expired; 0: Not Expired +bool hp4570n_read_status_vindpm(void);// 1: In DPM; 0: Not DPM +bool hp4570n_read_status_vbus_pg(void);// 1: Power Good; 0: Not Good +bool hp4570n_read_status_thermal(void);// 1: In thermal; 0: Not thermal +bool hp4570n_read_status_vin_fault(void);// 1: Input fault ovp or bad source plug out; 0: normal +bool hp4570n_read_status_tshut(void);// 1: Thermal shutdown; 0: Normal +bool hp4570n_read_status_vbat_ovp(void);// 1: BAT_OVP; 0: Not BAT_OVP +bool hp4570n_read_status_safety_mode(void);// Charger safety timer expired 1: Expired; 0: Not Expired +bool hp4570n_read_status_ntc_hot(void);// 1: Hot; 0: Not hot +bool hp4570n_read_status_ntc_cold(void);// 1: Cold; 0: Not cold +bool hp4570n_read_status_iindpm(void);// 1: In DPM; 0: Not DPM +bool hp4570n_read_status_vin_entry_rst(void);// VIN_ENTRY_RST once happenned +bool hp4570n_read_status_pwrkey_rst(void);// PWRKEY reset once happened +bool hp4570n_read_status_hiccup_latch(void);// Hiccup once happened +bool hp4570n_read_status_pwrkey_wk(void);// PWRKEY 2S low time wake up from ship mode +bool hp4570n_read_status_vbus_wk(void);// VBUS plug in wake up from ship mode +bool hp4570n_read_status_watchdog_int(void);// Watch dog time expire IRQ + +void hp4570n_set_iterm_2x_en(bool en);//Terminate charge current X2 enable control +void hp4570n_set_ipre_4x_en(bool en);//Pre-charge current X4 enable control +void hp4570n_set_ideadbat_4x_en(bool en);//dead battary charge current X4 enable control +uint8_t hp4570n_get_id(void); +#endif // HP4570N_CHARGER_H \ No newline at end of file diff --git a/code/sdk/zhihui/drivers/charge/service/charge_at_cmd.c b/code/sdk/zhihui/drivers/charge/service/charge_at_cmd.c index ef11b8d7b..50d01872a 100644 --- a/code/sdk/zhihui/drivers/charge/service/charge_at_cmd.c +++ b/code/sdk/zhihui/drivers/charge/service/charge_at_cmd.c @@ -75,7 +75,7 @@ static uint32_t hp4570_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd) // PRINT("SKIP CHARGEtest start, already started\r\n"); // return 0; // } - hp4570_init(HP4570N); + hp4570n_init(HP4570N); g_charge_test_started = 1; }else if (start == 2){ if (g_charge_test_started == 0) diff --git a/code/sdk/zhihui/services/battery/service/battery_service.cpp b/code/sdk/zhihui/services/battery/service/battery_service.cpp index 29bf842c5..80c122d1e 100644 --- a/code/sdk/zhihui/services/battery/service/battery_service.cpp +++ b/code/sdk/zhihui/services/battery/service/battery_service.cpp @@ -448,7 +448,7 @@ static void battery_check_chargement(void) { printf("hp4570_set_ceb_en(false); \n"); #ifdef ENABLE_HP4570 - hp4570_set_ceb_en(false); + hp4570n_set_ceb_en(false); #endif } g_chargestatus = 0; @@ -481,7 +481,7 @@ static void battery_check_chargement(void) last_charge_mA = (uint16_t)charge_mA; // printf("last_charge_mA : %d\n",last_charge_mA); #ifdef ENABLE_HP4570 - hp4570_set_chrg_ichg_mA(charge_mA); + hp4570n_set_chrg_ichg_mA(charge_mA); #endif } @@ -496,7 +496,7 @@ static void battery_check_chargement(void) { printf("hp4570_set_ceb_en(true) \n"); #ifdef ENABLE_HP4570 - hp4570_set_ceb_en(true); + hp4570n_set_ceb_en(true); #endif } enable_charge(); @@ -804,7 +804,7 @@ errcode_t uapi_battery_init(void) { #ifdef ENABLE_HP4570 - hp4570_init(HP4570N); + hp4570n_init(HP4570N); #endif battery_restore_vol(); battery_check_voltage(); diff --git a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c index 409cb4f33..6d7dd9c28 100644 --- a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c +++ b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c @@ -518,7 +518,7 @@ void aging_task(void) } #ifdef ENABLE_HP4570 - uint8_t charge_id = hp4570_get_id(); + uint8_t charge_id = hp4570n_get_id(); if (charge_id != 0x2) { aging_t.charge_error++; @@ -876,7 +876,7 @@ void factorytest_protocol_common_decode(uint8_t submode,uint8_t testitem,uint8_t bool state; state = uapi_get_charger_plug_status(); #ifdef ENABLE_HP4570 - id = hp4570_get_id(); + id = hp4570n_get_id(); if (state != 1 || id != 0x2) send_data[1] |= 1 << 0; #else @@ -1029,8 +1029,8 @@ void factorytest_protocol_common_decode(uint8_t submode,uint8_t testitem,uint8_t mcu_pm_remove_vote(NULL,NULL); #ifdef ENABLE_HP4570 - hp4570_set_batfet_dis(true); - hp4570_set_ceb_en(false); + hp4570n_set_batfet_dis(true); + hp4570n_set_ceb_en(false); #endif factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_COMMON, @@ -2081,7 +2081,7 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint //获取充电IC ID uint8_t id = 0; #ifdef ENABLE_HP4570 - id = hp4570_get_id(); + id = hp4570n_get_id(); #endif uint8_t send_data[2] = {0}; send_data[1] = id; -- 2.17.1