// USB500 mode charging
void charging_ic_active_default(void)
{
u32 wait;
if(charging_ic_status == POWER_SUPPLY_TYPE_USB)
{
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: it's already %s mode!!\n", __func__);
return;
}
if(charging_ic_status != POWER_SUPPLY_TYPE_BATTERY)
{
charging_ic_deactive();
}
mutex_lock(&charging_lock);
// USB500 mode
#if (1)
charging_ic_set_chargingmode(CHR_USB_500_MODE);
#else
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ZERO);
udelay(1500);
#endif /* 1 */
charging_ic_status = POWER_SUPPLY_TYPE_USB;
mutex_unlock(&charging_lock);
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: %s :\n", __func__);
}
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");
}
static kal_uint32 charging_hw_init(void *data)
{
kal_uint32 status = STATUS_OK;
int polling_timeout_value = 10;
int polling_time = 0;
mt6333_set_rg_usbdl_mode_b(1);
//0729 chenyap
mt6333_set_rg_force_non_oc(1);
mt6333_set_rg_strup_ther_rg_th(0x8);
while(mt6333_get_rgs_power_on_ready() != 1)
{
if(polling_time++ >= polling_timeout_value)
{
battery_log(BAT_LOG_FULL, "check rgs_power_on_ready fail\n");
break;
}
}
battery_log(BAT_LOG_CRTI, "polling_time=%d of rgs_power_on_ready\n", polling_time);
#if defined(HIGH_BATTERY_VOLTAGE_SUPPORT)
mt6333_set_rg_cv_sel(0);
battery_log(BAT_LOG_CRTI, "HIGH_BATTERY_VOLTAGE_SUPPORT\n");
#endif
return status;
}
void charging_ic_deactive(void)
{
if(charging_ic_status == POWER_SUPPLY_TYPE_BATTERY)
{
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: it's already %s mode!! :\n", __func__);
return;
}
mutex_lock(&charging_lock);
#if 1
charging_ic_set_chargingmode(CHR_DENACTIVE_MODE);
#else
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ONE);
udelay(2000);
#endif /* 0 */
charging_ic_status = POWER_SUPPLY_TYPE_BATTERY;
mutex_unlock(&charging_lock);
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: %s :\n", __func__);
}
int hw_charging_get_charger_type(void)
{
#if 0
return STANDARD_HOST;
//return STANDARD_CHARGER; //adaptor
#else
CHARGER_TYPE CHR_Type_num = CHARGER_UNKNOWN;
/********* Step initial ***************/
hw_bc11_init();
/********* Step DCD ***************/
if(1 == hw_bc11_DCD())
{
/********* Step A1 ***************/
if(1 == hw_bc11_stepA1())
{
CHR_Type_num = APPLE_2_1A_CHARGER;
battery_log(BAT_LOG_CRTI, "step A1 : Apple 2.1A CHARGER!\r\n");
}
else
{
CHR_Type_num = NONSTANDARD_CHARGER;
battery_log(BAT_LOG_CRTI, "step A1 : Non STANDARD CHARGER!\r\n");
}
}
else
{
/********* Step A2 ***************/
if(1 == hw_bc11_stepA2())
{
/********* Step B2 ***************/
if(1 == hw_bc11_stepB2())
{
// is_dcp_type = true;
CHR_Type_num = STANDARD_CHARGER;
battery_log(BAT_LOG_CRTI, "step B2 : STANDARD CHARGER!\r\n");
}
else
{
CHR_Type_num = CHARGING_HOST;
battery_log(BAT_LOG_CRTI, "step B2 : Charging Host!\r\n");
}
}
else
{
CHR_Type_num = STANDARD_HOST;
battery_log(BAT_LOG_CRTI, "step A2 : Standard USB Host!\r\n");
}
}
/********* Finally setting *******************************/
hw_bc11_done();
return CHR_Type_num;
#endif
}
void select_charging_curret(void)
{
if (g_ftm_battery_flag) {
battery_log(BAT_LOG_CRTI, "[BATTERY] FTM charging : %d\r\n",
charging_level_data[0]);
g_temp_CC_value = charging_level_data[0];
} else {
if (BMT_status.charger_type == STANDARD_HOST) {
#ifdef CONFIG_USB_IF
{
if (g_usb_state == USB_SUSPEND) {
g_temp_CC_value = batt_cust_data.usb_charger_current_suspend;
} else if (g_usb_state == USB_UNCONFIGURED) {
g_temp_CC_value = batt_cust_data.usb_charger_current_unconfigured;
} else if (g_usb_state == USB_CONFIGURED) {
g_temp_CC_value = batt_cust_data.usb_charger_current_configured;
} else {
g_temp_CC_value = batt_cust_data.usb_charger_current_unconfigured;
}
battery_log(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_CC_value = batt_cust_data.usb_charger_current;
}
#endif
} else if (BMT_status.charger_type == NONSTANDARD_CHARGER) {
g_temp_CC_value = batt_cust_data.non_std_ac_charger_current;
} else if (BMT_status.charger_type == STANDARD_CHARGER) {
g_temp_CC_value = batt_cust_data.ac_charger_current;
#if defined(CONFIG_MTK_PUMP_EXPRESS_SUPPORT)
if(is_ta_connect == KAL_TRUE && ta_vchr_tuning == KAL_TRUE)
g_temp_CC_value = CHARGE_CURRENT_1500_00_MA;
#endif
} else if (BMT_status.charger_type == CHARGING_HOST)
{
g_temp_CC_value = batt_cust_data.charging_host_charger_current;
} else if (BMT_status.charger_type == APPLE_2_1A_CHARGER) {
g_temp_CC_value = batt_cust_data.apple_2_1a_charger_current;
} else if (BMT_status.charger_type == APPLE_1_0A_CHARGER) {
g_temp_CC_value = batt_cust_data.apple_1_0a_charger_current;
} else if (BMT_status.charger_type == APPLE_0_5A_CHARGER) {
g_temp_CC_value = batt_cust_data.apple_0_5a_charger_current;
} else {
g_temp_CC_value = CHARGE_CURRENT_70_00_MA;
}
/* battery_log(BAT_LOG_CRTI, "[BATTERY] Default CC mode charging : %d\r\n",
g_temp_CC_value); */
#if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
set_jeita_charging_current();
#endif
}
}
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 int __init charging_ic_init(void)
{
int ret=0;
battery_log(BAT_LOG_CRTI, "[charger_rt9536] Charging IC Driver Init\n");
ret = platform_device_register(&charger_ic_dev);
if (ret) {
battery_log(BAT_LOG_CRTI, "[charger_rt9536] Unable to device register(%d)\n", ret);
return ret;
}
return platform_driver_register(&charging_ic_driver);
}
void charging_ic_set_factory_mode(void)
{
u32 wait;
#if 0
if(charging_ic_status == POWER_SUPPLY_TYPE_FACTORY)
{
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: it's already %s mode!! :\n", __func__);
return;
}
#endif /* 0 */
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: charging_ic_set_factory_mode\n");
if(charging_ic_status != POWER_SUPPLY_TYPE_BATTERY)
{
charging_ic_deactive();
}
mutex_lock(&charging_lock);
#if (1)
charging_ic_set_chargingmode(CHR_PTM_MODE);
#else
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ZERO);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ONE);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ZERO);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ONE);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ZERO);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ONE);
udelay(400);
mt_set_gpio_out(CHG_EN_SET_N, GPIO_OUT_ZERO);
udelay(1500);
#endif /* 0 */
#if 0
charging_ic_status = POWER_SUPPLY_TYPE_FACTORY;
#endif /* 0 */
mutex_unlock(&charging_lock);
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: %s :\n", __func__);
}
PMU_STATUS BAT_BatteryStatusFailAction(void)
{
kal_uint32 charging_enable;
battery_log(BAT_LOG_CRTI, "[BATTERY] BAD Battery status... Charging Stop !!\n\r");
#if defined(CONFIG_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_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;
}
static kal_uint32 charging_reset_watch_dog_timer(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 ret = 0;
kal_uint8 val=0;
int vbat_bal = 0;
int check_vbat = 3950;
#if 1
// cable plug-out sw workaround
ret=mt6333_read_interface(0x04, (&val),0x1, 0);
if(val==1)
{
vbat_bal = PMIC_IMM_GetOneChannelValue(7,3,1);
if(vbat_bal > check_vbat)
{
ret=mt6333_config_interface(0x04, 0x94, 0xFF, 0x0);
mdelay(50);
ret=mt6333_config_interface(0x04, 0x95, 0xFF, 0x0);
}
}
battery_log(BAT_LOG_CRTI, "chr_en=%d, curr_vbat=%d, check_vbat=%d\n", val, vbat_bal, check_vbat);
#endif
mt6333_set_rg_chrwdt_wr(1); // write 1 to kick chr wdt
mt6333_set_rg_chrwdt_td(1); // 32s
mt6333_set_rg_chrwdt_en(1);
return status;
}
static U32 hw_bc11_stepA1(void)
{
U32 wChargerAvail = 0;
//RG_bc11_IPD_EN[1.0] = 01
bc11_set_register_value(PMIC_RG_BC11_IPD_EN,0x1);
//RG_bc11_VREF_VTH = [1:0]=00
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH,0x0);
//RG_bc11_CMP_EN[1.0] = 01
bc11_set_register_value(PMIC_RG_BC11_CMP_EN,0x1);
msleep(80);
//mdelay(80);
wChargerAvail = bc11_get_register_value(PMIC_RGS_BC11_CMP_OUT);
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_stepA1() \r\n");
hw_bc11_dump_register();
}
//RG_bc11_IPD_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_IPD_EN,0x0);
//RG_bc11_CMP_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_CMP_EN,0x0);
return wChargerAvail;
}
static void hw_bc11_init(void)
{
msleep(200);
Charger_Detect_Init();
//RG_bc11_BIAS_EN=1
bc11_set_register_value(PMIC_RG_BC11_BIAS_EN,1);
//RG_bc11_VSRC_EN[1:0]=00
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN,0);
//RG_bc11_VREF_VTH = [1:0]=00
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH,0);
//RG_bc11_CMP_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_CMP_EN,0);
//RG_bc11_IPU_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_IPU_EN,0);
//RG_bc11_IPD_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_IPD_EN,0);
//bc11_RST=1
bc11_set_register_value(PMIC_RG_BC11_RST,1);
//bc11_BB_CTRL=1
bc11_set_register_value(PMIC_RG_BC11_BB_CTRL,1);
msleep(50);
//mdelay(50);
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_init() \r\n");
hw_bc11_dump_register();
}
}
kal_uint32 charging_parameter_to_value(const kal_uint32 *parameter, const kal_uint32 array_size, const kal_uint32 val)
{
kal_uint32 i;
for(i=0;i<array_size;i++)
{
if (*(parameter) > *(parameter+1)) {
if (val >= *(parameter + i))
{
if (abs(val - *(parameter + i)) < abs(val - *(parameter + i-1)))
return i;
else
return i-1;
}
} else {
if (val <= *(parameter + i)) {
if (abs(val - *(parameter + i)) < abs(val - *(parameter + i-1)))
return i;
else
return i-1;
}
}
}
battery_log(BAT_LOG_CRTI, "NO register value match \r\n");
//TODO: ASSERT(0); // not find the value
return 0;
}
static void hw_bc11_done(void)
{
//RG_bc11_VSRC_EN[1:0]=00
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN,0x0);
//RG_bc11_VREF_VTH = [1:0]=0
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH,0x0);
//RG_bc11_CMP_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_CMP_EN,0x0);
//RG_bc11_IPU_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_IPU_EN,0x0);
//RG_bc11_IPD_EN[1.0] = 00
bc11_set_register_value(PMIC_RG_BC11_IPD_EN,0x0);
//RG_bc11_BIAS_EN=0
bc11_set_register_value(PMIC_RG_BC11_BIAS_EN,0x0);
Charger_Detect_Release();
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_done() \r\n");
hw_bc11_dump_register();
}
}
static void hw_bc11_done(void)
{
//RG_bc11_VSRC_EN[1:0]=00
mt6325_upmu_set_rg_bc11_vsrc_en(0x0);
//RG_bc11_VREF_VTH = [1:0]=0
mt6325_upmu_set_rg_bc11_vref_vth(0x0);
//RG_bc11_CMP_EN[1.0] = 00
mt6325_upmu_set_rg_bc11_cmp_en(0x0);
//RG_bc11_IPU_EN[1.0] = 00
mt6325_upmu_set_rg_bc11_ipu_en(0x0);
//RG_bc11_IPD_EN[1.0] = 00
mt6325_upmu_set_rg_bc11_ipd_en(0x0);
//RG_bc11_BIAS_EN=0
mt6325_upmu_set_rg_bc11_bias_en(0x0);
// if (!is_dcp_type)
Charger_Detect_Release();
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_done() \r\n");
hw_bc11_dump_register();
}
}
static kal_uint32 charging_hw_init(void *data)
{
kal_uint32 status = STATUS_OK;
static bool charging_init_flag = KAL_FALSE;
mt_set_gpio_mode(gpio_number,gpio_on_mode);
mt_set_gpio_dir(gpio_number,gpio_on_dir);
mt_set_gpio_out(gpio_number,gpio_on_out);
#if defined(MTK_WIRELESS_CHARGER_SUPPORT)
mt_set_gpio_mode(wireless_charger_gpio_number,0); // 0:GPIO mode
mt_set_gpio_dir(wireless_charger_gpio_number,0); // 0: input, 1: output
#endif
battery_log(BAT_LOG_FULL, "gpio_number=0x%x,gpio_on_mode=%d,gpio_off_mode=%d\n", gpio_number, gpio_on_mode, gpio_off_mode);
upmu_set_rg_usbdl_set(0); //force leave USBDL mode
upmu_set_rg_usbdl_rst(1); //force leave USBDL mode
#if defined(HIGH_BATTERY_VOLTAGE_SUPPORT)
fan5405_reg_config_interface(0x06,0x77); // ISAFE = 1250mA, VSAFE = 4.34V
#else
fan5405_reg_config_interface(0x06,0x70);
#endif
fan5405_reg_config_interface(0x00,0xC0); //kick chip watch dog
fan5405_reg_config_interface(0x01,0xb8); //TE=1, CE=0, HZ_MODE=0, OPA_MODE=0
fan5405_reg_config_interface(0x05,0x03);
if ( !charging_init_flag ) {
fan5405_reg_config_interface(0x04,0x1A); //146mA
charging_init_flag = KAL_TRUE;
}
return status;
}
void BATTERY_SetUSBState(int usb_state_value)
{
#if defined(CONFIG_POWER_EXT)
battery_log(BAT_LOG_CRTI, "[BATTERY_SetUSBState] in FPGA/EVB, no service\r\n");
#else
if ((usb_state_value < USB_SUSPEND) || ((usb_state_value > USB_CONFIGURED))) {
battery_log(BAT_LOG_CRTI,
"[BATTERY] BAT_SetUSBState Fail! Restore to default value\r\n");
usb_state_value = USB_UNCONFIGURED;
} else {
battery_log(BAT_LOG_CRTI, "[BATTERY] BAT_SetUSBState Success! Set %d\r\n",
usb_state_value);
g_usb_state = usb_state_value;
}
#endif
}
static void hw_bc11_init(void)
{
msleep(300);
Charger_Detect_Init();
//RG_BC11_BIAS_EN=1
upmu_set_rg_bc11_bias_en(0x1);
//RG_BC11_VSRC_EN[1:0]=00
upmu_set_rg_bc11_vsrc_en(0x0);
//RG_BC11_VREF_VTH = [1:0]=00
upmu_set_rg_bc11_vref_vth(0x0);
//RG_BC11_CMP_EN[1.0] = 00
upmu_set_rg_bc11_cmp_en(0x0);
//RG_BC11_IPU_EN[1.0] = 00
upmu_set_rg_bc11_ipu_en(0x0);
//RG_BC11_IPD_EN[1.0] = 00
upmu_set_rg_bc11_ipd_en(0x0);
//BC11_RST=1
upmu_set_rg_bc11_rst(0x1);
//BC11_BB_CTRL=1
upmu_set_rg_bc11_bb_ctrl(0x1);
//msleep(10);
mdelay(50);
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_init() \r\n");
hw_bc11_dump_register();
}
}
static U32 hw_bc11_stepB2(void)
{
U32 wChargerAvail = 0;
//RG_BC11_IPU_EN[1:0]=10
upmu_set_rg_bc11_ipu_en(0x2);
//RG_BC11_VREF_VTH = [1:0]=10
upmu_set_rg_bc11_vref_vth(0x1);
//RG_BC11_CMP_EN[1.0] = 01
upmu_set_rg_bc11_cmp_en(0x1);
//msleep(80);
mdelay(80);
wChargerAvail = upmu_get_rgs_bc11_cmp_out();
if(Enable_BATDRV_LOG == BAT_LOG_FULL)
{
battery_log(BAT_LOG_FULL, "hw_bc11_stepB2() \r\n");
hw_bc11_dump_register();
}
//RG_BC11_IPU_EN[1.0] = 00
upmu_set_rg_bc11_ipu_en(0x0);
//RG_BC11_CMP_EN[1.0] = 00
upmu_set_rg_bc11_cmp_en(0x0);
//RG_BC11_VREF_VTH = [1:0]=00
upmu_set_rg_bc11_vref_vth(0x0);
return wChargerAvail;
}
static void hw_bc11_dump_register(void)
{
battery_log(BAT_LOG_FULL, "Reg[0x%x]=0x%x,Reg[0x%x]=0x%x\n",
MT6325_CHR_CON20, upmu_get_reg_value(MT6325_CHR_CON20),
MT6325_CHR_CON21, upmu_get_reg_value(MT6325_CHR_CON21)
);
}
static kal_uint32 charging_enable(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 enable = *(kal_uint32*)(data);
if(KAL_TRUE == enable)
{
bq24196_set_en_hiz(0x0);
bq24196_set_chg_config(0x1); // charger enable
}
else
{
#if defined(CONFIG_USB_MTK_HDRC_HCD)
if(mt_usb_is_device())
#endif
{
bq24196_set_chg_config(0x0);
if (charging_get_error_state()) {
battery_log(BAT_LOG_CRTI, "[charging_enable] bq24196_set_hz_mode(0x1)\n");
bq24196_set_en_hiz(0x1); // disable power path
}
}
#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
bq24196_set_chg_config(0x0);
bq24196_set_en_hiz(0x1); // disable power path
#endif
}
return status;
}
static kal_uint32 charging_enable(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 enable = *(kal_uint32*)(data);
if(KAL_TRUE == enable)
{
ncp1854_set_chg_en(0x1); // charger enable
//Set SPM = 1
mt_set_gpio_mode(GPIO_CHR_SPM_PIN, GPIO_MODE_00);
mt_set_gpio_dir(GPIO_CHR_SPM_PIN, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO_CHR_SPM_PIN, GPIO_OUT_ONE);
}
else
{
#if defined(CONFIG_USB_MTK_HDRC_HCD)
if(mt_usb_is_device())
#endif
{
if(charging_get_error_state())
{
ncp1854_set_chg_en(0x0); // charger disable
battery_log(BAT_LOG_CRTI,"[charging_enable] ncp1854_set_pwr_path(0)\n");
ncp1854_set_pwr_path(0); // disable power path
}
}
}
return status;
}
static kal_uint32 charging_full_check(void)
{
kal_uint32 status = KAL_FALSE;
#if defined(POST_TIME_ENABLE)
static kal_uint32 post_charging_time = 0;
if (post_charging_time >= POST_CHARGING_TIME) {
status = KAL_TRUE;
post_charging_time = 0;
battery_log(BAT_LOG_CRTI,
"[BATTERY] Battery real full and disable charging on %d mA\n",
BMT_status.ICharging);
} else if (post_charging_time > 0) {
post_charging_time += BAT_TASK_PERIOD;
battery_log(BAT_LOG_CRTI,
"[BATTERY] post_charging_time=%d,POST_CHARGING_TIME=%d\n",
post_charging_time, POST_CHARGING_TIME);
} else if ((BMT_status.TOPOFF_charging_time > 60)
&& (BMT_status.ICharging <= charging_full_current)) {
post_charging_time = BAT_TASK_PERIOD;
battery_log(BAT_LOG_CRTI,
"[BATTERY] Enter Post charge, post_charging_time=%d,POST_CHARGING_TIME=%d\n",
post_charging_time, POST_CHARGING_TIME);
} else {
post_charging_time = 0;
}
#else
static kal_uint8 full_check_count = 0;
if (BMT_status.ICharging <= charging_full_current) {
full_check_count++;
if (6 == full_check_count) {
status = KAL_TRUE;
full_check_count = 0;
battery_log(BAT_LOG_CRTI,
"[BATTERY] Battery full and disable charging on %d mA\n",
BMT_status.ICharging);
}
} else {
full_check_count = 0;
}
#endif
return status;
}
static kal_uint32 is_chr_det(void)
{
kal_uint32 val=0;
val = mt6325_upmu_get_rgs_chrdet();
battery_log(BAT_LOG_CRTI, "[is_chr_det] %d\n", val);
return val;
}
static kal_uint32 charging_dump_register(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 reg_val = 0;
kal_uint32 i = 0;
for(i=MT6328_CHR_CON0 ; i<=MT6328_CHR_CON40 ; i+=2)
{
reg_val = upmu_get_reg_value(i);
battery_log(BAT_LOG_CRTI, "[0x%x]=0x%x,", i, reg_val);
}
battery_log(BAT_LOG_CRTI, "\n");
return status;
}
unsigned char rt9536_check_eoc_status(void)
{
unsigned char reg_val = 0;
unsigned char eoc_status = 0;
// TO DO
eoc_status = mt_get_gpio_in(CHG_EOC_N);;
if( eoc_status == 1 )
{
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: (%s) eoc_status(%d)\n", __func__, eoc_status);
return 1;
}
battery_log(BAT_LOG_CRTI, "[charger_rt9536] :: (%s) eoc_status(%d)\n", __func__, eoc_status);
return 0;
}
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");
}
}
