From: penglei <1624952103@qq.com> Date: Mon, 10 Nov 2025 08:00:34 +0000 (+0800) Subject: 优化272充电参数设置,优化tp测试、ppg测试。优化雷鸟电池曲线 X-Git-Tag: V1.0.9_20251128_194606_LN~86^2~11 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=9b3ed27aff739e238e0402b21db0ed680fdda159;p=mirrors%2FFD230.git 优化272充电参数设置,优化tp测试、ppg测试。优化雷鸟电池曲线 --- diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c index 5524ab5c7..fd82f5e93 100644 --- a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.c @@ -1159,6 +1159,44 @@ selftest_end: return ret; } + +static uint16_t cst92xx_read_id(void) +{ + uint8_t buf[30]; + struct tp_info *ic = &hyn_92xxdata->hw_info; + int ret = 0; + + cst92xx_set_workmode(0xff,DISABLE); + ret = hyn_wr_reg(hyn_92xxdata,0xD101,2,buf,0); + if(ret == FALSE){ + return FALSE; + } + LOS_Mdelay(5); + + //firmware_project_id firmware_ic_type + ret = hyn_wr_reg(hyn_92xxdata,0xD1F4,2,buf,28); + if(ret == FALSE){ + return FALSE; + } + + cst92xx_set_workmode(NOMAL_MODE,ENABLE); + + uint16_t id = ((uint16_t)buf[19] <<8) + buf[18]; + return id; +} + +void cst92xx_get_chip_id(uint16_t *chip_id) +{ +#ifdef BOARD_FD272 + uapi_gpio_set_dir(LCD_VDD_EN, GPIO_DIRECTION_OUTPUT); + + uapi_gpio_set_val(LCD_VDD_EN, GPIO_LEVEL_HIGH); + uapi_tcxo_delay_ms(10); /* delay 10 ms */ +#endif + cst92xx_resum(); + *chip_id = cst92xx_read_id(); +} + const struct hyn_ts_fuc cst92xx_fuc = { .tp_rest = cst92xx_reset, .tp_report = cst92xx_report, diff --git a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h index 4039cf8d4..c9b9515fa 100644 --- a/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h +++ b/code/sdk/drivers/drivers/driver/touch/cst92xx_touch/cst92xx_touch1.h @@ -225,6 +225,7 @@ struct hyn_ts_fuc{ int cst92xx_init(struct hyn_ts_data* ts_data); int cst92xx_set_workmode(uint8_t mode,uint8_t enable); +void cst92xx_get_chip_id(uint16_t *chip_id); //ic type extern const struct hyn_ts_fuc cst1xx_fuc; extern const struct hyn_ts_fuc cst3xx_fuc; diff --git a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c index a8a8ac4da..cadc3ac88 100644 --- a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c +++ b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.c @@ -531,5 +531,7 @@ void touch_get_chip_id(uint16_t *id) cst86xx_get_chip_id(id); #elif defined TPTYPE_FT6X46 ft6x46_get_chip_id(id); +#elif defined TPTYPE_CST92XX + cst92xx_get_chip_id(id); #endif } \ No newline at end of file diff --git a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.h b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.h index 3624e1152..b6b9f8695 100644 --- a/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.h +++ b/code/sdk/drivers/drivers/driver/touch/touch_screen_drv.h @@ -38,6 +38,8 @@ struct ts_ops { #define TP_CHIP_ID 0x6456 #elif defined TPTYPE_CST86XX #define TP_CHIP_ID 0xb7 +#elif defined TPTYPE_CST92XX +#define TP_CHIP_ID 0x9217 #else #define TP_CHIP_ID 0 #endif diff --git a/code/sdk/zhihui/UI/producttest/src/testhrsenson.cpp b/code/sdk/zhihui/UI/producttest/src/testhrsenson.cpp index be20567a2..d4227f03f 100644 --- a/code/sdk/zhihui/UI/producttest/src/testhrsenson.cpp +++ b/code/sdk/zhihui/UI/producttest/src/testhrsenson.cpp @@ -124,7 +124,7 @@ namespace OHOS uint32_t ch0 = 0; uint32_t ch1 = 0; uint32_t ch2 = 0; - ppg_get_leaklight_data(&ch0,&ch1,&ch2); + ppg_get_factory_data(&ch0,&ch1,&ch2); send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); sprintf(buf,"leaklight:\ngreen:%d\nred:%d\nir:%d",ch0,ch1,ch2); WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s",buf); diff --git a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c index b6289a358..8152f542e 100644 --- a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c +++ b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.c @@ -1,7 +1,58 @@ +/** + * @file HP4570.c + * @brief This is the source file containing the HP4570 APIs. + * @author Hypower Applications + * @date June 26, 2023 + * + * Copyright (C) 2023 Hypower Microelectronics (Wuxi) Co., Ltd. All rights reserved. + * + * THIS SOFTWARE IS PROVIDED BY HYPOWER MICROELECTRONICS "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL HYPOWER MICROELECTRONICS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + #include "hp4570.h" #include "custom_utils.h" -#include "platform_core.h" +struct CHIP_STATE{ + bool vin_fault; + bool tshut; + bool vbat_ovp; + bool safety_mode; + bool ntc_hot; + bool ntc_cold; +}hp4570_chip_state; + +uint8_t hp4570_i2c_addr = HP4570_I2C_ADDR; + +#define SUCCESS 0 +#define FAIL 1 +#define I2C_ERROR 1 +#define INVALID_INPUT 1 + +#if defined(BOARD_L22) || defined(BOARD_FD272) +#define HP4570_I2C_BUS I2C_BUS_0 +#elif defined BOARD_U8 +#define HP4570_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); + +} + +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); +} #define INPUT_PARA_FAIL_RETURN(value, min, max) \ do { \ @@ -33,757 +84,740 @@ SET_BIT(value, mask, !en_code, shift); \ } while (0) - -struct CHIP_STATE{ - bool vin_fault; - bool tshut; - bool vbat_ovp; - bool safety_mode; - bool ntc_hot; - bool ntc_cold; -}hp45xxx_chip_state; - -uint8_t hp45xxx_i2c_addr = 0; - -#define SUCCESS 0 -#define FAIL 1 -#define I2C_ERROR 1 -#define INVALID_INPUT 1 - -#if defined(BOARD_L22) || defined(BOARD_FD272) -#define HP4570_I2C_BUS I2C_BUS_0 -#elif defined BOARD_U8 -#define HP4570_I2C_BUS I2C_BUS_3 -#endif - -bool hp45xxx_write_reg(uint8_t reg, uint8_t value) -{ - return custom_i2c_write_reg(hp45xxx_i2c_addr, reg, 1, &value, 1, HP4570_I2C_BUS); - -} - -bool hp45xxx_read_reg(uint8_t reg, uint8_t *value) -{ - return custom_i2c_read_regs(hp45xxx_i2c_addr, reg, 1, value, 1, HP4570_I2C_BUS); -} - // Initialize HP4570 chip -bool hp45xxx_init(uint8_t chip_ver) -{ +bool hp4570_init(uint8_t chip_ver){ custom_i2c_init(HP4570_I2C_BUS); - switch (chip_ver){ case HP4570K: - hp45xxx_i2c_addr = HP4570K_I2C_ADDR; + hp4570_i2c_addr = HP4570_I2C_ADDR; break; default: - hp45xxx_i2c_addr = HP45XXX_I2C_ADDR; + hp4570_i2c_addr = HP4570_I2C_ADDR; break; } - if(hp45xxx_identify(chip_ver) != SUCCESS) + if(hp4570_identify(chip_ver) != SUCCESS) { - printf("hp45xxx_identify(chip_ver) failed !!!! \n"); + printf("hp4570_identify(chip_ver) failed !!!! \n"); return FAIL; } - printf("hp45xxx_identify(chip_ver) succed !!!! \n"); - // hp45xxx_reg_rst(); + printf("hp4570_identify(chip_ver) succed !!!! \n"); + // hp4570_reg_rst(); // Add initialization code here, such as configuring registers - hp45xxx_set_ceb_en(true); - int ret = hp45xxx_set_chrg_vbat_mV(4374.0); - printf("hp45xxx_set_chrg_vbat_mV ret:%d\n",ret); - - ret = hp45xxx_set_chrg_ichg_mA(400); - printf("hp45xxx_set_chrg_ichg_mA(400) ret:%d\n",ret); - - ret = hp45xxx_set_chrg_iterm_mA(34); - printf("hp45xxx_set_chrg_iterm_mA(34) ret:%d\n",ret); - - ret = hp45xxx_set_iindpm_mA(1000); - printf("hp45xxx_set_iindpm_mA(1000) ret:%d\n",ret); - - // if( hp45xxx_set_chrg_vbat_mV(4374.0) - // && - // hp45xxx_set_chrg_ipre_mA(34) && - // hp45xxx_set_chrg_ichg_mA(400) && - // hp45xxx_set_chrg_iterm_mA(34) && - // hp45xxx_set_iindpm_mA(1000) - // // hp45xxx_set_vin_min_mV(3800) - // ) + hp4570_set_ceb_en(true); + + int ret = hp4570_set_chrg_vbat_mV(4374.0); + printf("hp4570_set_chrg_vbat_mV ret:%d\n",ret); + + ret = hp4570_set_chrg_ichg_mA(400); + printf("hp4570_set_chrg_ichg_mA(400) ret:%d\n",ret); + + ret = hp4570_set_chrg_iterm_mA(34); + printf("hp4570_set_chrg_iterm_mA(34) ret:%d\n",ret); + + ret = hp4570_set_iindpm_mA(1000); + printf("hp4570_set_iindpm_mA(1000) ret:%d\n",ret); + + // 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)) return SUCCESS; - return FAIL; + // return FAIL; } -bool hp45xxx_identify(uint8_t chip_ver){ +bool hp4570_identify(uint8_t chip_ver){ uint8_t vid_value[2]; uint8_t pid_value[2]; uint8_t chip_ver_value; - hp45xxx_read_reg(HP45XXX_REG_VID_LSB, &vid_value[0]); - hp45xxx_read_reg(HP45XXX_REG_VID_MSB, &vid_value[1]); - hp45xxx_read_reg(HP45XXX_REG_PID_LSB, &pid_value[0]); - hp45xxx_read_reg(HP45XXX_REG_PID_MSB, &pid_value[1]); - hp45xxx_read_reg(HP45XXX_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); - if((vid_value[0]!=HP45XXX_REG_VID_LSB_DEF)|| - (vid_value[1]!=HP45XXX_REG_VID_MSB_DEF)|| - (pid_value[0]!=HP45XXX_REG_PID_LSB_DEF)|| - (pid_value[1]!=HP45XXX_REG_PID_MSB_DEF)|| + 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); + 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)|| + (pid_value[1]!=HP4570_REG_PID_MSB_DEF)|| (chip_ver_value != chip_ver)) return FAIL; return SUCCESS; } -void hp45xxx_entry_shipmode(void){ - hp45xxx_set_batfet_dis(true); +void hp4570_entry_shipmode(void){ + hp4570_set_batfet_dis(true); } -void hp45xxx_reg_rst(void){ +void hp4570_reg_rst(void){ // Write 1 will auto be 0 - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL1, HP45XXX_REG_RST_RESET << HP45XXX_REG_RST_BIT_SHIFT); + hp4570_write_reg(HP4570_REG_SYS_CTRL1, HP4570_REG_RST_RESET << HP4570_REG_RST_BIT_SHIFT); } -void hp45xxx_wdt_rst(void){ +void hp4570_wdt_rst(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL1, &value); + hp4570_read_reg(HP4570_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, HP45XXX_WDT_RST_MASK, HP45XXX_WDT_RST_RESET, HP45XXX_WDT_RST_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL1,value); + SET_BIT(value, HP4570_WDT_RST_MASK, HP4570_WDT_RST_RESET, HP4570_WDT_RST_BIT_SHIFT); + hp4570_write_reg(HP4570_REG_SYS_CTRL1,value); } -void hp45xxx_vsys_rst(void){ +void hp4570_vsys_rst(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL5, &value); - SET_BIT(value, HP45XXX_VSYS_RST_MASK, HP45XXX_VSYS_RST_RESET, HP45XXX_VSYS_RST_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL5,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); } -bool hp45xxx_set_vindpm_mV(uint16_t voltage){ +bool hp4570_set_vindpm_mV(uint16_t voltage){ uint8_t value; uint8_t vin_min_code; - INPUT_PARA_FAIL_RETURN(voltage,HP45XXX_VIN_MIN_MIN_mV,HP45XXX_VIN_MIN_MAX_mV); - hp45xxx_read_reg(HP45XXX_REG_DPM_SET, &value); - vin_min_code = (uint8_t)((voltage - HP45XXX_VIN_MIN_OFFSET_mV)/HP45XXX_VIN_MIN_STEP_mV); - SET_BIT(value, HP45XXX_VIN_MIN_MASK, vin_min_code, HP45XXX_VIN_MIN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_DPM_SET, value); + 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); return SUCCESS; } -bool hp45xxx_set_iindpm_mA(uint16_t current){ +bool hp4570_set_iindpm_mA(uint16_t current){ uint8_t value; uint8_t iindpm_code; - INPUT_PARA_FAIL_RETURN(current,HP45XXX_IINDPM_MIN_mA,HP45XXX_IINDPM_MAX_mA); - hp45xxx_read_reg(HP45XXX_REG_DPM_SET, &value); - iindpm_code = (uint8_t)((current - HP45XXX_IINDPM_OFFSET_mA)/HP45XXX_IINDPM_STEP_mA); - SET_BIT(value, HP45XXX_IINDPM_MASK, iindpm_code, HP45XXX_IINDPM_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_DPM_SET, value); + 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); return SUCCESS; } -bool hp45xxx_set_trst_dgl_mS(uint32_t time){ +bool hp4570_set_trst_dgl_mS(uint32_t time){ uint8_t value; uint8_t trst_dgl_code; - INVALID_INPUT_RETURN(time, trst_dgl_code, hp45xxx_trst_dgl_time, HP45XXX_NUM_TRST_DGL_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL0, &value); - SET_BIT(value, HP45XXX_TRST_DGL_MASK, trst_dgl_code, HP45XXX_TRST_DGL_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL0, value); + 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); return SUCCESS; } -bool hp45xxx_set_trst_dur_mS(uint16_t time){ +bool hp4570_set_trst_dur_mS(uint16_t time){ uint8_t value; uint8_t trst_dur_code; - INVALID_INPUT_RETURN(time, trst_dur_code, hp45xxx_trst_dur_time, HP45XXX_NUM_TRST_DUR_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL0, &value); - SET_BIT(value, HP45XXX_TRST_DUR_MASK, trst_dur_code, HP45XXX_TRST_DUR_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL0,value); + 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); return SUCCESS; } -void hp45xxx_set_hiz_en(bool en){ +void hp4570_set_hiz_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL0, &value); - SET_ENABLE(en, value, HP45XXX_EN_HIZ_MASK, HP45XXX_EN_HIZ_ENABLE, HP45XXX_EN_HIZ_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL0,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); } -void hp45xxx_set_ceb_en(bool en){ +void hp4570_set_ceb_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL0, &value); - SET_ENABLE(en, value, HP45XXX_CEB_MASK, HP45XXX_CEB_ENABLE, HP45XXX_CEB_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL0, 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); } -bool hp45xxx_set_vbat_uvlo_mV(uint16_t voltage){ +bool hp4570_set_vbat_uvlo_mV(uint16_t voltage){ uint8_t value; uint8_t vbat_uvlo_code; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL0, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP45XXX_VBAT_UVLO_MIN_mV,HP45XXX_VBAT_UVLO_MAX_mV); - vbat_uvlo_code = (uint8_t)((voltage - HP45XXX_VBAT_UVLO_OFFSET_mV)/HP45XXX_VBAT_UVLO_STEP_mV); - SET_BIT(value, HP45XXX_VBAT_UVLO_MASK, vbat_uvlo_code, HP45XXX_VBAT_UVLO_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL0, value); + 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); return SUCCESS; } -bool hp45xxx_set_chrg_ichg_mA(uint16_t current){ +bool hp4570_set_chrg_ichg_mA(uint16_t current){ uint8_t value; uint8_t ichg_code; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL1, &value); - INPUT_PARA_FAIL_RETURN(current,HP45XXX_ICHG_MIN_mA,HP45XXX_ICHG_MAX_mA); - ichg_code = (uint8_t)((current - HP45XXX_ICHG_OFFSET_mA)/HP45XXX_ICHG_STEP_mA); - SET_BIT(value, HP45XXX_ICHG_MASK, ichg_code, HP45XXX_ICHG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL1, value); + 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); return SUCCESS; } bool hp4570i_set_chrg_ichg_mA(uint16_t current){ uint8_t value; uint8_t ichg_code; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL1, &value); + 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, HP45XXX_ICHG_MASK, ichg_code, HP45XXX_ICHG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL1, value); + SET_BIT(value, HP4570_ICHG_MASK, ichg_code, HP4570_ICHG_BIT_SHIFT); + hp4570_write_reg(HP4570_REG_SYS_CTRL1, value); return SUCCESS; } -bool hp45xxx_set_ibatfet_ocp_mA(uint16_t current){ +bool hp4570_set_ibatfet_ocp_mA(uint16_t current){ uint8_t value; uint8_t ibatfet_ocp_code; - hp45xxx_read_reg(HP45XXX_REG_IDSG_ITERM_SET, &value); - INPUT_PARA_FAIL_RETURN(current,HP45XXX_IBATFET_OCP_MIN_mA,HP45XXX_IBATFET_OCP_MAX_mA); - ibatfet_ocp_code = (uint8_t)((current - HP45XXX_IBATFET_OCP_OFFSET_mA)/HP45XXX_IBATFET_OCP_STEP_mA); - SET_BIT(value, HP45XXX_IBATFET_OCP_MASK, ibatfet_ocp_code, HP45XXX_IBATFET_OCP_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_IDSG_ITERM_SET,value); + 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); return SUCCESS; } -bool hp45xxx_set_chrg_iterm_mA(uint8_t current){ +bool hp4570_set_chrg_iterm_mA(uint8_t current){ uint8_t value; uint8_t iterm_code; - hp45xxx_read_reg(HP45XXX_REG_IDSG_ITERM_SET, &value); - INPUT_PARA_FAIL_RETURN(current,HP45XXX_ITERM_MIN_mA,HP45XXX_ITERM_MAX_mA); - iterm_code = (uint8_t)((current - HP45XXX_ITERM_OFFSET_mA)/HP45XXX_ITERM_STEP_mA); - SET_BIT(value, HP45XXX_ITERM_MASK, iterm_code, HP45XXX_ITERM_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_IDSG_ITERM_SET,value); + 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); return SUCCESS; } -bool hp45xxx_set_chrg_vbat_mV(float voltage){ +bool hp4570_set_chrg_vbat_mV(float voltage){ uint8_t value; uint8_t vbatreg_code; - hp45xxx_read_reg(HP45XXX_REG_BAT_VOL_SET, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP45XXX_VBATREG_MIN_mV,HP45XXX_VBATREG_MAX_mV); - vbatreg_code = (uint8_t)((voltage - HP45XXX_VBATREG_OFFSET_mV)/HP45XXX_VBATREG_STEP_mV); - SET_BIT(value, HP45XXX_VBATREG_MASK, vbatreg_code, HP45XXX_VBATREG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_BAT_VOL_SET,value); + 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); return SUCCESS; } -bool hp45xxx_set_chrg_vpre_mV(uint8_t voltage){ +bool hp4570_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, hp45xxx_vbat_pre_voltage, HP45XXX_NUM_VBAT_PRE_VAL); - hp45xxx_read_reg(HP45XXX_REG_BAT_VOL_SET, value0); - hp45xxx_read_reg(HP45XXX_REG_VIPRE, value1); - SET_BIT(value0, HP45XXX_VBAT_PRE_0_MASK, (vbat_pre_code & 0x1), HP45XXX_VBAT_PRE_0_BIT_SHIFT); - SET_BIT(value1, HP45XXX_VBAT_PRE_1_MASK, (vbat_pre_code & 0x2)>>1, HP45XXX_VBAT_PRE_1_BIT_SHIFT); - (hp45xxx_write_reg(HP45XXX_REG_BAT_VOL_SET,value0) & hp45xxx_write_reg(HP45XXX_REG_VIPRE,value1)); + 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)); return SUCCESS; } -bool hp45xxx_set_chrg_vre_mV(uint8_t voltage){ +bool hp4570_set_chrg_vre_mV(uint8_t voltage){ uint8_t value; uint8_t vre_chg_code; - INVALID_INPUT_RETURN(voltage, vre_chg_code, hp45xxx_vre_chg_voltage, HP45XXX_NUM_VRE_CHG_VAL); - hp45xxx_read_reg(HP45XXX_REG_BAT_VOL_SET, &value); - SET_BIT(value, HP45XXX_VRE_CHG_MASK, vre_chg_code, HP45XXX_VRE_CHG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_BAT_VOL_SET,value); + 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); return SUCCESS; } -void hp45xxx_set_wdt_dsg_en(bool en){ +void hp4570_set_wdt_dsg_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP45XXX_EN_WDT_DSG_MASK, HP45XXX_EN_WDT_DSG_ENABLE, HP45XXX_EN_WDT_DSG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2, 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); } -void hp45xxx_set_wdt_timer_en(bool en){ +void hp4570_set_wdt_timer_en(bool en){ uint8_t value; uint32_t wdt_timer_code; if(!en) - hp45xxx_set_wdt_timer_mS(HP45XXX_WDT_TIMER_DIS); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - value &= HP45XXX_WDT_TIMER_MASK; - if(value >> HP45XXX_WDT_TIMER_BIT_SHIFT == HP45XXX_WDT_TIMER_DIS) + 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) // do nothing return; - wdt_timer_code = (HP45XXX_REG_SYS_CTRL2_DEF & HP45XXX_WDT_TIMER_MASK) >> HP45XXX_WDT_TIMER_BIT_SHIFT; - SET_BIT(value, HP45XXX_WDT_TIMER_MASK, wdt_timer_code, HP45XXX_WDT_TIMER_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2,value); + 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); } -bool hp45xxx_set_wdt_timer_mS(uint32_t time){ +bool hp4570_set_wdt_timer_mS(uint32_t time){ uint8_t value; uint8_t wdt_timer_code; - INVALID_INPUT_RETURN(time, wdt_timer_code, hp45xxx_watchdog_time, HP45XXX_NUM_WDT_TIMER_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_BIT(value, HP45XXX_WDT_TIMER_MASK, wdt_timer_code, HP45XXX_WDT_TIMER_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2,value); + 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); return SUCCESS; } -void hp45xxx_set_chrg_term_en(bool en){ +void hp4570_set_chrg_term_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP45XXX_EN_TERM_MASK, HP45XXX_EN_TERM_ENABLE, HP45XXX_EN_TERM_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2, 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); } -void hp45xxx_set_chrg_timer_en(bool en){ +void hp4570_set_chrg_timer_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP45XXX_EN_TIMER_MASK, HP45XXX_EN_TIMER_ENABLE, HP45XXX_EN_TIMER_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2, 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); } -bool hp45xxx_set_chrg_timer_hour(uint8_t time){ +bool hp4570_set_chrg_timer_hour(uint8_t time){ uint8_t value; uint8_t chg_timer_code; - INVALID_INPUT_RETURN(time, chg_timer_code, hp45xxx_fast_chg_time, HP45XXX_NUM_CHG_TIMER_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_BIT(value, HP45XXX_CHG_TIMER_MASK, chg_timer_code, HP45XXX_CHG_TIMER_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2,value); + 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); return SUCCESS; } // when TERM_TMR is enabled, the IC will not suspend the charge current after the charge termination -void hp45xxx_set_chrg_term_tmr(bool en){ +void hp4570_set_chrg_term_tmr(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL2, &value); - SET_ENABLE(en, value, HP45XXX_TERM_TMR_MASK, HP45XXX_TERM_TMR_ENABLE, HP45XXX_TERM_TMR_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL2, 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); } -void hp45xxx_set_ntc_en(bool en){ +void hp4570_set_ntc_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_NTC_EN_MASK, HP45XXX_NTC_EN_ENABLE, HP45XXX_NTC_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } -void hp45xxx_set_chrg_tmr2x_en(bool en){ +void hp4570_set_chrg_tmr2x_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_TMR2X_EN_MASK, HP45XXX_TMR2X_EN_ENABLE, HP45XXX_TMR2X_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } // when set 1, enter ship mode w/o vbus, the bit will be set to 0 after exiting ship mode -bool hp45xxx_set_batfet_dis(bool en){ +bool hp4570_set_batfet_dis(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_BATFET_DIS_MASK, HP45XXX_BATFET_DIS_ENABLE, HP45XXX_BATFET_DIS_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); return SUCCESS; } -void hp45xxx_set_int_pg_en(bool en){ +void hp4570_set_int_pg_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_PG_INT_CONTROL_MASK, HP45XXX_PG_INT_CONTROL_ENABLE, HP45XXX_PG_INT_CONTROL_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } -void hp45xxx_set_int_chrg_done_en(bool en){ +void hp4570_set_int_chrg_done_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_CHG_DONE_INT_EN_MASK, HP45XXX_CHG_DONE_INT_EN_ENABLE, HP45XXX_CHG_DONE_INT_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } // Include: not charge to CC, Pre into CC ,CC into CV, not charge into CC(Auto recharge) -void hp45xxx_set_int_chrg_stat_en(bool en){ +void hp4570_set_int_chrg_stat_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_CHG_STAT_INT_EN_MASK, HP45XXX_CHG_STAT_INT_EN_ENABLE, HP45XXX_CHG_STAT_INT_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } -void hp45xxx_set_int_ntc_transition_en(bool en){ +void hp4570_set_int_ntc_transition_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_NTC_TRANSITION_EN_MASK, HP45XXX_NTC_TRANSITION_EN_ENABLE, HP45XXX_NTC_TRANSITION_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } -void hp45xxx_set_int_batovp_en(bool en){ +void hp4570_set_int_batovp_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL3, &value); - SET_ENABLE(en, value, HP45XXX_BATOVP_INT_EN_MASK, HP45XXX_BATOVP_INT_EN_ENABLE, HP45XXX_BATOVP_INT_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL3, 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); } -void hp45xxx_set_pcb_otp_en(bool en){ +void hp4570_set_pcb_otp_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL4, &value); - SET_ENABLE(en, value, HP45XXX_EN_PCB_OTP_MASK, HP45XXX_EN_PCB_OTP_ENABLE, HP45XXX_EN_PCB_OTP_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL4, 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); } -void hp45xxx_set_vindpm_en(bool en){ +void hp4570_set_vindpm_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL4, &value); - SET_ENABLE(en, value, HP45XXX_VINDPM_EN_MASK, HP45XXX_VINDPM_EN_ENABLE, HP45XXX_VINDPM_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL4, 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); } -bool hp45xxx_set_thermal_reg_degree(uint8_t degree){ +bool hp4570_set_thermal_reg_degree(uint8_t degree){ uint8_t value; uint8_t thermal_reg_code; - INVALID_INPUT_RETURN(degree, thermal_reg_code, hp45xxx_thermal_reg_degree, HP45XXX_NUM_THERMAL_REG_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL4, &value); - SET_BIT(value, HP45XXX_THERMAL_REG_MASK, thermal_reg_code, HP45XXX_THERMAL_REG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL4, value); + 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); return SUCCESS; } -bool hp45xxx_set_vsys_reg_mV(float voltage){ +bool hp4570_set_vsys_reg_mV(float voltage){ uint8_t value; uint8_t vsys_reg_code; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL4, &value); - INPUT_PARA_FAIL_RETURN(voltage,HP45XXX_VSYS_REG_MIN_mV,HP45XXX_VSYS_REG_MAX_mV); - vsys_reg_code = (uint8_t)((voltage - HP45XXX_VSYS_REG_OFFSET_mV)/HP45XXX_VSYS_REG_STEP_mV); - SET_BIT(value, HP45XXX_VSYS_REG_MASK, vsys_reg_code, HP45XXX_VSYS_REG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL4,value); + 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); return SUCCESS; } -bool hp45xxx_set_ship_dgl_mS(uint16_t time){ +bool hp4570_set_ship_dgl_mS(uint16_t time){ uint8_t value; uint8_t ship_dgl_code; - INVALID_INPUT_RETURN(time, ship_dgl_code, hp45xxx_ship_dgl_time, HP45XXX_NUM_SHIP_DGL_VAL); - SET_BIT(value, HP45XXX_SHIP_DGL_MASK, ship_dgl_code, HP45XXX_SHIP_DGL_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_CHIP_STAT1, value); + 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); return SUCCESS; } -bool hp45xxx_set_vin_exit_ship_tset_mS(uint16_t time){ +bool hp4570_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, hp45xxx_ship_dgl_time, HP45XXX_NUM_IN_EXIT_SHIP_TSET_VAL); - hp45xxx_read_reg(HP45XXX_REG_VIPRE, &value); - SET_BIT(value, HP45XXX_IN_EXIT_SHIP_TSET_MASK, in_exit_ship_tset_code, HP45XXX_IN_EXIT_SHIP_TSET_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_VIPRE, value); + 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); return SUCCESS; } -bool hp45xxx_set_chrg_ipre_mA(uint16_t current){ +bool hp4570_set_chrg_ipre_mA(uint16_t current){ uint8_t value; uint8_t ipre_code; - hp45xxx_read_reg(HP45XXX_REG_VIPRE, &value); - INPUT_PARA_FAIL_RETURN(current,HP45XXX_IPRE_MIN_mA,HP45XXX_IPRE_MAX_mA); - ipre_code = (uint8_t)((current - HP45XXX_IPRE_OFFSET_mA)/HP45XXX_IPRE_STEP_mA); - SET_BIT(value, HP45XXX_IPRE_MASK, ipre_code, HP45XXX_IPRE_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_VIPRE,value); + 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); return SUCCESS; } -void hp45xxx_set_rst_vin_entry_en(bool en){ +void hp4570_set_rst_vin_entry_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_EXT_CTRL, &value); - SET_ENABLE(en, value, HP45XXX_VINDPM_EN_MASK, HP45XXX_VIN_ENTRY_RST_EN_ENABLE, HP45XXX_VIN_ENTRY_RST_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_EXT_CTRL, 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); } -bool hp45xxx_set_chrg_idead_mA(uint16_t current){ +bool hp4570_set_chrg_idead_mA(uint16_t current){ uint8_t value; uint8_t ideadbat_code; - hp45xxx_read_reg(HP45XXX_REG_EXT_CTRL, &value); - INPUT_PARA_FAIL_RETURN(current,HP45XXX_IDEADBAT_MIN_mA,HP45XXX_IDEADBAT_MAX_mA); - ideadbat_code = (uint8_t)((current - HP45XXX_IDEADBAT_OFFSET_mA)/HP45XXX_IDEADBAT_STEP_mA); - SET_BIT(value, HP45XXX_IDEADBAT_MASK, ideadbat_code, HP45XXX_IDEADBAT_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_EXT_CTRL,value); + 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); return SUCCESS; } -bool hp45xxx_set_en_iindpm_en(bool en){ +bool hp4570_set_en_iindpm_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_EXT_CTRL, &value); - SET_ENABLE(en, value, HP45XXX_EN_IINDPM_MASK, HP45XXX_EN_IINDPM_ENABLE, HP45XXX_EN_IINDPM_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL5, 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); return SUCCESS; } -bool hp45xxx_set_key_wk_time_mS(uint16_t time){ +bool hp4570_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, hp45xxx_key_wk_set_time, HP45XXX_NUM_KEY_WK_SET_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL5, &value); - SET_BIT(value, HP45XXX_KEY_WK_SET_MASK, key_wk_set_code, HP45XXX_KEY_WK_SET_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL5, value); + 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); return SUCCESS; } -bool hp45xxx_set_t_hiccup_mS(uint16_t time){ +bool hp4570_set_t_hiccup_mS(uint16_t time){ uint8_t value; uint8_t t_hiccup_code; - INVALID_INPUT_RETURN(time, t_hiccup_code, hp45xxx_key_wk_set_time, HP45XXX_NUM_T_HICCUP_VAL); - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL5, &value); - SET_BIT(value, HP45XXX_T_HICCUP_MASK, t_hiccup_code, HP45XXX_T_HICCUP_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL5, value); + 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); return SUCCESS; } -void hp45xxx_set_wdt_vsys_rst_en(bool en){ +void hp4570_set_wdt_vsys_rst_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP45XXX_WDT_VSYS_RST_MASK, HP45XXX_WDT_VSYS_RST_ENABLE, HP45XXX_WDT_VSYS_RST_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL6, 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); } -void hp45xxx_set_ship_dgl_en(bool en){ +void hp4570_set_ship_dgl_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL6, &value); - SET_ENABLE(en, value, HP45XXX_EN_SHIP_DGL_MASK, HP45XXX_EN_SHIP_DGL_ENABLE, HP45XXX_EN_SHIP_DGL_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL6, 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); } -void hp45xxx_set_wdt_chg_en(bool en){ +void hp4570_set_wdt_chg_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP45XXX_EN_WDT_CHG_MASK, HP45XXX_EN_WDT_CHG_ENABLE, HP45XXX_EN_WDT_CHG_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, 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); } -void hp45xxx_set_rst_pwrkey_en(bool en){ +void hp4570_set_rst_pwrkey_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP45XXX_EN_PWRKEY_RST_MASK, HP45XXX_EN_PWRKEY_RST_ENABLE, HP45XXX_EN_PWRKEY_RST_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, 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); } -void hp45xxx_set_rst_vsys_wvbus_en(bool en){ +void hp4570_set_rst_vsys_wvbus_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP45XXX_VSYS_RST_WVBUS_MASK, HP45XXX_VSYS_RST_WVBUS_ENABLE, HP45XXX_VSYS_RST_WVBUS_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, 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); } -void hp45xxx_set_pwrkey_en(bool en){ +void hp4570_set_pwrkey_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP45XXX_PWRKEY_EN_MASK, HP45XXX_PWRKEY_EN_ENABLE, HP45XXX_PWRKEY_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, 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); } -void hp45xxx_set_vbus_wk_en(bool en){ +void hp4570_set_vbus_wk_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); - SET_ENABLE(en, value, HP45XXX_VBUS_WK_EN_MASK, HP45XXX_VBUS_WK_EN_ENABLE, HP45XXX_VBUS_WK_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, 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); } -void hp45xxx_set_pwrkey_wk_en(bool en){ +void hp4570_set_pwrkey_wk_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_CTRL7, &value); + hp4570_read_reg(HP4570_REG_SYS_CTRL7, &value); if(en){ - SET_BIT(value, HP45XXX_PWRKEY_WK_EN_MASK, HP45XXX_PWRKEY_WK_EN_ENABLE, HP45XXX_PWRKEY_WK_EN_BIT_SHIFT); + SET_BIT(value, HP4570_PWRKEY_WK_EN_MASK, HP4570_PWRKEY_WK_EN_ENABLE, HP4570_PWRKEY_WK_EN_BIT_SHIFT); // Note: bit 2 must be 1 - value |= (HP45XXX_PWRKEY_EN_ENABLE << HP45XXX_PWRKEY_EN_BIT_SHIFT); + value |= (HP4570_PWRKEY_EN_ENABLE << HP4570_PWRKEY_EN_BIT_SHIFT); }else - SET_BIT(value, HP45XXX_PWRKEY_WK_EN_MASK, !HP45XXX_PWRKEY_WK_EN_ENABLE, HP45XXX_PWRKEY_WK_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_SYS_CTRL7, value); + 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); } -bool hp45xxx_set_watchdog_int_enable(bool en){ +bool hp4570_set_watchdog_int_enable(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_INT0_ENABLE, &value); - SET_ENABLE(en, value, HP45XXX_WATCHDOG_INT_EN_MASK, HP45XXX_WATCHDOG_INT_EN_ENABLE, HP45XXX_WATCHDOG_INT_EN_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_INT0_ENABLE, 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); return SUCCESS; } -bool hp45xxx_set_chg_safety_expired_enable(bool en){ +bool hp4570_set_chg_safety_expired_enable(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_INT0_ENABLE, &value); - SET_ENABLE(en, value, HP45XXX_CHG_SAFETY_EXPIRED_MASK, HP45XXX_CHG_SAFETY_EXPIRED_ENABLE, HP45XXX_CHG_SAFETY_EXPIRED_BIT_SHIFT); - hp45xxx_write_reg(HP45XXX_REG_INT0_ENABLE, 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); return SUCCESS; } -bool hp45xxx_read_status_wdt_fault(void){ +bool hp4570_read_status_wdt_fault(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return (value & HP45XXX_WDT_FAULT_MASK) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return (value & HP4570_WDT_FAULT_MASK) ? true : false; } -bool hp45xxx_read_chrg_stat_not_chrg(void){ +bool hp4570_read_chrg_stat_not_chrg(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return ((value & HP45XXX_CHRG_STAT_MASK) == HP45XXX_CHRG_STAT_NOT_CHRG) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_NOT_CHRG) ? true : false; } -bool hp45xxx_read_chrg_stat_dead_chrg(void){ +bool hp4570_read_chrg_stat_dead_chrg(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return ((value & HP45XXX_CHRG_STAT_MASK) == HP45XXX_CHRG_STAT_DEAD_CHRG) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_DEAD_CHRG) ? true : false; } -bool hp45xxx_read_chrg_stat_pre_chrg(void){ +bool hp4570_read_chrg_stat_pre_chrg(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return ((value & HP45XXX_CHRG_STAT_MASK) == HP45XXX_CHRG_STAT_PRE_CHRG) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_PRE_CHRG) ? true : false; } -bool hp45xxx_read_chrg_stat_fast_chrg(void){ +bool hp4570_read_chrg_stat_fast_chrg(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return ((value & HP45XXX_CHRG_STAT_MASK) == HP45XXX_CHRG_STAT_FAST_CHRG) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_FAST_CHRG) ? true : false; } -bool hp45xxx_read_chrg_stat_chrg_done(void){ +bool hp4570_read_chrg_stat_chrg_done(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return ((value & HP45XXX_CHRG_STAT_MASK) == HP45XXX_CHRG_STAT_CHRG_DONE) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return ((value & HP4570_CHRG_STAT_MASK) == HP4570_CHRG_STAT_CHRG_DONE) ? true : false; } -bool hp45xxx_read_status_vindpm(void){ +bool hp4570_read_status_vindpm(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return (value & HP45XXX_VIN_DPM_STAT_MASK) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return (value & HP4570_VIN_DPM_STAT_MASK) ? true : false; } -bool hp45xxx_read_status_vbus_pg(void){ +bool hp4570_read_status_vbus_pg(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return (value & HP45XXX_VBUS_PG_STAT_MASK) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return (value & HP4570_VBUS_PG_STAT_MASK) ? true : false; } -bool hp45xxx_read_status_thermal(void){ +bool hp4570_read_status_thermal(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT0, &value); - return (value & HP45XXX_THERM_STAT_MASK) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT0, &value); + return (value & HP4570_THERM_STAT_MASK) ? true : false; } -void hp45xxx_update_status_chip_stat1(void){ +void hp4570_update_status_chip_stat1(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT1, &value); - if(value & HP45XXX_VIN_FAULT_MASK) - hp45xxx_chip_state.vin_fault |= true; - if(value & HP45XXX_TSHUT_MASK) - hp45xxx_chip_state.tshut |= true; - if(value & HP45XXX_VBAT_OVP_MASK) - hp45xxx_chip_state.vbat_ovp |= true; - if(value & HP45XXX_SAFETY_MODE_MASK) - hp45xxx_chip_state.safety_mode |= true; - hp45xxx_chip_state.ntc_hot = (value & HP45XXX_NTC_HOT_MASK) ? true : false; - hp45xxx_chip_state.ntc_cold = (value & HP45XXX_NTC_COLD_MASK) ? true : false; + 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; } -void hp45xxx_clear_status_chip_stat1(void){ - hp45xxx_chip_state.vin_fault = false; - hp45xxx_chip_state.tshut = false; - hp45xxx_chip_state.vbat_ovp = false; - hp45xxx_chip_state.safety_mode = 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; } -bool hp45xxx_read_status_vin_fault(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.vin_fault; +bool hp4570_read_status_vin_fault(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.vin_fault; } -bool hp45xxx_read_status_tshut(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.tshut; +bool hp4570_read_status_tshut(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.tshut; } -bool hp45xxx_read_status_vbat_ovp(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.vbat_ovp; +bool hp4570_read_status_vbat_ovp(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.vbat_ovp; } -bool hp45xxx_read_status_safety_mode(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.safety_mode; +bool hp4570_read_status_safety_mode(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.safety_mode; } -bool hp45xxx_read_status_ntc_hot(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.ntc_hot; +bool hp4570_read_status_ntc_hot(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.ntc_hot; } -bool hp45xxx_read_status_ntc_cold(void){ - hp45xxx_update_status_chip_stat1(); - return hp45xxx_chip_state.ntc_cold; +bool hp4570_read_status_ntc_cold(void){ + hp4570_update_status_chip_stat1(); + return hp4570_chip_state.ntc_cold; } -bool hp45xxx_read_status_iindpm(void){ +bool hp4570_read_status_iindpm(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_CHIP_STAT2, &value); - return (value & HP45XXX_IIN_DPM_STAT_MASK) ? true : false; + hp4570_read_reg(HP4570_REG_CHIP_STAT2, &value); + return (value & HP4570_IIN_DPM_STAT_MASK) ? true : false; } -bool hp45xxx_read_status_vin_entry_rst(void){ +bool hp4570_read_status_vin_entry_rst(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP45XXX_ENTRY_RST_STAT_MASK){ - hp45xxx_write_reg(HP45XXX_REG_SYS_WAKE_UP_SRC,HP45XXX_ENTRY_RST_STAT_MASK); + 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); return true; } return false; } -bool hp45xxx_read_status_pwrkey_rst(void){ +bool hp4570_read_status_pwrkey_rst(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP45XXX_PWRKEY_RST_STAT_MASK){ - hp45xxx_write_reg(HP45XXX_REG_SYS_WAKE_UP_SRC,HP45XXX_PWRKEY_RST_STAT_MASK); + 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); return true; } return false; } -bool hp45xxx_read_status_hiccup_latch(void){ +bool hp4570_read_status_hiccup_latch(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP45XXX_HICCUP_LATCH_STAT_MASK){ - hp45xxx_write_reg(HP45XXX_REG_SYS_WAKE_UP_SRC,HP45XXX_HICCUP_LATCH_STAT_MASK); + 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); return true; } return false; } -bool hp45xxx_read_status_pwrkey_wk(void){ +bool hp4570_read_status_pwrkey_wk(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP45XXX_PWRKEY_WK_MASK){ - hp45xxx_write_reg(HP45XXX_REG_SYS_WAKE_UP_SRC,HP45XXX_PWRKEY_WK_MASK); + 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); return true; } return false; } -bool hp45xxx_read_status_vbus_wk(void){ +bool hp4570_read_status_vbus_wk(void){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_SYS_WAKE_UP_SRC, &value); - if(value & HP45XXX_VBUS_WK_MASK){ - hp45xxx_write_reg(HP45XXX_REG_SYS_WAKE_UP_SRC,HP45XXX_VBUS_WK_MASK); + 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); return true; } return false; } -bool hp45xxx_read_status_watchdog_int(void){ +bool hp4570_read_status_watchdog_int(void){ + uint8_t value; + hp4570_read_reg(HP4570_REG_INT0_STAT, &value); + return (value & HP4570_WATCHDOG_INT_MASK) ? true : false; +} + +void hp4570_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); +} + +void hp4570_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); +} + +void hp4570_set_ideadbat_4x_en(bool en){ uint8_t value; - hp45xxx_read_reg(HP45XXX_REG_INT0_STAT, &value); - return (value & HP45XXX_WATCHDOG_INT_MASK) ? true : false; + 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); } uint8_t hp4507_get_id(void) { uint8_t id = 0; - hp45xxx_i2c_addr = HP45XXX_I2C_ADDR; - hp45xxx_read_reg(HP45XXX_REG_CHIP_VER, &id); + hp4570_i2c_addr = HP4570_I2C_ADDR; + hp4570_read_reg(HP4570_REG_CHIP_VER, &id); 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 1dee10411..0044a1e77 100644 --- a/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h +++ b/code/sdk/zhihui/drivers/charge/hp4570/hp4570.h @@ -1,10 +1,10 @@ /** - * @file HP4570.h + * @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. * @author Hypower Applications - * @date June 26, 2023 + * @date October 14, 2024 * * Copyright (C) 2023 Hypower Microelectronics (Wuxi) Co., Ltd. All rights reserved. * @@ -25,11 +25,11 @@ #include #include -#include "chip_io.h" +#include "std_def.h" // for example // Avoid using "X", x stands for General Condition -enum hp45xxx_chip_ver { +enum HP4570_chip_ver { HP4570A,// all default, package typeA HP4570B,// all default, package typeB HP4570I = 0x0A,// different ichg range and step @@ -39,726 +39,482 @@ enum hp45xxx_chip_ver { HP4570C9 = 0x02,// just different name }; - // 7-bit Slave Address -#define HP45XXX_I2C_ADDR 0x07 -#define HP4570K_I2C_ADDR 0x3F +#define HP4570_I2C_ADDR 0x07 + // Register address definitions -#define HP45XXX_REG_DPM_SET 0x00 -#define HP45XXX_REG_SYS_CTRL0 0x01 -#define HP45XXX_REG_SYS_CTRL1 0x02 -#define HP45XXX_REG_IDSG_ITERM_SET 0x03 -#define HP45XXX_REG_BAT_VOL_SET 0x04 -#define HP45XXX_REG_SYS_CTRL2 0x05 -#define HP45XXX_REG_SYS_CTRL3 0x06 -#define HP45XXX_REG_SYS_CTRL4 0x07 -#define HP45XXX_REG_CHIP_STAT0 0x08 -#define HP45XXX_REG_CHIP_STAT1 0x09 -#define HP45XXX_REG_CHIP_STAT2 0x0B -#define HP45XXX_REG_VIPRE 0x0C -#define HP45XXX_REG_EXT_CTRL 0x0D -#define HP45XXX_REG_SYS_CTRL5 0x15 -#define HP45XXX_REG_SYS_CTRL6 0x19 -#define HP45XXX_REG_SYS_CTRL7 0x1B -#define HP45XXX_REG_SYS_WAKE_UP_SRC 0x1E -#define HP45XXX_REG_INT0_ENABLE 0x50 -#define HP45XXX_REG_INT0_STAT 0x58 -#define HP45XXX_REG_VID_LSB 0x60 -#define HP45XXX_REG_VID_MSB 0x61 -#define HP45XXX_REG_PID_LSB 0x62 -#define HP45XXX_REG_PID_MSB 0x63 -#define HP45XXX_REG_CHIP_VER 0x64 +#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 #ifndef GENMASK #define GENMASK(h, l) (((uint8_t) -1 >> (7 - (h))) & ~((1U << (l)) - 1)) #endif -#define HP45XXX_VIN_MIN_MASK GENMASK(7, 4) -#define HP45XXX_VIN_MIN_STEP_mV 100 -#define HP45XXX_VIN_MIN_OFFSET_mV 3800 -#define HP45XXX_VIN_MIN_MIN_mV 3800 -#define HP45XXX_VIN_MIN_MAX_mV 4700 -#define HP45XXX_VIN_MIN_BIT_SHIFT 4 - -#define HP45XXX_IINDPM_MASK GENMASK(2, 0) -#define HP45XXX_IINDPM_STEP_mA 100 -#define HP45XXX_IINDPM_OFFSET_mA 100 -#define HP45XXX_IINDPM_MIN_mA 100 -#define HP45XXX_IINDPM_MAX_mA 900 -#define HP45XXX_IINDPM_BIT_SHIFT 0 - -#define HP45XXX_NUM_TRST_DGL_VAL 4 -#define HP45XXX_TRST_DGL_MASK GENMASK(7, 6) -#define HP45XXX_TRST_DGL_BIT_SHIFT 6 - -#define HP45XXX_NUM_TRST_DUR_VAL 2 -#define HP45XXX_TRST_DUR_MASK BIT(5) -#define HP45XXX_TRST_DUR_BIT_SHIFT 5 - -#define HP45XXX_EN_HIZ_MASK BIT(4) -#define HP45XXX_EN_HIZ_ENABLE 1 -#define HP45XXX_EN_HIZ_BIT_SHIFT 4 - -#define HP45XXX_CEB_MASK BIT(3) -#define HP45XXX_CEB_ENABLE 0 -#define HP45XXX_CEB_BIT_SHIFT 3 - -#define HP45XXX_VBAT_UVLO_MASK GENMASK(2, 0) -#define HP45XXX_VBAT_UVLO_STEP_mV 100 -#define HP45XXX_VBAT_UVLO_OFFSET_mV 2400 -#define HP45XXX_VBAT_UVLO_MIN_mV 2400 -#define HP45XXX_VBAT_UVLO_MAX_mV 3100 -#define HP45XXX_VBAT_UVLO_DEF_mV 2800 -#define HP45XXX_VBAT_UVLO_BIT_SHIFT 0 - -#define HP45XXX_REG_RST_MASK BIT(7) -#define HP45XXX_REG_RST_RESET 1 -#define HP45XXX_REG_RST_BIT_SHIFT 7 - -#define HP45XXX_WDT_RST_MASK BIT(6) -#define HP45XXX_WDT_RST_RESET 1 -#define HP45XXX_WDT_RST_BIT_SHIFT 6 - -#define HP45XXX_ICHG_MASK GENMASK(5, 0) -#define HP45XXX_ICHG_STEP_mA 8 -#define HP45XXX_ICHG_OFFSET_mA 8 -#define HP45XXX_ICHG_MIN_mA 8 -#define HP45XXX_ICHG_MAX_mA 512 +#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 HP45XXX_ICHG_BIT_SHIFT 0 - -#define HP45XXX_IBATFET_OCP_MASK GENMASK(7, 4) -#define HP45XXX_IBATFET_OCP_STEP_mA 200 -#define HP45XXX_IBATFET_OCP_OFFSET_mA 200 -#define HP45XXX_IBATFET_OCP_MIN_mA 200 -#define HP45XXX_IBATFET_OCP_MAX_mA 3200 -#define HP45XXX_IBATFET_OCP_BIT_SHIFT 4 - -#define HP45XXX_ITERM_MASK GENMASK(3, 0) -#define HP45XXX_ITERM_STEP_mA 2 -#define HP45XXX_ITERM_OFFSET_mA 1 -#define HP45XXX_ITERM_MIN_mA 1 -#define HP45XXX_ITERM_MAX_mA 31 -#define HP45XXX_ITERM_BIT_SHIFT 0 - -#define HP45XXX_VBATREG_MASK GENMASK(7, 2) -#define HP45XXX_VBATREG_STEP_mV 12.5 -#define HP45XXX_VBATREG_OFFSET_mV 4000 -#define HP45XXX_VBATREG_MIN_mV 4000 -#define HP45XXX_VBATREG_MAX_mV 4500 -#define HP45XXX_VBATREG_BIT_SHIFT 2 - -#define HP45XXX_NUM_VBAT_PRE_VAL 4 -#define HP45XXX_VBAT_PRE_0_MASK BIT(1) -#define HP45XXX_VBAT_PRE_1_MASK BIT(4) -#define HP45XXX_VBAT_PRE_0_BIT_SHIFT 1 -#define HP45XXX_VBAT_PRE_1_BIT_SHIFT 4 - -#define HP45XXX_NUM_VRE_CHG_VAL 2 -#define HP45XXX_VRE_CHG_MASK BIT(0) -#define HP45XXX_VRE_CHG_BIT_SHIFT 0 - -#define HP45XXX_EN_WDT_DSG_MASK BIT(7) -#define HP45XXX_EN_WDT_DSG_ENABLE 1 -#define HP45XXX_EN_WDT_DSG_BIT_SHIFT 7 - -#define HP45XXX_NUM_WDT_TIMER_VAL 4 -#define HP45XXX_WDT_TIMER_MASK GENMASK(6, 5) -#define HP45XXX_WDT_TIMER_DIS 0 -#define HP45XXX_WDT_TIMER_BIT_SHIFT 5 - -#define HP45XXX_EN_TERM_MASK BIT(4) -#define HP45XXX_EN_TERM_ENABLE 1 -#define HP45XXX_EN_TERM_BIT_SHIFT 4 - -#define HP45XXX_EN_TIMER_MASK BIT(3) -#define HP45XXX_EN_TIMER_ENABLE 1 -#define HP45XXX_EN_TIMER_BIT_SHIFT 3 - -#define HP45XXX_NUM_CHG_TIMER_VAL 4 -#define HP45XXX_CHG_TIMER_MASK GENMASK(2, 1) -#define HP45XXX_CHG_TIMER_BIT_SHIFT 1 - -#define HP45XXX_TERM_TMR_MASK BIT(0) -#define HP45XXX_TERM_TMR_ENABLE 1 -#define HP45XXX_TERM_TMR_BIT_SHIFT 0 - -#define HP45XXX_NTC_EN_MASK BIT(7) -#define HP45XXX_NTC_EN_ENABLE 1 -#define HP45XXX_NTC_EN_BIT_SHIFT 7 - -#define HP45XXX_TMR2X_EN_MASK BIT(6) -#define HP45XXX_TMR2X_EN_ENABLE 1 -#define HP45XXX_TMR2X_EN_BIT_SHIFT 6 - -#define HP45XXX_BATFET_DIS_MASK BIT(5) -#define HP45XXX_BATFET_DIS_ENABLE 1 -#define HP45XXX_BATFET_DIS_BIT_SHIFT 5 - -#define HP45XXX_PG_INT_CONTROL_MASK BIT(4) -#define HP45XXX_PG_INT_CONTROL_ENABLE 0 -#define HP45XXX_PG_INT_CONTROL_BIT_SHIFT 4 - -#define HP45XXX_CHG_DONE_INT_EN_MASK BIT(3) -#define HP45XXX_CHG_DONE_INT_EN_ENABLE 0 -#define HP45XXX_CHG_DONE_INT_EN_BIT_SHIFT 3 - -#define HP45XXX_CHG_STAT_INT_EN_MASK BIT(2) -#define HP45XXX_CHG_STAT_INT_EN_ENABLE 0 -#define HP45XXX_CHG_STAT_INT_EN_BIT_SHIFT 2 - -#define HP45XXX_NTC_TRANSITION_EN_MASK BIT(1) -#define HP45XXX_NTC_TRANSITION_EN_ENABLE 0 -#define HP45XXX_NTC_TRANSITION_EN_BIT_SHIFT 1 - -#define HP45XXX_BATOVP_INT_EN_MASK BIT(0) -#define HP45XXX_BATOVP_INT_EN_ENABLE 0 -#define HP45XXX_BATOVP_INT_EN_BIT_SHIFT 0 - -#define HP45XXX_EN_PCB_OTP_MASK BIT(7) -#define HP45XXX_EN_PCB_OTP_ENABLE 0 -#define HP45XXX_EN_PCB_OTP_BIT_SHIFT 7 - -#define HP45XXX_VINDPM_EN_MASK BIT(6) -#define HP45XXX_VINDPM_EN_ENABLE 1 -#define HP45XXX_VINDPM_EN_BIT_SHIFT 6 - -#define HP45XXX_NUM_THERMAL_REG_VAL 4 -#define HP45XXX_THERMAL_REG_MASK GENMASK(5, 4) -#define HP45XXX_THERMAL_REG_BIT_SHIFT 4 - -#define HP45XXX_VSYS_REG_MASK GENMASK(2, 0) -#define HP45XXX_VSYS_REG_STEP_mV 100 -#define HP45XXX_VSYS_REG_OFFSET_mV 4250 -#define HP45XXX_VSYS_REG_MIN_mV 4250 -#define HP45XXX_VSYS_REG_MAX_mV 4950 -#define HP45XXX_VSYS_REG_BIT_SHIFT 0 - -#define HP45XXX_CHRG_STAT_MASK GENMASK(5, 3) -#define HP45XXX_CHRG_STAT_BIT_SHIFT 3 -#define HP45XXX_CHRG_STAT_NOT_CHRG 0 -#define HP45XXX_CHRG_STAT_DEAD_CHRG (BIT(5) | BIT(3)) -#define HP45XXX_CHRG_STAT_PRE_CHRG BIT(3) -#define HP45XXX_CHRG_STAT_FAST_CHRG BIT(4) -#define HP45XXX_CHRG_STAT_CHRG_DONE (BIT(4) | BIT(3)) - -#define HP45XXX_WDT_FAULT_MASK BIT(7) -#define HP45XXX_VIN_DPM_STAT_MASK BIT(2) -#define HP45XXX_VBUS_PG_STAT_MASK BIT(1) -#define HP45XXX_THERM_STAT_MASK BIT(0) - -#define HP45XXX_NUM_SHIP_DGL_VAL 4 -#define HP45XXX_SHIP_DGL_MASK GENMASK(7, 6) -#define HP45XXX_SHIP_DGL_BIT_SHIFT 6 - -#define HP45XXX_VIN_FAULT_MASK BIT(5) -#define HP45XXX_TSHUT_MASK BIT(4) -#define HP45XXX_VBAT_OVP_MASK BIT(3) -#define HP45XXX_SAFETY_MODE_MASK BIT(2) -#define HP45XXX_NTC_HOT_MASK BIT(1) -#define HP45XXX_NTC_COLD_MASK BIT(0) - -#define HP45XXX_IIN_DPM_STAT_MASK BIT(6) - -#define HP45XXX_NUM_IN_EXIT_SHIP_TSET_VAL 2 -#define HP45XXX_IN_EXIT_SHIP_TSET_MASK BIT(5) -#define HP45XXX_IN_EXIT_SHIP_TSET_BIT_SHIFT 5 - -#define HP45XXX_IPRE_MASK GENMASK(3, 0) -#define HP45XXX_IPRE_STEP_mA 2 -#define HP45XXX_IPRE_OFFSET_mA 1 -#define HP45XXX_IPRE_MIN_mA 1 -#define HP45XXX_IPRE_MAX_mA 31 -#define HP45XXX_IPRE_BIT_SHIFT 0 - -#define HP45XXX_VIN_ENTRY_RST_EN_MASK BIT(4) -#define HP45XXX_VIN_ENTRY_RST_EN_ENABLE 1 -#define HP45XXX_VIN_ENTRY_RST_EN_BIT_SHIFT 4 - -#define HP45XXX_IDEADBAT_MASK GENMASK(3, 0) -#define HP45XXX_IDEADBAT_STEP_mA 2 -#define HP45XXX_IDEADBAT_OFFSET_mA 1 -#define HP45XXX_IDEADBAT_MIN_mA 1 -#define HP45XXX_IDEADBAT_MAX_mA 31 -#define HP45XXX_IDEADBAT_BIT_SHIFT 0 - -#define HP45XXX_VSYS_RST_MASK BIT(7) -#define HP45XXX_VSYS_RST_RESET 1 -#define HP45XXX_VSYS_RST_BIT_SHIFT 7 - -#define HP45XXX_EN_IINDPM_MASK BIT(5) -#define HP45XXX_EN_IINDPM_ENABLE 1 -#define HP45XXX_EN_IINDPM_BIT_SHIFT 5 - -#define HP45XXX_NUM_KEY_WK_SET_VAL 2 -#define HP45XXX_KEY_WK_SET_MASK BIT(2) -#define HP45XXX_KEY_WK_SET_BIT_SHIFT 2 - -#define HP45XXX_NUM_T_HICCUP_VAL 2 -#define HP45XXX_T_HICCUP_MASK BIT(0) -#define HP45XXX_T_HICCUP_BIT_SHIFT 0 - -#define HP45XXX_WDT_VSYS_RST_MASK BIT(3) -#define HP45XXX_WDT_VSYS_RST_ENABLE 1 -#define HP45XXX_WDT_VSYS_RST_BIT_SHIFT 3 - -#define HP45XXX_EN_SHIP_DGL_MASK BIT(2) -#define HP45XXX_EN_SHIP_DGL_ENABLE 1 -#define HP45XXX_EN_SHIP_DGL_BIT_SHIFT 2 - -#define HP45XXX_EN_WDT_CHG_MASK BIT(7) -#define HP45XXX_EN_WDT_CHG_ENABLE 1 -#define HP45XXX_EN_WDT_CHG_BIT_SHIFT 7 - -#define HP45XXX_EN_PWRKEY_RST_MASK BIT(5) -#define HP45XXX_EN_PWRKEY_RST_ENABLE 1 -#define HP45XXX_EN_PWRKEY_RST_BIT_SHIFT 5 - -#define HP45XXX_VSYS_RST_WVBUS_MASK BIT(4) -#define HP45XXX_VSYS_RST_WVBUS_ENABLE 1 -#define HP45XXX_VSYS_RST_WVBUS_BIT_SHIFT 4 - -#define HP45XXX_PWRKEY_EN_MASK BIT(2) -#define HP45XXX_PWRKEY_EN_ENABLE 1 -#define HP45XXX_PWRKEY_EN_BIT_SHIFT 2 - -#define HP45XXX_VBUS_WK_EN_MASK BIT(1) -#define HP45XXX_VBUS_WK_EN_ENABLE 1 -#define HP45XXX_VBUS_WK_EN_BIT_SHIFT 1 - -#define HP45XXX_PWRKEY_WK_EN_MASK BIT(0) -#define HP45XXX_PWRKEY_WK_EN_ENABLE 1 -#define HP45XXX_PWRKEY_WK_EN_BIT_SHIFT 0 - -#define HP45XXX_ENTRY_RST_STAT_MASK BIT(7) -#define HP45XXX_PWRKEY_RST_STAT_MASK BIT(5) -#define HP45XXX_HICCUP_LATCH_STAT_MASK BIT(4) -#define HP45XXX_PWRKEY_WK_MASK BIT(1) -#define HP45XXX_VBUS_WK_MASK BIT(0) - -#define HP45XXX_WATCHDOG_INT_EN_MASK BIT(7) -#define HP45XXX_WATCHDOG_INT_EN_ENABLE 0 -#define HP45XXX_WATCHDOG_INT_EN_BIT_SHIFT 7 - -#define HP45XXX_CHG_SAFETY_EXPIRED_MASK BIT(1) -#define HP45XXX_CHG_SAFETY_EXPIRED_ENABLE 0 -#define HP45XXX_CHG_SAFETY_EXPIRED_BIT_SHIFT 1 - -#define HP45XXX_WATCHDOG_INT_MASK BIT(7) - -static const uint32_t hp45xxx_trst_dgl_time[HP45XXX_NUM_TRST_DGL_VAL] = { +#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) + +static const uint32_t HP4570_trst_dgl_time[HP4570_NUM_TRST_DGL_VAL] = { 80000, 120000, 160000, 200000 }; -static const uint16_t hp45xxx_trst_dur_time[HP45XXX_NUM_TRST_DUR_VAL] = { +static const uint16_t HP4570_trst_dur_time[HP4570_NUM_TRST_DUR_VAL] = { 2000, 4000 }; -static const uint16_t hp45xxx_vbat_pre_voltage[HP45XXX_NUM_VBAT_PRE_VAL] = { +static const uint16_t HP4570_vbat_pre_voltage[HP4570_NUM_VBAT_PRE_VAL] = { 2800, 3000, 3200, 3300 }; -static const uint8_t hp45xxx_vre_chg_voltage[HP45XXX_NUM_VRE_CHG_VAL] = { +static const uint8_t HP4570_vre_chg_voltage[HP4570_NUM_VRE_CHG_VAL] = { 100, 200 }; -static const uint32_t hp45xxx_watchdog_time[HP45XXX_NUM_WDT_TIMER_VAL] = { +static const uint32_t HP4570_watchdog_time[HP4570_NUM_WDT_TIMER_VAL] = { 0, 40000, 80000, 160000 }; -static const uint8_t hp45xxx_fast_chg_time[HP45XXX_NUM_CHG_TIMER_VAL] = { +static const uint8_t HP4570_fast_chg_time[HP4570_NUM_CHG_TIMER_VAL] = { 3, 5, 8, 12 }; -static const uint8_t hp45xxx_thermal_reg_degree[HP45XXX_NUM_THERMAL_REG_VAL] = { +static const uint8_t HP4570_thermal_reg_degree[HP4570_NUM_THERMAL_REG_VAL] = { 80, 100, 120, 130 }; -static const uint16_t hp45xxx_ship_dgl_time[HP45XXX_NUM_SHIP_DGL_VAL] = { +static const uint16_t HP4570_ship_dgl_time[HP4570_NUM_SHIP_DGL_VAL] = { 1000, 2000, 4000, 8000 }; -static const uint16_t hp45xxx_in_exit_ship_tset_time[HP45XXX_NUM_IN_EXIT_SHIP_TSET_VAL] = { +static const uint16_t HP4570_in_exit_ship_tset_time[HP4570_NUM_IN_EXIT_SHIP_TSET_VAL] = { 50, 2000 }; -static const uint16_t hp45xxx_key_wk_set_time[HP45XXX_NUM_KEY_WK_SET_VAL] = { +static const uint16_t HP4570_key_wk_set_time[HP4570_NUM_KEY_WK_SET_VAL] = { 2000, 200 }; -static const uint16_t hp45xxx_t_hiccup_time[HP45XXX_NUM_T_HICCUP_VAL] = { +static const uint16_t HP4570_t_hiccup_time[HP4570_NUM_T_HICCUP_VAL] = { 256, 512 }; //Default value for a register. -#define HP45XXX_REG_DPM_SET_DEF 0x84 -#define HP45XXX_REG_SYS_CTRL0_DEF 0xA4 -#define HP45XXX_REG_SYS_CTRL1_DEF 0x00 -#define HP45XXX_REG_IDSG_ITERM_SET_DEF 0x91 -#define HP45XXX_REG_BAT_VOL_SET_DEF 0x43 -#define HP45XXX_REG_SYS_CTRL2_DEF 0x3A -#define HP45XXX_REG_SYS_CTRL3_DEF 0x40 -#define HP45XXX_REG_SYS_CTRL4_DEF 0x24 -#define HP45XXX_REG_CHIP_STAT1_DEF 0x00 -#define HP45XXX_REG_VIPRE_DEF 0x01 -#define HP45XXX_REG_EXT_CTRL_DEF 0x11 -#define HP45XXX_REG_SYS_CTRL5_DEF 0x31 -#define HP45XXX_REG_SYS_CTRL6_DEF 0x0C -#define HP45XXX_REG_SYS_CTRL7_DEF 0xB6 -#define HP45XXX_REG_INT0_ENABLE_DEF 0x4C -#define HP45XXX_REG_INT0_STAT_DEF 0x00 -#define HP45XXX_REG_VID_LSB_DEF 0xC6 -#define HP45XXX_REG_VID_MSB_DEF 0x34 -#define HP45XXX_REG_PID_LSB_DEF 0x81 -#define HP45XXX_REG_PID_MSB_DEF 0x00 +#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 0x03 #define HP4570J_REG_SYS_CTRL0_DEF 0xAC -// 函数声明 -// 芯片初始化:初始化指定型号的HP45XXX芯片(如HP4570A),完成I2C通信配置及寄存器默认值设置 -// 返回值:true表示初始化成功,false表示失败 -bool hp45xxx_init(uint8_t chip_ver); - -// 芯片识别:验证I2C总线上是否存在目标型号的HP45XXX芯片,确认通信正常 -// 返回值:true表示识别成功(芯片存在),false表示识别失败 -bool hp45xxx_identify(uint8_t chip_ver); - - -// 设置PWRKEY功能使能:开启或关闭PWRKEY引脚的唤醒、复位等功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_pwrkey_en(bool en); - -// 设置复位消抖时间:配置拉低INT引脚断开电池后自动开机的消抖时间(防止误触发) -// 参数time:目标消抖时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_trst_dgl_mS(uint32_t time); - - -// 寄存器复位:将所有配置寄存器恢复为默认值(软件复位) -void hp45xxx_reg_rst(void); - -// 看门狗复位:重置看门狗定时器(避免因超时触发系统复位) -void hp45xxx_wdt_rst(void); - -// VSYS复位:触发系统电压(VSYS)复位,重启整个供电系统 -void hp45xxx_vsys_rst(void); - -// 使能VIN输入脉冲复位:开启/关闭通过VIN引脚的4次脉冲信号触发复位的功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_rst_vin_entry_en(bool en); - -// 使能PWRKEY复位功能:开启/关闭通过PWRKEY引脚操作触发VSYS复位的功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_rst_pwrkey_en(bool en); - -// 使能VBUS存在时VSYS复位:开启/关闭当VBUS(外部电源)接入时允许VSYS复位的功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_rst_vsys_wvbus_en(bool en); - - -// 进入船运模式:使芯片进入低功耗休眠状态(仅特定条件可唤醒,如VBUS插入、PWRKEY触发) -void hp45xxx_entry_shipmode(void); - -// 强制关闭BATFET:断开电池与系统的连接(用于紧急断电或保护场景) -// 参数en:true=强制关闭,false=正常工作(允许电池供电) -// 返回值:true表示配置成功,false表示失败 -bool hp45xxx_set_batfet_dis(bool en); - -// 使能VBUS唤醒功能:开启/关闭通过插入VBUS(外部电源)唤醒船运模式的功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_vbus_wk_en(bool en); - -// 使能PWRKEY唤醒功能:开启/关闭通过拉低PWRKEY引脚唤醒船运模式的功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_pwrkey_wk_en(bool en); - -// 设置VIN唤醒船运模式的延时:配置VIN端口检测到有效电源后,延迟多久退出船运模式 -// 参数time:目标延时时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_vin_exit_ship_tset_mS(uint16_t time); - -// 设置PWRKEY唤醒时间:配置PWRKEY引脚需要保持低电平多久才能唤醒系统 -// 参数time:目标时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_key_wk_time_mS(uint16_t time); - -// 使能船运模式消抖:开启/关闭进入船运模式时的信号消抖功能(防止误触发) -// 参数en:true=使能,false=禁用 -void hp45xxx_set_ship_dgl_en(bool en); - -// 设置船运模式消抖时间:配置进入船运模式前的信号稳定时间(过滤毛刺) -// 参数time:目标消抖时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_ship_dgl_mS(uint16_t time); - - -// 使能VBUS高阻模式:开启/关闭VBUS电源路径的高阻状态(断开VBUS与系统的连接) -// 参数en:true=使能高阻,false=正常导通 -void hp45xxx_set_hiz_en(bool en); - -// 使能充电功能:开启/关闭芯片的充电功能(控制是否对电池充电) -// 参数en:true=允许充电,false=禁止充电 -void hp45xxx_set_ceb_en(bool en); - - -// 设置VSYS输出电压:配置系统电压(VSYS)的稳压值 -// 参数voltage:目标电压(单位:毫伏,如4200表示4.2V) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_vsys_reg_mV(float voltage); - -// 设置复位持续时间:配置VSYS关闭后,经过多久自动开机 -// 参数time:目标持续时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_trst_dur_mS(uint16_t time); - -// 使能输入电压DPM:开启/关闭输入电压动态功率管理(防止输入电压过低) -// 参数en:true=使能,false=禁用 -void hp45xxx_set_vindpm_en(bool en); - -// 使能输入电流DPM:开启/关闭输入电流动态功率管理(防止输入电流过大) -// 参数en:true=使能,false=禁用 -void hp45xxx_set_iindpm_en(bool en); - -// 设置输入电压DPM阈值:配置输入电压的保护阈值(低于此值触发功率限制) -// 参数voltage:目标阈值(单位:毫伏) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_vindpm_mV(uint16_t voltage); - -// 设置输入电流DPM阈值:配置输入电流的保护阈值(超过此值触发功率限制) -// 参数current:目标阈值(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_iindpm_mA(uint16_t current); - - -// 设置预充电电压:配置电池预充电阶段的目标电压(适用于电池电压较低时) -// 参数voltage:目标电压(单位:毫伏) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_vpre_mV(uint8_t voltage); - -// 设置电池满充电压:配置电池快充阶段的目标电压(电池充满时的电压) -// 参数voltage:目标电压(单位:毫伏,如4350表示4.35V) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_vbat_mV(float voltage); - -// 设置复充电压:配置电池放电至该电压后,重新开始充电的阈值 -// 参数voltage:目标电压(单位:毫伏) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_vre_mV(uint8_t voltage); - -// 设置深度放电充电电流:配置电池深度放电(电压极低)时的充电电流 -// 参数current:目标电流(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_idead_mA(uint16_t current); - -// 设置预充电电流:配置电池预充电阶段的充电电流(适用于电池电压较低时) -// 参数current:目标电流(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_ipre_mA(uint16_t current); - -// 设置快充电流:配置电池快充阶段的充电电流(主要充电阶段的电流) -// 参数current:目标电流(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_ichg_mA(uint16_t current); - -// HP4570I型号专用快充电流设置:针对HP4570I型号的快充电流配置(该型号电流范围不同) -// 参数current:目标电流(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 +// 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); - -// 设置充电终止电流:当充电电流低于该值时,判定为电池充满(结束充电) -// 参数current:目标电流(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_iterm_mA(uint8_t current); - -// 使能充电终止功能:允许/禁止根据终止电流判断充电完成的功能 -// 参数en:true=允许终止,false=禁止终止(持续充电) -void hp45xxx_set_chrg_term_en(bool en); - -// 使能终止定时器:开启/关闭充电终止阶段的定时器(确保终止判断稳定) -// 参数en:true=使能,false=禁用 -void hp45xxx_set_chrg_term_tmr(bool en); - -// 使能充电安全定时器:开启/关闭充电过程中的安全定时器(防止过充) -// 参数en:true=使能(超时后停止充电),false=禁用 -void hp45xxx_set_chrg_timer_en(bool en); - -// 设置快充定时器时长:配置快充阶段的最大允许时间(超时后进入保护) -// 参数time:目标时间(单位:小时,如3表示3小时) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_chrg_timer_hour(uint8_t time); - -// 使能安全定时器加倍:开启/关闭在DPM或 thermal模式下,安全定时器时长加倍的功能 -// 参数en:true=使能(延长保护时间),false=禁用 -void hp45xxx_set_chrg_tmr2x_en(bool en); - - -// 设置电池FET过流保护阈值:配置BATFET(电池通路开关)的过流保护电流 -// 参数current:目标阈值(单位:毫安) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_ibatfet_ocp_mA(uint16_t current); - -// 设置电池欠压锁定阈值:配置电池电压低于该值时触发欠压保护(停止放电) -// 注:回差约为150mV(电压回升至阈值+150mV时解除保护) -// 参数voltage:目标阈值(单位:毫伏) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_vbat_uvlo_mV(uint16_t voltage); - -// 设置打嗝模式定时器:配置过流保护时的打嗝间隔时间(保护期间的重试间隔) -// 参数time:目标时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_t_hiccup_mS(uint16_t time); - - -// 使能看门狗定时器:开启/关闭看门狗功能(若已使能则不操作,否则按默认值配置) -// 参数en:true=使能,false=禁用 -void hp45xxx_set_wdt_timer_en(bool en); - -// 设置看门狗超时时间:配置看门狗定时器的超时阈值(超过此时长未喂狗则触发复位) -// 参数time:目标时间(单位:毫秒) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_wdt_timer_mS(uint32_t time); - -// 使能充电阶段看门狗:开启/关闭充电过程中的看门狗功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_wdt_chg_en(bool en); - -// 使能放电阶段看门狗:开启/关闭放电过程中的看门狗功能 -// 参数en:true=使能,false=禁用 -void hp45xxx_set_wdt_dsg_en(bool en); - -// 使能看门狗VSYS复位:开启/关闭看门狗超时后触发VSYS复位的功能 -// 参数en:true=使能(超时复位),false=禁用(仅触发中断) -void hp45xxx_set_wdt_vsys_rst_en(bool en); - - -// 使能NTC温度检测:开启/关闭充电过程中对电池温度(通过NTC)的监测 -// 参数en:true=使能(温度异常时停止充电),false=禁用 -void hp45xxx_set_ntc_en(bool en); - -// 使能PCB过温保护:开启/关闭PCB板的过温保护功能 -// 参数en:true=使能(PCB过热时触发保护),false=禁用 -void hp45xxx_set_pcb_otp_en(bool en); - -// 设置芯片热调节温度:配置芯片内部温度达到该值时触发热调节(降低充电电流) -// 参数degree:目标温度(单位:摄氏度,如80表示80℃) -// 返回值:true表示配置成功,false表示参数超出范围 -bool hp45xxx_set_thermal_reg_degree(uint8_t degree); - - -// 使能电源良好中断:开启/关闭VBUS电源良好状态变化的中断 -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_pg_en(bool en); - -// 使能充电完成中断:开启/关闭电池充电完成的中断(充电状态变为“完成”时触发) -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_chrg_done_en(bool en); - -// 使能充电状态变化中断:开启/关闭充电状态动态切换的中断(如预充→快充) -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_chrg_stat_en(bool en); - -// 使能NTC温度区间变化中断:开启/关闭电池温度区间切换的中断(如正常→高温) -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_ntc_transition_en(bool en); - -// 使能电池过压中断:开启/关闭电池过压保护的中断(电池电压过高时触发) -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_batovp_en(bool en); - -// 使能看门狗超时中断:开启/关闭看门狗定时器超时的中断 -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_wdt_en(bool en); - -// 使能充电安全超时中断:开启/关闭充电安全定时器超时(进入安全模式)的中断 -// 参数en:true=使能中断,false=禁用 -void hp45xxx_set_int_chg_safety_expired_en(bool en); - - -// 读取充电状态:判断当前是否处于“未充电”状态 -// 返回值:true=未充电,false=正在充电或已完成 -bool hp45xxx_read_chrg_stat_not_chrg(void); - -// 读取充电状态:判断当前是否处于“深度放电充电”状态(电池电压极低时的小电流充电) -// 返回值:true=深度放电充电,false=其他状态 -bool hp45xxx_read_chrg_stat_dead_chrg(void); - -// 读取充电状态:判断当前是否处于“预充电”状态(电池电压较低时的过渡充电阶段) -// 返回值:true=预充电,false=其他状态 -bool hp45xxx_read_chrg_stat_pre_chrg(void); - -// 读取充电状态:判断当前是否处于“快速充电”状态(主要充电阶段) -// 返回值:true=快充中,false=其他状态 -bool hp45xxx_read_chrg_stat_fast_chrg(void); - -// 读取充电状态:判断当前是否处于“充电完成”状态 -// 返回值:true=充电完成,false=未完成 -bool hp45xxx_read_chrg_stat_chrg_done(void); - - -// 读取看门狗故障状态:判断看门狗定时器是否已超时 -// 返回值:true=已超时(故障),false=未超时(正常) -bool hp45xxx_read_status_wdt_fault(void); - -// 读取输入电压DPM状态:判断是否因输入电压过低进入DPM模式 -// 返回值:true=处于DPM模式,false=正常模式 -bool hp45xxx_read_status_vindpm(void); - -// 读取VBUS电源状态:判断VBUS(外部电源)是否处于“电源良好”状态 -// 返回值:true=电源良好(电压/电流正常),false=电源异常 -bool hp45xxx_read_status_vbus_pg(void); - -// 读取芯片热调节状态:判断芯片是否因过热进入热调节模式 -// 返回值:true=处于热调节(降低功率),false=正常散热 -bool hp45xxx_read_status_thermal(void); - -// 读取输入故障状态:判断VIN(输入电压)是否存在故障(过压或电源断开) -// 返回值:true=存在故障,false=正常 -bool hp45xxx_read_status_vin_fault(void); - -// 读取芯片热关断状态:判断芯片是否因过热进入热关断模式 -// 返回值:true=已热关断(停止工作),false=正常工作 -bool hp45xxx_read_status_tshut(void); - -// 读取电池过压状态:判断电池是否处于过压保护状态 -// 返回值:true=电池过压,false=电压正常 -bool hp45xxx_read_status_vbat_ovp(void); - -// 读取充电安全模式状态:判断充电安全定时器是否已超时(进入安全模式) -// 返回值:true=已超时(安全模式),false=未超时(正常充电) -bool hp45xxx_read_status_safety_mode(void); - -// 读取NTC高温状态:判断电池是否处于NTC检测的“高温”区间 -// 返回值:true=电池过热,false=温度正常 -bool hp45xxx_read_status_ntc_hot(void); - -// 读取NTC低温状态:判断电池是否处于NTC检测的“低温”区间 -// 返回值:true=电池过冷,false=温度正常 -bool hp45xxx_read_status_ntc_cold(void); - -// 读取输入电流DPM状态:判断是否因输入电流过大进入DPM模式 -// 返回值:true=处于DPM模式,false=正常模式 -bool hp45xxx_read_status_iindpm(void); - -// 读取VIN输入复位状态:判断是否发生过VIN脉冲触发的复位 -// 返回值:true=发生过,false=未发生 -bool hp45xxx_read_status_vin_entry_rst(void); - -// 读取PWRKEY复位状态:判断是否发生过PWRKEY触发的复位 -// 返回值:true=发生过,false=未发生 -bool hp45xxx_read_status_pwrkey_rst(void); - -// 读取打嗝保护状态:判断是否发生过打嗝模式(过流保护重试) -// 返回值:true=发生过,false=未发生 -bool hp45xxx_read_status_hiccup_latch(void); - -// 读取PWRKEY唤醒状态:判断是否通过PWRKEY引脚拉低2秒唤醒系统(从船运模式) -// 返回值:true=已唤醒,false=未唤醒 -bool hp45xxx_read_status_pwrkey_wk(void); - -// 读取VBUS唤醒状态:判断是否通过插入VBUS唤醒系统(从船运模式) -// 返回值:true=已唤醒,false=未唤醒 -bool hp45xxx_read_status_vbus_wk(void); - -// 读取看门狗中断状态:判断是否发生过看门狗超时中断 -// 返回值:true=发生过中断,false=未发生 -bool hp45xxx_read_status_watchdog_int(void); - - +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 hp4507_get_id(void); - - #endif // HP4570_CHARGER_H \ No newline at end of file diff --git a/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.c b/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.c index b7a8c4faf..c199565b1 100644 --- a/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.c +++ b/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.c @@ -2,7 +2,7 @@ * @Author: penglei 1624952103@qq.com * @Date: 2024-03-13 15:08:38 * @LastEditors: penglei 1624952103@qq.com - * @LastEditTime: 2025-11-08 15:16:35 + * @LastEditTime: 2025-11-10 13:46:36 * @FilePath: /FD230/code/sdk/drivers/peripheral/ppg/hx3695/hx3695_hal.c * @Description: * @@ -190,24 +190,31 @@ void ppg_send_cmd_to_driver(char* mode, uint8_t enable) } -void ppg_get_leaklight_data(uint32_t *ch0,uint32_t *ch1,uint32_t *ch2) +void ppg_get_graycard_data(uint32_t *ch0,uint32_t *ch1,uint32_t *ch2) { #ifdef PPG_HX3695 - hx3695_get_leaklight_data(ch0,ch1,ch2); + hx3695_get_graycard_data(ch0,ch1,ch2); +#endif +} + +void ppg_get_factory_data(uint32_t *ch0,uint32_t *ch1,uint32_t *ch2) +{ +#ifdef PPG_HX3695 + hx3695_get_factory_data(ch0,ch1,ch2); #elif defined PPG_VC9202 vc9202_get_leaklight_data(ch0,ch1,ch2); #elif defined PPG_PAH8009 - pah8009_get_leaklight_data(ch0,ch1,ch2); + pah8009_get_factory_data(ch0,ch1,ch2); #endif } -int32_t ppg_get_factory_data(void) +int32_t ppg_get_led_data(void) { int32_t data = 0; #ifdef PPG_PAH8009 - data = pah8009_get_factory_data(); + data = pah8009_get_led_data(); #elif defined PPG_HX3695 - data = hx3695_get_factory_data(); + data = hx3695_get_led_data(); #endif return data; } diff --git a/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.h b/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.h index fe22e78c9..cc300472d 100644 --- a/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.h +++ b/code/sdk/zhihui/drivers/ppg/hal/ppg_hal.h @@ -57,8 +57,8 @@ void ppg_wear_status_update(uint8_t status); void ppg_power_on(void); void ppg_power_off(void); void ppg_int_handler(void); -void ppg_get_leaklight_data(uint32_t *ch0,uint32_t *ch1,uint32_t *ch2); -int32_t ppg_get_factory_data(void); +void ppg_get_factory_data(uint32_t *ch0,uint32_t *ch1,uint32_t *ch2); +int32_t ppg_get_led_data(void); void ppg_ble_send(uint8_t hr); void ppg_check_int(void); diff --git a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.c b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.c index f0645a4fb..458a4fc2d 100644 --- a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.c +++ b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.c @@ -1368,7 +1368,7 @@ void hx3695_alg_send_data(ppg_sensor_data_t *ppg_sensor_dat, WORK_MODE_T mode, u } #endif - factory_data = ppg_sensor_dat->led_data[0].data_val; + factory_data = ppg_sensor_dat->led_data[0].data_val[0]; // printf("factory_data:%d\n", factory_data); tyhx_hrs_alg_send_data(ppg_sensor_dat->led_data[0].data_val,data_count, gsen_data_x_fifo, gsen_data_y_fifo, gsen_data_z_fifo, ppg_sensor_dat->led_data[0].offset_idac); //tyhx_hrs_alg_send_data(ppg_sensor_dat->led_data[0].data_val,data_count, gsen_data_x_fifo, gsen_data_y_fifo, gsen_data_z_fifo); @@ -1380,6 +1380,8 @@ void hx3695_alg_send_data(ppg_sensor_data_t *ppg_sensor_dat, WORK_MODE_T mode, u } case SPO2_MODE: { + factory_data = ppg_sensor_dat->led_data[1].data_val[0]; + // printf("factory_data:%d\n", factory_data); tyhx_spo2_alg_send_data(ppg_sensor_dat->led_data[1].data_val, ppg_sensor_dat->led_data[2].data_val, ppg_sensor_dat->led_data[0].data_val, \ ppg_sensor_dat->led_data[1].offset_idac, ppg_sensor_dat->led_data[2].offset_idac,ppg_sensor_dat->led_data[0].offset_idac, \ gsen_data_x_fifo, gsen_data_y_fifo, gsen_data_z_fifo, data_count); @@ -1595,7 +1597,7 @@ void hx3695_control(char *mode,uint8_t enable) } -int32_t hx3695_get_factory_data(void) +int32_t hx3695_get_led_data(void) { int32_t data = factory_data; factory_data = 0; diff --git a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.h b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.h index 504766708..d818eda9f 100644 --- a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.h +++ b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695.h @@ -242,6 +242,6 @@ uint8_t hx3695_get_hrs(void); uint8_t hx3695_get_spo2(void); uint8_t hx3695_get_hrv(void); uint8_t hx3695_get_wear_status(void); -int32_t hx3695_get_factory_data(void); +int32_t hx3695_get_led_data(void); void hx3695_control(char *mode,uint8_t enable); #endif diff --git a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.c b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.c index 1ea493b4b..5078ae56f 100644 --- a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.c +++ b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.c @@ -2605,7 +2605,9 @@ FT_RESULTS_t hx3695_factroy_test(TEST_MODE_t test_mode) factory_red = ft_result.ldr1_data_final; factory_ir = ft_result.ldr2_data_final; - // TYHX_LOG("leak LDR0=%d\r\n",hrsresult.leak_ldr0); + TYHX_LOG("leak LDR0=%d\r\n",ft_result.ldr0_data_final); + TYHX_LOG("leak LDR1=%d\r\n",ft_result.ldr1_data_final); + TYHX_LOG("leak LDR2=%d\r\n",ft_result.ldr2_data_final); break; case GRAY_CARD_TEST: @@ -2620,6 +2622,10 @@ FT_RESULTS_t hx3695_factroy_test(TEST_MODE_t test_mode) factory_green = ft_result.ldr0_data_final; factory_red = ft_result.ldr1_data_final; factory_ir = ft_result.ldr2_data_final; + + TYHX_LOG("leak LDR0=%d\r\n",ft_result.ldr0_data_final); + TYHX_LOG("leak LDR1=%d\r\n",ft_result.ldr1_data_final); + TYHX_LOG("leak LDR2=%d\r\n",ft_result.ldr2_data_final); break; case GNOISE_TEST: hx3695_factory_Gnoise_config(); @@ -2646,7 +2652,7 @@ FT_RESULTS_t hx3695_factroy_test(TEST_MODE_t test_mode) return ft_result; } -void hx3695_get_leaklight_data(uint32_t *green,uint32_t *red,uint32_t *ir) +void hx3695_get_factory_data(uint32_t *green,uint32_t *red,uint32_t *ir) { *green = factory_green; *red = factory_red; @@ -2655,4 +2661,4 @@ void hx3695_get_leaklight_data(uint32_t *green,uint32_t *red,uint32_t *ir) factory_green = 0; factory_red = 0; factory_ir = 0; -} \ No newline at end of file +} diff --git a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.h b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.h index 723a9fc9f..201fa7a84 100644 --- a/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.h +++ b/code/sdk/zhihui/drivers/ppg/hx3695/hx3695_factory_test.h @@ -95,7 +95,7 @@ FT_RESULTS_t hx3695_factroy_test(TEST_MODE_t test_mode); void hx3695_lab_test(uint32_t test_mode); void hx3695_lab_test_read(void); -void hx3695_get_leaklight_data(uint32_t *green,uint32_t *red,uint32_t *ir); +void hx3695_get_factory_data(uint32_t *green,uint32_t *red,uint32_t *ir); #endif // _HX3695_FACTORY_TEST_H_ diff --git a/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.c b/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.c index 153b81962..d3e65df2d 100644 --- a/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.c +++ b/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.c @@ -546,7 +546,7 @@ static pah_ret _pah_800x_hal_check_enable_channel(pah_800x_test_t *factory_state } -void pah8009_get_leaklight_data(uint16_t *ch0,uint16_t *ch1,uint16_t *ch2) +void pah8009_get_factory_data(uint16_t *ch0,uint16_t *ch1,uint16_t *ch2) { *ch0 = factory_test_ch[0]; *ch1 = factory_test_ch[1]; diff --git a/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.h b/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.h index 7519958b8..7b31a17d1 100644 --- a/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.h +++ b/code/sdk/zhihui/drivers/ppg/pah8009/factory/pah800x_factory_test.h @@ -155,6 +155,6 @@ typedef struct // Public function //============================================================================ void factory_test_mode(factory_test_type test_type, bool expo_adjust_en, uint16_t expo_a, uint16_t expo_b, uint16_t expo_c); -void pah8009_get_leaklight_data(uint16_t *ch0,uint16_t *ch1,uint16_t *ch2); +void pah8009_get_factory_data(uint16_t *ch0,uint16_t *ch1,uint16_t *ch2); #endif // header guard diff --git a/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.c b/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.c index 460684492..93b04d8fc 100644 --- a/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.c +++ b/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.c @@ -1802,7 +1802,7 @@ uint16_t pah8009_get_chip_id(void) return product_id; } -int32_t pah8009_get_factory_data(void) +int32_t pah8009_get_led_data(void) { int32_t data = factory_data; factory_data = 0; diff --git a/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.h b/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.h index 19cb4bce8..e79dfc894 100644 --- a/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.h +++ b/code/sdk/zhihui/drivers/ppg/pah8009/sensor/pah800x_main.h @@ -158,7 +158,7 @@ void stress_alg_task(int grade); uint16_t pah8009_get_chip_id(void); void pah8009_control(char *mode,uint8_t enable); -int32_t pah8009_get_factory_data(void); +int32_t pah8009_get_led_data(void); void pah8009_int_handler(void); void pah8009_check_int(void); diff --git a/code/sdk/zhihui/services/battery/service/battery_driver.cpp b/code/sdk/zhihui/services/battery/service/battery_driver.cpp index 829b4a707..1c12fe257 100644 --- a/code/sdk/zhihui/services/battery/service/battery_driver.cpp +++ b/code/sdk/zhihui/services/battery/service/battery_driver.cpp @@ -73,6 +73,9 @@ typedef enum { // #include "cat1_utils.h" #include // #include "custom_save_runtime.h" +#ifdef ENABLE_HP4570 +#include "hp4570.h" +#endif #define HAL_ADC_SAMPLE_NUMBER_CONFIG_0 10 /* Channel with buffer manual sample average number. */ #define HAL_ADC_SAMPLE_NUMBER_CONFIG_1 10 /* Channel without buffer manual sample average number. */ @@ -234,27 +237,27 @@ float battery_ntc_map[][2]={ float battery_percent_map[][2]={ #ifdef BOARD_LEINIAO - {4.2,100}, - {4.182,95}, - {4.165,90}, - {4.148,85}, - {4.120,80}, - {4.090,75}, - {4.060,70}, - {4.020,65}, - {3.980,60}, - {3.930,55}, - {3.890,50}, - {3.840,45}, - {3.780,40}, - {3.710,35}, - {3.650,30}, - {3.580,25}, - {3.500,20}, - {3.440,15}, - {3.380,10}, - {3.330,5}, - {3.3,0} + {4.200, 100} + {4.180, 95}, + {4.160, 90}, + {4.140, 85}, + {4.110, 80}, + {4.080, 75}, + {4.050, 70}, + {4.020, 65}, + {3.980, 60}, + {3.940, 55}, + {3.900, 50}, + {3.860, 45}, + {3.820, 40}, + {3.770, 35}, + {3.720, 30}, + {3.660, 25}, + {3.600, 20}, + {3.530, 15}, + {3.460, 10}, + {3.390, 5}, + {3.300, 0} #elif defined BOARD_FD272 {4.374, 100}, {4.186, 95}, @@ -837,6 +840,10 @@ void disable_charge(void) uapi_gpio_set_val(GPIO_PIN_ENABLE_CHARGE, GPIO_LEVEL_HIGH); uint8_t level = uapi_gpio_get_output_val(GPIO_PIN_ENABLE_CHARGE); // PRINT("GPIO_PIN_ENABLE_CHARGE uapi_gpio_get_output_val %d\r\n",level); +#elif defined BOARD_FD272 +#ifdef ENABLE_HP4570 + hp4570_set_ceb_en(false); +#endif #endif } @@ -850,6 +857,10 @@ void enable_charge(void) uapi_gpio_set_val(GPIO_PIN_ENABLE_CHARGE, GPIO_LEVEL_LOW); uint8_t level = uapi_gpio_get_output_val(GPIO_PIN_ENABLE_CHARGE); // PRINT("GPIO_PIN_ENABLE_CHARGE uapi_gpio_get_output_val %d\r\n",level); +#elif defined BOARD_FD272 +#ifdef ENABLE_HP4570 + hp4570_set_ceb_en(true); +#endif #endif } diff --git a/code/sdk/zhihui/services/battery/service/battery_service.cpp b/code/sdk/zhihui/services/battery/service/battery_service.cpp index 64348f22c..9d107cf13 100644 --- a/code/sdk/zhihui/services/battery/service/battery_service.cpp +++ b/code/sdk/zhihui/services/battery/service/battery_service.cpp @@ -721,8 +721,7 @@ errcode_t uapi_battery_init(void) uapi_register_charger_event_callback(battery_charger_plug_event_callback); #ifdef ENABLE_HP4570 - - hp45xxx_init(HP4570C9); + hp4570_init(HP4570C9); #endif //开始timer diff --git a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c index ba9263c30..a6e8acb87 100644 --- a/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c +++ b/code/sdk/zhihui/services/factorytest_service/factorytest_protocol.c @@ -2,7 +2,7 @@ * @Author: penglei 1624952103@qq.com * @Date: 2024-06-17 14:31:08 * @LastEditors: penglei 1624952103@qq.com - * @LastEditTime: 2025-11-07 12:21:41 + * @LastEditTime: 2025-11-10 15:57:04 * @FilePath: /FD230/code/sdk/application/wearable/service/factorytest_service/factorytest_protocol.c * @Description: * @@ -542,7 +542,7 @@ void aging_task(void) #ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_LEAKLIGHT_TEST); LOS_Msleep(2000); - ppg_get_leaklight_data(&green,&red,&ir); + ppg_get_factory_data(&green,&red,&ir); send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); #endif PRINT("green : %d , red : %d , ir : %d\r\n",green,red,ir); @@ -688,6 +688,12 @@ void factorytest_protocol_common_decode(uint8_t submode,uint8_t testitem,uint8_t factorytest_mode_flag = 1; + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_P_TEST); + if (cnt == 0) + { + uapi_pm_add_sleep_veto(PM_ID_P_TEST); + } + ChargerEventPublish(TOPIC_EVENT_CHARGE_UNPLUG,0); //进入产测模式 关闭充电弹窗 uapi_dev_runtime_set_factory_test_status(1); //设置产测模式runtime svr_ble_adv_factory_test_start_param(); //设置蓝牙广播 避免出现连接问题 @@ -863,9 +869,10 @@ void factorytest_protocol_common_decode(uint8_t submode,uint8_t testitem,uint8_t } else if(testitem == 0x02) { uint8_t send_data = 0x00; - +#ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_WEAR_MODE_TEST); send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_SPO2_TEST); +#endif uapi_set4GCapability(false); @@ -882,9 +889,17 @@ void factorytest_protocol_common_decode(uint8_t submode,uint8_t testitem,uint8_t stop_custom_ble_service(); LOS_Msleep(50); uapi_set4GCapability(false); + + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_P_TEST); + if (PM_ID_P_TEST == 1) + { + uapi_pm_remove_sleep_veto(PM_ID_P_TEST); + } + LOS_Msleep(50); mcu_pm_lcd_off(NULL,NULL) ; mcu_pm_remove_vote(NULL,NULL); + factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_COMMON, BLE_TEST_CMD_COMMON_SUB_MODE_POWERCONSUMPTION, 0x03, @@ -1624,44 +1639,20 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint { //获取绿灯数据 uint8_t databuf[4] = {0}; -#ifdef BOARD_FD230 -#ifdef PPG_HX3695 - // send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_SINGLE_CHECK_MODE_TEST); - // LOS_Msleep(2000); - // FT_RESULTS_t ft_result = ppg_get_factory_data(SINGLE_CHECK_TEST); - // send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); - - // databuf[0] = (uint8_t)((ft_result.gr_data_final & 0xFF000000) >> 24); - // databuf[1] = (uint8_t)((ft_result.gr_data_final & 0x00FF0000) >> 16); - // databuf[2] = (uint8_t)((ft_result.gr_data_final & 0x0000FF00) >> 8); - // databuf[3] = (uint8_t)((ft_result.gr_data_final & 0x000000FF) >> 0); - - // PRINT("%2X %2X %2X %2X \r\n",databuf[0],databuf[1],databuf[2],databuf[3]); - - factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_SOFT_TEST, - BLE_TEST_CMD_SOFT_TEST_SUB_MODE_HRS, - 0x03, - databuf, - 4); -#endif -#elif defined BOARD_N9 int32_t data = 0; #ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_PPG_TEST); LOS_Msleep(2000); + data = ppg_get_led_data(); send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); - data = ppg_get_factory_data(); #endif - PRINT("%d\r\n",data); - databuf[0] = (uint8_t)((data & 0xFF000000) >> 24); databuf[1] = (uint8_t)((data & 0x00FF0000) >> 16); databuf[2] = (uint8_t)((data & 0x0000FF00) >> 8); databuf[3] = (uint8_t)((data & 0x000000FF) >> 0); -#endif - - PRINT("%2X %2X %2X %2X \r\n",databuf[0],databuf[1],databuf[2],databuf[3]); + PRINT("%d\r\n",data); + PRINT("%2X %2X %2X %2X \r\n",databuf[0],databuf[1],databuf[2],databuf[3]); factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_SOFT_TEST, BLE_TEST_CMD_SOFT_TEST_SUB_MODE_HRS, @@ -1672,35 +1663,19 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint } else if(testitem == 0x04) { uint8_t databuf[4] = {0}; -#ifdef BOARD_FD230 -#ifdef PPG_HX3695 - // send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_SINGLE_CHECK_MODE_TEST); - // LOS_Msleep(500); - // FT_RESULTS_t ft_result = hx3695_factroy_test(SINGLE_CHECK_TEST); - // send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); - - // databuf[0] = (uint8_t)((ft_result.red_data_final & 0xFF000000) >> 24); - // databuf[1] = (uint8_t)((ft_result.red_data_final & 0x00FF0000) >> 16); - // databuf[2] = (uint8_t)((ft_result.red_data_final & 0x0000FF00) >> 8); - // databuf[3] = (uint8_t)((ft_result.red_data_final & 0x000000FF) >> 0); -#endif -#elif defined BOARD_N9 - //获取红灯数据 - int32_t data = 0; + int32_t data = {0}; #ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_SPO2_TEST); LOS_Msleep(2000); - send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); - data = ppg_get_factory_data(); + data = ppg_get_led_data(); + send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_SPO2_TEST); #endif PRINT("%d\r\n",data); - - databuf[0] = (uint8_t)((data & 0xFF000000) >> 24); databuf[1] = (uint8_t)((data & 0x00FF0000) >> 16); databuf[2] = (uint8_t)((data & 0x0000FF00) >> 8); databuf[3] = (uint8_t)((data & 0x000000FF) >> 0); -#endif + PRINT("%2X %2X %2X %2X \r\n",databuf[0],databuf[1],databuf[2],databuf[3]); factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_SOFT_TEST, @@ -1711,39 +1686,40 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint } else if(testitem == 0x05) { -#ifdef PPG_HX3695 //灰卡测试 + uint8_t databuf[12] = {0}; + + uint32_t green = 0; + uint32_t red = 0; + uint32_t ir = 0; + +#ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_GRAYCARD_TEST); LOS_Msleep(2000); - uint8_t databuf[12] = {0}; - // FT_RESULTS_t ft_result = hx3695_factroy_test(GRAY_CARD_TEST); - // databuf[0] = (uint8_t)((ft_result.gr_data_final & 0xFF000000) >> 24); - // databuf[1] = (uint8_t)((ft_result.gr_data_final & 0x00FF0000) >> 16); - // databuf[2] = (uint8_t)((ft_result.gr_data_final & 0x0000FF00) >> 8); - // databuf[3] = (uint8_t)((ft_result.gr_data_final & 0x000000FF) >> 0); + ppg_get_factory_data(&green,&red,&ir); + send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); +#endif + PRINT("%d %d %d \r\n",green,red,ir); + databuf[0] = (uint8_t)((green & 0xFF000000) >> 24); + databuf[1] = (uint8_t)((green & 0x00FF0000) >> 16); + databuf[2] = (uint8_t)((green & 0x0000FF00) >> 8); + databuf[3] = (uint8_t)((green & 0x000000FF) >> 0); - // databuf[4] = (uint8_t)((ft_result.red_data_final & 0xFF000000) >> 24); - // databuf[5] = (uint8_t)((ft_result.red_data_final & 0x00FF0000) >> 16); - // databuf[6] = (uint8_t)((ft_result.red_data_final & 0x0000FF00) >> 8); - // databuf[7] = (uint8_t)((ft_result.red_data_final & 0x000000FF) >> 0); + databuf[4] = (uint8_t)((red & 0xFF000000) >> 24); + databuf[5] = (uint8_t)((red & 0x00FF0000) >> 16); + databuf[6] = (uint8_t)((red & 0x0000FF00) >> 8); + databuf[7] = (uint8_t)((red & 0x000000FF) >> 0); - // databuf[8] = (uint8_t)((ft_result.ir_data_final & 0xFF000000) >> 24); - // databuf[9] = (uint8_t)((ft_result.ir_data_final & 0x00FF0000) >> 16); - // databuf[10] = (uint8_t)((ft_result.ir_data_final & 0x0000FF00) >> 8); - // databuf[11] = (uint8_t)((ft_result.ir_data_final & 0x000000FF) >> 0); + databuf[8] = (uint8_t)((ir & 0xFF000000) >> 24); + databuf[9] = (uint8_t)((ir & 0x00FF0000) >> 16); + databuf[10] = (uint8_t)((ir & 0x0000FF00) >> 8); + databuf[11] = (uint8_t)((ir & 0x000000FF) >> 0); factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_SOFT_TEST, BLE_TEST_CMD_SOFT_TEST_SUB_MODE_HRS, 0x05, databuf, 12); - send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); -#endif - // PRINT("%2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X\r\n", - // databuf[0],databuf[1],databuf[2],databuf[3], - // databuf[4],databuf[5],databuf[6],databuf[7], - // databuf[8],databuf[9],databuf[10],databuf[11] - // ); } else if(testitem == 0x06) @@ -1758,7 +1734,7 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint #ifdef SUPPORT_PPG_SERVICE send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_DO_LEAKLIGHT_TEST); LOS_Msleep(2000); - ppg_get_leaklight_data(&green,&red,&ir); + ppg_get_factory_data(&green,&red,&ir); send_ppg_cmd_msg(PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST); #endif databuf[0] = (uint8_t)((green & 0xFF000000) >> 24); @@ -1776,12 +1752,13 @@ void factorytest_protocol_soft_test_decode(uint8_t submode,uint8_t testitem,uint databuf[10] = (uint8_t)((ir & 0x0000FF00) >> 8); databuf[11] = (uint8_t)((ir & 0x000000FF) >> 0); + PRINT("%d %d %d \r\n",green,red,ir); - // PRINT("%2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X\r\n", - // databuf[0],databuf[1],databuf[2],databuf[3], - // databuf[4],databuf[5],databuf[6],databuf[7], - // databuf[8],databuf[9],databuf[10],databuf[11] - // ); + PRINT("%2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X %2X\r\n", + databuf[0],databuf[1],databuf[2],databuf[3], + databuf[4],databuf[5],databuf[6],databuf[7], + databuf[8],databuf[9],databuf[10],databuf[11] + ); factorytest_protocol_replymsg(BLE_TEST_CMD_MODE_SOFT_TEST, BLE_TEST_CMD_SOFT_TEST_SUB_MODE_HRS, diff --git a/code/sdk/zhihui/utils/custom_save_runtime.c b/code/sdk/zhihui/utils/custom_save_runtime.c index ce43b9bf4..7f5bf698c 100644 --- a/code/sdk/zhihui/utils/custom_save_runtime.c +++ b/code/sdk/zhihui/utils/custom_save_runtime.c @@ -78,7 +78,7 @@ errcode_t uapi_save_runtime_log(uint16_t cmd) if(custom_running_log_state_stat==0 || g_runtime_log_queue_created==0) { - PRINT("Error task or queue no ready\r\n"); + // PRINT("Error task or queue no ready\r\n"); return ERRCODE_FAIL; } ret = osal_msg_queue_write_copy(g_custom_runtime_log_cmd_queue, (void *)&mail, sizeof(custom_cmd_t), 0); diff --git a/code/sdk/zhihui/utils/custom_utils.c b/code/sdk/zhihui/utils/custom_utils.c index 3b44f5fa8..f00b845c5 100644 --- a/code/sdk/zhihui/utils/custom_utils.c +++ b/code/sdk/zhihui/utils/custom_utils.c @@ -4662,10 +4662,10 @@ void uapi_lcd_backlight_on(void) for (uint8_t i = 0; i < fall_edge_cnt; i++) { uapi_gpio_set_val(S_AGPIO_L16, GPIO_LEVEL_HIGH); - uapi_tcxo_delay_us(1); + uapi_tcxo_delay_us(10); uapi_gpio_set_val(S_AGPIO_L16, GPIO_LEVEL_LOW); - uapi_tcxo_delay_us(1); + uapi_tcxo_delay_us(10); } uapi_gpio_set_val(S_AGPIO_L16, GPIO_LEVEL_HIGH);