void adc_pwrdown_enable(void)
{
#ifndef DRV_ADC_NOT_EXIST
#ifndef DRV_ADC_NO_PDN
#if (!defined(DRV_ADC_6208_PWRDOWN)) && (!defined(DRV_ADC_MODEM_SIDE))
if((adc_sche_rw_status==0)&&!(DRV_ADC_Reg(AUXADC_CON) & AUXADC_CON_RUN))
#endif // #if (!defined(DRV_ADC_6208_PWRDOWN)) && (!defined(DRV_ADC_MODEM_SIDE))
{
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_ENABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Enable(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#endif /*ADC_DRVPDN_FAST*/
#else // #if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_ENABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
//DRVPDN_Enable(PDN_ADC);
PDN_SET(PDN_ADC);
L1SM_SleepEnable(ADCSM_handler);
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
}
#endif //#ifndef DRV_ADC_NO_PDN
#endif // #ifndef DRV_ADC_NOT_EXIST
}
void L1sim_PowerOff_All(SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
kal_uint32 simInterface;
sim_HW_cb *hw_cb;
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
if(KAL_TRUE == sim_physicalSlotChanged)
simInterface = 1-simInterface;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
simDriver->addMessage(SIM_AL_ACTION_POWOFF, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
simDriver->powerOff((sim_HW_cb *)(hwCbArray[simInterface]));
simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
}
void bmt_enable_sleepmode(kal_bool enable)
{
if (KAL_TRUE==enable)
{
bmt_sleepmode=KAL_TRUE;
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_cancel_timer(bmt_sw_polling_timerId);
#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(bmt_sm_handle);
#endif
drv_trace0(TRACE_GROUP_10, BMT_SW_ENABLE_SLEEP_MODE);
}
else
{
bmt_sleepmode=KAL_FALSE;
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_ov, NULL,43 , 0);
#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(bmt_sm_handle);
#endif
drv_trace0(TRACE_GROUP_10, BMT_SW_DISABLE_SLEEP_MODE);
}
}
kal_bool L1sim_Set_ClockStopMode_All(sim_clock_stop_enum mode, SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
kal_bool status;
kal_uint32 simInterface;
sim_HW_cb *hw_cb;
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
if(KAL_TRUE == sim_physicalSlotChanged)
simInterface = 1-simInterface;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
status = simDriver->setClockStopMode(mode, (sim_HW_cb *)(hwCbArray[simInterface]));
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
return status;
}
void hif1_lisr(void)
{
#if defined (HIF1_CHANNEL_SUPPORT)
IRQMask(IRQ_HIF_1_CODE);
#endif
//(*(volatile kal_uint32*)HIF_INTSTA_REG(1)) = 0;//hif int status,write clear
HIF_INT_CLEAR(1);
hif_internal_handle[1].DMA_BUSY = KAL_FALSE;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(hif_sleepMode_handle[1]);//lock MD sleep mode
#endif
SLA_CustomLogging("HDM",0);//set for debug
if(hif_internal_handle[1].realtime_callback == KAL_TRUE)
{
if(hif_cb[1])
{
hif_cb[1]();
}
#if defined (HIF1_CHANNEL_SUPPORT)
IRQUnmask(IRQ_HIF_1_CODE);
#endif
}
else
drv_active_hisr((kal_uint8)DRV_HIF1_HISR_ID);
}
void rda_bt_poweroff_for_test(void)
{
pmd_EnablePower(PMD_POWER_BT, FALSE);
hal_GpioClr(g_btdConfig->pinReset);
rdabt_uart_stop();
#ifdef __RDA_SHARE_CRYSTAL__
L1SM_SleepEnable(bt_sleephdl);
#endif
}
/*************************************************************************
* FUNCTION
* PDN_iniEnable
*
* DESCRIPTION
*
* CALLS
*
* PARAMETERS
* MTK_SLEEP_ENABLE is to enable sleep mode
* DRV_SLEEPONLY is only to enable drver sleep mode
*
* RETURNS
*
* GLOBALS AFFECTED
*
* HISTORY
* NAME DATE REMARKS
* Jessen Hu 04-03-2002 Create initial version 1.0
* Rex Luo 04-03-2002 Add comements and function description
*
*************************************************************************/
void DRVPDN_Enable(kal_uint32 addr,kal_uint16 code,kal_uint8 handle)
{
#if defined(MT6205) || defined(MT6208)
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
if ((code == DRVPDN_CON1_UART1) ||
(code == DRVPDN_CON1_UART2)
)
{
;
}
else
DRV_Reg(addr) |= code;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(PDNhandle[handle]);
#endif /*MTK_SLEEP_ENABLE*/
RestoreIRQMask(savedMask);
#else /* MT6205 || MT6208 */
#if defined(MT6208) || defined(MT6205B) || defined(MT6218B) || defined(MT6217)
if ((code == DRVPDN_CON1_UART1) || (code == DRVPDN_CON1_UART2))
#else /* MT6208, MT6205B, MT6218B, MT6217 */
if ((code == DRVPDN_CON1_UART1) || (code == DRVPDN_CON1_UART2) || (code == DRVPDN_CON1_UART3))
#endif /* MT6208, MT6205B, MT6218B, MT6217 */
{
;
}
else
DRV_Reg(addr+0x10) = code;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(PDNhandle[handle]);
#endif /*MTK_SLEEP_ENABLE*/
#endif /*MT6205B,MT6218*/
}
void bmt_enable_sleepmode(kal_bool enable)
{
if (KAL_TRUE == enable)
{
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_cancel_timer(bmt_sw_polling_timerId);
#endif
#if(defined(MTK_SLEEP_ENABLE) && defined(__CENTRALIZED_SLEEP_MANAGER__) && defined(__DRV_BMT_WAKE_UP_TDMA_TIMER__))
{
L1SM_SleepEnable( BMTLockARM_handle ); // should un-lock ARM first
L1SM_IntSleepEnable( BMTLockMD2G_handle );
}
#elif defined(MTK_SLEEP_ENABLE)
L1SM_SleepEnable(BMTLockARM_handle);
#endif
}
else
{
#if(defined(MTK_SLEEP_ENABLE) && defined(__CENTRALIZED_SLEEP_MANAGER__) && defined(__DRV_BMT_WAKE_UP_TDMA_TIMER__))
{
L1SM_IntSleepDisable( BMTLockMD2G_handle ); // should lock MD2G first
L1SM_SleepDisable( BMTLockARM_handle );
L1SM_Multi_SW_WakeUp();
}
#elif defined(MTK_SLEEP_ENABLE)
L1SM_SleepDisable(BMTLockARM_handle);
#endif
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_charger_ov, NULL, KAL_TICKS_200_MSEC ,0);
#endif
}
}
void lcd_power_ctrl__disable(kal_uint32 module)
{
kal_uint32 save_irq_mask;
if (lcd_ctrl_cntx.lcd_power_ctrl_init == 0)
{
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__ERROR_NOT_INITIALIZED___X);
return;
}
if (module >= lcd_power_ctrl__get_registered_module_count())
{
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__ERROR_INVALID_MODULE____X);
return;
}
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__DISABLE___B_____________X);
save_irq_mask = SaveAndSetIRQMask();
// Clear power module handle.
lcd_power_ctrl__clear_module_handle(module);
// Turn off power
if (lcd_power_ctrl__get_module_handle() == 0)
{
mm_disable_power(MMPWRMGR_LCD);
#if defined(__SERIAL_LCM__) && defined(MT6252)
mm_disable_power(MMPWRMGR_LCD104M);
#elif defined(__SERIAL_LCM__) && (defined(MT6250) || defined(MT6260))
mm_disable_power(MMPWRMGR_SLCD);
#endif
}
RestoreIRQMask(save_irq_mask);
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__DISABLE___E_____________X);
#ifdef MTK_SLEEP_ENABLE
save_irq_mask = SaveAndSetIRQMask( );
if (0 == lcd_power_ctrl__get_module_handle( )) //Because lcd_power_ctrl__enable( ) may be invoked from last I-bit protection to now
{
L1SM_SleepEnable(lcd_power_sleep_mode_hander);
}
RestoreIRQMask(save_irq_mask);
#endif
}
/*
* FUNCTION
* bmt_charge_end
*
* DESCRIPTION
* This function is to stop charging when charger is plugged out
* or serious error in charging stage.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_charge_end(void)
{
kal_uint8 index;
BMT.pmictrl_state = PMIC_CHARGEOFF;
BMT.VBAT_UEM= VBAT_UEM_CHR_OUT_FIRST;
BMT_Charge(KAL_FALSE);
for(index=0;index<BMT_MAX_CHANNEL;index++)
adc_sche_remove_item(bmt_bmtid_adcscheid[index]);
adc_sche_set_timer_page_align(KAL_TRUE);
bmt_stop_stoptimer();
stack_stop_timer(&ChargeTimeout_timer);
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_SAFETY_TIMER_STOP_TRC);
#endif
SaftyTimer_Flag = BMT_SaftyTimer_Off;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(bmt_sm_handle);
#endif
}
void PWM2_Stop(void)
{
kal_uint16 reg;
kal_uint32 clock;
reg = DRV_Reg(PWM2_CTRL);
if (reg & 0x0004)
clock = 32000;
else
clock = 13000000;
#if defined(MTK_SLEEP_ENABLE) && !defined(__FUE__)
if(clock == 13000000)
L1SM_SleepEnable(PWM2_PDNhandle);
#endif
DRV_WriteReg(DRVPDN_CON1_SET,DRVPDN_CON1_PWM2);
#if defined(DRV_PWM_PWM2_SWDBG)
#if !defined(__FUE__)
swdbg_pwr_down();
#endif
#endif
}
void PWM1_Stop(void)
{
#if defined(DRV_PWM_CLK_SEL)
kal_uint16 reg;
kal_uint32 clock;
reg = DRV_Reg(PWM1_CTRL);
if (reg & 0x0004)
clock = 32000;
else
clock = 13000000;
DRV_WriteReg(DRVPDN_CON1_SET,DRVPDN_CON1_PWM);
#if defined(MTK_SLEEP_ENABLE) && !defined(__FUE__)
if(clock == 13000000)
L1SM_SleepEnable(PWM1_PDNhandle);
#endif
#else /*!(DRV_PWM_CLK_SEL)*/
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
DRV_Reg(DRVPDN_CON1) |= DRVPDN_CON1_PWM;
RestoreIRQMask(savedMask);
#endif /*DRV_PWM_CLK_SEL*/
}
sim_status L1sim_Cmd_All(kal_uint8 *txData,kal_uint32 *txSize,kal_uint8 *rxData, kal_uint32 *rxSize, SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
sim_status status;
kal_uint32 simInterface;
sim_HW_cb *hw_cb;
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
if(KAL_TRUE == sim_physicalSlotChanged)
simInterface = 1-simInterface;
if(0x0 == txData || 0x0 == txSize || 0x0 == rxSize)
ASSERT(0);
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
simDriver->addMessage(SIM_AL_ACTION_COMMAND, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
status = simDriver->command(txData, txSize, rxData, rxSize, (sim_HW_cb *)(hwCbArray[simInterface]));
simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
return status;
}
sim_status L1sim_Cmd_All(kal_uint8 *txData,kal_uint32 *txSize,kal_uint8 *rxData, kal_uint32 *rxSize, SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
sim_status status;
kal_uint32 simInterface;
sim_HW_cb *hw_cb;
#if defined(__SIM_HOT_SWAP_POLL_TIMER__) && defined(__SIM_HOT_SWAP_SUPPORT__)
Sim_Card *SimCard;
usim_dcb_struct *usim_dcb;
#endif
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
if(KAL_TRUE == sim_physicalSlotChanged)
simInterface = 1-simInterface;
if(0x0 == txData || 0x0 == txSize || 0x0 == rxSize)
ASSERT(0);
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
simDriver->addMessage(SIM_AL_ACTION_COMMAND, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
status = simDriver->command(txData, txSize, rxData, rxSize, (sim_HW_cb *)(hwCbArray[simInterface]));
simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
#if defined(__SIM_HOT_SWAP_POLL_TIMER__) && defined(__SIM_HOT_SWAP_SUPPORT__)
SimCard = GET_SIM_CB(hw_cb->simInterface);
usim_dcb = GET_USIM_CB(hw_cb->simInterface);
if(SimCard->poll_sim_2s || usim_dcb->poll_sim_2s)
{
sim_hot_swap_poll_timer_rollback(application);
SimCard->poll_sim_2s = KAL_FALSE;
usim_dcb->poll_sim_2s = KAL_FALSE;
#if !defined( __MAUI_BASIC__)
tst_sys_trace("[SIM DRV]stop timer\n\r");
#else
dbg_print("[SIM DRV]stop timer\n\r");
#endif
if(status == 0x0000)
{
#ifdef __SIM_HOT_SWAP_SUPPORT__
iccHotPlugTable[simInterface].plugOutcb(simInterface);
#endif
#if !defined( __MAUI_BASIC__)
tst_sys_trace("[SIM DRV]real hot plug\n\r");
#else
dbg_print("[SIM DRV]real hot plug\n\r");
#endif
}
}
#endif
return status;
}
void adc_pwrdown_enable(void)
{
#ifndef DRV_ADC_NOT_EXIST
{
#if defined(DRV_DIE_TO_DIE_INTERFACE)
{
kal_uint32 mask;
mask = SaveAndSetIRQMask();
auxadc_die2die_enable = KAL_FALSE;
DRV_ADC_ClearBits(ABB_AUX_CON0, AUX_FIFO_EN); // auxadc fifo enable
DRV_ADC_ClearBits(ABB_AUX_CON0, AUX_FIFO_CLK_EN); // auxadc fifo enable
ust_busy_wait(8);
DRV_ADC_ClearBits(ABB_WR_PATH0, AUX_PWDB); //triggle die to die interface to send and receive auxadc data
DRV_ADC_ClearBits(ABBA_WR_PATH0, ABBA_AUX_PWDB); // enable clock for auxadc analog interface logic
// DRV_ADC_ClearBits(ABB_WR_PATH0, F26M_CLK_EN); //enable clock for die to die interface
// DRV_ADC_ClearBits(ABB_RSV_CON1, AUXADC_FSM_CTRL|AUXADC_26M_CLK_CTRL); //enable clock for die to die interface
DRV_ADC_ClearBits(ABB_RSV_CON1, AUXADC_FSM_CTRL); //enable clock for die to die interface
ust_busy_wait(2);
DRV_ADC_ClearBits(ABB_RSV_CON1, AUXADC_26M_CLK_CTRL); //enable clock for die to die interface
PDN_SET(PDN_ADC); // TP use the AuxADC PDN, make sure the PDN is enable
DRV_ADC_ClearBits(0xa0160020,0x8000);
RestoreIRQMask(mask);
}
#elif defined(DRV_DIE_TO_DIE_INTERFACE_V2)
{
DRV_ADC_ClearBits(D2D_D_APC_AUX_CON1, D2D_D_AUX_EN);
DRV_ADC_ClearBits(D2D_A_APC_AUD_CON1, D2D_A_AUX_EN);
ust_busy_wait(8);
DRV_ADC_ClearBits(D2D_D_APC_AUX_CON1, D2D_D_AUX_EN | D2D_D_F26M_AUX_EN);
}
#endif
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_ENABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Enable(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#endif /*ADC_DRVPDN_FAST*/
#else // #if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_ENABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
#if !defined(__DRV_SUPPORT_LPWR__)
PDN_SET(PDN_ADC);
L1SM_SleepEnable(ADCSM_handler);
#else
DRVPDN_Enable(PDN_ADC);
#endif //#if !defined(__DRV_SUPPORT_LPWR__)
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
}
#endif // #ifndef DRV_ADC_NOT_EXIST
}
/**
* To deinitialize TV out module
*
* @param None.
*
* @return KAL_TRUE, initialize successfully.
*/
void deinit_tv(void)
{
tv_power_off();
L1SM_SleepEnable(tv_sleep_mode_handler);
} /* deinit_tv() */
usim_status_enum L1sim_Reset_All(sim_power_enum ExpectVolt, sim_power_enum *ResultVolt, kal_bool warm, SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
usim_status_enum status;
kal_uint32 simInterface;
#ifdef __SIM_HOT_SWAP_SUPPORT__
kal_int32 ipcStatus;
#if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
kal_uint8 *query, querystring[25] = "MD1_SIM1_HOT_PLUG_EINT";
#elif defined (__MD2__)
kal_uint8 *query, querystring[25] = "MD2_SIM1_HOT_PLUG_EINT";
#else
kal_uint8 *query, querystring[20] = "SIM1_HOT_PLUG_EINT";
#endif
SIM_ICC_HOT_PLUG iccHotPlug = {KAL_FALSE, KAL_FALSE, KAL_FALSE, 0, 0, 0, 0, 0, 0, NULL, NULL};
query = &querystring[0];
#endif
#ifdef SIM_4_CARD_SMT_TEST
SIM_ICC_APPLICATION anotherApplication;
kal_uint32 anotherSimInterface;
sim_power_enum anotherResultVolt;
sim_ctrlDriver *anotherSimDriver;
usim_status_enum anotherStatus;
#endif
sim_HW_cb *hw_cb;
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#ifdef SIM_4_CARD_SMT_TEST
if(SIM_ICC_APPLICATION_PHONE1 == application)
anotherApplication = SIM_ICC_APPLICATION_PHONE3;
else if(SIM_ICC_APPLICATION_PHONE2 == application)
anotherApplication = SIM_ICC_APPLICATION_PHONE4;
else
ASSERT(0);
anotherSimInterface = sim_get_logicalNum_from_app(anotherApplication);
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
#ifdef SIM_4_CARD_SMT_TEST
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= anotherSimInterface)
ASSERT(0);
#endif
if(KAL_TRUE == sim_physicalSlotChanged){
#if !defined( __MAUI_BASIC__)
tst_sys_trace("[SIM]:sim interface inversed!!");
#else
dbg_print("[SIM]:sim interface inversed!!");
#endif
simInterface = 1-simInterface;
application = 1-application; // need to switch to get correct hwcb and SIMIF number
}
if(0x0 == ResultVolt)
ASSERT(0);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
#ifdef __CUSTOMER_HW_VERIFICATION__
simInterface = 0;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0);
status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface]));
sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
simInterface = 1;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0);
/*when we release single SIM MMI, we only release SIM1 MMI, cusrtomer won't get SIM2 MMI, SIM1 is what MMI need*/
//status = simDriver->reset(ExpectVolt, ResultVolt, warm, simInterface);
sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0);
simDriver->EOC(simInterface);
#else
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
simDriver->addMessage(SIM_AL_ACTION_RESET, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface]));
#ifdef __SIM_HOT_SWAP_SUPPORT__
/* we should always register eint. If we bootup without plugin simcard, status will display NO_CARD.
we will never get insert event because eint is not registered */
#if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"MD1_SIM2_HOT_PLUG_EINT";
#elif defined (__MD2__)
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"MD2_SIM2_HOT_PLUG_EINT";
#else
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"SIM2_HOT_PLUG_EINT";
#endif
/* if any rpc error happens, we should leave register eint */
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get eint no fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.eintNo);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get debounce fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.debounceTime);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get polarity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.polarity);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get sensitivity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.sensitivity);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get socket fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.socketType);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
sim_reg_hot_plug_eint(application, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType);
LEAVE_REG_EINT:
kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %d, %d %d %d %d %d %d", application, ipcStatus, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %s", query);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
#endif /* End of #ifdef __SIM_HOT_SWAP_SUPPORT__ */
simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
#ifdef SIM_4_CARD_SMT_TEST
/*find out the hooked function table*/
anotherSimDriver = sim_driverTable[anotherSimInterface];
ASSERT(0 != anotherSimDriver);
anotherSimDriver->addMessage(SIM_AL_ACTION_RESET, anotherSimInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
anotherStatus = anotherSimDriver->reset(UNKNOWN_POWER_CLASS, &anotherResultVolt, warm, (sim_HW_cb *)(hwCbArray[anotherSimInterface]));
if(USIM_NO_ERROR == anotherStatus)
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("another SIM card found!!");
#else
dbg_print("another SIM card found!!");
#endif
}
else
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("another SIM card not found!!");
#else
dbg_print("another SIM card not found!!");
#endif
}
anotherSimDriver->addMessage(SIM_AL_ACTION_EOC, anotherSimInterface, 0, 0);
anotherSimDriver->EOC((sim_HW_cb *)(hwCbArray[anotherSimInterface]));
#endif
#endif
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
return status;
}
