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
}
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 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);
}
}
void adc_pwrdown_disable(void)
{
#ifndef DRV_ADC_NOT_EXIST
#ifndef DRV_ADC_NO_PDN
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Disable(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_DISABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
//DRVPDN_Disable(PDN_ADC);
PDN_CLR(PDN_ADC);
L1SM_SleepDisable(ADCSM_handler);
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
#endif //#ifdef DRV_ADC_NO_PDN
#endif // #ifndef DRV_ADC_NOT_EXIST
}
/*
* FUNCTION
* bmt_charge_start
*
* DESCRIPTION
* This function is to start charging algorithm.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_charge_start(void)
{
kal_uint8 index;
BMT_Charge(KAL_FALSE);
BMT.pmictrl_state = PMIC_CHARGEOFF;
BMT.bat_state = CHR_PRE;
BMT.VBAT_UEM= VBAT_UEM_CHR_IN_FISRT;
bmt_charge_time_value = 10;
low_charger_count = 0;
low_current_count = 0;
low_temper_count = 0;
over_temper_count = 0;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(bmt_sm_handle);
#endif
for(index=0;index<BMT_MAX_CHANNEL;index++)
{
adc_sche_modify_parameters(bmt_bmtid_adcscheid[index],1,1);
adc_sche_add_item(bmt_bmtid_adcscheid[index],bmt_measure_complete1[index], bmt_adc_sche_measure);
}
adc_sche_set_timer_page_align(KAL_FALSE);
stack_start_timer(&ChargeTimeout_timer, 0, KAL_TICKS_1_MIN*60*6);
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_SAFETY_TIMER_START_TRC);
#endif
SaftyTimer_Flag = BMT_SaftyTimer_On;
#if defined(MT6318)
#if !defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)
if(pmic_is_chr_det(AC_CHR))
pmic_charging_currnet_ctrl(pmic_return_current(AC_CHR));
#ifdef __USB_MULTI_CHARGE_CURRENT__
else if (bmt_support_usb_charge()) /* If not support, charging current is not set here. */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#else /* __USB_MULTI_CHARGE_CURRENT__ */
else
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#endif /* __USB_MULTI_CHARGE_CURRENT__ */
#else/*defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)*/
if(chr_usb_detect.chr_usb_present == CHARGER_PRESENT)
pmic_charging_currnet_ctrl(pmic_return_current(AC_CHR));
else if(chr_usb_detect.chr_usb_present == USB_PRESENT)
{
#ifdef __USB_MULTI_CHARGE_CURRENT__
if (bmt_support_usb_charge()) /* If not support, charging current is not set here. */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#else /* __USB_MULTI_CHARGE_CURRENT__ */
pmic_charging_currnet_ctrl(pmic_return_current(USB_CHR));
#endif /* __USB_MULTI_CHARGE_CURRENT__ */
}
#endif
#endif /* defined(MT6318) */
}
/*************************************************************************
* 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_Disable(kal_uint32 addr,kal_uint16 code,kal_uint8 handle)
{
#if ( (defined(MT6205)) || (defined(MT6208)) )
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
DRV_Reg(addr) &= (~code);
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(PDNhandle[handle]);
#endif /*MTK_SLEEP_ENABLE*/
RestoreIRQMask(savedMask);
#else
DRV_Reg(addr+0x20) = code;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(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
}
}
/*duty=50 ==> 50%*/
void PWM2_Start(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_SleepDisable(PWM2_PDNhandle);
#endif
DRV_WriteReg(DRVPDN_CON1_CLR,DRVPDN_CON1_PWM2);
/*to cover HW issue*/
#if defined(MT6228)|| defined(MT6229) || defined(MT6230)
#if !defined(__FUE__)
swdbg_pwr_up();
#endif
#endif
}
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;
}
//Caller shall handle rollback register
void lcd_power_ctrl__enable(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__ENABLE____B_____________X);
// Set power module handle.
save_irq_mask = SaveAndSetIRQMask();
lcd_power_ctrl__set_module_handle(module);
RestoreIRQMask(save_irq_mask);
// Turn on power
mm_enable_power(MMPWRMGR_LCD);
#if defined(__SERIAL_LCM__) && defined(MT6252)
mm_enable_power(MMPWRMGR_LCD104M);
#elif defined(__SERIAL_LCM__) && (defined(MT6250) || defined(MT6260))
mm_enable_power(MMPWRMGR_SLCD);
#endif
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__ENABLE____MMPWRMGR_ON___X);
_lcd_power_ctrl__trace(module, LCD_PWR_CTRL__ENABLE____E_____________X);
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(lcd_power_sleep_mode_hander);
#endif
}
/*duty=50 ==> 50%*/
void PWM1_Start(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;
#if defined(MTK_SLEEP_ENABLE) && !defined(__FUE__)
if(clock == 13000000)
L1SM_SleepDisable(PWM1_PDNhandle);
#endif
DRV_WriteReg(DRVPDN_CON1_CLR,DRVPDN_CON1_PWM);
#else /*!(MT6205B,MT6218, MT6218B, MT6219, MT6217, MT6228,MT6229)*/
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
DRV_Reg(DRVPDN_CON1) &= ~DRVPDN_CON1_PWM;
RestoreIRQMask(savedMask);
#endif /*DRV_PWM_CLK_SEL*/
}
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;
}
HIF_RESULT hif_dma_read_internal(HIF_HANDLE handle, HIF_TYPE type, kal_uint32 addr, kal_uint32 size, HIF_CALLBACK fCB)
{
HIF_RESULT result = HIF_RESULT_OK;
HIF_INTERNAL_HANDLE_T* pHandle = (HIF_INTERNAL_HANDLE_T*) handle;
kal_uint32 retrieved_events;
// Enable HIF interrupt.
ENABLE_HIF_INTR(pHandle->engine_id);
pHandle->DMA_BUSY = KAL_TRUE;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(hif_sleepMode_handle[pHandle->engine_id]);//unlock MD sleep mode
#endif
if (fCB == NULL)
{
if(!(kal_if_lisr()||kal_if_hisr()))
{
//Clear the evnet for pHandle->engine_id HIF for task level
kal_set_eg_events(hif_events, ~(1 << pHandle->engine_id), KAL_AND);
}
else
ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR
}
// Setup HIF.
//SET_HIF_BUS_WIDTH(pHandle->engine_id, pHandle->config.hif_bus_width);
SET_HIF_READ(pHandle->engine_id);
if(type == HIF_TYPE_A0H_DMA)
{
SET_HIF_A0_HIGH(pHandle->engine_id);
}
else if(type == HIF_TYPE_A0L_DMA)
{
SET_HIF_A0_LOW(pHandle->engine_id);
}
SET_HIF_DAMOUNT(pHandle->engine_id, size);
/* // Set DMA address.
PDMA_SET_BUF_ADDR(pHandle->engine_id, addr);
PDMA_SET_RW_DIRECTION(pHandle->engine_id, 1); // 1:read; 0: write
PDMA_SET_BUF_LEN(pHandle->engine_id, size);
PDMA_SET_BURST_LEN(pHandle->engine_id, 7);
PDMA_START(pHandle->engine_id); //Start DMA
*/
//dma config
SLA_CustomLogging("HDM",1);//set for debug
#if (defined(MT6752) && !defined(__ANDROID_MODEM__))
hif_dma_menu[pHandle->engine_id].addr = addr + 0x80000000;
#else
hif_dma_menu[pHandle->engine_id].addr = addr;
#endif
hif_dma_input[pHandle->engine_id].count = (pHandle->config.hif_bus_width == 16) ? (size >> 1) : size;
hif_dma_input[pHandle->engine_id].type = DMA_HWRX;
hif_dma_input[pHandle->engine_id].size = (pHandle->config.hif_bus_width == 16) ? DMA_SHORT : DMA_BYTE;
hif_dma_input[pHandle->engine_id].callback = NULL;
hif_dma_input[pHandle->engine_id].menu = (void*) &hif_dma_menu[pHandle->engine_id];
DMA_Config(hif_sysdma_id[pHandle->engine_id], &hif_dma_input[pHandle->engine_id], KAL_TRUE);
// Set fCB as HIF interrupt callback.
hif_cb[pHandle->engine_id] = fCB;
// Start HIF
START_HIF(pHandle->engine_id);
if (fCB == NULL)
{
if(!(kal_if_lisr()||kal_if_hisr()))
{
kal_retrieve_eg_events(hif_events, (1<<pHandle->engine_id), KAL_OR_CONSUME, &retrieved_events, KAL_SUSPEND);
pHandle->DMA_BUSY = KAL_FALSE;
}
else
ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR
}
return result;
}
/**
* To initialize TV out module
*
* @param None.
*
* @return None.
*/
void init_tv(void)
{
tv_power_on();
tv_output_owner=TV_OUT_OWNER_MMI;
tv_output_config_data.tv_output_mode=0;/*TV_FORMAT_NTSCTV_OUTPUT_DISABLE*/
tv_output_config_data.tv_output_format=0;/*TV_FORMAT_NTSC*/
tv_output_config_data.tv_output_offset_x=0;
tv_output_config_data.tv_output_offset_y=0;
/* configure TV encoder mode */
/*?????=> don't change*/
DISABLE_TV_UV_SWAP;
DISABLE_TV_BLACKER_MODE;
DISABLE_TV_HORIZONTAL_SLEW;
SET_TV_SYDELAY_BIT;
SET_TV_Y_DELAY(2);
DISABLE_TV_CHROMA_UP_SAMPLE;
DISABLE_TV_LUMA_LPF;
ENABLE_TV_CHROMA_LPF;
SET_TV_CHROMA_LPF0;
SET_TV_ENC_SCALE_BLANK(4);
/* configure TV controller contorl register */
/*?????*/
SET_TV_CON_WRITE_SINGLE_BUFFER;
DISABLE_TV_CON_BURST_MODE;
#if defined(DRV_TVOUT_6228_SERIES)
ENABLE_TV_CON_DEEPER_BUFFER;
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK, need to confirm with designer
ENABLE_TV_CON_HIGHER_BUS_PRIORITY;
ENABLE_TV_CTRL_HANDSHAKE_WTITH_VIDEC;
DISABLE_TV_CTRL_PREFETCH;
SET_TV_CON_READ_ACTIVE_BUFFER;
ENABLE_TV_CTRL_AVG_MODE;
ENABLE_TV_CTRL_CLIP_MODE;
DISABLE_TV_CTRL_CHKLINE_INT_MODE;
DISABLE_TV_CTRL_OVR_INT_MODE;
/*TVC slow control, may need to fine tune*/
DRV_WriteReg32(TV_CON_SLOW_CTRL_REG,(4<<24)|(4<<20)|(2<<16)|(400));
#endif
ENABLE_TV_CON_FILL_BLACK_PIXEL;
if (custom_ifLPSDRAM()==KAL_TRUE)
{
ENABLE_TV_CON_VERTICAL_INTERPOLATION;
}
else
{
DISABLE_TV_CON_VERTICAL_INTERPOLATION;
}
SET_TV_CON_READ_WRITE_BUFFER;
/*可讓邊緣不sharp*/
#if defined(DRV_TVOUT_6228_SERIES)
ENABLE_TV_CON_MAGIC_SWITCH;
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK, need to confirm with DE
//this resiger doesn't exist anymore
#endif
/*enable handshake between tv out and mpeg4*/
ENABLE_TV_CTRL_HANDSHAKE_WTITH_VIDEC;
ENABLE_TV_DAC_MAGIC_SWITCH;
/*sleep mode*/
if (tv_sleep_mode_handler==0xFF)
tv_sleep_mode_handler=L1SM_GetHandle();
L1SM_SleepDisable(tv_sleep_mode_handler);
} /* init_tv() */
/*
* FUNCTION
* adc_pwrdown_disable
*
* DESCRIPTION
* This function is to disable adc power down control
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* Note that this function must be called between SaveAndSetIRQMask()
* and RestoreIRQMask().
*/
void adc_pwrdown_disable(void)
{
#ifndef DRV_ADC_NOT_EXIST
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Disable(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_DISABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
#if !defined(__DRV_SUPPORT_LPWR__)
PDN_CLR(PDN_ADC);
L1SM_SleepDisable(ADCSM_handler);
#else
DRVPDN_Disable(PDN_ADC);
#endif //#if !defined(__DRV_SUPPORT_LPWR__)
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
#if defined(DRV_DIE_TO_DIE_INTERFACE)
{
kal_uint32 mask;
mask = SaveAndSetIRQMask();
auxadc_die2die_enable = KAL_TRUE;
PDN_CLR(PDN_ADC); // TP use the AuxADC PDN, make sure the PDN is disable
DRV_ADC_SetBits(ABB_WR_PATH0, F26M_CLK_EN); //enable clock for die to die interface, MT6250E1
//DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_FSM_CTRL|AUXADC_26M_CLK_CTRL); //enable clock for die to die interface, MT6250E2
DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_26M_CLK_CTRL); //enable clock for die to die interface, MT6250E2
ust_busy_wait(2);
DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_FSM_CTRL); //enable clock for die to die interface, MT6250E2
DRV_ADC_SetBits(0xa0160020,0x8000);
DRV_ADC_SetBits(ABBA_WR_PATH0, ABBA_AUX_PWDB); // enable clock for auxadc analog interface logic
DRV_ADC_SetBits(ABB_WR_PATH0, AUX_PWDB); //triggle die to die interface to send and receive auxadc data
ust_busy_wait(8);
DRV_ADC_SetBits(ABB_AUX_CON0, AUX_FIFO_CLK_EN); // auxadc fifo enable
DRV_ADC_SetBits(ABB_AUX_CON0, AUX_FIFO_EN); // auxadc fifo enable
RestoreIRQMask(mask);
}
#elif defined(DRV_DIE_TO_DIE_INTERFACE_V2)
{
DRV_ADC_SetBits(D2D_D_APC_AUX_CON1, D2D_D_F26M_AUX_EN);
DRV_ADC_SetBits(D2D_A_APC_AUD_CON1, D2D_A_AUX_EN);
DRV_ADC_Reg(D2D_A_APC_AUD_CON1);
DRV_ADC_SetBits(D2D_D_APC_AUX_CON1, D2D_D_AUX_EN|D2D_D_F26M_AUX_EN);
}
#endif
#endif // #ifndef DRV_ADC_NOT_EXIST
}
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;
}
kal_uint8 rda_bt_poweron_for_test(void)
{
// Enable 26M AUX clock
hal_SysAuxClkOut(TRUE);
#ifdef __RDA_SHARE_CRYSTAL__
if(bt_sleephdl == 0xff)
bt_sleephdl = L1SM_GetHandle();
L1SM_SleepDisable(bt_sleephdl);
#endif
rdabt_chip_sel = 0;
rda_bt_power_on();
rda_bt_rf_init();
rda_bt_uart_init();
RDA_bt_Power_On_Reset();
RDABT_DELAY(70);
switch(rdabt_chip_sel)
{
#ifdef __RDA_CHIP_R5_5868__
case RDA_BT_R5_5868_ENUM:
Rdabt_Pskey_Write_rf_r5();
RDABT_DELAY(10);
Rdabt_dut_pskey_write_r578();
break;
#endif
#ifdef __RDA_CHIP_R7_5868plus__
case RDA_BT_R7_5868PLUS_ENUM:
Rdabt_Pskey_Write_rf_r7();
RDABT_DELAY(10);
Rdabt_dut_pskey_write_r578();
break;
#endif
#ifdef __RDA_CHIP_R8_5870__
case RDA_BT_R8_5870_ENUM:
Rdabt_Pskey_Write_rf_r8();
RDABT_DELAY(10);
Rdabt_dut_pskey_write_r578();
break;
#endif
#if defined( __RDA_CHIP_R10_5868E__ ) || defined(__RDA_CHIP_R10_5872__)
case RDA_BT_R10_5872_ENUM:
case RDA_BT_R10_5868E_ENUM:
Rdabt_core_uart_Intialization_r10();
RDABT_DELAY(10); //wait for first uart data
Rdabt_Pskey_Write_rf_r10();
Rdabt_test_pskey_write_r10();
break;
#endif
#if defined(__RDA_CHIP_R10_5868H__) || defined(__RDA_CHIP_R10_5872H__)
case RDA_BT_R10_AL_5868H_ENUM:
case RDA_BT_R10_AL_5872H_ENUM:
RDABT_rf_Intialization_r10_al();
Rdabt_Pskey_Write_rf_r10_al();
RDABT_DELAY(5); //wait for digi running
rdabt_DC_write_r10_al();
Rdabt_test_pskey_write_r10();
break;
#endif
#ifdef __RDA_CHIP_R10_5870E__
case RDA_BT_R10_5870E_ENUM:
RDABT_rf_Intialization_r10_e();
Rdabt_Pskey_Write_rf_r10_e();
RDABT_DELAY(5); //wait for digi running
rdabt_DC_write_r10_e();
Rdabt_test_pskey_write_r10();
break;
#endif
#ifdef __RDA_CHIP_R11_5872P__
case RDA_BT_R11_5872P_ENUM:
Rdabt_Pskey_Write_rf_r11_p();
RDABT_rf_Intialization_r11_p();
rda_bt_pin_to_low();
rda_bt_ldoon_toggle_high();
RDABT_DELAY(10); //wait for digi running
Rdabt_Pskey_Write_rf_r11_p();
RDABT_rf_Intialization_r11_p();
rdabt_DC_write_r11_p();
Rdabt_test_pskey_write_r11();
break;
#endif
#ifdef __RDA_CHIP_R11_5875__
case RDA_BT_R11_5875_ENUM:
rda_bt_ldoon_toggle_high();
RDABT_DELAY(10); //wait for digi running
RDABT_rf_Intialization_r11();
Rdabt_Pskey_Write_rf_r11();
rdabt_DC_write_r11();
Rdabt_test_pskey_write_r11();
break;
#endif
default:
// ASSERT(0); // xiaoyifeng
break;
}
// Disable 26M AUX clock
hal_SysAuxClkOut(FALSE);
return 1;
}
