static kal_uint32 charging_reset_watch_dog_timer(void *data)
{
kal_uint32 status = STATUS_OK;
battery_xlog_printk(BAT_LOG_CRTI, "charging_reset_watch_dog_timer\r\n");
bq24196_set_wdt_rst(0x1); //Kick watchdog
return status;
}
static kal_uint32 is_chr_det(void)
{
kal_uint32 val=0;
val = mt6325_upmu_get_rgs_chrdet();
battery_xlog_printk(BAT_LOG_CRTI,"[is_chr_det] %d\n", val);
return val;
}
static kal_uint32 charging_get_platfrom_boot_mode(void *data)
{
kal_uint32 status = STATUS_OK;
*(kal_uint32*)(data) = get_boot_mode();
battery_xlog_printk(BAT_LOG_CRTI, "get_boot_mode=%d\n", get_boot_mode());
return status;
}
static kal_uint32 charging_set_platform_reset(void *data)
{
kal_uint32 status = STATUS_OK;
battery_xlog_printk(BAT_LOG_CRTI, "charging_set_platform_reset\n");
arch_reset(0,NULL);
return status;
}
static kal_uint32 charging_dump_register(void *data)
{
kal_uint32 status = STATUS_OK;
battery_xlog_printk(BAT_LOG_CRTI, "charging_dump_register\r\n");
bq24196_dump_register();
return status;
}
kal_uint32 set_bat_charging_current_limit(int current_limit)
{
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] set_bat_charging_current_limit (%d)\r\n",
current_limit);
if (current_limit != -1) {
g_bcct_flag = 1;
if (current_limit < 70)
g_temp_CC_value = CHARGE_CURRENT_0_00_MA;
else if (current_limit < 200)
g_temp_CC_value = CHARGE_CURRENT_70_00_MA;
else if (current_limit < 300)
g_temp_CC_value = CHARGE_CURRENT_200_00_MA;
else if (current_limit < 400)
g_temp_CC_value = CHARGE_CURRENT_300_00_MA;
else if (current_limit < 450)
g_temp_CC_value = CHARGE_CURRENT_400_00_MA;
else if (current_limit < 550)
g_temp_CC_value = CHARGE_CURRENT_450_00_MA;
else if (current_limit < 650)
g_temp_CC_value = CHARGE_CURRENT_550_00_MA;
else if (current_limit < 700)
g_temp_CC_value = CHARGE_CURRENT_650_00_MA;
else if (current_limit < 800)
g_temp_CC_value = CHARGE_CURRENT_700_00_MA;
else if (current_limit < 900)
g_temp_CC_value = CHARGE_CURRENT_800_00_MA;
else if (current_limit < 1000)
g_temp_CC_value = CHARGE_CURRENT_900_00_MA;
else if (current_limit < 1100)
g_temp_CC_value = CHARGE_CURRENT_1000_00_MA;
else if (current_limit < 1200)
g_temp_CC_value = CHARGE_CURRENT_1100_00_MA;
else if (current_limit < 1300)
g_temp_CC_value = CHARGE_CURRENT_1200_00_MA;
else if (current_limit < 1400)
g_temp_CC_value = CHARGE_CURRENT_1300_00_MA;
else if (current_limit < 1500)
g_temp_CC_value = CHARGE_CURRENT_1400_00_MA;
else if (current_limit < 1600)
g_temp_CC_value = CHARGE_CURRENT_1500_00_MA;
else if (current_limit == 1600)
g_temp_CC_value = CHARGE_CURRENT_1600_00_MA;
else
g_temp_CC_value = CHARGE_CURRENT_450_00_MA;
} else {
/* change to default current setting */
g_bcct_flag = 0;
}
wake_up_bat();
return g_bcct_flag;
}
static kal_uint32 charging_get_charging_status(void *data)
{
int voltage = *(int*)data;
int status;
int rc = 0;
if (g_charger_type == CHARGER_UNKNOWN) {
*(int*)data = 0;
return STATUS_OK;
}
rc = get_property(POWER_SUPPLY_PROP_STATUS, &status);
if (rc) {
battery_xlog_printk(BAT_LOG_CRTI, "[PowerSupply] failed to get charging status.(%d)\n", rc);
return STATUS_UNSUPPORTED;
}
/* if eoc check is not supported in charger ic, check battery voltage instead */
if (status == STATUS_UNSUPPORTED) {
/* battery voltage is invalid range */
if (voltage > 5000) {
*(int*)data = 0;
return STATUS_OK;
}
if (voltage > RECHARGING_VOLTAGE)
*(int*)data = 1;
else
*(int*)data = 0;
return STATUS_OK;
}
if (status == POWER_SUPPLY_STATUS_FULL) {
*(int*)data = 1;
} else {
*(int*)data = 0;
}
battery_xlog_printk(BAT_LOG_FULL, "[PowerSupply] End of Charging : %d\n", *(int*)data);
return STATUS_OK;
}
static kal_uint32 charging_enable(void *data)
{
int status;
int enable = *(int*)(data);
int rc = 0;
if (enable == g_charging_enabled && !g_charging_setting_chagned)
return STATUS_OK;
/* Do not disable charging when battery disconnected */
if (!enable && upmu_get_rgs_baton_undet())
return STATUS_OK;
if (enable) {
status = POWER_SUPPLY_STATUS_CHARGING;
} else {
status = POWER_SUPPLY_STATUS_NOT_CHARGING;
}
rc = set_property(POWER_SUPPLY_PROP_STATUS, status);
if (rc) {
battery_xlog_printk(BAT_LOG_CRTI,
"[PowerSupply] failed to %s charging.(%d)\n",
(enable ? "start" : "stop"), rc);
return STATUS_UNSUPPORTED;
}
g_charging_enabled = enable;
/* clear charging setting */
if (!g_charging_enabled) {
g_charging_current = 0;
g_charging_current_limit = 0;
g_charging_voltage = 0;
}
g_charging_setting_chagned = 0;
battery_xlog_printk(BAT_LOG_CRTI, "[PowerSupply] %s charging.\n",
(g_charging_enabled ? "start" : "stop"));
return STATUS_OK;
}
static void mt_swchr_debug_msg(void)
{
battery_xlog_printk(BAT_LOG_CRTI,"[0x%x]=0x%x,[0x%x]=0x%x,[0x%x]=0x%x,[0x%x]=0x%x,[0x%x]=0x%x,[0x%x]=0x%x\n",
0x805E, upmu_get_reg_value(0x805E),
0x8056, upmu_get_reg_value(0x8056),
0x80E2, upmu_get_reg_value(0x80E2),
0x8062, upmu_get_reg_value(0x8062),
0x8178, upmu_get_reg_value(0x8178),
0x8054, upmu_get_reg_value(0x8054)
);
}
static kal_uint32 is_chr_det(void)
{
kal_uint32 val=0;
pmic_config_interface(0x10A, 0x1, 0xF, 8);
pmic_config_interface(0x10A, 0x17,0xFF,0);
pmic_read_interface(0x108, &val,0x1, 1);
battery_xlog_printk(BAT_LOG_CRTI,"[is_chr_det] %d\n", val);
return val;
}
int upmu_is_chr_det_hal(void)
{
if(is_chr_det() == 0)
{
return 0;
}
else
{
if( mt_usb_is_device() )
{
battery_xlog_printk(BAT_LOG_CRTI, "[upmu_is_chr_det_hal] Charger exist and USB is not host\n");
return 1;
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "[upmu_is_chr_det_hal] Charger exist but USB is host\n");
return 0;
}
}
}
static void mtk_ta_reset_vchr(void)
{
CHR_CURRENT_ENUM chr_current = CHARGE_CURRENT_70_00_MA;
battery_charging_control(CHARGING_CMD_SET_CURRENT,&chr_current);
msleep(250); // reset Vchr to 5V
ta_current_level = 5000;
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 kal_uint32 charging_get_charger_type(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_POWER_EXT)
*(CHARGER_TYPE*)(data) = STANDARD_HOST;
#else
#if defined(MTK_WIRELESS_CHARGER_SUPPORT)
int wireless_state = 0;
wireless_state = mt_get_gpio_in(wireless_charger_gpio_number);
if(wireless_state == WIRELESS_CHARGER_EXIST_STATE)
{
*(CHARGER_TYPE*)(data) = WIRELESS_CHARGER;
battery_xlog_printk(BAT_LOG_CRTI, "WIRELESS_CHARGER!\r\n");
return status;
}
if(g_charger_type!=CHARGER_UNKNOWN && g_charger_type!=WIRELESS_CHARGER)
{
*(CHARGER_TYPE*)(data) = g_charger_type;
battery_xlog_printk(BAT_LOG_CRTI, "return %d!\r\n", g_charger_type);
return status;
}
#endif
charging_type_det_done = KAL_FALSE;
charger_type = hw_get_charger_type();
#ifdef MTK_AC_CHARGER_DEBOUNCE
if(NONSTANDARD_CHARGER == charger_type)
{
charger_type = hw_get_charger_type();
}
#endif
*(CHARGER_TYPE*)(data) = charger_type;
charging_type_det_done = KAL_TRUE;
#endif
return status;
}
static void hw_bc11_dump_register(void)
{
kal_uint32 reg_val = 0;
kal_uint32 reg_num = CHR_CON18;
kal_uint32 i = 0;
for(i=reg_num ; i<=CHR_CON19 ; i+=2)
{
reg_val = upmu_get_reg_value(i);
battery_xlog_printk(BAT_LOG_FULL, "Chr Reg[0x%x]=0x%x \r\n", i, reg_val);
}
}
static kal_uint32 charging_get_battery_status(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 val = 0;
#if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
*(kal_bool*)(data) = 0; // battery exist
battery_xlog_printk(BAT_LOG_CRTI,"bat exist for evb\n");
#else
val=pmic_get_register_value(PMIC_BATON_TDET_EN);
battery_xlog_printk(BAT_LOG_FULL,"[charging_get_battery_status] BATON_TDET_EN = %d\n", val);
if (val) {
pmic_set_register_value(PMIC_BATON_TDET_EN,1);
pmic_set_register_value(PMIC_RG_BATON_EN,1);
*(kal_bool*)(data) = pmic_get_register_value(PMIC_RGS_BATON_UNDET);
} else {
*(kal_bool*)(data) = KAL_FALSE;
}
#endif
return status;
}
static kal_uint32 charging_set_power_off(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
#else
battery_xlog_printk(BAT_LOG_CRTI, "charging_set_power_off\n");
mt_power_off();
#endif
return status;
}
// ============================================================ //
kal_uint32 charging_value_to_parameter(const kal_uint32 *parameter, const kal_uint32 array_size, const kal_uint32 val)
{
if (val < array_size)
{
return parameter[val];
}
else
{
battery_xlog_printk(BAT_LOG_CRTI, "Can't find the parameter \r\n");
return parameter[0];
}
}
static kal_uint32 bmt_find_closest_level(const kal_uint32 *pList,kal_uint32 number,kal_uint32 level)
{
kal_uint32 i;
kal_uint32 max_value_in_last_element;
if(pList[0] < pList[1])
max_value_in_last_element = KAL_TRUE;
else
max_value_in_last_element = KAL_FALSE;
if(max_value_in_last_element == KAL_TRUE)
{
for(i = (number-1); i != 0; i--) //max value in the last element
{
if(pList[i] <= level)
{
return pList[i];
}
}
battery_xlog_printk(BAT_LOG_CRTI, "Can't find closest level, small value first \r\n");
return pList[0];
//return CHARGE_CURRENT_0_00_MA;
}
else
{
for(i = 0; i< number; i++) // max value in the first element
{
if(pList[i] <= level)
{
return pList[i];
}
}
battery_xlog_printk(BAT_LOG_CRTI, "Can't find closest level, large value first \r\n");
return pList[number -1];
//return CHARGE_CURRENT_0_00_MA;
}
}
static kal_uint32 charging_get_battery_status(void *data)
{
kal_uint32 status = STATUS_OK;
kal_uint32 val = 0;
#if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
*(kal_bool*)(data) = 0; // battery exist
battery_xlog_printk(BAT_LOG_CRTI,"[charging_get_battery_status] battery exist for bring up.\n");
#else
pmic_read_interface( MT6325_CHR_CON7, &val, MT6325_PMIC_BATON_TDET_EN_MASK, MT6325_PMIC_BATON_TDET_EN_SHIFT);
battery_xlog_printk(BAT_LOG_FULL,"[charging_get_battery_status] BATON_TDET_EN = %d\n", val);
if (val) {
mt6325_upmu_set_baton_tdet_en(1);
mt6325_upmu_set_rg_baton_en(1);
*(kal_bool*)(data) = mt6325_upmu_get_rgs_baton_undet();
} else {
*(kal_bool*)(data) = KAL_FALSE;
}
#endif
return status;
}
static kal_uint32 charging_get_platfrom_boot_mode(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_MTK_FPGA)
#else
*(kal_uint32*)(data) = get_boot_mode();
battery_xlog_printk(BAT_LOG_CRTI, "get_boot_mode=%d\n", get_boot_mode());
#endif
return status;
}
static kal_uint32 charging_get_charger_det_status(void *data)
{
kal_uint32 status = STATUS_OK;
#if 1
kal_uint32 val=0;
pmic_config_interface(0x10A, 0x1, 0xF, 8);
pmic_config_interface(0x10A, 0x17,0xFF,0);
pmic_read_interface(0x108, &val,0x1, 1);
*(kal_bool*)(data) = val;
battery_xlog_printk(BAT_LOG_FULL,"[charging_get_charger_det_status] CHRDET status = %d\n", val);
#else
//*(kal_bool*)(data) = upmu_get_rgs_chrdet();
*(kal_bool*)(data) = 1;
battery_xlog_printk(BAT_LOG_CRTI,"[charging_get_charger_det_status] no HW function\n");
#endif
if(val == 0)
g_charger_type = CHARGER_UNKNOWN;
return status;
}
void set_usb_dc_in_mode(int is_sw_en, int is_sw_mode)
{
pmic_config_interface(0x8D1E, is_sw_en, 0x1, 4);
pmic_config_interface(0x8D2C, is_sw_mode, 0x1, 4);
pmic_config_interface(0x8D1E, is_sw_en, 0x1, 5);
pmic_config_interface(0x8D2C, is_sw_mode, 0x1, 5);
battery_xlog_printk(BAT_LOG_CRTI,"[set_usb_dc_in_mode] Reg[0x%x]=0x%x, Reg[0x%x]=0x%x\n",
0x8D1E, upmu_get_reg_value(0x8D1E),
0x8D2C, upmu_get_reg_value(0x8D2C)
);
}
static void set_jeita_charging_current(void)
{
#ifdef CONFIG_USB_IF
if(BMT_status.charger_type == STANDARD_HOST)
return;
#endif
if(g_temp_status == TEMP_NEG_10_TO_POS_0)
{
g_temp_CC_value = CHARGE_CURRENT_200_00_MA; //for low temp
battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] JEITA set charging current : %d\r\n", g_temp_CC_value);
}
}
static kal_uint32 charging_set_platform_reset(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_MTK_FPGA)
#else
battery_xlog_printk(BAT_LOG_CRTI, "charging_set_platform_reset\n");
arch_reset(0,NULL);
#endif
return status;
}
static kal_bool mtk_ta_retry_increase(void)
{
int real_v_chrA;
int real_v_chrB;
kal_bool retransmit = KAL_TRUE;
kal_uint32 retransmit_count=0;
do
{
real_v_chrA = battery_meter_get_charger_voltage();
mtk_ta_increase(); //increase TA voltage to 7V
real_v_chrB = battery_meter_get_charger_voltage();
if(real_v_chrB - real_v_chrA >= 1000) // 1.0V
{
retransmit = KAL_FALSE;
}
else
{
retransmit_count++;
battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_detector(): retransmit_count =%d, chrA=%d, chrB=%d\n",
retransmit_count, real_v_chrA, real_v_chrB);
}
if((retransmit_count == 3) || (BMT_status.charger_exist == KAL_FALSE))
{
retransmit = KAL_FALSE;
}
}while((retransmit == KAL_TRUE) && (ta_cable_out_occur == KAL_FALSE));
battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_retry_increase() real_v_chrA=%d, real_v_chrB=%d, retry=%d\n",
real_v_chrA, real_v_chrB,retransmit_count);
if(retransmit_count == 3)
return KAL_FALSE;
else
return KAL_TRUE;
}
static kal_uint32 charging_get_hv_status(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
*(kal_bool*)(data) = 0;
battery_xlog_printk(BAT_LOG_CRTI,"[charging_get_hv_status] charger ok for bring up.\n");
#else
*(kal_bool*)(data) = mt6325_upmu_get_rgs_vcdt_hv_det();
#endif
return status;
}
static kal_uint32 charging_get_charger_det_status(void *data)
{
kal_uint32 status = STATUS_OK;
#if defined(CONFIG_MTK_FPGA)
*(kal_bool*)(data) = 1;
battery_xlog_printk(BAT_LOG_CRTI,"chr exist for fpga\n");
#else
*(kal_bool*)(data) = pmic_get_register_value(PMIC_RGS_CHRDET);
#endif
return status;
}
static kal_uint32 charging_get_is_pcm_timer_trigger(void *data)
{
kal_uint32 status = STATUS_OK;
if(slp_get_wake_reason() == WR_PCM_TIMER)
*(kal_bool*)(data) = KAL_TRUE;
else
*(kal_bool*)(data) = KAL_FALSE;
battery_xlog_printk(BAT_LOG_CRTI, "slp_get_wake_reason=%d\n", slp_get_wake_reason());
return status;
}
static int get_property(enum power_supply_property prop, int *data)
{
union power_supply_propval val;
int rc = 0;
*(int*)data = STATUS_UNSUPPORTED;
if(!is_property_support(prop))
return 0;
rc = power_supply->get_property(power_supply, prop, &val);
if (rc) {
battery_xlog_printk(BAT_LOG_CRTI, "[PowerSupply] failed to get property %d\n", prop);
*(int*)data = 0;
return rc;
}
*(int*)data = val.intval;
battery_xlog_printk(BAT_LOG_FULL, "[PowerSupply] set property %d to %d\n", prop, val.intval);
return rc;
}
