📄 pwic.c
字号:
#ifdef _USB_VBUS_DETECT_WITH_NIRQ_
kal_uint16 delay;
kal_bool status=KAL_FALSE;
kal_uint32 nirq_status;
kal_uint32 level;
#ifdef __OTG_ENABLE__
if(OTG_PowerOn_Is_A_Plug()==KAL_TRUE)
return KAL_FALSE;
#endif
/*GPIO mode setting*/
#ifdef __CUST_NEW__
GPIO_DinvSetup(36, KAL_TRUE);
#else
GPIO_ModeSetup(36, 0x01);
/* inverse, plug in detect high*/
DRV_WriteReg(GPIO_DINV3, DRV_Reg(GPIO_DINV3)|0x0010);
#endif /* __CUST_NEW__ */
/*level trigger*/
level=DRV_Reg32(IRQ_SENSL);
DRV_WriteReg32(IRQ_SENSL, (level|0x00040000));
IRQUnmask(IRQ_GPII_CODE);
for(delay=0;delay<300;delay++);
nirq_status=DRV_Reg32(IRQ_STS2);
if(nirq_status&0x12)
status=KAL_TRUE;
IRQMask(IRQ_GPII_CODE);
return status;
#else
return KAL_TRUE;
#endif
}
#if !defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)
charger_usb_present_enum PW_is_charger_usb_present(void)
{
kal_uint16 status;
kal_uint16 delay;
// charger triggers CHRDET_EINT_NO
// USB triggers CHRDET_EINT_NO and USB_EINT_NO
#if !defined(MT6318)
/***********External Interrupt bug fix *********************/
/**/ *EINT_MASK &= (kal_uint16)(~EINT_MASK_EINT(gCHRDET_EINT_NO)); /**/
/**/ EINTaddr(gCHRDET_EINT_NO) = EINT_CON_HIGHLEVEL; /**/
/**/ /*HW bug fix*/ /**/
/**/ *EINT_INTACK = EINT_INTACK_EINT(gCHRDET_EINT_NO); /**/
#ifdef __USB_ENABLE__
if (gUSB_EINT_NO != EINT_CHANNEL_NOT_EXIST) {
/**/ *EINT_MASK &= (kal_uint16)(~EINT_MASK_EINT(gUSB_EINT_NO));
/**/ EINTaddr(gUSB_EINT_NO) = EINT_CON_HIGHLEVEL;
/**/ *EINT_INTACK = EINT_INTACK_EINT(gUSB_EINT_NO);
}
#endif
/**/ for(delay=0;delay<500;delay++); /**/
/**/ status = *EINT_STATUS; /**/
/**/ EINT_Mask(gCHRDET_EINT_NO); /**/
/**/ *EINT_INTACK = EINT_INTACK_EINT(gCHRDET_EINT_NO); /**/
#ifdef __USB_ENABLE__
if (gUSB_EINT_NO != EINT_CHANNEL_NOT_EXIST) {
/**/ EINT_Mask(gUSB_EINT_NO);
/**/ *EINT_INTACK = EINT_INTACK_EINT(gUSB_EINT_NO);
}
#endif
/**/ IRQClearInt(IRQ_EIT_CODE); /**/
/******************************External Interrupt bug fix *************/
#endif // !defined(MT6318)
#if defined(MT6318)
if(pmic_is_chr_det(AC_CHR))
return CHARGER_PRESENT;
#ifdef __USB_ENABLE__
else if(pmic_is_chr_det(USB_CHR))
return USB_PRESENT;
#endif
#else // MT6318
if (status & EINT_STATUS_EINT(gCHRDET_EINT_NO))
{
#ifdef __USB_ENABLE__
#ifdef _USB_VBUS_DETECT_WITH_NIRQ_
if(PW_is_usb_present())
#else
if (gUSB_EINT_NO != EINT_CHANNEL_NOT_EXIST && (status & EINT_STATUS_EINT(gUSB_EINT_NO)))
#endif
{
return USB_PRESENT;
}
#endif // __USB_ENABLE__
return CHARGER_PRESENT;
}
#ifdef _USB_VBUS_DETECT_WITH_NIRQ_
else if(PW_is_usb_present())
{
return USB_PRESENT;
}
#endif
#endif // MT6318
return NO_PRESENT;
}
#else //__CHARGER_USB_DETECT_WIHT_ONE_EINT__
#if 0/*XXXXX*/
#if defined(MT6318)
/* under construction !*/
#endif
#endif
charger_usb_present_enum PW_is_charger_usb_present(void)
{
kal_uint16 status,delay,adc=0;
kal_int32 volt;
kal_uint8 eint;
kal_uint8 adc_channel;
extern chr_usb_detect_struct chr_usb_detect;
eint = chr_usb_detect.chr_usb_eint;
adc_channel = chr_usb_detect.chr_usb_adc;
#if defined(MT6305)
*EINT_MASK &= (kal_uint16)(~EINT_MASK_EINT(eint));
EINTaddr(eint) = EINT_CON_HIGHLEVEL;
*EINT_INTACK = EINT_INTACK_EINT(eint);
for(delay=0;delay<500;delay++);
status = *EINT_STATUS;
EINT_Mask(eint);
*EINT_INTACK = EINT_INTACK_EINT(eint);
if (status & EINT_STATUS_EINT(eint))
#else
if(pmic_is_chr_det(AC_CHR))
#endif
{
extern charger_usb_present_enum bmt_check_ac_usb(kal_int32 vol);
charger_usb_present_enum state;
// use adc to distinguish between charger & usb
USB_PowerControl(KAL_TRUE);
DRV_Reg(DRVPDN_CON2_CLR) = DRVPDN_CON2_AUXADC;
if(adc_channel<ADC_MAX_CHANNEL)
adc = ADC_GetData(adc_channel);
DRV_Reg(DRVPDN_CON2_SET) = DRVPDN_CON2_AUXADC;
volt = (kal_int32)((adc_adc2vol(adc_channel, (double)adc)/100)*bmt_charing_para->adc_volt_factor[adc_channel]);
USB_PowerControl(KAL_FALSE);
state=bmt_check_ac_usb(volt);
//if(volt < chr_usb_detect.chr_usb_volt)
if(state==USB_PRESENT)
return USB_PRESENT;
else
return CHARGER_PRESENT;
}
return NO_PRESENT;
}
#endif //__CHARGER_USB_DETECT_WIHT_ONE_EINT__
/*************************************************************************
* FUNCTION
* PW_update_flags
*
* DESCRIPTION
* Update the current state of the nonvolatile flags.
*
* PARAMETERS
* None
*
* RETURNS
*
* GLOBALS AFFECTED
* DRV_COMM_REG2
*
*************************************************************************/
void PW_update_flags(void)
{
kal_uint16 REG_COMM2;
REG_COMM2 = DRV_Reg(DRV_COMM_REG2);
if(BMT.PWRon == PWRKEYPWRON || BMT.PWRon == ABNRESET)
{
REG_COMM2 &= ~(DRV_COMM_REG2_NORMAL_RESET|DRV_COMM_REG2_CHRPWRON|DRV_COMM_REG2_RTCPWRON);
#if defined(__USB_ENABLE__)
REG_COMM2 &= ~(DRV_COMM_REG2_USBMS_PWRON);
#endif
}
else if(BMT.PWRon == CHRPWRON)
{
REG_COMM2 &= ~(DRV_COMM_REG2_NORMAL_RESET|DRV_COMM_REG2_RTCPWRON);
#if defined(__USB_ENABLE__)
REG_COMM2 &= ~(DRV_COMM_REG2_USBMS_PWRON);
#endif
REG_COMM2 |= DRV_COMM_REG2_CHRPWRON;
}
#if defined(__USB_ENABLE__)
else if(BMT.PWRon == USBPWRON)
{
// 1. set when selecting mass storage.
// 2. USB cable is plugged in and powered on.
REG_COMM2 &= ~(DRV_COMM_REG2_NORMAL_RESET|DRV_COMM_REG2_CHRPWRON|DRV_COMM_REG2_RTCPWRON);
REG_COMM2 |= DRV_COMM_REG2_USBMS_PWRON;
}
#endif //__USB_ENABLE__
else if(BMT.PWRon == RTCPWRON)
{
REG_COMM2 &= ~(DRV_COMM_REG2_NORMAL_RESET|DRV_COMM_REG2_CHRPWRON);
#if defined(__USB_ENABLE__)
REG_COMM2 &= ~(DRV_COMM_REG2_USBMS_PWRON);
#endif
REG_COMM2 |= DRV_COMM_REG2_RTCPWRON;
}
DRV_WriteReg(DRV_COMM_REG2,REG_COMM2);
#ifdef BMT_DEBUG
if(BMT.PWRon == PWRKEYPWRON)
DRV_POWERON();
#endif /*BMT_DEBUG*/
BMT.BatType = LIBAT;
#ifndef __CUST_NEW__
//GPIO_WriteIO(KAL_FALSE,bmt_charing_para->GPIO_BATDET);
#endif /* __CUST_NEW__ */
/*BMT struct initialize*/
BMT.call_state = idle_mode;
BMT.pmictrl_state = PMIC_CHARGEOFF;
BMT_Charge(KAL_FALSE);
}
/*************************************************************************
* FUNCTION
* PW_is_precharge_on
*
* DESCRIPTION
* check if phone is in precharge state
*
* PARAMETERS
* None
*
* RETURNS
* KAL_TRUE or KAL_FALSE
*
* GLOBALS AFFECTED
* DRV_COMM_REG2
*
*************************************************************************/
kal_bool PW_is_precharge_on(void)
{
extern kal_uint8 custom_adc_get_channel(adc_channel_type type);
kal_uint8 channel;
kal_uint16 adc;
kal_int32 volt;
channel=custom_adc_get_channel(vbat_adc_channel);
#if defined(__USB_ENABLE__)
USB_PowerControl(KAL_TRUE);
#endif
DRV_Reg(DRVPDN_CON2_CLR) = DRVPDN_CON2_AUXADC;
adc = ADC_GetData(channel);
DRV_Reg(DRVPDN_CON2_SET) = DRVPDN_CON2_AUXADC;
volt = (kal_int32)((adc_adc2vol(channel, (double)adc)/100)*bmt_charing_para->adc_volt_factor[channel]);
#if defined(__USB_ENABLE__)
USB_PowerControl(KAL_FALSE);
#endif
if(volt<=BMT_PRECHARGE_THRESHOLD)
return KAL_TRUE;
else
return KAL_FALSE;
}
/*
* FUNCTION
* PW_PowerInit
*
* DESCRIPTION
* This function is the initial function when power on.
* 1. Check which source power on
* 2. Configure the external interrupt(Battery remove, Charger in/out)
* 3. Initialize the setting of charge module.
* 4. update the nonvolatile flags.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void PW_PowerInit(void)
{
#if ( (defined(MT6208)) || (defined(FPGA)) )
kal_uint32 delay;
#endif
kal_uint8 RTC_Firston;
kal_uint16 REG_COMM2;
kal_bool factors[PWR_FACTOR_MAX] = {0};
REG_COMM2 = DRV_Reg(DRV_COMM_REG2);
RTC_Firston = RTC_isFisrtOn();
if (RTC_Firston)
{
#if ( (defined(MT6205B)) || (defined(MT6218)) || (defined(MT6218B))|| (defined(MT6219))||(defined(MT6217))||(defined(MT6228))|| defined(MT6229) || defined(MT6230)|| (defined(MT6226))|| (defined(MT6227))||defined(MT6226M) )
REG_COMM2 = DRV_COMM_REG2_NORMAL_RESET;
DRV_WriteReg(DRV_COMM_REG2,REG_COMM2);
#endif
#if ( (defined(MT6205)) || (defined(MT6205B)) || (defined(MT6218))|| (defined(MT6218B))|| (defined(MT6219)) ||(defined(MT6217))||(defined(MT6228))|| defined(MT6229) || defined(MT6230)|| (defined(MT6226))|| (defined(MT6227))||defined(MT6226M) )
wait_32k_start();
#elif ( (defined(MT6208)) || (defined(FPGA)) )
for(delay=0;delay<22030000;delay++);
#endif
}
#if ( (defined(MT6205)) || (defined(MT6208)) || (defined(FPGA)))
// initialize ADC
DRV_WriteReg(AUXADC_CTRL2,AUXADC_CTRL2_MON);
#endif /*(MT6205,MT6208,FPGA)*/
#ifdef __MULTI_BOOT__
if (INT_BootMode() != MTK_NORMAL_MODE)
{
BMT.PWRon = PWRKEYPWRON;
DRV_POWERON();
return;
}
#endif /*__MULTI_BOOT__*/
// collect all factors
// check RTC expired
if(PW_is_RTC_expired())
factors[PWR_FACTOR_RTC_EXPIRE] = KAL_TRUE;
// check power key pressed
if(PowerKey_Pressed())
factors[PWR_FACTOR_POWER_KEY] = KAL_TRUE;
// check charger or usb existence
switch (PW_is_charger_usb_present())
{
case CHARGER_PRESENT:
factors[PWR_FACTOR_CHARGER_IN] = KAL_TRUE;
break;
case USB_PRESENT:
factors[PWR_FACTOR_USB_IN] = KAL_TRUE;
break;
case NO_PRESENT:
break;
}
/*check Precharge*/
if (factors[PWR_FACTOR_CHARGER_IN]==KAL_TRUE)
{
if(PW_is_precharge_on())
factors[PWR_FACTOR_PRECHRPWRON_FLG] = KAL_TRUE;
}
// check watch dog reset
if(WDT_RST)
{
factors[PWR_FACTOR_WDT_RESET] = KAL_TRUE;
is_wdt_power=KAL_TRUE;/*for NFB*/
}
// check flags
if(REG_COMM2 & DRV_COMM_REG2_NORMAL_RESET)
factors[PWR_FACTOR_NORMAL_RESET_FLG] = KAL_TRUE;
if(REG_COMM2 & DRV_COMM_REG2_CHRPWRON)
factors[PWR_FACTOR_CHRPWRON_FLG] = KAL_TRUE;
if(REG_COMM2 & DRV_COMM_REG2_USBMS_PWRON)
factors[PWR_FACTOR_USBMS_PWRON_FLG] = KAL_TRUE;
if(REG_COMM2 & DRV_COMM_REG2_RTCPWRON)
factors[PWR_FACTOR_RTCPWRON_FLG] = KAL_TRUE;
// check power on type
// priority: PWRKEYPWRON > ABNRESET > CHRPWRON > USBPWRON_WDT > USBPWRON > RTCPWRON
if(factors[PWR_FACTOR_PRECHRPWRON_FLG])
{
BMT.PWRon = CHRPWRON;//PRECHRPWRON
}
else if((factors[PWR_FACTOR_POWER_KEY]&& !factors[PWR_FACTOR_CHARGER_IN]&& !factors[PWR_FACTOR_USB_IN])||
(factors[PWR_FACTOR_POWER_KEY]&& factors[PWR_FACTOR_CHARGER_IN]&& factors[PWR_FACTOR_WDT_RESET]&& factors[PWR_FACTOR_CHRPWRON_FLG])||
(factors[PWR_FACTOR_POWER_KEY]&& factors[PWR_FACTOR_USB_IN]&& factors[PWR_FACTOR_WDT_RESET]&& factors[PWR_FACTOR_USBMS_PWRON_FLG])||
(factors[PWR_FACTOR_POWER_KEY]&& factors[PWR_FACTOR_CHARGER_IN]&& !factors[PWR_FACTOR_WDT_RESET])||
(factors[PWR_FACTOR_POWER_KEY]&& factors[PWR_FACTOR_USB_IN]&& !factors[PWR_FACTOR_WDT_RESET]))
{
BMT.PWRon = PWRKEYPWRON;
}
#ifdef __PRODUCTION_RELEASE__
else if(factors[PWR_FACTOR_WDT_RESET]&&!factors[PWR_FACTOR_CHRPWRON_FLG]&&!factors[PWR_FACTOR_USBMS_PWRON_FLG]
&&!factors[PWR_FACTOR_RTCPWRON_FLG]&& !factors[PWR_FACTOR_NORMAL_RESET_FLG])
{
BMT.PWRon = ABNRESET;
}
#endif //__PRODUCTION_RELEASE__
else if((factors[PWR_FACTOR_CHARGER_IN]&&!factors[PWR_FACTOR_POWER_KEY])||
(factors[PWR_FACTOR_CHARGER_IN]&&factors[PWR_FACTOR_POWER_KEY]&&!factors[PWR_FACTOR_RTCPWRON_FLG]))
{
BMT.PWRon = CHRPWRON;
}
#ifdef __USB_ENABLE__
else if((factors[PWR_FACTOR_USB_IN]&&!factors[PWR_FACTOR_POWER_KEY]&&factors[PWR_FACTOR_WDT_RESET]&&
!factors[PWR_FACTOR_NORMAL_RESET_FLG]&&factors[PWR_FACTOR_USBMS_PWRON_FLG]))
{
BMT.PWRon = USBPWRON_WDT;
}
else if((factors[PWR_FACTOR_USB_IN]&&!factors[PWR_FACTOR_POWER_KEY])||
(factors[PWR_FACTOR_USB_IN]&&factors[PWR_FACTOR_POWER_KEY]&&!factors[PWR_FACTOR_USBMS_PWRON_FLG])
)
{
BMT.PWRon = USBPWRON;
}
#endif // __USB_ENABLE__
else if((factors[PWR_FACTOR_RTC_EXPIRE]&&!factors[PWR_FACTOR_RTCPWRON_FLG]))
{
BMT.PWRon = RTCPWRON;
}
else
{
kal_uint32 loop=0, wait=0;
kal_uint16 mask=0;
#if 0
/* under construction !*/
/* under construction !*/
#else
while(1)/*to cover crstal oscillates too late case*/
{
mask = DRV_Reg(RTC_AL_MASK);
if((mask&1) == 1)/*make sure user doesn't configure Alarm*/
{
for(loop=0;loop<10000;loop++)
{
/*Diable all alarm mask*/
DRV_WriteReg(RTC_AL_MASK,0);
for(wait=0;wait<10000;wait++){};
mask = DRV_Reg(RTC_AL_MASK);
if(mask==0)
break;
}
}
DRV_POWEROFF();
for(wait=0;wait<50000;wait++){};
}
#endif
}
// reset flags
PW_update_flags();
}
#endif /*(!defined(__L1_STANDALONE__)) && (!defined(MT6208))*/
/*
* FUNCTION
* Modify_PowerOn_Type
*
* DESCRIPTION
* This function is to modify power on type
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void Modify_PowerOn_Type(kal_uint8 powen_type)/*TY add 0218*/
{
kal_uint32 reg;
BMT.PWRon = powen_type;
#if ( (defined(MT6205B)) || (defined(MT6218)) || (defined(MT6218B))|| (defined(MT6219))||(defined(MT6217))||(defined(MT6228))|| defined(MT6229) || defined(MT6230)|| (defined(MT6226))|| (defined(MT6227))||defined(MT6226M) )
if(BMT.PWRon == PWRKEYPWRON)
{
reg = DRV_Reg(DRV_COMM_REG2);
reg &= ~(DRV_COMM_REG2_RTCPWRON);
DRV_WriteReg(DRV_COMM_REG2,reg);
}
#endif
}
kal_bool INT_USBBoot(void)
{
if (BMT.PWRon == USBPWRON)
return KAL_TRUE;
else
return KAL_FALSE;
}
/*
* FUNCTION
* BMT_Charge
*
* DESCRIPTION
* This function is to control the switch of charge
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void BMT_Charge(char data)
{
#if defined(MT6205)
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
#ifdef __CUST_NEW__
GPIO_WriteIO(data, gpio_bmt_chr_ctrl_pin);
#else /* __CUST_NEW__ */
GPIO_WriteIO(data,bmt_charing_para->GPIO_CHRCTRL);
#endif /* __CUST_NEW__ */
RestoreIRQMask(savedMask);
#elif ( (defined(MT6205B)) || (defined(MT6218)) || (defined(MT6218B))|| (defined(MT6219))||(defined(MT6217))||(defined(MT6228))|| defined(MT6229) || defined(MT6230)|| (defined(MT6226))|| (defined(MT6227)) ||defined(MT6226M))
#if defined(MT6318)
if(data==KAL_TRUE)
{
if(KAL_TRUE==pmic_is_chr_det(AC_CHR))/*check if AC exists*/
pmic_chr_enable(data);
if(KAL_TRUE==pmic_is_chr_det(USB_CHR))
{
pmic_usb_enable(data);
pmic_usb_chr_enable(data);
}
}
else
{
pmic_chr_enable(data);
pmic_usb_chr_enable(data);
}
#else
#ifdef __CUST_NEW__
GPIO_WriteIO(data, gpio_bmt_chr_ctrl_pin);
#else /* __CUST_NEW__ */
GPIO_WriteIO(data,bmt_charing_para->GPIO_CHRCTRL);
#endif /* __CUST_NEW__ */
#endif
#endif
}
kal_uint16 clear_ext_intr_init(kal_uint8 eint_no)
{
kal_uint16 delay;
kal_uint16 status;
*EINT_MASK &= (kal_uint16)(~EINT_MASK_EINT(eint_no));
*EINT_INTACK = EINT_INTACK_EINT(eint_no);
for(delay=0;delay<500;delay++);
status = *EINT_STATUS;
EINT_Mask(eint_no);
*EINT_INTACK = EINT_INTACK_EINT(eint_no);
IRQClearInt(IRQ_EIT_CODE);
return status;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -