/*
* FUNCTION
* GPTI_StartItem
*
* DESCRIPTION
* GPT start a item.
*
* CALLS
*
* PARAMETERS
* moudle = UART_Module, SIM_Module, GPT_Module
* tick = the delay(the unit is 10ms)
* gptimer_func = the callback function when the tick is reached.
* parameter = the parameter inputed into gptimer_func
*
* RETURNS
* KAL_TRUE, start item successfully
* KAL_FALSE, start item fail
*
* GLOBALS AFFECTED
* external_global
*/
kal_bool GPTI_StartItem(kal_uint8 module,kal_uint16 tick,void (*gptimer_func)(void *),void *parameter)
{
kal_uint32 savedMask;
if (GPTTimer.status & (1<<module))
{
return KAL_FALSE;
}
GPTTimer.GPTItems[module].tick = GPTTimer.GPT_TICK+tick;
GPTTimer.GPTItems[module].gptimer_func = gptimer_func;
GPTTimer.GPTItems[module].parameter = parameter;
savedMask = SaveAndSetIRQMask();
//if (tick == 0)
// tick =1;
GPTTimer.status |= (1<<module);
if(GPTTimer.GPTSTOP == KAL_TRUE)
{
GPTTimer.GPTSTOP = KAL_FALSE;
RestoreIRQMask(savedMask);
savedMask = SaveAndSetIRQMask();
if (((volatile kal_bool)GPTTimer.GPTSTOP) == KAL_FALSE)
GPT_Start(gptimer_num);
}
RestoreIRQMask(savedMask);
return KAL_TRUE;
}
/*************************************************************************
* FUNCTION
* DclSADC_Open
*
* DESCRIPTION
* This function is to open the SW ADC module and return a handle
*
* PARAMETERS
* dev: only valid for DCL_ADC
* flags: no sepcial flags is needed. Please use FLAGS_NONE
*
* RETURNS
* DCL_HANDLE_INVALID: Open failed
* Other value: A valid handle
*
*************************************************************************/
DCL_HANDLE DclSADC_Open(DCL_DEV dev, DCL_FLAGS flags)
{
DCL_UINT32 savedMask;
DCL_UINT32 i;
if (dev != DCL_ADC){
return DCL_HANDLE_INVALID; // Incorrecr device ID
}
for (i=0;i<MAX_DCL_ADC_HANDLE;i++)
{
savedMask = SaveAndSetIRQMask();
if(dcl_adc_handle_used[i] == 0)
{
dcl_adc_handle_used[i] = 1;
RestoreIRQMask(savedMask);
break;
}
RestoreIRQMask(savedMask);
}
if(i >= MAX_DCL_ADC_HANDLE)
{
return DCL_HANDLE_INVALID;
}
return (DCL_HANDLE)i;
}
kal_int32 cc_irq_trigger_interrupt_with_buff(kal_uint32 index, void *addr, kal_uint32 length)
{
kal_uint32 savedMask;
kal_int32 ret;
if (!CC_IRQ_TX_INDEX_IS_IN_RANGE(index) || addr == NULL || length > CC_IRQ_BUFF_MAX)
{
return CC_IRQ_ERR_PARAM;
}
index = CC_IRQ_TX_INDEX_OFFSET(index);
savedMask = SaveAndSetIRQMask();
if (CC_IRQ_IS_TX_RESOURCE_AVAIL(index, length))
{
if (!CC_IRQ_IS_ENABLED())
{
RestoreIRQMask(savedMask);
return CC_IRQ_ERR_PEER_ASYNC;
}
CC_IRQ_ENQUEUE_BUFF(index, addr, length);
CC_IRQ_TRIGGER_INTR(index);
ret = CC_IRQ_SUCCESS;
}
else
{
ret = CC_IRQ_ERR_CHANNEL_FULL;
}
RestoreIRQMask(savedMask);
return ret;
}
void Audio_SW_CPD_Eevent_ChangeMode(kal_bool flag)
{
kal_uint32 savedMask;
kal_uint32 reg_value;
if(flag){
savedMask = SaveAndSetIRQMask();
reg_value = *MCU_TOPSM_SM_SW_WAKEUP;
reg_value |= (0x1 << 0); //bit[0]: request to md2gsys
*MCU_TOPSM_SM_SW_WAKEUP = reg_value;
RestoreIRQMask( savedMask );
//This only needs to be applied to these three chips due to CPD HW status bug
#if defined(MT6250) || defined(MT6280) || defined(MT6583) || defined(MT6260)
AUDIO_DELAY(33);
#endif
while(!(*MCU_TOPSM_SM_MAS_RDY_STA & 0x00000001));
}
else{
savedMask = SaveAndSetIRQMask();
reg_value = *MCU_TOPSM_SM_SW_WAKEUP;
reg_value &= ~(0x1 << 0);
*MCU_TOPSM_SM_SW_WAKEUP = reg_value;
RestoreIRQMask( savedMask );
}
}
void MT6302_Writer_GPIO(kal_uint8 data)
{
kal_uint32 i, j;
kal_uint8 MT6302_CS_PIN, MT6302_CLK_PIN, MT6302_DAT_PIN;
i = SaveAndSetIRQMask();
if(KAL_FALSE == MT6302_checkSPIMode()){
RestoreIRQMask(i);
// some states of 3 SPI pins don't match our expectation.
ASSERT(0);
}
MT6302_CS_PIN=MT6302_getGPIOCS();
MT6302_CLK_PIN=MT6302_getGPIOCLK();
MT6302_DAT_PIN=MT6302_getGPIODAT();
GPIO_WriteIO(0, MT6302_CS_PIN);
for(j=8;j>0;j--)
{
if(data&(0x1<<(j-1)))
GPIO_WriteIO(1, MT6302_DAT_PIN);
else
GPIO_WriteIO(0, MT6302_DAT_PIN);
GPIO_WriteIO(1, MT6302_CLK_PIN);
GPIO_WriteIO(0, MT6302_CLK_PIN);
}
GPIO_WriteIO(0, MT6302_DAT_PIN);
GPIO_WriteIO(1, MT6302_CS_PIN);
RestoreIRQMask(i);
}
DCL_STATUS DclSIM_Initialize(void)
{
kal_uint32 maskedValue;
kal_uint32 loopIndex;
maskedValue = SaveAndSetIRQMask();
if(KAL_FALSE == fgSIMInit) {
fgSIMInit = KAL_FALSE;
RestoreIRQMask(maskedValue);
kal_mem_set(simResource, 0, sizeof(DCL_SIM_RESOURCE) * DCL_SIM_MAX_INTERFACE);
dclSimArb = kal_create_sem("SIM_DCL", 1);
for(loopIndex = 0; DCL_SIM_MAX_INTERFACE > loopIndex; loopIndex ++) {
simResource[loopIndex].guardHead = SIM_RESOURCE_HEAD;
simResource[loopIndex].guardTail = SIM_RESOURCE_TAIL;
simResource[loopIndex].driverHandle = SIM_RSC_HANDLE_UDEF;
}
sim_init_all_cb();
#ifdef MEUT_ON_FPGA
MT6302_test();
#endif
}
else {
RestoreIRQMask(maskedValue);
}
return STATUS_OK;
}
static kal_bool _VideoCommGetBuffData(
const VIDEO_COMM_BUFF_QUEUE_T* prBuffQueue,
VIDEO_COMM_STATE_T *prCommState,
VIDEO_BUFFERHEADER_TYPE_T *prBuffHeader)
{
const kal_uint32 u4ReadIdx = prBuffQueue->u4ReadIdx;
const kal_uint32 u4WriteIdx = prBuffQueue->u4WriteIdx;
kal_uint32 u4SavedMask;
u4SavedMask = SaveAndSetIRQMask();
prCommState->u4EntryCount++;
RestoreIRQMask(u4SavedMask);
if (u4ReadIdx == u4WriteIdx)
{
u4SavedMask = SaveAndSetIRQMask();
prCommState->u4EntryCount--;
RestoreIRQMask(u4SavedMask);
return KAL_FALSE;
}
*prBuffHeader = prBuffQueue->prBuffQ[u4ReadIdx];
u4SavedMask = SaveAndSetIRQMask();
prCommState->u4EntryCount--;
RestoreIRQMask(u4SavedMask);
return KAL_TRUE;
}
/*-----------------------------------------------------------------------*
* FUNCTION
* DclHGPT_Open
*
* DESCRIPTION
* This function is to open a HW GPT module. Note that HW GPT only supports
* single open for each valid eDev and if DCL_GPT1 is chosen SGPT may be
* influenced and work abnormally.
*
* PARAMETERS
* eDev - only valid for GPT1 and GPT2
* flags - no sepcial flags is needed. Please use FLAGS_NONE
*
* RETURNS
* DCL_HANDLE_INVALID - Open failed.
* other value - a valid handle
*
*------------------------------------------------------------------------*/
DCL_HANDLE DclHGPT_Open(GPT_DEV eDev, DCL_FLAGS flags)
{
kal_uint32 savedMask;
switch(eDev)
{
case GPT1:
savedMask = SaveAndSetIRQMask();
if (KAL_TRUE == fgGPT1Open)
{
RestoreIRQMask(savedMask);
return (DCL_HGPT_MAGIC_NUM | GPT1);
}
fgGPT1Open = KAL_TRUE;
RestoreIRQMask(savedMask);
return (DCL_HGPT_MAGIC_NUM | GPT1);//use return instead of break;
case GPT2:
#if !defined(__IC_SLT__) // for slt load, always return a valid handle
savedMask = SaveAndSetIRQMask();
if (KAL_TRUE == fgGPT2Open)
{
RestoreIRQMask(savedMask);
return DCL_HANDLE_INVALID;
}
fgGPT2Open = KAL_TRUE;
RestoreIRQMask(savedMask);
#endif
return (DCL_HGPT_MAGIC_NUM | GPT2);//use return instead of break;
default:
ASSERT(0);
return DCL_HANDLE_INVALID;
}
}
/*-----------------------------------------------------------------------
* FUNCTION
* GPTCB_US_HISR
*
* DESCRIPTION
* GPT Callback HISR : 10ms
*
* CALLS
*
* PARAMETERS
* void
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*------------------------------------------------------------------------*/
DEVDRV_LS_INTSRAM_ROCODE void GPTCB_US_HISR(void)
{
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
if( KAL_TRUE == gptCBUS_running )
{
gptCBUS_running = KAL_FALSE;
RestoreIRQMask(savedMask);
#if defined(__CR4__)
IFDEF_GPT_CB_MEASURE_TIME(CP15_PMU_GET_CYCLE_CNT(gpt_uscb_enter_time));
#elif defined(__MTK_MMU_V2__) /* __CR4__ */
IFDEF_GPT_CB_MEASURE_TIME(gpt_uscb_enter_time=CACHE_FREE_RUN_CYCLE_COUNTER_GET_CYCLE());
#endif /* __MTK_MMU_V2__ */
gptCBUS_instance.gptimer_func(gptCBUS_instance.parameter);
#if defined(__CR4__)
IFDEF_GPT_CB_MEASURE_TIME(CP15_PMU_GET_CYCLE_CNT(gpt_uscb_leave_time));
#elif defined(__MTK_MMU_V2__) /* __CR4__ */
IFDEF_GPT_CB_MEASURE_TIME(gpt_uscb_leave_time=CACHE_FREE_RUN_CYCLE_COUNTER_GET_CYCLE());
#endif /* __MTK_MMU_V2__ */
}
else
{
RestoreIRQMask(savedMask);
}
savedMask = SaveAndSetIRQMask();
DCL_GPT_BUS_CLOCK_TRY_OFF();
RestoreIRQMask(savedMask);
}
/*-----------------------------------------------------------------------*
* FUNCTION
* DclHGPT_Open
*
* DESCRIPTION
* This function is to open a HW GPT module. Note that HW GPT only supports
* single open for each valid eDev and if DCL_GPT1 is chosen SGPT may be
* influenced and work abnormally.
*
* PARAMETERS
* eDev - only valid for GPT1 and GPT2
* flags - no sepcial flags is needed. Please use FLAGS_NONE
*
* RETURNS
* DCL_HANDLE_INVALID - Open failed.
* other value - a valid handle
*
*------------------------------------------------------------------------*/
DCL_HANDLE DclHGPT_Open(GPT_DEV eDev, DCL_FLAGS flags)
{
kal_uint32 savedMask;
switch(eDev)
{
case GPT1:
savedMask = SaveAndSetIRQMask();
if (KAL_TRUE == fgGPT1Open)
{
RestoreIRQMask(savedMask);
return (DCL_HGPT_MAGIC_NUM | GPT1);
}
fgGPT1Open = KAL_TRUE;
RestoreIRQMask(savedMask);
return (DCL_HGPT_MAGIC_NUM | GPT1);//use return instead of break;
case GPT2:
savedMask = SaveAndSetIRQMask();
if (KAL_TRUE == fgGPT2Open)
{
RestoreIRQMask(savedMask);
return DCL_HANDLE_INVALID;
}
fgGPT2Open = KAL_TRUE;
RestoreIRQMask(savedMask);
return (DCL_HGPT_MAGIC_NUM | GPT2);//use return instead of break;
default:
ASSERT(0);
return DCL_HANDLE_INVALID;
}
}
/*************************************************************************
* FUNCTION
* USC_Get_TimeStamp
*
* DESCRIPTION
* This function calculate the frame number.
*
* PARAMETERS
* none
*
* RETURNS
* Frame number since system power up
*
*************************************************************************/
kal_uint32 DEVDRV_LS_INTSRAM_ROCODE USC_Get_TimeStamp( void )
{
#if defined(__ALIGN_2G_CLOCK__)
kal_uint32 uscnti,curFrame,_savedMask;
_savedMask = SaveAndSetIRQMask();
uscnti= ust_get_current_time();
if (uscnti >= Pre_USCNTI) {
curFrame = USCNT_TO_FRAME( uscnti - Pre_USCNTI ); // dur/3250/(120/26)
} else {
curFrame = USCNT_TO_FRAME((USCNT_WRAP - Pre_USCNTI) + uscnti);
}
FrameCount += curFrame;
Pre_USCNTI += FRAME_TO_USCNT(curFrame);
if( Pre_USCNTI > USCNT_WRAP )
{
Pre_USCNTI -= USCNT_WRAP;
}
RestoreIRQMask(_savedMask);
return FrameCount;
#else
kal_uint32 uscnti,curFrame,_savedMask;
_savedMask = SaveAndSetIRQMask();
#if defined(__HW_OSTICK_CNT__)
HW_WRITE(OST_CMD, CMD_MAGIC_VALUE | 0x02);
curFrame = HW_READ(OST_TIMER_CNT_R);
#else
uscnti= ust_get_current_time();
if (uscnti >= Pre_USCNTI) {
Total_USCNTI += (uscnti - Pre_USCNTI);
} else {
Total_USCNTI += ((USCNT_WRAP - Pre_USCNTI) + uscnti);
}
Pre_USCNTI = uscnti;
curFrame = USCNT_TO_FRAME(Total_USCNTI);
#endif
RestoreIRQMask(_savedMask);
return curFrame;
#endif
}
/*-----------------------------------------------------------------------
* FUNCTION
* GPTCB_10MS_HISR
*
* DESCRIPTION
* GPT Callback HISR : 10ms
*
* CALLS
*
* PARAMETERS
* void
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*------------------------------------------------------------------------*/
DEVDRV_LS_INTSRAM_ROCODE void GPTCB_10MS_HISR(void)
{
kal_uint8 index;
kal_uint32 savedMask;
kal_uint32 checkMask = 0xFFFFFFFF;
IFDEF_GPT_TRACE(kal_uint32 time1);
IFDEF_GPT_TRACE(kal_uint32 time2);
gptCB_ticks++;
// Bit matched method to check if a GPT items is activated
// Search whole GPT items
for (index = 0; (index < MAX_GPT_ITEMS)&&(gptCB_status&checkMask); index++)
{
savedMask = SaveAndSetIRQMask();
if( (gptCB_status & (1 << index)) && (gptCB_ticks >= gptCB_items[index].tick) )
{
gptCB_status &= ~(1<<index);
RestoreIRQMask(savedMask);
IFDEF_GPT_TRACE(time1 = ust_get_current_time());
#if defined(__CR4__)
IFDEF_GPT_CB_MEASURE_TIME(CP15_PMU_GET_CYCLE_CNT(gpt_cb_enter_time[index]));
#elif defined(__MTK_MMU_V2__) /* __CR4__ */
IFDEF_GPT_CB_MEASURE_TIME(gpt_cb_enter_time[index]=CACHE_FREE_RUN_CYCLE_COUNTER_GET_CYCLE());
#endif /* __MTK_MMU_V2__ */
gptCB_items[index].gptimer_func(gptCB_items[index].parameter);
#if defined(__CR4__)
IFDEF_GPT_CB_MEASURE_TIME(CP15_PMU_GET_CYCLE_CNT(gpt_cb_leave_time[index]));
#elif defined(__MTK_MMU_V2__) /* __CR4__ */
IFDEF_GPT_CB_MEASURE_TIME(gpt_cb_leave_time[index]=CACHE_FREE_RUN_CYCLE_COUNTER_GET_CYCLE());
#endif /* __MTK_MMU_V2__ */
IFDEF_GPT_TRACE(time2 = ust_get_current_time());
GPT_DBG(index, time1, time2);
}
else
{
RestoreIRQMask(savedMask);
}
checkMask ^= (1 << index);
}
savedMask = SaveAndSetIRQMask();
if (gptCB_status == 0)
{
// UT Test road test.
gptCB_ticks = 0;
drv_gpt_stop_timer(DRV_GPT_CALLBACK_TIMER);
DCL_GPT_BUS_CLOCK_TRY_OFF();
}
RestoreIRQMask(savedMask);
}
void L1Audio_HISR( void )
{
uint32 savedMask;
L1Audio_Disable_DSPSlowIdle();
if( l1audio.hisrMagicFlag ) {
int32 I;
kal_uint16 temp;
temp = *AUDIO_DBG_SHERIF;
for( I = 0; I < MAX_HISR_HANDLER; I++ ) {
if( l1audio.hisrMagicFlag & (1<<I) ) {
savedMask = SaveAndSetIRQMask();
l1audio.hisrMagicFlag &= ~(1<<I);
RestoreIRQMask( savedMask );
kal_brief_trace( TRACE_GROUP_DSPDEBUG, DSPDEBUG_CTRLFLOW, temp, I);
l1audio.hisrHandler[I]( l1audio.hisrUserData[I] );
if( l1audio.postHisrHandler != (L1Audio_EventHandler)0 )
l1audio.postHisrHandler( (void*)l1audio.hisrMagicNo[I] );
}
}
}
#if !defined( MED_MODEM )
//special case when MED_MODEM( of MED_PROFILE ) is defined, all Media_Play, Media_record
//do not exist, then mediaHisr could be removed to reduce memory size.
//In the future, when old interface are not used, mediaHisr should be removed officially.
if( l1audio.media_flag != 0 ) { /* Audio File Playback/Recording */
#ifndef __L1_STANDALONE__ // avoid link error
mediaHisr( l1audio.media_flag );
#endif
if( l1audio.postHisrHandler != (L1Audio_EventHandler)0 )
l1audio.postHisrHandler( (void*)l1audio.media_flag );
l1audio.media_flag = 0;
}
#endif
if( l1audio.event_flag ) {
int16 I;
for( I = 0; I < MAX_AUDIO_FUNCTIONS; I++ ) {
if( l1audio.event_flag & (1<<I) ) {
savedMask = SaveAndSetIRQMask();
l1audio.event_flag &= ~(1<<I);
RestoreIRQMask( savedMask );
L1Audio_SetEvent( I, l1audio.evData[I] );
}
}
}
// To restore slow idle ctrl for DSP
L1Audio_Enable_DSPSlowIdle();
}
/*
* FUNCTION
* adc_sche_measure
*
* DESCRIPTION
* This function is to measure ADC channel.
*
* CALLS
*
* PARAMETERS
* adc_sche_id: logical channel id
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void adc_sche_measure(void* msg_ptr)
{
MeasParameter *adc_param = (MeasParameter *)msg_ptr;
#if ( (defined(MT6205B))||defined(MT6226M) || (defined(MT6218))|| (defined(MT6218B))|| (defined(MT6219))|| (defined(MT6217))|| (defined(MT6225))|| (defined(MT6228))|| (defined(MT6229))|| (defined(MT6230))|| (defined(MT6226))|| (defined(MT6227)))
#ifdef BMT_DEBUG
//dbg_printWithTime("mea,%d..\r\n",adc_param->adc_logic_id);
#endif
#if 0
/* under construction !*/
/* under construction !*/
#endif
adc_parameters[adc_param->adc_logic_id].adc_sche_event_id = NULL;
if (adc_parameters[adc_param->adc_logic_id].conti_measure)
{
#if !defined(__CHARGER_WITH_IMMEDIMATE_ADC__)
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
adc_sync_mode_on = KAL_TRUE;
adc_pwrdown_disable();
DRV_Reg(AUXADC_SYNC) |= (1<<adc_param->adc_phy_id);
RestoreIRQMask(savedMask);
#endif
adc_sche_rw_status |= (1 << adc_param->adc_logic_id);
adc_sche_set_timer(adc_param->adc_logic_id,1,adc_sche_readback);
}
#endif /*MT6205B,MT6218, MT6218B*/
}
//----------------------------Sccb internal arbiteration------------------------------
//--When return from this function, I bit is turned off!!--
static kal_uint32 i2c_wait_transaction_complete_and_lock(SCCB_OWNER owner)
{
kal_uint32 savedMask;
while(1)
{
if(i2c_status.state==SCCB_READY_STATE)
{
savedMask = SaveAndSetIRQMask();
#if defined(I2C_DEBUG)
LT=DRV_Reg(0x80200000);
#endif
if(i2c_status.state==SCCB_READY_STATE) //The sccb is currently free
{
i2c_status.state=SCCB_BUSY_STATE; //Lock it
i2c_status.owner=owner;
I2C_POWER_ON;
return savedMask;
}
else
RestoreIRQMask(savedMask); // What a pity, that the handle is locked by somebody again. back to waiting loop
}
else if(sccb_handle[owner].sccb_config.get_handle_wait==KAL_FALSE)
return 0;
}//end of while
}
/* clear tx buffer */
static void USB2UART_ClrTxBuffer(UART_PORT port, module_type ownerid)
{
kal_uint32 savedMask;
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
}
#endif
drv_trace0(TRACE_FUNC, USBACM_CLEAR_TX_BUF);
// kal_prompt_trace(MOD_USB, "clrTx\n");
/* stop dma channel if current status is CDC ACM*/
if ( (gUsbDevice.device_type == USB_CDC_ACM) && (USB2UARTPort.initialized == KAL_TRUE)
&&(gUsbDevice.nDevState==DEVSTATE_CONFIG))
{
USB_Stop_DMA_Channel(g_UsbACM.txpipe->byEP, USB_TX_EP_TYPE);
}
savedMask = SaveAndSetIRQMask();
USB2UARTPort.Tx_Buffer.Write = 0;
USB2UARTPort.Tx_Buffer.Read = 0;
g_UsbACM.send_Txilm = KAL_TRUE;
RestoreIRQMask(savedMask);
drv_trace1(TRACE_FUNC, USBACM_CLEAR_TX_BUF_READY_TO_READ_FLAG, ownerid);
// kal_prompt_trace(MOD_USB, "clr RDY W %d", ownerid);
}
kal_bool sim_switchPhysicalSlotMapping(kal_bool inverse)
{
kal_uint32 maskValue;
maskValue = SaveAndSetIRQMask();
sim_physicalSlotChanged = inverse;
RestoreIRQMask(maskValue);
if(KAL_FALSE == maskValue)
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("SIM slots mapping is default mapping now");
#else
dbg_print("SIM slots mapping is default mapping now");
#endif
}
else
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("SIM slots mapping is inverse mapping now");
#else
dbg_print("SIM slots mapping is inverse mapping now");
#endif
}
return sim_physicalSlotChanged;
}
/*
* FUNCTION
* pmic_reg_write
*
* DESCRIPTION
* write data to PMIC
*
* CALLS
* used to write data to PMIC
*
* PARAMETERS
* data: write data
* register_index: register index
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*/
void pmic_reg_write(kal_uint8 data, kal_uint16 register_index)
{
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
B2PSI_write(data, register_index);
RestoreIRQMask(savedMask);
}
/** to workaround WHQA_00012220, "may not update way_en while disabling prefetch buffer",
* here provides an API to switch MCUBUS DCM dynamically.
*/
void DCM_MCUBUS_DCM_OFF(kal_uint32 off)
{
#if defined (REENTRY_SUPPORT)
kal_uint32 _savedMask;
_savedMask = SaveAndSetIRQMask();
if (0 != off) {
dcm_mcubus_dcm_off++;
}
else {
if (dcm_mcubus_dcm_off>0)
dcm_mcubus_dcm_off--;
}
RestoreIRQMask(_savedMask);
#else //#if defined (REENTRY_SUPPORT)
if (0 != off) {
dcm_mcubus_dcm_off++;
}
else {
if (dcm_mcubus_dcm_off>0)
dcm_mcubus_dcm_off--;
}
#endif //#if defined (REENTRY_SUPPORT)
#if defined (DCM_ENABLE)
*PWR_DCM_DEBUG_CON1 = reg_aor(*PWR_DCM_DEBUG_CON1, ~(1<<7), (0 != dcm_mcubus_dcm_off) ? (1<<7) : 0);
#endif //#if defined (DCM_ENABLE)
}
/* Init and set seek LISR and HISR functions
* @param None.
* @return None
*/
void video_set_seek_isr(DECODE_TYPE decode_type)
{
kal_uint32 savedMask;
if((decode_type == DECODE_TYPE_MPEG4) || (decode_type == DECODE_TYPE_H263))
{
savedMask = SaveAndSetIRQMask();
#ifdef DRV_MP4_V1
IRQMask(IRQ_MPEG4_CODE);
#else /*!DRV_MP4_V1*/
IRQMask(IRQ_MPEG4_DEC_CODE);
#endif /*DRV_MP4_V1*/
RestoreIRQMask(savedMask);
//savedMask = SaveAndSetIRQMask();
mpeg4_dec_init_isr_param();
g_mpeg4_dec_info_ptr->dec_state = MPEG4_DEC_STATE_SEEK;
#ifdef MP4_MOVE_LISR_TO_HISR
VISUAL_Register_HISR(VISUAL_MPEG4_SEEK_FIRST_HISR_ID, mpeg4_dec_seek_first_HISR);
#endif
VISUAL_Register_HISR(VISUAL_MP4_SEEK_HISR_ID, mpeg4_dec_seek_HISR);
#ifdef DRV_MP4_V1
IRQ_Register_LISR(IRQ_MPEG4_CODE, mpeg4_dec_seek_LISR, "MPEG4Seek");
IRQSensitivity(IRQ_MPEG4_CODE, LEVEL_SENSITIVE);
IRQUnmask(IRQ_MPEG4_CODE);
#else /*!DRV_MP4_V1*/
IRQ_Register_LISR(IRQ_MPEG4_DEC_CODE, mpeg4_dec_seek_LISR, "MPEG4Seek");
IRQSensitivity(IRQ_MPEG4_DEC_CODE, LEVEL_SENSITIVE);
IRQUnmask(IRQ_MPEG4_DEC_CODE);
#endif /*DRV_MP4_V1*/
//RestoreIRQMask(savedMask);
}
}
kal_bool sim_switchPhysicalSlotMapping(kal_bool inverse)
{
kal_uint32 maskValue;
maskValue = SaveAndSetIRQMask();
sim_physicalSlotChanged = inverse;
RestoreIRQMask(maskValue);
if(KAL_FALSE == maskValue)
{
#ifdef ATEST_DRV_ENABLE
dbg_print("SIM slots mapping is default mapping now");
#else
dhl_print(TRACE_INFO, DHL_USER_FLAG_NONE, MOD_SIM_DRV, "SIM slots mapping is default mapping now");
#endif
}
else
{
#ifdef ATEST_DRV_ENABLE
dbg_print("SIM slots mapping is inverse mapping now");
#else
dhl_print(TRACE_INFO, DHL_USER_FLAG_NONE, MOD_SIM_DRV, "SIM slots mapping is inverse mapping now");
#endif
}
return sim_physicalSlotChanged;
}
kal_int32 cc_irq_trigger_interrupt(kal_uint32 index, kal_uint32 para0, kal_uint32 para1, kal_uint32 para2)
{
kal_uint32 savedMask;
kal_int32 ret;
if (!CC_IRQ_TX_INDEX_IS_IN_RANGE(index))
{
return CC_IRQ_ERR_PARAM;
}
index = CC_IRQ_TX_INDEX_OFFSET(index);
savedMask = SaveAndSetIRQMask();
if (CC_IRQ_IS_TX_RESOURCE_AVAIL(index, CC_IRQ_PARA_DATA_LENGTH))
{
CC_IRQ_ENQUEUE_PARA(index, para0, para1, para2);
CC_IRQ_TRIGGER_INTR(index);
ret = CC_IRQ_SUCCESS;
}
else
{
ret = CC_IRQ_ERR_CHANNEL_FULL;
}
RestoreIRQMask(savedMask);
return ret;
}
/*
* FUNCTION
* GPTI_StopItem
*
* DESCRIPTION
* GPT stop a item.
*
* CALLS
*
* PARAMETERS
* moudle = UART_Module, SIM_Module, GPT_Module
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*/
void GPTI_StopItem(kal_uint8 module)
{
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
GPTTimer.status &= ~(1<<module);
if (GPTTimer.status == 0)
{
GPTTimer.GPTSTOP = KAL_TRUE;
GPTTimer.GPT_TICK = 0;
RestoreIRQMask(savedMask);
savedMask = SaveAndSetIRQMask();
if (((volatile kal_bool)GPTTimer.GPTSTOP) == KAL_TRUE)
GPT_Stop(gptimer_num);
}
RestoreIRQMask(savedMask);
}
void L1Audio_ClearFlag( uint16 audio_id )
{
uint32 savedMask;
if (!kal_if_hisr() && !kal_if_lisr())
kal_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_CLEARFLAG_A,audio_id,l1audio.runningState);
else
kal_dev_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_CLEARFLAG_A,audio_id,l1audio.runningState);
kal_take_sem( l1audio.sema, KAL_INFINITE_WAIT );
ASSERT( l1audio.id_flag & (1 << audio_id) );
ASSERT( l1audio.runningState & (1 << audio_id) );
savedMask = SaveAndSetIRQMask();
l1audio.runningState &= ~(1 << audio_id);
RestoreIRQMask( savedMask );
if(l1audio.runningState == 0 ) {
SLEEP_UNLOCK();
}
if( (l1audio.runningState == 0) && (l1audio.disallowSleepState == 0) ) {
#if defined( __CENTRALIZED_SLEEP_MANAGER__ )
Audio_Wake_DSP(audio_id, KAL_FALSE);
#endif
}
kal_give_sem( l1audio.sema );
}
/*************************************************************************
* FUNCTION
* DclAUX_Open
*
* DESCRIPTION
* This function is to open the AUX module and return a handle
* Note that multiple opens are prohibited.
*
* PARAMETERS
* dev: only valid for DCL_AUX
* flags: no sepcial flags is needed. Please use FLAGS_NONE
*
* RETURNS
* DCL_HANDLE_INVALID: Open failed
* Other value: A valid handle
*
*************************************************************************/
DCL_HANDLE DclAUX_Open(DCL_DEV dev, DCL_FLAGS flags)
{
DCL_HANDLE handle_tmp;
kal_uint32 savedMask;
kal_uint8 i;
if (dev != DCL_AUX)
{
ASSERT(0);
return DCL_HANDLE_INVALID; // Incorrecr device ID
}
if (dcl_aux_handle_count >= MAX_DCL_AUX_HANDLE)
{
ASSERT(0);
return DCL_HANDLE_INVALID; // Too many opened handles
}
for (i=0;i<MAX_DCL_AUX_HANDLE;i++)
{
if (dcl_aux_handle[i] == INVALID_AUX_SCHE_ID)
{
savedMask = SaveAndSetIRQMask();
dcl_aux_handle_count++;
dcl_aux_handle[i] = IN_USE_AUX_SCHE_ID;
handle_tmp = (DCL_AUX_DEV_MAGIC_NUM | i);
RestoreIRQMask(savedMask);
return handle_tmp;
}
}
return DCL_HANDLE_INVALID;
}
/*-----------------------------------------------------------------------
* FUNCTION
* GPTCB_StartItem
*
* DESCRIPTION
* GPT CB start a item.
*
* CALLS
*
* PARAMETERS
* handler = instance number
* tick = the delay(the unit is 10ms)
* gptimer_func = the callback function when the tick is reached.
* parameter = the parameter inputed into gptimer_func
*
* RETURNS
* KAL_TRUE, start item successfully
* KAL_FALSE, start item fail
*
* GLOBALS AFFECTED
* external_global
*------------------------------------------------------------------------*/
static kal_bool GPTCB_StartItem(DCL_HANDLE handler,kal_uint16 tick,void (*gptimer_func)(void *),void *parameter)
{
kal_uint32 savedMask;
if (gptCB_status & (1<<handler))
{
return KAL_FALSE;
}
savedMask = SaveAndSetIRQMask();
gptCB_items[handler].tick = gptCB_ticks + tick;
gptCB_items[handler].gptimer_func = gptimer_func;
gptCB_items[handler].parameter = parameter;
if(0 == gptCB_status)
{
drv_gpt_start_timer(DRV_GPT_CALLBACK_TIMER);
}
gptCB_status |= (1<<handler);
RestoreIRQMask(savedMask);
return KAL_TRUE;
}
void VideoCommClrAllQ(VIDEO_COMM_STATE_T *prCommState)
{
kal_uint32 u4SavedMask;
kal_uint32 i = 0;
u4SavedMask = SaveAndSetIRQMask();
if (prCommState->u4EntryCount != 0)
{
EXT_ASSERT(0, prCommState->u4EntryCount, 0, 0);
}
prCommState->rCmdQ.u4WriteIdx = 0;
prCommState->rCmdQ.u4ReadIdx = 0;
for (;i < VIDEO_PORT_MAX_NUM; i++)
{
prCommState->rInputBuffQ[i].u4WriteIdx = 0;
prCommState->rInputBuffQ[i].u4ReadIdx = 0;
prCommState->rInputBuffQ[i].u4UsedNum= 0;
prCommState->rOutputBuffQ[i].u4WriteIdx = 0;
prCommState->rOutputBuffQ[i].u4ReadIdx = 0;
prCommState->rOutputBuffQ[i].u4UsedNum= 0;
}
RestoreIRQMask(u4SavedMask);
}
/*************************************************************************
* FUNCTION
* EINT_RestoreMaskAll
*
* DESCRIPTION
* This function restores the MASK of the specified external interrupt
*
* PARAMETERS
* val - value to restore
*
* RETURNS
* No return
*
*************************************************************************/
void EINT_RestoreMaskAll(kal_uint32 val)
{
kal_uint32 savedMask;
#if 0
/* under construction !*/
/* under construction !*/
#if !defined(__HW_US_TIMER_SUPPORT__)
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
#endif
/* lockout interrupt */
savedMask = SaveAndSetIRQMask();
/*
* NoteXXX: The external interrupt should already be masked here (via the
* EINT_SaveAndMask() call). Only need to change the EINT_MASK
* when the external interrupt is originally un-masked.
*/
EINT_Set_Mask_all(0xffffffff);
EINT_Set_UnMask_all(~val);
/* un-lockout interrupt */
RestoreIRQMask(savedMask);
}
void ast_hif_set_driving_current(kal_uint32 current)
{
kal_uint32 saved_irq;
kal_uint8 tempCurrent;
switch(current)
{
case 0:
case 1:tempCurrent = 0;break;
case 2:
case 3:tempCurrent = 1;break;
case 4:
case 5:tempCurrent = 2;break;
case 6:
case 7:tempCurrent = 3;break;
default:tempCurrent = 1;
}
saved_irq = SaveAndSetIRQMask();
IO_DRV1 &= ~IO_DRV1_MASK_BITS;
IO_DRV1 |= (tempCurrent & IO_DRV1_MASK_BITS); // set ctrl pin driving current
IO_DRV1 &= ~(IO_DRV1_MASK_BITS << IO_DRV_OFFSET_8_BIT);
IO_DRV1 |= ((tempCurrent & IO_DRV1_MASK_BITS)<<IO_DRV_OFFSET_8_BIT); // set data pin driving current
IO_DRV2 &= ~IO_DRV2_MASK_BITS;
IO_DRV2 |= (current & IO_DRV2_MASK_BITS_2) |((current & IO_DRV2_MASK_BITS_2) << IO_DRV_OFFSET_4_BIT)\
|((current & IO_DRV2_MASK_BITS_2) << IO_DRV_OFFSET_8_BIT)\
|((current & IO_DRV2_MASK_BITS_2) << IO_DRV_OFFSET_12_BIT)\
|((current & IO_DRV2_MASK_BITS_2) << IO_DRV_OFFSET_16_BIT)\
|((current & IO_DRV2_MASK_BITS_2) << IO_DRV_OFFSET_20_BIT) ;
RestoreIRQMask(saved_irq);
}
/* Init and set decode LISR and HISR functions
* @param None.
* @return None
*/
void video_set_dec_isr(DECODE_TYPE decode_type)
{
kal_uint32 savedMask;
if((decode_type == DECODE_TYPE_MPEG4) || (decode_type == DECODE_TYPE_H263))
{
savedMask = SaveAndSetIRQMask();
#ifdef DRV_MP4_V1
IRQMask(IRQ_MPEG4_CODE);
#else /*!DRV_MP4_V1*/
IRQMask(IRQ_MPEG4_DEC_CODE);
#endif /*DRV_MP4_V1*/
RestoreIRQMask(savedMask);
//savedMask = SaveAndSetIRQMask();
mpeg4_dec_init_isr_param();
g_mpeg4_dec_info_ptr->dec_state = MPEG4_DEC_STATE_NORMAL;
#ifdef MP4_MOVE_LISR_TO_HISR
VISUAL_Register_HISR(VISUAL_MPEG4_DEC_FIRST_HISR_ID, mpeg4_dec_first_HISR);
#endif
VISUAL_Register_HISR(VISUAL_MPEG4_DEC_HISR_ID, mpeg4_dec_HISR);
//video_dec_set_enable_av_callback(mpeg4_dec_LISR);
//RestoreIRQMask(savedMask);
}
}
