707 lines
20 KiB
C
Executable File
707 lines
20 KiB
C
Executable File
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "kwrap/util.h"
|
|
#include "Utility/SwTimer.h"
|
|
//#include "GxSystem.h"
|
|
#include "DxPower.h"
|
|
#include "GxPower.h"
|
|
#include "PowerDef.h"
|
|
#include "DxApi.h"
|
|
#include "Dx.h"
|
|
#include "DxType.h"
|
|
|
|
#define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define __MODULE__ GxPwr
|
|
#define __DBGLVL__ THIS_DBGLVL
|
|
//#define __DBGFLT__ "*" //*=All, [mark]=CustomClass
|
|
#define __DBGFLT__ "[charge]" //*=All, [mark]=CustomClass
|
|
#include "kwrap/debug.h"
|
|
|
|
#define CHARGE_TEMPERATURE_STATUS_NORMAL 0
|
|
#define CHARGE_TEMPERATURE_STATUS_COLD 1
|
|
#define CHARGE_TEMPERATURE_STATUS_LOW 2
|
|
#define CHARGE_TEMPERATURE_STATUS_MEDIUM 3
|
|
#define CHARGE_TEMPERATURE_STATUS_HIGH 4
|
|
|
|
#define CHARGE_TEMPERATURE_COLD 0
|
|
#define CHARGE_TEMPERATURE_LOW 10
|
|
#define CHARGE_TEMPERATURE_MEDIUM 45
|
|
#define CHARGE_TEMPERATURE_HIGH 60
|
|
#define CHARGE_TEMPERATURE_TH 2
|
|
|
|
|
|
#define KEYSCAN_AUTOPOWEROFF_DISABLED 0
|
|
|
|
DX_HANDLE power_obj = 0;
|
|
|
|
volatile UINT32 g_uiKeyScanSleepCnt = 0;
|
|
volatile BOOL g_bKeyScanSleepEn = TRUE;
|
|
volatile BOOL g_bKeyScanResetSleeping = FALSE;
|
|
volatile UINT32 g_uiKeyScanSleepLevel = 0;
|
|
|
|
|
|
static volatile UINT32 g_uiKeyScanAutoPoweroffCnt;
|
|
static volatile BOOL g_bKeyScanAutoPoweroffEn = FALSE;
|
|
//extern BOOL bEnterPoweroff;
|
|
static UINT32 uiSystemAutoPoweroffTime = KEYSCAN_AUTOPOWEROFF_DISABLED;
|
|
static UINT32 uiLCDAutoPoweroffTime = KEYSCAN_AUTOPOWEROFF_DISABLED;
|
|
static UINT32 uiLCDAutoPoweroffTime_L = KEYSCAN_AUTOPOWEROFF_DISABLED;
|
|
static UINT32 uiLCDAutoPoweroffTime_D = KEYSCAN_AUTOPOWEROFF_DISABLED;
|
|
static UINT32 ubBatteryLevel = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
static UINT32 uiPrevBatteryLvl = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
static UINT32 uiBatteryLvl = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
GX_CALLBACK_PTR g_fpPowerCB = NULL;
|
|
static BOOL g_bBatteryDetEn = TRUE;
|
|
static UINT32 uiChargeCount = 0;
|
|
static UINT32 uiReChargeCount = 0;
|
|
static BOOL bIsReCharge = FALSE;
|
|
static UINT32 ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_NORMAL;
|
|
static UINT32 normalTempChargeCurrent;
|
|
static BOOL g_bIgnoreDet = FALSE;
|
|
|
|
#define CHARGE_OK_STABLE_COUNT 3
|
|
|
|
//extern void xGxPower_InstallCmd(void);
|
|
|
|
UINT32 GxPower_Open(DX_HANDLE hPwr, GX_CALLBACK_PTR DxPower_CB)
|
|
{
|
|
//xGxPower_InstallCmd();
|
|
UINT32 uiDxState = 0;
|
|
power_obj = hPwr;
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return GX_ERROR_INITDEVICE;
|
|
}
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_IS_DUMMUYLOAD_POWEROFF, &uiDxState)) {
|
|
ubBatteryLevel = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
} else {
|
|
Dx_Init(power_obj, NULL, (DX_CALLBACK_PTR)DxPower_CB, 0);
|
|
// DrvPower_PowerOnInit();
|
|
}
|
|
if (Dx_Open((DX_HANDLE)power_obj) != DX_OK) { //here will update current size to INFOBUF
|
|
DBG_ERR("Dx_Open fail\r\n");
|
|
return GX_ERROR_INITDEVICE;
|
|
}
|
|
return GX_OK;
|
|
}
|
|
|
|
UINT32 GxPower_Close(void)
|
|
{
|
|
UINT32 ret;
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return GX_ERROR_INITDEVICE;
|
|
}
|
|
ret = Dx_Close(power_obj);
|
|
if (DX_OK != ret && DX_NOT_OPEN != ret) {
|
|
DBG_ERR("Dx_Close fail, err: %d\r\n", ret);
|
|
return GX_ERROR_INITDEVICE;
|
|
}
|
|
power_obj = 0;
|
|
return GX_OK;
|
|
}
|
|
|
|
static UINT32 GxPower_MapBattLvl(UINT32 DxpwrLvl)
|
|
{
|
|
UINT32 rtnlvl = 0;
|
|
|
|
switch (DxpwrLvl) {
|
|
case DRVPWR_BATTERY_LVL_UNKNOWN:
|
|
rtnlvl = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_EMPTY:
|
|
rtnlvl = VOLDET_BATTERY_LVL_EMPTY;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_0:
|
|
rtnlvl = VOLDET_BATTERY_LVL_0;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_1:
|
|
rtnlvl = VOLDET_BATTERY_LVL_1;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_2:
|
|
rtnlvl = VOLDET_BATTERY_LVL_2;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_3:
|
|
rtnlvl = VOLDET_BATTERY_LVL_3;
|
|
break;
|
|
case DRVPWR_BATTERY_LVL_4:
|
|
rtnlvl = VOLDET_BATTERY_LVL_4;
|
|
break;
|
|
default:
|
|
DBG_ERR("Unknown BattLvl %d\r\n", DxpwrLvl);
|
|
break;
|
|
}
|
|
return rtnlvl;
|
|
}
|
|
|
|
/**
|
|
Detect battery voltage level
|
|
|
|
Detect battery voltage level and store it in uiBatteryLvl (static variable)
|
|
If the battery voltage is VOLDET_BATTERY_LVL_EMPTY, then power off the system.
|
|
[KeyScan internal API]
|
|
|
|
@param void
|
|
@return void
|
|
*/
|
|
void GxPower_DetBattery(void)
|
|
{
|
|
#define EMPTY_BATT_COUNT 2
|
|
//static UINT32 u32EmptyBattCount = 0;
|
|
static BOOL bLockBattery = FALSE;
|
|
UINT32 uiDxStatus = 0;
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return;
|
|
}
|
|
|
|
if ((GxPower_GetControl(GXPWR_CTRL_BATTERY_DETECT_EN))) {
|
|
|
|
//uiBatteryLvl = GxPower_MapBattLvl(DrvPower_GetControl(DRVPWR_CTRL_BATTERY_LEVEL));
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_LEVEL, &uiDxStatus) == DX_OK) {
|
|
|
|
uiBatteryLvl = GxPower_MapBattLvl(uiDxStatus);
|
|
} else {
|
|
DBG_ERR("Dx_GetState get DRVPWR_CTRL_BATTERY_LEVEL error\r\n");
|
|
}
|
|
}
|
|
if (uiBatteryLvl == VOLDET_BATTERY_LVL_EMPTY) {
|
|
if (g_fpPowerCB) {
|
|
g_fpPowerCB(POWER_CB_BATT_EMPTY, 0, 0);
|
|
}
|
|
} else if ((uiPrevBatteryLvl == VOLDET_BATTERY_LVL_UNKNOWN)
|
|
&& (uiBatteryLvl != VOLDET_BATTERY_LVL_UNKNOWN)) {
|
|
//this is first time detect
|
|
ubBatteryLevel = uiBatteryLvl;
|
|
uiPrevBatteryLvl = uiBatteryLvl;
|
|
if (g_fpPowerCB) {
|
|
g_fpPowerCB(POWER_CB_BATT_CHG, 0, 0);
|
|
}
|
|
} else if (!Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, &uiDxStatus)) { //use power
|
|
if ((uiPrevBatteryLvl > uiBatteryLvl) && (!bLockBattery)) {
|
|
ubBatteryLevel = uiBatteryLvl;
|
|
uiPrevBatteryLvl = uiBatteryLvl;
|
|
if (g_fpPowerCB) {
|
|
g_fpPowerCB(POWER_CB_BATT_CHG, 0, 0);
|
|
}
|
|
}
|
|
} else { //charge power
|
|
if ((uiPrevBatteryLvl < uiBatteryLvl) && (!bLockBattery)) {
|
|
ubBatteryLevel = uiBatteryLvl;
|
|
uiPrevBatteryLvl = uiBatteryLvl;
|
|
if (g_fpPowerCB) {
|
|
g_fpPowerCB(POWER_CB_BATT_CHG, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
if (u32EmptyBattCount) {
|
|
u32EmptyBattCount++;
|
|
if (u32EmptyBattCount > EMPTY_BATT_COUNT) {
|
|
g_fpPowerCB(POWER_CB_BATT_EMPTY, 0, 0);
|
|
}
|
|
}
|
|
if (uiBatteryLvl == VOLDET_BATTERY_LVL_EMPTY) {
|
|
u32EmptyBattCount ++;
|
|
bLockBattery = TRUE;
|
|
}
|
|
#else
|
|
#endif
|
|
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_IS_BATT_OVERHEAT, &uiDxStatus)) {
|
|
if (g_fpPowerCB) {
|
|
g_fpPowerCB(POWER_CB_BATT_OVERHEAT, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Detect auto power off
|
|
|
|
Detect auto power off.
|
|
If the auto power off counter reach auto power off setting, then do power off
|
|
[KeyScan internal API]
|
|
|
|
@param void
|
|
@return void
|
|
*/
|
|
void GxPower_DetAutoPoweroff(void)
|
|
{
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return;
|
|
}
|
|
|
|
if ((GxPower_GetControl(GXPWR_CTRL_AUTOPOWEROFF_TIME) != KEYSCAN_AUTOPOWEROFF_DISABLED)
|
|
&& (g_bKeyScanAutoPoweroffEn == TRUE)) {
|
|
DBG_IND("AutoPwrOff Cnt = %d\r\n", g_uiKeyScanAutoPoweroffCnt);
|
|
|
|
g_uiKeyScanAutoPoweroffCnt++;
|
|
|
|
if (g_uiKeyScanAutoPoweroffCnt >= GxPower_GetControl(GXPWR_CTRL_AUTOPOWEROFF_TIME)) {
|
|
DBG_IND("Do AutoPwrOff!\r\n");
|
|
g_fpPowerCB(POWER_CB_POWEROFF, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void GxPower_DetSleep(void)
|
|
{
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return;
|
|
}
|
|
|
|
if (g_bKeyScanResetSleeping) {
|
|
g_bKeyScanResetSleeping = FALSE;
|
|
GxPower_SetControl(GXPWR_CTRL_AUTOSLEEP_EN, 0xff); //reset
|
|
}
|
|
if ((!g_bKeyScanSleepEn) || (g_uiKeyScanSleepLevel == 3)) {
|
|
return;
|
|
}
|
|
|
|
if (GxPower_GetControl(GXPWR_CTRL_AUTOSLEEP_TIME) != 0) {
|
|
UINT32 OffTime = GxPower_GetControl(GXPWR_CTRL_AUTOSLEEP_TIME) ;
|
|
UINT32 OffTime_L = GxPower_GetControl(GXPWR_CTRL_AUTOSLEEP_TIME_L) ;
|
|
UINT32 OffTime_D = GxPower_GetControl(GXPWR_CTRL_AUTOSLEEP_TIME_D) ;
|
|
|
|
DBG_IND("AutoSleep Cnt = %d\r\n", g_uiKeyScanSleepCnt);
|
|
|
|
g_uiKeyScanSleepCnt++;
|
|
|
|
if ((OffTime_L > 0) && (g_uiKeyScanSleepCnt == OffTime_L)) {
|
|
g_uiKeyScanSleepLevel = 1;
|
|
DBG_IND("Do AutoSleep level 1\r\n");
|
|
g_fpPowerCB(POWER_CB_SLEEP_ENTER_L, 0, 0);
|
|
}
|
|
if ((OffTime > 0) && (g_uiKeyScanSleepCnt == OffTime)) {
|
|
g_uiKeyScanSleepLevel = 2;
|
|
DBG_IND("Do AutoSleep level 2\r\n");
|
|
g_fpPowerCB(POWER_CB_SLEEP_ENTER, 0, 0);
|
|
}
|
|
if ((OffTime_D > 0) && (g_uiKeyScanSleepCnt == OffTime_D)) {
|
|
g_uiKeyScanSleepLevel = 3;
|
|
DBG_IND("Do AutoSleep level 3\r\n");
|
|
g_fpPowerCB(POWER_CB_SLEEP_ENTER_D, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GxPower_DetCharge(void)
|
|
{
|
|
INT32 temperature;
|
|
UINT32 uiDxState = 0;
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return;
|
|
}
|
|
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, &uiDxState)) {
|
|
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_OK, &uiDxState) && uiReChargeCount > CHARGE_OK_STABLE_COUNT) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, TRUE);
|
|
g_fpPowerCB(POWER_CB_CHARGE_OK, 0, 0);
|
|
DBG_DUMP("Charge OK\r\n");
|
|
}
|
|
|
|
else if (Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_OK, &uiDxState) && uiChargeCount > CHARGE_OK_STABLE_COUNT) {
|
|
|
|
if (Dx_GetState(power_obj, DRVPWR_CTRL_IS_NEED_RECHARGE, &uiDxState) && bIsReCharge == FALSE) {
|
|
// need to set ISET false and recharge again.
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, FALSE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
|
|
SwTimer_DelayMs(10);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, TRUE);
|
|
bIsReCharge = TRUE;
|
|
} else {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
g_fpPowerCB(POWER_CB_CHARGE_OK, 0, 0);
|
|
DBG_DUMP("Charge OK\r\n");
|
|
}
|
|
}
|
|
|
|
temperature = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_TEMPERATURE, &uiDxState);
|
|
//#NT#2011/04/19#Lincy Lin -begin
|
|
//#NT#add control for batt not have Temperature Sensor
|
|
if (temperature == BATTERY_TEMPERATURE_UNKNOWN) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
g_fpPowerCB(POWER_CB_CHARGE_OK, 0, 0);
|
|
DBG_DUMP("Charge OK\r\n");
|
|
}
|
|
//#NT#2011/04/19#Lincy Lin -end
|
|
else if (temperature > CHARGE_TEMPERATURE_HIGH) {
|
|
if (ChargeTemperatureSts != CHARGE_TEMPERATURE_STATUS_HIGH) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_HIGH;
|
|
g_fpPowerCB(POWER_CB_CHARGE_SUSPEND, 0, 0);
|
|
DBG_ERR("Charge Temp High\r\n");
|
|
}
|
|
|
|
} else if (temperature > CHARGE_TEMPERATURE_MEDIUM) {
|
|
if (ChargeTemperatureSts != CHARGE_TEMPERATURE_STATUS_MEDIUM) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, TRUE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_VSET, FALSE);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_MEDIUM;
|
|
DBG_ERR("Charge Temp Med\r\n");
|
|
}
|
|
} else if (temperature < CHARGE_TEMPERATURE_COLD) {
|
|
if (ChargeTemperatureSts != CHARGE_TEMPERATURE_STATUS_COLD) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, FALSE);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_COLD;
|
|
g_fpPowerCB(POWER_CB_CHARGE_SUSPEND, 0, 0);
|
|
DBG_ERR("Charge Temp Cold\r\n");
|
|
}
|
|
} else if (temperature < CHARGE_TEMPERATURE_LOW) {
|
|
if (ChargeTemperatureSts != CHARGE_TEMPERATURE_STATUS_LOW) {
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_LOW;
|
|
normalTempChargeCurrent = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, &uiDxState);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, BATTERY_CHARGE_CURRENT_MEDIUM);
|
|
DBG_ERR("Charge Temp low\r\n");
|
|
}
|
|
} else {
|
|
if (ChargeTemperatureSts != CHARGE_TEMPERATURE_STATUS_NORMAL) {
|
|
if ((ChargeTemperatureSts == CHARGE_TEMPERATURE_STATUS_MEDIUM) && (temperature <= CHARGE_TEMPERATURE_MEDIUM - CHARGE_TEMPERATURE_TH)) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, TRUE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_VSET, TRUE);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_NORMAL;
|
|
DBG_ERR("Charge Temp medium -> normal\r\n");
|
|
} else if ((ChargeTemperatureSts == CHARGE_TEMPERATURE_STATUS_LOW) && (temperature >= CHARGE_TEMPERATURE_LOW + CHARGE_TEMPERATURE_TH)) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, TRUE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_VSET, TRUE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, normalTempChargeCurrent);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_NORMAL;
|
|
DBG_ERR("Charge Temp low -> normal\r\n");
|
|
}
|
|
}
|
|
}
|
|
uiChargeCount++;
|
|
if (bIsReCharge) {
|
|
uiReChargeCount++;
|
|
}
|
|
DBG_IND("[charge]Cnt=%d,Rcnt=%d,Rchg=%d,Curr=%d,ISET=%d,VSET=%d,En=%d,OK=%d,AD=%d,Tmp=%d,TmpS=%d\r\n"\
|
|
, uiChargeCount, uiReChargeCount, bIsReCharge\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_VSET, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_OK, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_ADC_VALUE, &uiDxState)\
|
|
, Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_TEMPERATURE, &uiDxState)\
|
|
, ChargeTemperatureSts);
|
|
{
|
|
#if 0
|
|
struct tm cDateTime = GxSysTime_GetValue();
|
|
DBG_IND("[charge]H=%d, M=%d, S=%d\r\n", cDateTime.tm_hour, cDateTime.tm_min, cDateTime.tm_sec);
|
|
#endif
|
|
}
|
|
} else if (ChargeTemperatureSts == CHARGE_TEMPERATURE_STATUS_HIGH) {
|
|
|
|
temperature = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_TEMPERATURE, &uiDxState);
|
|
if (temperature <= CHARGE_TEMPERATURE_HIGH - CHARGE_TEMPERATURE_TH) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, TRUE);
|
|
g_fpPowerCB(POWER_CB_CHARGE_RESUME, 0, 0);
|
|
}
|
|
} else if (ChargeTemperatureSts == CHARGE_TEMPERATURE_STATUS_COLD) {
|
|
temperature = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_TEMPERATURE, &uiDxState);
|
|
if (temperature >= (CHARGE_TEMPERATURE_COLD + CHARGE_TEMPERATURE_TH)) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, TRUE);
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_LOW;
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, BATTERY_CHARGE_CURRENT_MEDIUM);
|
|
DBG_ERR("Charge Temp cold -> low\r\n");
|
|
g_fpPowerCB(POWER_CB_CHARGE_RESUME, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
UINT32 GxPower_GetPwrKey(GXPWR_KEY kid)
|
|
{
|
|
UINT32 getv = 0;
|
|
UINT32 key;
|
|
if (!power_obj) {
|
|
return 0;
|
|
}
|
|
|
|
switch (kid) {
|
|
case GXPWR_KEY_POWER1:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_PSW1, (UINT32*)&key);
|
|
break;
|
|
case GXPWR_KEY_HWRESET:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_HWRT, (UINT32*)&key);
|
|
break;
|
|
case GXPWR_KEY_SWRESET:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_SWRT, (UINT32*)&key);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return getv;
|
|
}
|
|
|
|
void GxPower_SetPwrKey(GXPWR_KEY kid, UINT32 key)
|
|
{
|
|
if (!power_obj) {
|
|
return;
|
|
}
|
|
|
|
switch (kid) {
|
|
case GXPWR_KEY_POWER1:
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_PSW1, key);
|
|
break;
|
|
case GXPWR_KEY_HWRESET:
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_HWRT, key);
|
|
break;
|
|
case GXPWR_KEY_SWRESET:
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_SWRT, key);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
UINT32 GxPower_GetControl(GXPWR_CTRL PowerCtrl)
|
|
{
|
|
UINT32 getv = 0;
|
|
UINT32 uiDxState = 0;
|
|
if (!power_obj) {
|
|
return 0;
|
|
}
|
|
|
|
switch (PowerCtrl) {
|
|
case GXPWR_CTRL_POWERON_DETECT_EN:
|
|
getv = 0;
|
|
break;
|
|
case GXPWR_CTRL_POWERON_SRC:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_POWERON_SOURCE, &uiDxState);
|
|
getv =uiDxState;
|
|
break;
|
|
case GXPWR_CTRL_POWERON_LOST:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_POWER_LOST, &uiDxState); //"firs time power-on" or "lost power of Gold capacitor"
|
|
getv =uiDxState;
|
|
break;
|
|
case GXPWR_CTRL_AUTOPOWEROFF_EN:
|
|
getv = (UINT32)g_bKeyScanAutoPoweroffEn;
|
|
break;
|
|
case GXPWR_CTRL_AUTOPOWEROFF_TIME:
|
|
getv = uiSystemAutoPoweroffTime;
|
|
break;
|
|
|
|
case GXPWR_CTRL_SLEEP_LEVEL:
|
|
getv = g_uiKeyScanSleepLevel;
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_EN:
|
|
getv = (UINT32)g_bKeyScanSleepEn;
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME:
|
|
getv = uiLCDAutoPoweroffTime;
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME_L:
|
|
getv = uiLCDAutoPoweroffTime_L;
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME_D:
|
|
getv = uiLCDAutoPoweroffTime_D;
|
|
break;
|
|
|
|
case GXPWR_CTRL_BATTERY_DETECT_EN:
|
|
getv = (UINT32)g_bBatteryDetEn;
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_LEVEL:
|
|
getv = ubBatteryLevel;
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_IS_INSERT:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_IS_BATT_INSERT, &uiDxState);
|
|
//DBG_IND("[charge] IsBattIn=%d\r\n",getv);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_IS_DEAD:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_IS_DEAD_BATT, &uiDxState);
|
|
//DBG_IND("[charge] IsDeatBatt=%d\r\n",getv);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_CHARGE_EN:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, &uiDxState);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_CHARGE_OK:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_OK, &uiDxState);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_POWERON_CHECK_EN:
|
|
getv = (UINT32)(g_bIgnoreDet)?(0):(1);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_FAIL_POWEROFF_EN:
|
|
getv = Dx_GetState(power_obj, DRVPWR_CTRL_IS_DUMMUYLOAD_POWEROFF, &uiDxState);
|
|
break;
|
|
default:
|
|
DBG_ERR("PowerCtrl(%d)\r\n", PowerCtrl);
|
|
getv = 0;
|
|
break;
|
|
}
|
|
return getv;
|
|
}
|
|
|
|
void GxPower_SetControl(GXPWR_CTRL PowerCtrl, UINT32 value)
|
|
{
|
|
if (!power_obj) {
|
|
DBG_ERR("can not get Dx power object\r\n");
|
|
return;
|
|
}
|
|
|
|
DBG_IND("cmd=(%d), value=%d\r\n", PowerCtrl, value);
|
|
switch (PowerCtrl) {
|
|
case GXPWR_CTRL_POWERON_DETECT_EN:
|
|
break;
|
|
case GXPWR_CTRL_AUTOPOWEROFF_EN:
|
|
if (value == 0xff) {
|
|
//reset
|
|
g_uiKeyScanAutoPoweroffCnt = 0;
|
|
} else {
|
|
if (g_bKeyScanAutoPoweroffEn == FALSE && value == TRUE) {
|
|
g_uiKeyScanAutoPoweroffCnt = 0;
|
|
}
|
|
g_bKeyScanAutoPoweroffEn = (INT32)value;
|
|
}
|
|
break;
|
|
case GXPWR_CTRL_AUTOPOWEROFF_TIME:
|
|
uiSystemAutoPoweroffTime = value;
|
|
DBG_IND("AutoPwrOff Max cnt = %d\r\n", uiSystemAutoPoweroffTime);
|
|
break;
|
|
|
|
case GXPWR_CTRL_AUTOSLEEP_EN:
|
|
if (value == 0xff) {
|
|
//reset
|
|
if (g_uiKeyScanSleepCnt && g_bKeyScanSleepEn) {
|
|
g_uiKeyScanSleepCnt = 0;
|
|
if (g_uiKeyScanSleepLevel > 0) {
|
|
g_fpPowerCB(POWER_CB_SLEEP_RESET, 0, 0);
|
|
g_uiKeyScanSleepLevel = 0;
|
|
}
|
|
}
|
|
} else {
|
|
g_bKeyScanSleepEn = (INT32)value;
|
|
}
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME:
|
|
uiLCDAutoPoweroffTime = value;
|
|
DBG_IND("AutoSleep Max2 cnt = %d\r\n", uiLCDAutoPoweroffTime);
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME_L:
|
|
uiLCDAutoPoweroffTime_L = value;
|
|
DBG_IND("AutoSleep Max1 cnt = %d\r\n", uiLCDAutoPoweroffTime_L);
|
|
break;
|
|
case GXPWR_CTRL_AUTOSLEEP_TIME_D:
|
|
uiLCDAutoPoweroffTime_D = value;
|
|
DBG_IND("AutoSleep Max3 cnt = %d\r\n", uiLCDAutoPoweroffTime_D);
|
|
break;
|
|
|
|
case GXPWR_CTRL_BATTERY_DETECT_EN:
|
|
g_bBatteryDetEn = (INT32)value;
|
|
if (value) {
|
|
uiPrevBatteryLvl = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
uiBatteryLvl = VOLDET_BATTERY_LVL_UNKNOWN;
|
|
}
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_CHARGE_EN:
|
|
if (value == TRUE) {
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_ISET, TRUE);
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_VSET, TRUE);
|
|
|
|
}
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_EN, value);
|
|
DBG_IND("[charge] Encharge =%d\r\n", value);
|
|
uiChargeCount = 0;
|
|
uiReChargeCount = 0;
|
|
bIsReCharge = FALSE;
|
|
ChargeTemperatureSts = CHARGE_TEMPERATURE_STATUS_NORMAL;
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_CHARGE_CURRENT:
|
|
Dx_SetState(power_obj, DRVPWR_CTRL_BATTERY_CHARGE_CURRENT, value);
|
|
DBG_IND("[charge] Charge Current=%d\r\n", value);
|
|
break;
|
|
case GXPWR_CTRL_BATTERY_POWERON_CHECK_EN:
|
|
g_bIgnoreDet = (BOOL)(value)?(0):(1);
|
|
break;
|
|
default:
|
|
DBG_ERR("PowerCtrl(%d)\r\n", PowerCtrl);
|
|
break;
|
|
}
|
|
}
|
|
|
|
UINT32 GxPower_DummyLoad(void)
|
|
{
|
|
return DrvPower_DummyLoad();
|
|
}
|
|
|
|
void GxPower_RegCB(GX_CALLBACK_PTR fpPowerCB)
|
|
{
|
|
g_fpPowerCB = fpPowerCB;
|
|
}
|
|
|
|
#if 0
|
|
void GxPower_OnSystem(int cmd)
|
|
{
|
|
switch (cmd) {
|
|
case SYSTEM_CMD_POWERON:
|
|
if (g_fpPowerCB) {
|
|
(*g_fpPowerCB)(SYSTEM_CB_CONFIG, 0, 0);
|
|
}
|
|
GxPower_PowerON();
|
|
break;
|
|
|
|
case SYSTEM_CMD_POWEROFF:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Date-Time util
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static struct tm g_ctv_zero = {0};
|
|
|
|
UINT32 GxPower_GetTime(GXTIME_ID tid, struct tm* p_ctv)
|
|
{
|
|
if (!power_obj) {
|
|
*(p_ctv) = g_ctv_zero;
|
|
return 0;
|
|
}
|
|
|
|
switch (tid) {
|
|
case GXTIME_HWRESET:
|
|
Dx_Control(power_obj, DRVPWR_CTRL_HWRT_TIME, 1, (UINT32)p_ctv);//1=read
|
|
break;
|
|
case GXTIME_SWRESET:
|
|
Dx_Control(power_obj, DRVPWR_CTRL_SWRT_TIME, 1, (UINT32)p_ctv);//1=read
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void GxPower_SetTime(GXTIME_ID tid, struct tm ctv, UINT32 param)
|
|
{
|
|
if (!power_obj) {
|
|
return;
|
|
}
|
|
|
|
switch (tid) {
|
|
case GXTIME_HWRESET:
|
|
Dx_Control(power_obj, DRVPWR_CTRL_HWRT_TIME, 0, (UINT32)&ctv); //0=write
|
|
break;
|
|
case GXTIME_SWRESET:
|
|
Dx_Control(power_obj, DRVPWR_CTRL_SWRT_TIME, 0, (UINT32)&ctv); //0=write
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//@}
|