kal_bool is_low_battery(kal_int32 val) { static UINT8 g_bat_low = 0xFF; //low battery only justice once in lk if(0xFF != g_bat_low) return g_bat_low; else g_bat_low = FALSE; #if defined(SWCHR_POWER_PATH) if(0 == val) val = get_i_sense_volt(1); #else if(0 == val) val = get_bat_sense_volt(1); #endif if (val < BATTERY_LOWVOL_THRESOLD) { printf("%s, TRUE\n", __FUNCTION__); g_bat_low = 0x1; } if(FALSE == g_bat_low) printf("%s, FALSE\n", __FUNCTION__); return g_bat_low; }
void mt65xx_bat_init(void) { kal_int32 bat_vol; // Low Battery Safety Booting #if defined(SWCHR_POWER_PATH) bat_vol = get_i_sense_volt(1); #else bat_vol = get_bat_sense_volt(1); #endif pchr_turn_on_charging(KAL_TRUE); dprintf(CRITICAL, "[mt65xx_bat_init] check VBAT=%d mV with %d mV\n", bat_vol, BATTERY_LOWVOL_THRESOLD); if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && (mt6325_upmu_get_pwrkey_deb()==0) ) { dprintf(CRITICAL, "[mt65xx_bat_init] KPOC+PWRKEY => change boot mode\n"); g_boot_reason_change = true; } rtc_boot_check(false); #ifndef MTK_DISABLE_POWER_ON_OFF_VOLTAGE_LIMITATION #ifndef MTK_BATLOWV_NO_PANEL_ON_EARLY if (bat_vol < BATTERY_LOWVOL_THRESOLD) #else if (is_low_battery(bat_vol)) #endif { if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && upmu_is_chr_det() == KAL_TRUE) { dprintf(CRITICAL, "[%s] Kernel Low Battery Power Off Charging Mode\n", __func__); g_boot_mode = LOW_POWER_OFF_CHARGING_BOOT; #if defined(SWCHR_POWER_PATH) check_bat_protect_status(); #endif return; } else { dprintf(CRITICAL, "[BATTERY] battery voltage(%dmV) <= CLV ! Can not Boot Linux Kernel !! \n\r",bat_vol); #ifndef NO_POWER_OFF mt6575_power_off(); #endif while(1) { dprintf(CRITICAL, "If you see the log, please check with RTC power off API\n\r"); } } } #endif return; }
//enter this function when low battery with charger void check_bat_protect_status() { kal_int32 bat_val = 0; #if defined(SWCHR_POWER_PATH) bat_val = get_i_sense_volt(5); #else bat_val = get_bat_sense_volt(5); #endif dprintf(CRITICAL, "[%s]: check VBAT=%d mV with %d mV, start charging... \n", __FUNCTION__, bat_val, BATTERY_LOWVOL_THRESOLD); if (bat_val < BATTERY_LOWVOL_THRESOLD) mt65xx_leds_brightness_set(MT65XX_LED_TYPE_RED, LED_FULL); while (bat_val < BATTERY_LOWVOL_THRESOLD) { mtk_wdt_restart(); if(upmu_is_chr_det() == KAL_FALSE) { dprintf(CRITICAL, "[BATTERY] No Charger, Power OFF !\n"); mt6575_power_off(); while(1); } pchr_turn_on_charging(KAL_TRUE); mdelay(5000); #if defined(SWCHR_POWER_PATH) pchr_turn_on_charging(KAL_FALSE); mdelay(100); bat_val = get_i_sense_volt(5); #else bat_val = get_bat_sense_volt(5); #endif } dprintf(CRITICAL, "[%s]: check VBAT=%d mV with %d mV, stop charging... \n", __FUNCTION__, bat_val, BATTERY_LOWVOL_THRESOLD); }
void mt65xx_bat_init(void) { kal_int32 bat_vol; // Low Battery Safety Booting bat_vol = get_bat_sense_volt(1); #ifdef MTK_BQ24196_SUPPORT bat_vol = get_i_sense_volt(5); #endif dprintf(INFO, "[mt65xx_bat_init] check VBAT=%d mV with %d mV\n", bat_vol, BATTERY_LOWVOL_THRESOLD); pchr_turn_on_charging(); if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && (upmu_get_pwrkey_deb()==0) ) { dprintf(INFO, "[mt65xx_bat_init] KPOC+PWRKEY => change boot mode\n"); g_boot_reason_change = true; } rtc_boot_check(false); #ifndef MTK_DISABLE_POWER_ON_OFF_VOLTAGE_LIMITATION //if (bat_vol < BATTERY_LOWVOL_THRESOLD) if (is_low_battery(bat_vol)) { if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && upmu_is_chr_det() == KAL_TRUE) { dprintf(INFO, "[%s] Kernel Low Battery Power Off Charging Mode\n", __func__); g_boot_mode = LOW_POWER_OFF_CHARGING_BOOT; return; } else { dprintf(INFO, "[BATTERY] battery voltage(%dmV) <= CLV ! Can not Boot Linux Kernel !! \n\r",bat_vol); #ifndef NO_POWER_OFF mt6575_power_off(); #endif while(1) { dprintf(INFO, "If you see the log, please check with RTC power off API\n\r"); } } } #endif return; }
//extern int BattVoltToTemp(int dwVolt); void mt65xx_bat_init(void) { kal_int32 bat_vol; kal_int32 bat_tempture; kal_int32 bat_temp; #ifdef MTK_IPO_POWERPATH_SUPPORT CHARGER_TYPE CHR_Type_num = CHARGER_UNKNOWN; #endif // Low Battery Safety Booting bat_vol = get_bat_sense_volt(1); bat_tempture = get_tbat_volt(1); bat_temp=BattVoltToTemp(bat_tempture); printf("the bat_vol is %d,the bat_tempture is %d,the bat_temp is %d\n",bat_vol,bat_tempture,bat_temp); #if defined(MTK_BQ24196_SUPPORT) ||defined(MTK_BQ24296_SUPPORT) bat_vol = get_i_sense_volt(5); #endif printf("[mt65xx_bat_init] check VBAT=%d mV with %d mV\n", bat_vol, BATTERY_LOWVOL_THRESOLD); pchr_turn_on_charging(); if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && (upmu_get_pwrkey_deb()==0) ) { printf("[mt65xx_bat_init] KPOC+PWRKEY => change boot mode\n"); g_boot_reason_change = true; } rtc_boot_check(false); #ifndef MTK_DISABLE_POWER_ON_OFF_VOLTAGE_LIMITATION //if (bat_vol < BATTERY_LOWVOL_THRESOLD) if (is_low_battery(bat_vol)) { if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT && upmu_is_chr_det() == KAL_TRUE) { printf("[%s] Kernel Low Battery Power Off Charging Mode\n", __func__); g_boot_mode = LOW_POWER_OFF_CHARGING_BOOT; return; } #ifdef BULMA_PROJECT else if((META_BOOT == g_boot_mode) ||(ADVMETA_BOOT == g_boot_mode)) { printf("Enter Meta Mode emw\n\r"); } #endif else { #ifdef MTK_IPO_POWERPATH_SUPPORT //boot linux kernel because of supporting powerpath and using standard AC charger if(upmu_is_chr_det() == KAL_TRUE) { charging_get_charger_type(&CHR_Type_num); if(STANDARD_CHARGER == CHR_Type_num) { return; } } #endif printf("[BATTERY] battery voltage(%dmV) <= CLV ! Can not Boot Linux Kernel !! \n\r",bat_vol); #ifndef NO_POWER_OFF mt6575_power_off(); #endif while(1) { printf("If you see the log, please check with RTC power off API\n\r"); } } } if(is_high_bat_tempature(bat_temp)) { printf("[BATTERY] battery tempature(%dmV) <= CLV ! Can not Boot Linux Kernel !! \n\r",bat_tempture); #ifndef NO_POWER_OFF mt6575_power_off(); #endif while(1) { printf("If you see the log, please check with RTC power off API\n\r"); } } #endif return; }
int entropy_thread(void * arg) { TZ_RESULT ret; KREE_SESSION_HANDLE ndbg_session; KREE_SESSION_HANDLE mem_session; KREE_SHAREDMEM_HANDLE shm_handle; KREE_SHAREDMEM_PARAM shm_param; MTEEC_PARAM param[4]; uint8_t* ptr; ptr = (uint8_t*)kmalloc(NDBG_REE_ENTROPY_SZ, GFP_KERNEL); memset(ptr, 0, NDBG_REE_ENTROPY_SZ); while(!kthread_should_stop()) { ret = KREE_CreateSession(TZ_TA_NDBG_UUID, &ndbg_session); if (ret != TZ_RESULT_SUCCESS) { printk("CreateSession error %d\n", ret); return 1; } ret = KREE_CreateSession(TZ_TA_MEM_UUID, &mem_session); if (ret != TZ_RESULT_SUCCESS) { printk("Create memory session error %d\n", ret); return 1; } shm_param.buffer = ptr; shm_param.size = NDBG_REE_ENTROPY_SZ; ret = KREE_RegisterSharedmem(mem_session, &shm_handle, &shm_param); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_RegisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } #ifdef CONFIG_MTK_SMART_BATTERY *((uint32_t*)(ptr+0)) = get_bat_sense_volt(1); *((uint32_t*)(ptr+4)) = get_i_sense_volt(1); *((uint32_t*)(ptr+8)) = get_charger_volt(1); *((uint32_t*)(ptr+12)) = get_charger_volt(1); get_urandom_value(ptr+NDBG_BAT_ST_SIZE, URAN_SIZE); #else /* without battery, any other good source for nondetermined #? */ get_urandom_value(ptr, NDBG_REE_ENTROPY_SZ); #endif param[0].memref.handle = (uint32_t) shm_handle; param[0].memref.offset = 0; param[0].memref.size = NDBG_REE_ENTROPY_SZ; param[1].value.a = NDBG_REE_ENTROPY_SZ; ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)ndbg_session, TZCMD_NDBG_INIT, TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); printk ("Start to wait reseed.\n"); ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)ndbg_session, TZCMD_NDBG_WAIT_RESEED, TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); printk ("OK to send reseed.\n"); ret = KREE_UnregisterSharedmem(mem_session, shm_handle); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_UnregisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } ret = KREE_CloseSession(ndbg_session); if (ret != TZ_RESULT_SUCCESS) printk("CloseSession error %d\n", ret); ret = KREE_CloseSession(mem_session); if (ret != TZ_RESULT_SUCCESS) printk("Close memory session error %d\n", ret); } kfree(ptr); return 0; }