//------------------------------------------------------------------------------ // // Copyright (C) 2004, Motorola Inc. All Rights Reserved // //------------------------------------------------------------------------------ // // Copyright (C) 2004-2007, Freescale Semiconductor, Inc. All Rights Reserved. // THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS // AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT // //------------------------------------------------------------------------------ // // File: battdrvr.cpp // // This file implements the PDD layer APIs for battery driver // //------------------------------------------------------------------------------ #pragma warning(push) #pragma warning(disable: 4115 4201 4204 4214) #include #include #include #include #include #pragma warning(pop) #include "bspbattdrvr.h" #include "battdrvrUtility.h" //------------------------------------------------------------------------------ // External Functions //------------------------------------------------------------------------------ // External Variables //------------------------------------------------------------------------------ // Defines #define C_HR_TO_SEC 3600 // convert factor from hour to sec #define C_S_TO_MS 1000 // convert factor from sec to milli sec #define LIMIT_LOW 20 // lower limit for battery capacity #define LIMIT_HIGH 65 // higher limit for battery capacity #define MAX_TIME 0xFFFFFFFF #define CHARGE_END_CURRENT (0.02 * Batt_FullCapacity) #define CURRENT_COUNT_CALC_TIMES 6 #define BATTERY_VOL_CALC_TIMES 120 #define VOLTAGE_LIMIT_LEVEL 4 //4.25V #define CURRENT_LIMIT_LEVEL 14 //1800mA Max #define VOLTAGE_LIMIT_VALUE 4250 #define VOLTAGE_LIMIT_DELTA 45 #define TRICKLEL 1 #define TRICKLEM 3 #define TRICKLEH 6 #define TRICKLEN 0 //disable trickle charging #define IS_TRICKLECHARGING(state) (((state) == STATE_TRICKLECHARGING_I) ||\ (state == STATE_TRICKLECHARGING_II)) #define IS_NORMALCHARGING(state) ((state) == STATE_NORMALCHARGING) //------------------------------------------------------------------------------ // Types typedef enum { STATE_TRICKLECHARGING_I, STATE_TRICKLECHARGING_II, STATE_NORMALCHARGING, STATE_DISCHARGING_WITHCHARGER, STATE_DISCHARGING_WITHOUTCHARGER, STATE_EXTERNAL, STATE_OTHERS } CHARGING_STATE; //------------------------------------------------------------------------------ // Global Variables //------------------------------------------------------------------------------ // Local Variables static DWORD Batt_FullLifeTime; // full batt life time from registry static DWORD Batt_FullCapacity; // full batt capacity from registry static DWORD Batt_MaxVoltage; // max batt voltage from registry static DWORD Batt_MinVoltage; // min batt voltage from registry static DWORD Batt_PeukertNumber; // batt peukert number from registry static DWORD Batt_ChargeEff; // batt charge efficiency from registry static DWORD Batt_BATTLVoltage = 2700; static DWORD Batt_BATTONVoltage = 3000; //static DWORD Batt_BATTHVoltage = 3700; static DWORD t1; // time stamp to determine the duration between each call static DWORD t2; static UINT32 capacity; // batt capacity static UINT32 percentage; // percentage of batt capacity static UINT32 percentage_charging = 0; static DWORD totalCurrent = 0; static UINT32 timesForCurrentCount = 0; static UINT32 timesForBtteryVoltage = 0; static CHARGING_STATE prev_state = STATE_OTHERS; static CHARGING_STATE next_state = STATE_OTHERS; static UINT32 max_percent = 0, min_percent = 100; static BOOL need_adjust_percent = TRUE; //------------------------------------------------------------------------------ // Local Functions static UINT32 BSPBattAdjustPercent(CHARGING_STATE state, UINT32 percent, BOOL bInited) { static INT32 last_percent = 0; static INT32 loops = 0; static INT32 ret_percent = percent; static DWORD t1; DWORD t2, t_delta; INT32 factors = 50; if (last_percent == 0) last_percent = percent; if (state == STATE_DISCHARGING_WITHOUTCHARGER) { if (percent < min_percent || bInited) min_percent = percent; ret_percent = min_percent; if (bInited) t1 = timeGetTime(); if (ret_percent != last_percent) { t2 = timeGetTime(); if(t2 > t1) t_delta = t2 - t1; else t_delta = ~(t1-1) + t2; if (t_delta < 1*60*1000) //1 minute ret_percent = last_percent; } } else if (IS_TRICKLECHARGING(state) || IS_NORMALCHARGING(state)) { if (percent > max_percent || bInited) max_percent = percent; ret_percent = max_percent; if (bInited) loops = 0; if (ret_percent != last_percent) { if (loops <= factors) { if ((ret_percent - last_percent)*loops/factors + last_percent != last_percent) { ret_percent = (ret_percent - last_percent)*loops/factors + last_percent; loops = 0; } else ret_percent = last_percent; } else loops = 0; loops++; } else loops = 0; } last_percent = ret_percent; return ret_percent; } //----------------------------------------------------------------------------- // // Function: BatteryPDDInitialize // // This function performs the deinit to the battery pdd // // Parameters: // pszRegistryContext // [in] pointer of the reigistry context // // Returns: // TRUE for success FALSE if else // //----------------------------------------------------------------------------- BOOL WINAPI BatteryPDDInitialize(LPCTSTR pszRegistryContext) { HKEY hKey; DWORD dwStatus; DWORD dwType; DWORD dwSize; DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDInitialize\r\n"))); //Get Info from registry //obtain the default full battery capacity in mAHr hKey = OpenDeviceKey(pszRegistryContext); //open the device key if(!hKey) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: OpenDeviceKey failed\r\n"))); goto InitFail; } dwSize = sizeof(DWORD); //obtain the batt full life time dwStatus = RegQueryValueEx(hKey, BATT_FULL_LIFETIME_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_FullLifeTime, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_FullLifeTime) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_FullLifeTime is %X\r\n"), Batt_FullLifeTime)); //obtain the batt full capacity dwStatus = RegQueryValueEx(hKey, BATT_FULL_CAPACITY_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_FullCapacity, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_FullCapacity) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_FullCapacity is %X\r\n"), Batt_FullCapacity)); //obtain the batt max voltage dwStatus = RegQueryValueEx(hKey, BATT_MAX_VOLTAGE_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_MaxVoltage, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_MaxVoltage) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_MaxVoltage is %X\r\n"), Batt_MaxVoltage)); //obtain the batt min voltage dwStatus = RegQueryValueEx(hKey, BATT_MIN_VOLTAGE_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_MinVoltage, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_MinVoltage) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_MinVoltage is %X\r\n"), Batt_MinVoltage)); //obtain the batt peukert number dwStatus = RegQueryValueEx(hKey, BATT_PEUKERT_NUMBER_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_PeukertNumber, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_PeukertNumber) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_PeukertNumber is %X\r\n"), Batt_PeukertNumber)); //obtain the batt charge efficiency dwStatus = RegQueryValueEx(hKey, BATT_CHARGE_EFF_SUBKEY, NULL, &dwType, (LPBYTE) &Batt_ChargeEff, &dwSize); if(dwStatus != ERROR_SUCCESS) { DEBUGMSG(ZONE_ERROR, (TEXT("BatteryPDDInitialize: RegQueryValueEx(Batt_ChargeEff) failed\r\n"))); goto InitFail; } DEBUGMSG(ZONE_BATTERY, (TEXT("Batt_ChargeEff is %X\r\n"), Batt_ChargeEff)); RegCloseKey(hKey); BSPBattAttach(); DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDInitialize\r\n"))); return TRUE; InitFail: if(hKey) RegCloseKey(hKey); return FALSE; } //----------------------------------------------------------------------------- // // Function: BatteryPDDDeinitialize // // This function performs the deinit to the battery pdd // // Parameters: // void // // Returns: // void // //----------------------------------------------------------------------------- void WINAPI BatteryPDDDeinitialize(void) { DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDDeinitialize\r\n"))); DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDDeinitialize\r\n"))); } //----------------------------------------------------------------------------- // // Function: BatteryPDDResume // // This function performs hardware-specific battery processing in a thread context // following system resume // // Parameters: // void // // Returns: // void // //----------------------------------------------------------------------------- void WINAPI BatteryPDDResume(void) { DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDResume\r\n"))); DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDResume\r\n"))); } //----------------------------------------------------------------------------- // // Function: BatteryPDDPowerHandler // // This power callback performs hardware-specific processing for the battery driver // // Parameters: // bOff // [in] TRUE if suspending, FALSE if resuming. // // Returns: // void // //----------------------------------------------------------------------------- void WINAPI BatteryPDDPowerHandler(BOOL bOff) { DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDPowerHandler\r\n"))); // in resuming case, do the init check if (bOff == FALSE) { need_adjust_percent = FALSE; LOCKBATTERY(); BatteryAPIGetSystemPowerStatusEx2(&gBatteryContext.st, sizeof(gBatteryContext.st), TRUE); UNLOCKBATTERY(); need_adjust_percent = TRUE; } DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDPowerHandler\r\n"))); } //----------------------------------------------------------------------------- // // Function: BatteryPDDGetStatus // // This routine obtains the most current battery/power status available on the platform. It fills // in the structures pointed to by its parameters // // Parameters: // pstatus // [in] pointer to the battery status structure // pfBatteriesChangedSinceLastCall // [in] Pointer to a flag that the function sets to TRUE if the user replaced or changed // the system's batteries since the last call to this function. // // Returns: // TRUE if success FALSE if error // //----------------------------------------------------------------------------- BOOL WINAPI BatteryPDDGetStatus(PSYSTEM_POWER_STATUS_EX2 pstatus, PBOOL pfBatteriesChangedSinceLastCall) { BATT_INFO BattInfo; // batt information structure obtained from bsp layer DWORD batt_V; DWORD charger_V; BOOL fCharge; BOOL fChargeTemp; DWORD current; DEBUGMSG(ZONE_FUNCTION, (TEXT("BatteryPDDGetStatus\r\n"))); //Get Info from BSP layer if(BSPBattdrvrGetInfo(&BattInfo) != TRUE) { ERRORMSG(TRUE, (TEXT("BSPBattdrvrGetInfo fail !!\r\n"))); return FALSE; } if(BSPBattdrvrGetParameters(&batt_V, &charger_V, &fCharge, ¤t) != TRUE) { ERRORMSG(TRUE, (TEXT("BSPBattdrvrGetParameters fail !!\r\n"))); pstatus->ACLineStatus = AC_LINE_UNKNOWN; pstatus->BatteryFlag = BATTERY_FLAG_UNKNOWN; return FALSE; } pstatus->Reserved1 = 0; pstatus->Reserved2 = 0; pstatus->BackupBatteryFlag = BATTERY_FLAG_UNKNOWN; pstatus->BackupBatteryLifePercent = 0; pstatus->Reserved3 = 0; pstatus->BackupBatteryLifeTime = BATTERY_LIFE_UNKNOWN; pstatus->BackupBatteryFullLifeTime = BATTERY_LIFE_UNKNOWN; pstatus->BatteryCurrent = 0; pstatus->BatteryAverageCurrent = 0; pstatus->BatteryAverageInterval = 0; pstatus->BatterymAHourConsumed = 0; pstatus->BatteryTemperature = 0; pstatus->BackupBatteryVoltage = 0; pstatus->ACLineStatus = AC_LINE_ONLINE; //if (charger_V < BattInfo.charger_V_limit) if (!BSPBattdrvrIsChargerDetect()) { next_state = STATE_DISCHARGING_WITHOUTCHARGER; pstatus->ACLineStatus = AC_LINE_OFFLINE; } // determine whether battery is available according to the min batt voltage from batt spec // there are two reasons for battery voltage under minvoltage, one is no battery, other is dead battery // since ADC battery range from 2.5V-4.65V, so we can not distinguish no battery and dead battery when // voltage under Batt_MinVoltage(2.5V), we consider it as no battery else if (batt_V <= BattInfo.adc_batt_min_V) //Batt_MinVoltage { DEBUGMSG(ZONE_BATTERY, (TEXT("No Battery!!!\r\n"))); next_state = STATE_EXTERNAL; } else if (batt_V < Batt_BATTLVoltage) { if (prev_state != STATE_NORMALCHARGING && prev_state != STATE_DISCHARGING_WITHCHARGER) next_state = STATE_TRICKLECHARGING_I; } else if (batt_V < Batt_BATTONVoltage) { if (prev_state != STATE_NORMALCHARGING && prev_state != STATE_DISCHARGING_WITHCHARGER) next_state = STATE_TRICKLECHARGING_II; } else if (batt_V < (VOLTAGE_LIMIT_VALUE + VOLTAGE_LIMIT_DELTA)) { if (batt_V < (VOLTAGE_LIMIT_VALUE - VOLTAGE_LIMIT_DELTA)) { next_state = STATE_NORMALCHARGING; } else { //Check if complete charging if (IS_NORMALCHARGING(prev_state)) { timesForCurrentCount++; totalCurrent += current; if (timesForCurrentCount >= CURRENT_COUNT_CALC_TIMES) { if ((totalCurrent/timesForCurrentCount) < CHARGE_END_CURRENT) { next_state = STATE_DISCHARGING_WITHCHARGER; } timesForCurrentCount = 0; totalCurrent = 0; } } else if (prev_state == STATE_DISCHARGING_WITHCHARGER) next_state = STATE_DISCHARGING_WITHCHARGER; else next_state = STATE_NORMALCHARGING; } } else // Batt_v > VOLTAGE_LIMIT_VALUE next_state = STATE_DISCHARGING_WITHCHARGER; switch(next_state) { case STATE_TRICKLECHARGING_I: if (IS_NORMALCHARGING(prev_state)) BSPBattdrvrDisableCharger(); if (prev_state != STATE_TRICKLECHARGING_I) BSPBattdrvrSetTrickleCurrent(TRICKLEL); break; case STATE_TRICKLECHARGING_II: if (IS_NORMALCHARGING(prev_state)) BSPBattdrvrDisableCharger(); if (prev_state != STATE_TRICKLECHARGING_II) BSPBattdrvrSetTrickleCurrent(TRICKLEM); break; case STATE_NORMALCHARGING: if (IS_TRICKLECHARGING(prev_state)) BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging else if (!IS_NORMALCHARGING(prev_state)) { BSPBattdrvrSetCharger(VOLTAGE_LIMIT_LEVEL, CURRENT_LIMIT_LEVEL); } break; case STATE_DISCHARGING_WITHCHARGER: if (IS_TRICKLECHARGING(prev_state)) BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging if (IS_NORMALCHARGING(prev_state)) { BSPBattdrvrDisableCharger(); } break; case STATE_DISCHARGING_WITHOUTCHARGER: if (IS_TRICKLECHARGING(prev_state)) BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging if (IS_NORMALCHARGING(prev_state)) { BSPBattdrvrDisableCharger(); } break; case STATE_EXTERNAL: if (IS_TRICKLECHARGING(prev_state)) BSPBattdrvrSetTrickleCurrent(TRICKLEN); //Disable trickle charging //BSPBattdrvrSetTrickleCurrent(TRICKLEL); if (IS_NORMALCHARGING(prev_state)) BSPBattdrvrDisableCharger(); //tread it as dead battery ?? //Upate pstatus: pstatus->BatteryFlag = BATTERY_FLAG_NO_BATTERY; pstatus->BatteryLifePercent = 0; pstatus->BatteryLifeTime = 0; pstatus->BatteryFullLifeTime = 0; pstatus->BatteryChemistry = BATTERY_CHEMISTRY_UNKNOWN; pstatus->BatteryVoltage = 0; *pfBatteriesChangedSinceLastCall = FALSE; goto END; break; //Never reach here case STATE_OTHERS: break; default: break; } if (pstatus->ACLineStatus == AC_LINE_ONLINE) { if (IS_NORMALCHARGING(next_state)) { timesForBtteryVoltage ++; if ((timesForBtteryVoltage >= BATTERY_VOL_CALC_TIMES) || (percentage_charging == 0)) { BSPBattdrvrDisableCharger(); BSPBattdrvrGetParameters(&batt_V, &charger_V, &fChargeTemp, ¤t); BSPBattdrvrSetCharger(VOLTAGE_LIMIT_LEVEL, CURRENT_LIMIT_LEVEL); if (batt_V > Batt_MinVoltage) percentage_charging = 100*(batt_V - Batt_MinVoltage)/(Batt_MaxVoltage - Batt_MinVoltage); else percentage_charging = 0; timesForBtteryVoltage = 0; } percentage = percentage_charging; } else if (IS_TRICKLECHARGING(prev_state)) { if (batt_V > Batt_MinVoltage) percentage = 100*(batt_V - Batt_MinVoltage)/(Batt_MaxVoltage - Batt_MinVoltage); else percentage = 0; } } else { if (batt_V > Batt_MinVoltage) percentage = 100*(batt_V - Batt_MinVoltage)/(Batt_MaxVoltage - Batt_MinVoltage); else percentage = 0; percentage_charging = 0; } if (percentage > 100) percentage = 100; if (need_adjust_percent == TRUE) { percentage = BSPBattAdjustPercent(next_state, percentage, prev_state != next_state); } if (percentage == 100) { BSPBattdrvrLedControl(FALSE); } // Level Indicator if(percentage >= LIMIT_HIGH) pstatus->BatteryFlag = BATTERY_FLAG_HIGH; else if (( percentage =LIMIT_LOW)) pstatus->BatteryFlag = BATTERY_FLAG_LOW; else if(percentage<=LIMIT_LOW) pstatus->BatteryFlag = BATTERY_FLAG_CRITICAL; if ((IS_NORMALCHARGING(next_state) || IS_TRICKLECHARGING(next_state)) && percentage != 100) //charging pstatus->BatteryFlag = BATTERY_FLAG_CHARGING; if (next_state == STATE_DISCHARGING_WITHOUTCHARGER) { if (pstatus->BatteryFlag == BATTERY_FLAG_CRITICAL) BSPBattAdjustPollTimeout(0); else BSPBattAdjustPollTimeout(1); } pstatus->BatteryLifePercent = (BYTE)percentage; pstatus->BatteryLifeTime = (DWORD) (percentage*Batt_FullLifeTime); pstatus->BatteryFullLifeTime = Batt_FullLifeTime*C_HR_TO_SEC; pstatus->BatteryChemistry = BATTERY_CHEMISTRY_LION; pstatus->BatteryVoltage = batt_V; *pfBatteriesChangedSinceLastCall = FALSE; END: prev_state = next_state; return TRUE; } //----------------------------------------------------------------------------- // // Function: BatteryPDDGetLevels // // This routine indicates how many battery levels will be reported // in the BatteryFlag and BackupBatteryFlag fields of the PSYSTEM_POWER_STATUS_EX2 // filed in by BatteryPDDGetStatus(). This number ranges from 0 through 3 -- // see the Platform Builder documentation for details. The main battery // level count is reported in the low word of the return value; the count // for the backup battery is in the high word. // // Parameters: // void // // Returns: // Number of battery levels // //----------------------------------------------------------------------------- long BatteryPDDGetLevels(void) { DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDGetLevels\r\n"))); LONG lLevels = MAKELONG (3 /* main battery levels */, 3 /* backup battery levels */); DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDGetLevels\r\n"))); return lLevels; } //----------------------------------------------------------------------------- // // Function: BatteryPDDSupportsChangeNotification // // This routine returns TRUE to indicate that the pfBatteriesChangedSinceLastCall // value filled in by BatteryPDDGetStatus() is valid. If there is no way to // tell that the platform's batteries have been changed this routine should // return FALSE. // // Parameters: // void // // Returns: // false // //----------------------------------------------------------------------------- BOOL BatteryPDDSupportsChangeNotification(void) { DEBUGMSG(ZONE_FUNCTION, (TEXT("+BatteryPDDSupportsChangeNotification\r\n"))); BOOL fSupportsChange = FALSE; DEBUGMSG(ZONE_FUNCTION, (TEXT("-BatteryPDDSupportsChangeNotification\r\n"))); return fSupportsChange; }