void mt_battery_charging_algorithm()
{
battery_charging_control(CHARGING_CMD_RESET_WATCH_DOG_TIMER,NULL);
#if defined(MTK_PUMP_EXPRESS_PLUS_SUPPORT)
battery_pump_express_charger_check();
#endif
switch(BMT_status.bat_charging_state)
{
case CHR_PRE :
BAT_PreChargeModeAction();
break;
case CHR_CC :
BAT_ConstantCurrentModeAction();
break;
case CHR_BATFULL:
BAT_BatteryFullAction();
break;
case CHR_HOLD:
BAT_BatteryHoldAction();
break;
case CHR_ERROR:
BAT_BatteryStatusFailAction();
break;
}
battery_charging_control(CHARGING_CMD_DUMP_REGISTER,NULL);
}
static void pchr_sw_cv_charing_current_check(void)
{
kal_bool charging_enable = KAL_TRUE;
kal_uint32 csdac_full_flag = KAL_TRUE;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&ulc_cv_charging_current);
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
msleep(192);
battery_charging_control(CHARGING_CMD_GET_CSDAC_FALL_FLAG,&csdac_full_flag);
if(csdac_full_flag == KAL_TRUE) {
ulc_cv_charging_current = battery_meter_get_charging_current() * 100; /* get immedeate charging current and align to enum value */
}
while(csdac_full_flag == KAL_TRUE && ulc_cv_charging_current !=CHARGE_CURRENT_0_00_MA) {
set_bat_sw_cv_charging_current_limit(ulc_cv_charging_current);
battery_charging_control(CHARGING_CMD_SET_CURRENT,&ulc_cv_charging_current);
ulc_cv_charging_current_flag = KAL_TRUE;
msleep(192); /* large than 512 code x 0.25ms */
battery_charging_control(CHARGING_CMD_GET_CSDAC_FALL_FLAG,&csdac_full_flag);
battery_log(BAT_LOG_CRTI, "[BATTERY] Sw CV set charging current, csdac_full_flag=%d, current=%d !\n",csdac_full_flag,ulc_cv_charging_current);
}
if(ulc_cv_charging_current == CHARGE_CURRENT_0_00_MA)
battery_log(BAT_LOG_CRTI, "[BATTERY] Sw CV set charging current Error!\n");
}
void mt_battery_charging_algorithm()
{
battery_charging_control(CHARGING_CMD_RESET_WATCH_DOG_TIMER,NULL);
switch(BMT_status.bat_charging_state)
{
case CHR_PRE :
BAT_PreChargeModeAction();
break;
case CHR_CC :
BAT_ConstantCurrentModeAction();
break;
case CHR_BATFULL:
BAT_BatteryFullAction();
break;
case CHR_HOLD:
BAT_BatteryHoldAction();
break;
case CHR_ERROR:
BAT_BatteryStatusFailAction();
break;
}
battery_charging_control(CHARGING_CMD_DUMP_REGISTER,NULL);
}
static void mtk_ta_init(void)
{
ta_current_level = 5000;
is_ta_connect = KAL_FALSE;
ta_pre_vbat = 0;
ta_vchr_tuning = KAL_FALSE;
ta_check_ta_control = KAL_FALSE;
ta_cable_out_occur = KAL_FALSE;
battery_charging_control(CHARGING_CMD_RESET_WATCH_DOG_TIMER, NULL);
battery_charging_control(CHARGING_CMD_INIT,NULL);
}
PMU_STATUS BAT_ConstantCurrentModeAction(void)
{
battery_log(BAT_LOG_CRTI, "[BATTERY] CC mode charge, timer=%d on %d !!\n\r",
BMT_status.CC_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time += BAT_TASK_PERIOD;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
ulc_cv_charging_current_flag = KAL_FALSE;
ulc_cv_charging_current = g_temp_CC_value;
if (BMT_status.bat_vol > v_cc2topoff_threshold) {
BMT_status.bat_charging_state = CHR_TOP_OFF;
}
#if defined(CONFIG_MTK_PUMP_EXPRESS_SUPPORT)//defined(MTK_LINEAR_CHARGER_NO_DISCHARGE)
// no disable charging#else
#else
{
kal_bool charging_enable = KAL_FALSE;
/* Charging 9s and discharging 1s : start */
battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
msleep(1000);
}
#endif
charging_current_calibration();
pchr_turn_on_charging();
return PMU_STATUS_OK;
}
PMU_STATUS BAT_TopOffModeAction(void)
{
kal_uint32 charging_enable = KAL_FALSE;
#ifdef HIGH_BATTERY_VOLTAGE_SUPPORT
kal_uint32 cv_voltage = 4350;
#else
kal_uint32 cv_voltage = 4200;
#endif
battery_log(BAT_LOG_CRTI, "[BATTERY] Top Off mode charge, timer=%d on %d !!\n\r",
BMT_status.TOPOFF_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time += BAT_TASK_PERIOD;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
if(BMT_status.bat_vol > (cv_voltage-CV_CHECK_DELAT_FOR_BANDGAP)) { /* CV - 0.08V */
pchr_sw_cv_charing_current_check();
}
pchr_turn_on_charging();
if ((BMT_status.TOPOFF_charging_time >= MAX_CV_CHARGING_TIME)
|| (charging_full_check() == KAL_TRUE)) {
BMT_status.bat_charging_state = CHR_BATFULL;
BMT_status.bat_full = KAL_TRUE;
g_charging_full_reset_bat_meter = KAL_TRUE;
/* Disable charging */
battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
}
return PMU_STATUS_OK;
}
PMU_STATUS BAT_BatteryFullAction(void)
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery full !!\n\r");
BMT_status.bat_full = KAL_TRUE;
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
BMT_status.bat_in_recharging_state = KAL_FALSE;
if(charging_full_check() == KAL_FALSE)
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Re-charging !!\n\r");
BMT_status.bat_in_recharging_state = KAL_TRUE;
BMT_status.bat_charging_state = CHR_CC;
battery_meter_reset();
}
else
{
if(need_recharge_check())
{
kal_uint32 charging_enable = 2;
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable); // 这里进行了扩展,2相当于先复位,然后在置位 苏 勇 2014年05月19日 09:56:24
}
}
return PMU_STATUS_OK;
}
PMU_STATUS BAT_BatteryStatusFailAction(void)
{
kal_uint32 charging_enable;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] BAD Battery status... Charging Stop !!\n\r");
#if defined(MTK_JEITA_STANDARD_SUPPORT)
if((g_temp_status == TEMP_ABOVE_POS_60) ||(g_temp_status == TEMP_BELOW_NEG_10))
{
temp_error_recovery_chr_flag=KAL_FALSE;
}
if((temp_error_recovery_chr_flag==KAL_FALSE) && (g_temp_status != TEMP_ABOVE_POS_60) && (g_temp_status != TEMP_BELOW_NEG_10))
{
temp_error_recovery_chr_flag=KAL_TRUE;
BMT_status.bat_charging_state=CHR_PRE;
}
#endif
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
/* Disable charger */
charging_enable = KAL_FALSE;
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
return PMU_STATUS_OK;
}
PMU_STATUS BAT_BatteryFullAction(void)
{
kal_uint32 charging_enable = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery full !!\n\r");
BMT_status.bat_full = KAL_TRUE;
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
BMT_status.bat_in_recharging_state = KAL_FALSE;
#if defined(MTK_JEITA_STANDARD_SUPPORT)
if(BMT_status.bat_vol < g_jeita_recharging_voltage)
#else
if(BMT_status.bat_vol < RECHARGING_VOLTAGE )
#endif
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Enter Re-charging!! , vbat=(%d)\n\r", BMT_status.bat_vol);
BMT_status.bat_in_recharging_state = KAL_TRUE;
BMT_status.bat_charging_state = CHR_CC;
}
/* Disable charging */
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
return PMU_STATUS_OK;
}
PMU_STATUS BAT_TopOffModeAction(void)
{
kal_uint32 charging_enable = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Top Off mode charge, timer=%ld on %ld !!\n\r", BMT_status.TOPOFF_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time += BAT_TASK_PERIOD;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
pchr_turn_on_charging();
if ((BMT_status.TOPOFF_charging_time >= MAX_CV_CHARGING_TIME) || (charging_full_check() == KAL_TRUE) )
{
BMT_status.bat_charging_state = CHR_BATFULL;
BMT_status.bat_full = KAL_TRUE;
g_charging_full_reset_bat_meter = KAL_TRUE;
/* Disable charging */
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
}
return PMU_STATUS_OK;
}
PMU_STATUS BAT_ConstantCurrentModeAction(void)
{
kal_bool charging_enable = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] CC mode charge, timer=%ld on %ld !!\n\r", BMT_status.CC_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time += BAT_TASK_PERIOD;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
if ( BMT_status.bat_vol > v_cc2topoff_threshold )
{
BMT_status.bat_charging_state = CHR_TOP_OFF;
}
/*Charging 9s and discharging 1s : start*/
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
msleep(1000);
charging_current_calibration();
pchr_turn_on_charging();
return PMU_STATUS_OK;
}
PMU_STATUS BAT_PreChargeModeAction(void)
{
kal_bool charging_enable = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Pre-CC mode charge, timer=%ld on %ld !!\n\r", BMT_status.PRE_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time += BAT_TASK_PERIOD;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
if (BMT_status.UI_SOC == 100)
{
BMT_status.bat_charging_state = CHR_BATFULL;
BMT_status.bat_full = KAL_TRUE;
g_charging_full_reset_bat_meter = KAL_TRUE;
}
else if(BMT_status.bat_vol > V_PRE2CC_THRES)
{
BMT_status.bat_charging_state = CHR_CC;
}
/*Charging 9s and discharging 1s : start*/
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
msleep(1000);
charging_current_calibration();
pchr_turn_on_charging();
return PMU_STATUS_OK;
}
static kal_uint32 charging_full_check(void)
{
kal_uint32 status;
battery_charging_control(CHARGING_CMD_GET_CHARGING_STATUS,&status);
return status;
}
static void mtk_ta_reset_vchr(void)
{
CHR_CURRENT_ENUM chr_current = CHARGE_CURRENT_70_00_MA;
battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,&chr_current);
msleep(250); // reset Vchr to 5V
battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_reset_vchr(): reset Vchr to 5V \n");
}
static void mtk_ta_increase(void)
{
kal_bool ta_current_pattern = KAL_TRUE; // TRUE = increase
if(ta_cable_out_occur == KAL_FALSE) {
battery_charging_control(CHARGING_CMD_SET_TA_CURRENT_PATTERN, &ta_current_pattern);
} else {
ta_check_chr_type = KAL_TRUE;
battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_increase() Cable out \n");
}
}
static void mtk_ta_init(void)
{
is_ta_connect = KAL_FALSE;
ta_cable_out_occur = KAL_FALSE;
#ifdef TA_9V_SUPPORT
ta_vchr_tuning = KAL_FALSE;
#endif
battery_charging_control(CHARGING_CMD_INIT,NULL);
}
static void mtk_ta_vchr_select(int i,int ta_v_chr_candidate[], int ta_charging_current_candidate[], int *max_charging_current, int *max_charging_current_i)
{
int current_vchr;
kal_bool retransmit = KAL_TRUE;
kal_uint32 retransmit_count=0;
current_vchr = battery_meter_get_charger_voltage();
if(ta_current_level != 5000 && current_vchr >= 4900) { /* pattern error before, so reset vchr to 5V */
battery_log(BAT_LOG_CRTI, "mtk_ta_vchr_select() : curr_VChr=%d, ta_current_level=%d\n",current_vchr,ta_current_level);
mtk_ta_reset_vchr();
}
do {
mtk_tuning_voltage(ta_current_level, ta_v_chr_candidate[i]);
current_vchr = battery_meter_get_charger_voltage();
if((abs(current_vchr - ta_current_level) > 300) && (ta_cable_out_occur == KAL_FALSE)) { /* variation > 0.3V, error occur */
retransmit_count++;
battery_log(BAT_LOG_CRTI, "mtk_ta_vchr_select(): retransmit_count =%d, cur_chr=%d, ta_current_level=%d\n",
retransmit_count, current_vchr, ta_current_level);
mtk_ta_reset_vchr();
} else {
retransmit = KAL_FALSE;
}
if((retransmit_count == 2) || (ta_cable_out_occur == KAL_TRUE)) {
retransmit = KAL_FALSE;
}
} while((retransmit == KAL_TRUE) && (ta_cable_out_occur == KAL_FALSE));
battery_charging_control(CHARGING_CMD_SET_CURRENT,&ta_charging_current); //1.5A
battery_log(BAT_LOG_CRTI, "mtk_ta_vchr_select() : use 1.5A for select max current\n");
msleep(900); // over 800ms to avoid interference pattern
ta_charging_current_candidate[i] = battery_meter_get_charging_current_imm();
/* we hope to choose the less VChr if the current difference between 2 step is not large, so we add weighting for different VChr step */
if(i == 1)
ta_charging_current_candidate[i] += 100; // weighting, plus 120mA for Vbat+0.4V
else if(i == 2)
ta_charging_current_candidate[i] += 50; // weighting, plug 60mA for Vbat+0.6V
if(ta_charging_current_candidate[i] > *max_charging_current) {
*max_charging_current = ta_charging_current_candidate[i];
*max_charging_current_i = i;
}
}
static void mtk_ta_increase(void)
{
kal_bool ta_current_pattern = KAL_TRUE; // TRUE = increase
//if(BMT_status.charger_exist == KAL_TRUE)
if(ta_cable_out_occur == KAL_FALSE) {
battery_charging_control(CHARGING_CMD_SET_TA_CURRENT_PATTERN,&ta_current_pattern);
ta_current_level += 200;
} else {
ta_check_chr_type = KAL_TRUE;
//is_ta_connect = KAL_FALSE;
battery_log(BAT_LOG_CRTI, "mtk_ta_increase() Cable out \n");
}
}
PMU_STATUS BAT_BatteryStatusFailAction(void)
{
kal_uint32 charging_enable;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] BAD Battery status... Charging Stop !!\n\r");
#if defined(MTK_JEITA_STANDARD_SUPPORT)
if((g_temp_status == TEMP_ABOVE_POS_60) ||(g_temp_status == TEMP_BELOW_NEG_10))
{
temp_error_recovery_chr_flag=KAL_FALSE;
}
if((temp_error_recovery_chr_flag==KAL_FALSE) && (g_temp_status != TEMP_ABOVE_POS_60) && (g_temp_status != TEMP_BELOW_NEG_10))
{
temp_error_recovery_chr_flag=KAL_TRUE;
BMT_status.bat_charging_state=CHR_PRE;
}
#endif
/* dongwei.cao START */
if ( (BMT_status.temperature <= MAX_CHARGE_TEMPERATURE_MINUS_X_DEGREE)
&& (BMT_status.temperature >= MIN_CHARGE_TEMPERATURE_PLUS_X_DEGREE)
&& (BMT_status.temperature != ERR_CHARGE_TEMPERATURE)
&& (BMT_status.charger_vol <= V_CHARGER_MAX) ) { /* release from OVER CHARGER VOLTAGE */
#if defined(HIGH_BATTERY_VOLTAGE_SUPPORT)
if (BMT_status.bat_vol <= HIGH_BATTERY_OVER_VOLTAGE)
#else
if (BMT_status.bat_vol <= NORMAL_BATTERY_OVER_VOLTAGE)
#endif
{
BMT_status.bat_charging_state = CHR_PRE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Recovery from FAIL status !! temperature = %d, BMT_status.bat_vol = %d \n\r",
BMT_status.temperature,
BMT_status.bat_vol);
}
}
/* END */
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
/* Disable charger */
charging_enable = KAL_FALSE;
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
return PMU_STATUS_OK;
}
static kal_uint32 charging_full_check(void)
{
kal_uint32 status;
battery_charging_control(CHARGING_CMD_GET_CHARGING_STATUS, &status);
if (status == KAL_TRUE) {
g_full_check_count++;
if (g_full_check_count >= FULL_CHECK_TIMES) {
return KAL_TRUE;
} else
return KAL_FALSE;
} else {
g_full_check_count = 0;
return status;
}
}
static void mtk_tuning_voltage(int curr_level, int target_level)
{
int is_increase = 0;
int exec_level = 0;
CHR_CURRENT_ENUM chr_current = CHARGE_CURRENT_70_00_MA;
/* if(BMT_status.charger_exist == KAL_TRUE) */
if(ta_cable_out_occur == KAL_FALSE) {
battery_log(BAT_LOG_CRTI, "mtk_tuning_voltage() start\n");
if(curr_level >= target_level) {
exec_level = (curr_level-target_level)/200;
is_increase = 0;
} else {
exec_level = (target_level-curr_level)/200;
is_increase = 1;
}
if(exec_level == 0) { /* curr_level == target_level */
battery_charging_control(CHARGING_CMD_SET_CURRENT,&chr_current);
msleep(50); // for VChr reading to check error occur or not
}
battery_log(BAT_LOG_CRTI, "mtk_tuning_voltage() before : ta_current_level=%d, real_v_chr=%d, is_ta_connect=%d, is_increase=%d, exec_level=%d\n",
ta_current_level, battery_meter_get_charger_voltage(), is_ta_connect, is_increase, exec_level);
while((exec_level > 0) && (ta_cable_out_occur == KAL_FALSE)) {
if(is_increase == 1)
mtk_ta_increase();
else
mtk_ta_decrease();
battery_log(BAT_LOG_CRTI, "mtk_tuning_voltage() after ta_current_level=%d, real_v_chr=%d, is_ta_connect=%d, is_increase=%d, exec_level=%d\n",
ta_current_level, battery_meter_get_charger_voltage(), is_ta_connect, is_increase, exec_level);
exec_level--;
}
battery_log(BAT_LOG_CRTI, "mtk_tuning_voltage() end\n");
} else {
ta_check_chr_type = KAL_TRUE;
//is_ta_connect = KAL_FALSE;
battery_log(BAT_LOG_CRTI, "mtk_tuning_voltage(), Cable Out\n");
}
}
PMU_STATUS BAT_BatteryHoldAction(void)
{
kal_uint32 charging_enable;
battery_log(BAT_LOG_CRTI, "[BATTERY] Hold mode !!\n\r");
if (BMT_status.bat_vol < batt_cust_data.talking_recharge_voltage || g_call_state == CALL_IDLE) {
BMT_status.bat_charging_state = CHR_CC;
battery_log(BAT_LOG_CRTI,
"[BATTERY] Exit Hold mode and Enter CC mode !!\n\r");
}
/* Disable charger */
charging_enable = KAL_FALSE;
battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
return PMU_STATUS_OK;
}
PMU_STATUS BAT_BatteryHoldAction(void)
{
kal_uint32 charging_enable;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Hold mode !!\n\r");
if(BMT_status.bat_vol < TALKING_RECHARGE_VOLTAGE || g_call_state == CALL_IDLE)
{
BMT_status.bat_charging_state = CHR_CC;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Exit Hold mode and Enter CC mode !!\n\r");
}
/* Disable charger */
charging_enable = KAL_FALSE;
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
return PMU_STATUS_OK;
}
static void mtk_ta_detector(void)
{
int real_v_chrA;
int real_v_chrB;
kal_bool retransmit = KAL_TRUE;
kal_uint32 retransmit_count=0;
U32 charging_enable = true;
battery_log(BAT_LOG_CRTI, "mtk_ta_detector() start\n");
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
do {
real_v_chrA = ta_get_charger_voltage();
mtk_ta_decrease();
mtk_ta_decrease();
real_v_chrB = ta_get_charger_voltage();
if(real_v_chrA - real_v_chrB >= 300) { /* 0.3V */
retransmit = KAL_FALSE;
is_ta_connect = KAL_TRUE;
} else {
retransmit_count++;
battery_log(BAT_LOG_CRTI, "mtk_ta_detector(): retransmit_count =%d, chrA=%d, chrB=%d\n",
retransmit_count, real_v_chrA, real_v_chrB);
mtk_ta_reset_vchr();
}
if((retransmit_count == 3) || (BMT_status.charger_exist == KAL_FALSE)) {
retransmit = KAL_FALSE;
is_ta_connect = KAL_FALSE;
}
} while((retransmit == KAL_TRUE) && (ta_cable_out_occur == KAL_FALSE));
battery_log(BAT_LOG_CRTI, "mtk_ta_detector() ta_current_level=%d, real_v_chrA=%d, real_v_chrB=%d, is_ta_connect=%d\n",
ta_current_level, real_v_chrA, real_v_chrB,is_ta_connect);
battery_log(BAT_LOG_CRTI, "mtk_ta_detector() end, retry_count=%d, ta_cable_out_occur=%d \n",retransmit_count,ta_cable_out_occur);
}
static void battery_pump_express_algorithm_start(void)
{
kal_int32 charger_vol;
kal_uint32 charging_enable = KAL_FALSE;
mutex_lock(&ta_mutex);
wake_lock(&TA_charger_suspend_lock);
if(KAL_TRUE == is_ta_connect)
{
/* check cable impedance */
charger_vol = battery_meter_get_charger_voltage();
if(KAL_FALSE == ta_vchr_tuning)
{
mtk_ta_retry_increase(); //increase TA voltage to 9V
charger_vol = battery_meter_get_charger_voltage();
ta_vchr_tuning = KAL_TRUE;
}
else if(BMT_status.SOC > TA_STOP_BATTERY_SOC)
{
//disable charging, avoid Iterm issue
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
mtk_ta_reset_vchr(); //decrease TA voltage to 5V
charger_vol = battery_meter_get_charger_voltage();
if(abs(charger_vol - ta_v_chr_org) <= 1000) // 1.0V
is_ta_connect = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "Stop battery_pump_express_algorithm, SOC=%d is_ta_connect =%d, TA_STOP_BATTERY_SOC: %d\n",
BMT_status.SOC, is_ta_connect, TA_STOP_BATTERY_SOC);
}
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] check cable impedance, VA(%d) VB(%d) delta(%d).\n",
ta_v_chr_org, charger_vol, charger_vol - ta_v_chr_org);
battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_algorithm() end\n");
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "It's not a TA charger, bypass TA algorithm\n");
}
wake_unlock(&TA_charger_suspend_lock);
mutex_unlock(&ta_mutex);
}
PMU_STATUS BAT_PreChargeModeAction(void)
{
battery_log(BAT_LOG_CRTI, "[BATTERY] Pre-CC mode charge, timer=%d on %d !!\n\r",
BMT_status.PRE_charging_time, BMT_status.total_charging_time);
BMT_status.PRE_charging_time += BAT_TASK_PERIOD;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.total_charging_time += BAT_TASK_PERIOD;
select_charging_curret();
ulc_cv_charging_current = g_temp_CC_value;
ulc_cv_charging_current_flag = KAL_FALSE;
if (BMT_status.UI_SOC == 100) {
BMT_status.bat_charging_state = CHR_BATFULL;
BMT_status.bat_full = KAL_TRUE;
g_charging_full_reset_bat_meter = KAL_TRUE;
} else if (BMT_status.bat_vol > batt_cust_data.v_pre2cc_thres) {
BMT_status.bat_charging_state = CHR_CC;
}
#if defined(CONFIG_MTK_PUMP_EXPRESS_SUPPORT)//defined(MTK_LINEAR_CHARGER_NO_DISCHARGE)
// no disable charging
#else
{
kal_bool charging_enable = KAL_FALSE;
/*Charging 9s and discharging 1s : start */
battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
msleep(1000);
}
#endif
charging_current_calibration();
pchr_turn_on_charging();
return PMU_STATUS_OK;
}
PMU_STATUS BAT_BatteryFullAction(void)
{
kal_uint32 charging_enable = KAL_FALSE;
battery_log(BAT_LOG_CRTI, "[BATTERY] Battery full !!\n\r");
BMT_status.bat_full = KAL_TRUE;
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
BMT_status.bat_in_recharging_state = KAL_FALSE;
#if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
if (BMT_status.bat_vol < g_jeita_recharging_voltage)
#else
if (BMT_status.bat_vol < batt_cust_data.recharging_voltage)
#endif
{
battery_log(BAT_LOG_CRTI,
"[BATTERY] Battery Enter Re-charging!! , vbat=(%d)\n\r",
BMT_status.bat_vol);
BMT_status.bat_in_recharging_state = KAL_TRUE;
BMT_status.bat_charging_state = CHR_CC;
ulc_cv_charging_current = g_temp_CC_value;
ulc_cv_charging_current_flag = KAL_FALSE;
}
/* Disable charging */
battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
return PMU_STATUS_OK;
}
static void pchr_turn_on_charging (void)
{
#if !defined(MTK_JEITA_STANDARD_SUPPORT)
BATTERY_VOLTAGE_ENUM cv_voltage;
#endif
kal_uint32 charging_enable = KAL_TRUE;
if ( BMT_status.bat_charging_state == CHR_ERROR )
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Charger Error, turn OFF charging !\n");
charging_enable = KAL_FALSE;
}
else if( (g_platform_boot_mode==META_BOOT) || (g_platform_boot_mode==ADVMETA_BOOT) )
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] In meta or advanced meta mode, disable charging.\n");
charging_enable = KAL_FALSE;
}
else
{
/*HW initialization*/
battery_charging_control(CHARGING_CMD_INIT,NULL);
battery_xlog_printk(BAT_LOG_FULL, "charging_hw_init\n" );
/* Set Charging Current */
if (g_bcct_flag == 1)
{
select_charging_curret_bcct();
battery_xlog_printk(BAT_LOG_FULL, "[BATTERY] select_charging_curret_bcct !\n");
}
else
{
select_charging_curret();
battery_xlog_printk(BAT_LOG_FULL, "[BATTERY] select_charging_curret !\n");
}
if( g_temp_CC_value == CHARGE_CURRENT_0_00_MA || g_temp_input_CC_value == CHARGE_CURRENT_0_00_MA)
{
charging_enable = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] charging current is set 0mA, turn off charging !\r\n");
}
else
{
#ifdef TEMPERATURE_CONTROL_CHARGING
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY]battery temperature = %d, [%d,%d]\r\n",
BMT_status.temperature,g_temp_CC_value,g_temp_input_CC_value);
if (BMT_status.temperature <= CURRENT_LIMIT_BOUNDARY_TEMPERATURE) //ckt guoyi add CKT low temperature(0-10) protect 2014-3-19
{
//g_temp_CC_value = g_temp_CC_value>AC_LESS_N_DEGRESS_CHARGER_CURRENT?AC_LESS_N_DEGRESS_CHARGER_CURRENT:g_temp_CC_value;
//g_temp_input_CC_value = g_temp_input_CC_value>AC_LESS_N_DEGRESS_CHARGER_CURRENT?AC_LESS_N_DEGRESS_CHARGER_CURRENT:g_temp_input_CC_value;
g_temp_CC_value =AC_LESS_N_DEGRESS_CHARGER_CURRENT;
g_temp_input_CC_value = AC_LESS_N_DEGRESS_CHARGER_CURRENT;
battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,&g_temp_input_CC_value);
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
cv_voltage = MIN_CURRENT_LIMIT_BOUNDARY_BATTERY;
battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE,&cv_voltage);
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] charging input_current= %d mA, current is set to %d mA, CKT battery temperature(0-10) protect !\r\n", g_temp_input_CC_value / 100 , g_temp_CC_value / 100);
}
else
{
#ifdef HIGH_BATTERY_VOLTAGE_SUPPORT
//g_temp_input_CC_value = g_temp_input_CC_value>AC_LESS_N_NORMAL_CHARGER_CURRENT?AC_LESS_N_NORMAL_CHARGER_CURRENT:g_temp_input_CC_value;
//g_temp_CC_value = g_temp_CC_value>AC_LESS_N_NORMAL_CHARGER_CURRENT?AC_LESS_N_NORMAL_CHARGER_CURRENT:g_temp_CC_value;
g_temp_input_CC_value = AC_LESS_N_NORMAL_CHARGER_CURRENT;
g_temp_CC_value = AC_LESS_N_NORMAL_CHARGER_CURRENT;
#endif
battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,&g_temp_input_CC_value);
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] charging input_current= %d mA, current is set to %d mA, CKT battery temperature(10-45) protect !\r\n", g_temp_input_CC_value / 100 , g_temp_CC_value / 100);
/*Set CV Voltage*/
#if !defined(MTK_JEITA_STANDARD_SUPPORT)
cv_voltage = MAX_CURRENT_LIMIT_BOUNDARY_BATTERY;
battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE,&cv_voltage);
#endif
}
#else
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] [>10]temperature = %d, [%d,%d]\r\n",
BMT_status.temperature,
g_temp_CC_value,
g_temp_input_CC_value);
battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,&g_temp_input_CC_value);
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
/*Set CV Voltage*/
#if !defined(MTK_JEITA_STANDARD_SUPPORT)
#ifdef HIGH_BATTERY_VOLTAGE_SUPPORT
cv_voltage = BATTERY_VOLT_04_340000_V;
#else
cv_voltage = BATTERY_VOLT_04_200000_V;
#endif
battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE,&cv_voltage);
#endif
#endif
}
}
/* enable/disable charging */
battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] pchr_turn_on_charging(), enable =%d !\r\n", charging_enable);
}
PMU_STATUS do_jeita_state_machine(void)
{
BATTERY_VOLTAGE_ENUM cv_voltage;
//JEITA battery temp Standard
if (BMT_status.temperature >= TEMP_POS_60_THRESHOLD)
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Over high Temperature(%d) !!\n\r", TEMP_POS_60_THRESHOLD);
g_temp_status = TEMP_ABOVE_POS_60;
return PMU_STATUS_FAIL;
}
else if(BMT_status.temperature > TEMP_POS_45_THRESHOLD) //control 45c to normal behavior
{
if((g_temp_status == TEMP_ABOVE_POS_60) && (BMT_status.temperature >= TEMP_POS_60_THRES_MINUS_X_DEGREE))
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r", TEMP_POS_60_THRES_MINUS_X_DEGREE,TEMP_POS_60_THRESHOLD);
return PMU_STATUS_FAIL;
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d !!\n\r", TEMP_POS_45_THRESHOLD,TEMP_POS_60_THRESHOLD);
g_temp_status = TEMP_POS_45_TO_POS_60;
}
}
else if(BMT_status.temperature >= TEMP_POS_10_THRESHOLD)
{
if( ((g_temp_status == TEMP_POS_45_TO_POS_60) && (BMT_status.temperature >= TEMP_POS_45_THRES_MINUS_X_DEGREE)) ||
((g_temp_status == TEMP_POS_0_TO_POS_10 ) && (BMT_status.temperature <= TEMP_POS_10_THRES_PLUS_X_DEGREE )))
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature not recovery to normal temperature charging mode yet!!\n\r");
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Normal Temperature between %d and %d !!\n\r", TEMP_POS_10_THRESHOLD,TEMP_POS_45_THRESHOLD);
g_temp_status = TEMP_POS_10_TO_POS_45;
}
}
else if(BMT_status.temperature >= TEMP_POS_0_THRESHOLD)
{
if((g_temp_status == TEMP_NEG_10_TO_POS_0 || g_temp_status == TEMP_BELOW_NEG_10) && (BMT_status.temperature <= TEMP_POS_0_THRES_PLUS_X_DEGREE))
{
if (g_temp_status == TEMP_NEG_10_TO_POS_0) {
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d !!\n\r", TEMP_POS_0_THRES_PLUS_X_DEGREE,TEMP_POS_10_THRESHOLD);
}
if (g_temp_status == TEMP_BELOW_NEG_10) {
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r", TEMP_POS_0_THRESHOLD,TEMP_POS_0_THRES_PLUS_X_DEGREE);
return PMU_STATUS_FAIL;
}
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d !!\n\r", TEMP_POS_0_THRESHOLD,TEMP_POS_10_THRESHOLD);
g_temp_status = TEMP_POS_0_TO_POS_10;
}
}
else if(BMT_status.temperature >= TEMP_NEG_10_THRESHOLD)
{
if((g_temp_status == TEMP_BELOW_NEG_10) && (BMT_status.temperature <= TEMP_NEG_10_THRES_PLUS_X_DEGREE))
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r", TEMP_NEG_10_THRESHOLD,TEMP_NEG_10_THRES_PLUS_X_DEGREE);
return PMU_STATUS_FAIL;
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Temperature between %d and %d !!\n\r", TEMP_NEG_10_THRESHOLD,TEMP_POS_0_THRESHOLD);
g_temp_status = TEMP_NEG_10_TO_POS_0;
}
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery below low Temperature(%d) !!\n\r", TEMP_NEG_10_THRESHOLD);
g_temp_status = TEMP_BELOW_NEG_10;
return PMU_STATUS_FAIL;
}
//set CV after temperature changed
cv_voltage = select_jeita_cv();
battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE,&cv_voltage);
return PMU_STATUS_OK;
}
void select_charging_curret(void)
{
#ifdef MEIZU_M71
kal_uint32 charger_voltage = 0, sum_voltage = 0;
int i;
#endif
if (g_ftm_battery_flag)
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] FTM charging : %d\r\n", charging_level_data[0]);
g_temp_CC_value = charging_level_data[0];
if(g_temp_CC_value == CHARGE_CURRENT_450_00_MA)
{
g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
}
else
{
g_temp_input_CC_value = CHARGE_CURRENT_MAX;
#ifdef MEIZU_M71
g_temp_CC_value = STANDARD_CHARGER_CURRENT;
#else
g_temp_CC_value = AC_CHARGER_CURRENT;
#endif
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] set_ac_current \r\n");
}
}
else
{
if ( BMT_status.charger_type == STANDARD_HOST )
{
#ifdef CONFIG_USB_IF
{
g_temp_input_CC_value = CHARGE_CURRENT_MAX;
if (g_usb_state == USB_SUSPEND)
{
g_temp_CC_value = USB_CHARGER_CURRENT_SUSPEND;
}
else if (g_usb_state == USB_UNCONFIGURED)
{
g_temp_CC_value = USB_CHARGER_CURRENT_UNCONFIGURED;
}
else if (g_usb_state == USB_CONFIGURED)
{
g_temp_CC_value = USB_CHARGER_CURRENT_CONFIGURED;
}
else
{
g_temp_CC_value = USB_CHARGER_CURRENT_UNCONFIGURED;
}
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] STANDARD_HOST CC mode charging : %d on %d state\r\n", g_temp_CC_value, g_usb_state);
}
#else
{
g_temp_input_CC_value = USB_CHARGER_CURRENT;
g_temp_CC_value = USB_CHARGER_CURRENT;
}
#endif
}
else if (BMT_status.charger_type == NONSTANDARD_CHARGER)
{
g_temp_input_CC_value = NON_STD_AC_CHARGER_CURRENT;
g_temp_CC_value = NON_STD_AC_CHARGER_CURRENT;
}
#ifdef MEIZU_M71
#ifdef MEIZU_M79
else if (BMT_status.charger_type == MEIZU_2_0A_CHARGER)
{
g_temp_input_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
g_temp_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
}
else if (BMT_status.charger_type == STANDARD_CHARGER)
{
g_temp_input_CC_value = MEIZU_1_5A_CHARGER_CURRENT;
g_temp_CC_value = MEIZU_1_5A_CHARGER_CURRENT;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
msleep(100);
for (i=0; i<5; i++) {
battery_meter_get_battery_voltage(TRUE);
charger_voltage = battery_meter_get_charger_voltage();
sum_voltage += charger_voltage;
msleep(10);
}
charger_voltage = sum_voltage / 5;
if (charger_voltage <= CHARGER_CURRENT_1_2A_THRESHOLD) {
g_temp_CC_value = STANDARD_CHARGER_CURRENT;
} else {
g_temp_CC_value = MEIZU_1_5A_CHARGER_CURRENT;
g_temp_input_CC_value = MEIZU_1_5A_CHARGER_CURRENT ;
}
}
else if (BMT_status.charger_type == CHARGING_HOST)
{
g_temp_input_CC_value = CHARGING_HOST_CHARGER_CURRENT;
g_temp_CC_value = CHARGING_HOST_CHARGER_CURRENT;
}
else if (BMT_status.charger_type == APPLE_CHARGER)
{
g_temp_input_CC_value = APPLE_2_1A_CHARGER_CURRENT;
g_temp_CC_value = APPLE_2_1A_CHARGER_CURRENT;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
msleep(100);
for (i=0; i<5; i++) {
charger_voltage = battery_meter_get_charger_voltage();
sum_voltage += charger_voltage;
msleep(10);
}
charger_voltage = sum_voltage / 5;
if (charger_voltage < CHARGER_CURRENT_1_2A_THRESHOLD) {
g_temp_CC_value = APPLE_1_0A_CHARGER_CURRENT;
} else {
g_temp_CC_value = APPLE_2_1A_CHARGER_CURRENT;
g_temp_input_CC_value = APPLE_2_1A_CHARGER_CURRENT ;
}
}
else if (BMT_status.charger_type == U200_CHARGER)
{
g_temp_input_CC_value = U200_1A_CHARGER_CURRENT;
g_temp_CC_value = U200_1A_CHARGER_CURRENT;
}
else
{
g_temp_input_CC_value = USB_CHARGER_CURRENT;
g_temp_CC_value = USB_CHARGER_CURRENT;
}
#else
else if (BMT_status.charger_type == MEIZU_2_0A_CHARGER)
{
g_temp_input_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
g_temp_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
}
else if (BMT_status.charger_type == STANDARD_CHARGER)
{
g_temp_input_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
g_temp_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
msleep(100);
for (i=0; i<5; i++) {
battery_meter_get_battery_voltage(TRUE);
charger_voltage = battery_meter_get_charger_voltage();
sum_voltage += charger_voltage;
msleep(10);
}
charger_voltage = sum_voltage / 5;
if(mz_get_hw_version() >= 20)
charger_voltage -= 15 ;
if(mz_get_operator_type() == 1)
charger_voltage += 30 ; //for china mobile
if (charger_voltage <= CHARGER_CURRENT_1A_THRESHOLD) {
g_temp_CC_value = STANDARD_CHARGER_CURRENT;
} else if (charger_voltage <= CHARGER_CURRENT_1_2A_THRESHOLD){
g_temp_CC_value = MEIZU_1_5A_CHARGER_CURRENT;
} else {
g_temp_CC_value = MEIZU_2_0A_CHARGER_CURRENT;
g_temp_input_CC_value = CHARGE_CURRENT_2000_00_MA ;
}
}
else if (BMT_status.charger_type == CHARGING_HOST)
{
g_temp_input_CC_value = CHARGING_HOST_CHARGER_CURRENT;
g_temp_CC_value = CHARGING_HOST_CHARGER_CURRENT;
}
else if (BMT_status.charger_type == APPLE_CHARGER)
{
g_temp_input_CC_value = APPLE_2_1A_CHARGER_CURRENT;
g_temp_CC_value = APPLE_2_1A_CHARGER_CURRENT;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&g_temp_CC_value);
msleep(100);
for (i=0; i<5; i++) {
charger_voltage = battery_meter_get_charger_voltage();
sum_voltage += charger_voltage;
msleep(10);
}
charger_voltage = sum_voltage / 5;
if(mz_get_hw_version() >= 20)
charger_voltage -= 15 ;
if(mz_get_operator_type() == 1)
charger_voltage += 30 ; //for china mobile
charger_voltage += 5 ;
if (charger_voltage < CHARGER_CURRENT_1A_THRESHOLD) {
g_temp_CC_value = APPLE_1_0A_CHARGER_CURRENT;
} else {
g_temp_CC_value = APPLE_2_1A_CHARGER_CURRENT;
g_temp_input_CC_value = CHARGE_CURRENT_2000_00_MA ;
}
}
else if (BMT_status.charger_type == U200_CHARGER)
{
g_temp_input_CC_value = U200_1A_CHARGER_CURRENT;
g_temp_CC_value = U200_1A_CHARGER_CURRENT;
}
else
{
g_temp_input_CC_value = USB_CHARGER_CURRENT;
g_temp_CC_value = USB_CHARGER_CURRENT;
}
#endif
#else
else if (BMT_status.charger_type == STANDARD_CHARGER)