/*
* FUNCTION
* IMGPROC_HISR_Entry
*
* DESCRIPTION
* Hisr for image processor(stands for filter mode)
*
* CALLS
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* imgproc_dcb.state
*/
void INTERN IMGPROC_HISR_Entry(void)
{
kal_uint32 reg = DRV_Reg32(IMGPROC_INTR);
#if (defined(DRV_IDP_6219_SERIES))
ASSERT(imgproc_dcb.mask != FILTER_NONE);
ASSERT(imgproc_dcb.state == IMGPROC_BUSY);
if(reg & IMGPROC_INTR_INT)
{
if(imgproc_dcb.cb)
imgproc_dcb.cb();
else
kal_set_eg_events(IMGPROC_Events,IMGPROC_EVENT,KAL_OR);
}
else
ASSERT(0);
imgproc_dcb.state = IMGPROC_READY;
#elif (defined(DRV_IDP_6228_SERIES))
if(reg & IMGPROC_INTR_INT)
kal_set_eg_events(IMGPROC_Events,IMGPROC_EVENT,KAL_OR);
else
ASSERT(0);
#endif
IRQClearInt(IRQ_IMGPROC_CODE);
IRQUnmask(IRQ_IMGPROC_CODE);
}
void nor_manual_reclaim(void)
{
#ifdef __NOR_FDM5__
kal_set_eg_events(nor_egid, NOR_BRECL_EVENT, KAL_OR);
#endif
return;
}
void nor_sweep_device(void)
{
#ifdef __NOR_FDM5__
kal_set_eg_events(nor_egid, NOR_DMAN_EVENT, KAL_OR);
#endif
return;
}
/*************************************************************************
* FUNCTION
* ipc_msgsvc_sendmsg_cb
*
* DESCRIPTION
* This function is the cb of sendmsg
*
* PARAMETERS
* bufp - ccci header
*
* RETURNS
* none
*
*************************************************************************/
void ccci_ipc_send_msg_cb(CCCI_CHANNEL_T channel, ccci_io_request_t* ior)
{
kal_uint32 i = 0;
ccci_io_request_t *current_ior = ior;
qbm_gpd *current_gpd;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_CB_FUNC_TRA);
while(current_ior != NULL){
current_gpd = current_ior->first_gpd ;
while( current_gpd != NULL){
CCCI_BUFF_T *bufp = CCCIDEV_GET_QBM_DATAPTR(current_gpd);
/* get task id from mapping table of ext queue id */
for (i = 0; i < MAX_CCCI_IPC_TASKS; i++)
{
if ( ccci_ipc_maptbl[i].extq_id == bufp->reserved )
{
break;
}
}
kal_set_eg_events(ccci_ipc_ch.event, (1 << i) , KAL_OR);
if (current_gpd == current_ior->last_gpd){
break;
}
else{
current_gpd = current_gpd->p_next;
}
}
qbmt_dest_q(ior->first_gpd, ior->last_gpd);
current_ior = current_ior->next_request;
}
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_CB_FUNC_PASS_TRA);
}
static void Kbd_hw_event_Callback(DCL_EVENT event, kal_uint8 key)
{
if(DCL_EVENT_HKBD_STATUS_CHANGE == event)
{
kal_set_eg_events(KBD.event,KBD_STATUS_CHANGE_EVENT,KAL_OR);
}
}
static void _IspVsyncTimeOutReportHandler(void *parameter)
{
if(IspVsyncGptHandle != NULL)
{
kal_set_eg_events(IspEventId,CAMERA_ISP_VD_READY_EVENT,KAL_OR);
IspVsyncGptTimeOut = KAL_TRUE;
}
}
void IspWaitOneFrameDone(ISP_VSYNC_TIME_OUT_UNIT TimeOut)
{
kal_uint32 EventGroup;
if(TimeOut ==0 || TimeOut > IspVsyncTimeOut500MS)
TimeOut = IspVsyncTimeOut500MS;
_IspVsyncTimeOutReportStart(TimeOut);
kal_set_eg_events(IspEventId,0,KAL_AND);
kal_retrieve_eg_events(IspEventId,CAMERA_ISP_FRAME_READY_EVENT,KAL_OR_CONSUME,&EventGroup,KAL_SUSPEND);
_IspVsyncTimeOutReportRelease();
}
void hif0_hisr(void)
{
if (hif_cb[0])
{
hif_cb[0]();
}
kal_set_eg_events(hif_events, 1, KAL_OR);
#if defined (HIF0_CHANNEL_SUPPORT)
IRQUnmask(IRQ_HIF_CODE);
#endif
}
void hif1_hisr(void)
{
if (hif_cb[1])
{
hif_cb[1]();
}
kal_set_eg_events(hif_events, 2, KAL_OR);
#if defined (HIF1_CHANNEL_SUPPORT)
IRQUnmask(IRQ_HIF_1_CODE);
#endif
}
/*****************************************************************************
* FUNCTION
* srv_cbm_lock
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void srv_cbm_unlock(kal_bool result)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, TRC_SRV_CBM_ALLOW_SET_EVENT_RESULT, result);
g_cbm_srv_cxt_ptr->nwk_srv.result = result;
kal_set_eg_events(g_cbm_srv_cxt_ptr->nwk_srv.wait_event,
CBM_NWK_DISALLOW_EVENT, KAL_OR);
return;
}
void IspWaitNVsync(ISP_VSYNC_TIME_OUT_UNIT TimeOut, kal_int32 Num)
{
kal_uint32 EventGroup;
if(TimeOut ==0 || TimeOut > IspVsyncTimeOut500MS)
TimeOut = IspVsyncTimeOut500MS;
if(Num == 0)
return;
while(Num>0)
{
_IspVsyncTimeOutReportStart(TimeOut);
kal_set_eg_events(IspEventId,0,KAL_AND);
kal_retrieve_eg_events(IspEventId,CAMERA_ISP_VD_READY_EVENT,KAL_OR_CONSUME,&EventGroup,KAL_SUSPEND);
_IspVsyncTimeOutReportRelease();
Num--;
}
}
/*************************************************************************
* FUNCTION
* mdci_hisr
*
* DESCRIPTION
* This function processes MDIF HISR.
*
* PARAMETERS
* none
*
* RETURNS
* none
*
*************************************************************************/
void mdci_hisr()
{
kal_uint32 channel, arb;
if (*MDIF_CON & MDIF_CON_ARB) {
arb = 1;
} else {
arb = 0;
}
/* get logical channel which has data to read */
for (channel = 0; channel < MDCI_MAX_CHANNEL; channel++) {
if (mdci_ctrl_pool[channel].state & MDCI_ACTIVE_ISR) {
#ifndef __IVP__
mdci_trans_log_pool[channel][mdci_trans_log_index[channel]].tick = kal_get_systicks();
#endif /* __IVP__ */
kal_mem_cpy(&(mdci_trans_log_pool[channel][mdci_trans_log_index[channel]].ct),&mdci_ctrl_pool[channel], sizeof(MDCI_CTRL_T));
mdci_trans_log_index[channel]++;
mdci_trans_log_index[channel]%=(DebugEntryNo);
if (mdci_ctrl_pool[channel].state & MDCI_ACTIVE_READ) {
/* a mdci_read() is waiting */
/* set an event */
#ifndef __IVP__
kal_set_eg_events(mdci_ctrl_pool[channel].event, 1, KAL_OR);
#else /* __IVP__ */
dbg_print("Error, IVP should not come here \n\r");
#endif
/* clear MDCI_ACTIVE_ISR (only keep MDCI_ACTIVE_READ) */
mdci_ctrl_pool[channel].state = MDCI_ACTIVE_READ;
} else {
/* invoke callback function */
if (mdci_ctrl_pool[channel].funp == NULL) {
EXT_ASSERT(0, channel, 0, 0);
} else {
mdci_ctrl_pool[channel].funp(&(mdci_ctrl_pool[channel].buff));
}
/* set IDLE */
mdci_ctrl_pool[channel].state = MDCI_IDLE;
}
/* only one channel at one time under sequential mode */
if (arb == 0) {
break;
}
}
}
if (arb == 0 && channel == MDCI_MAX_CHANNEL) {
ASSERT(0);
}
/* Unmask MDIF */
#if defined(MDIF_FOR_AP_SIDE)
IRQUnmask(IRQ_APMDIF_CODE);
#else
IRQUnmask(IRQ_MDIF_CODE);
#endif
}
void lcd_HISR(void)
{
#if (!defined(MT6205B)&&!defined(MT6208))
kal_uint32 save_irq_mask;
kal_uint8 i;
volatile kal_uint16 j;
#if !defined(DRV_IDP_SUPPORT)
#ifdef MT6225_IDP_DEBUG
dbg_time3=drv_get_current_time();
kal_prompt_trace(MOD_BMT,"lcd int= %d", dbg_time3);
#endif
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (main_lcd_operation_state==LCD_SW_UPDATE_STATE)
main_lcd_operation_state=LCD_STANDBY_STATE;
#ifdef DUAL_LCD
if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE)
sub_lcd_operation_state=LCD_STANDBY_STATE;
#endif
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
IRQUnmask(IRQ_LCD_CODE);
#elif defined(DRV_IDP_SUPPORT)
if (current_update_lcd==MAIN_LCD)
{
if (lcd_transfer_complete==KAL_TRUE)
{
if ((main_lcd_operation_state==LCD_SW_UPDATE_STATE)||
(main_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE)||
(main_lcd_operation_state==LCD_MEM_UPDATE_STATE))
{
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
#ifdef __VIDEO_EDITOR__
/*video editor*/
if(is_video_editor_running()==KAL_TRUE)
{
video_editor_data_path2();
main_lcd_operation_state=temp_main_lcd_operation_state;
}
#endif
}
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (main_lcd_operation_state==LCD_SW_UPDATE_STATE)
main_lcd_operation_state=LCD_STANDBY_STATE;
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
}
if (lcd_cmd_latch_complete==KAL_TRUE)/*set TRUE in LCD_LISR*/
{
if (lcd_hw_trigger_flag==KAL_TRUE)
{
#ifdef TV_OUT_SUPPORT
if ((tv_output_owner == TV_OUT_OWNER_LCD) && (tv_output_buffer_count<2))
{
IRQUnmask(IRQ_LCD_CODE);
return;
}
#endif
lcd_hw_trigger_flag=KAL_FALSE;
if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||/*back to video size*/
(main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
for (j=0;j<50;j++);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner == TV_OUT_OWNER_LCD)
{
if (tv_out_current_fb==0)
lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer1_address;
else
lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer2_address;
}
#endif
DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl);
DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset);
DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size);
#ifdef TV_OUT_SUPPORT
DRV_WriteReg32(LCD_ROI_WMEM_ADDR_REG,lcd_mem_out_address_shadow1);
#endif
for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++)
*((volatile unsigned int *) (LCD_CMD_PARAMETER_ADDR+(i<<2)))=lcd_hw_trigger_para[i];
#ifdef __SYNC_LCM_SW_SUPPORT__
if ((sync_lcm_enable_mode==KAL_TRUE)&&
((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
else
{
START_LCD_TRANSFER;
for (j=0;j<30;j++);
}
#else
START_LCD_TRANSFER;
for (j=0;j<30;j++);
#endif
}
else
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner!=TV_OUT_OWNER_LCD) {
DISABLE_LCD_TRANSFER_COMPLETE_INT;
}
#else
DISABLE_LCD_TRANSFER_COMPLETE_INT;
#endif
}
else /*lcd_hw_trigger_flag==KAL_FALSE*/
{
if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
}
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
}
}
#ifdef TV_OUT_SUPPORT
if (tv_output_buffer_rotate==1)
{
#if defined(DRV_TVOUT_6228_SERIES)
g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address1;
g2d_bitblt1(G2D_OWNER_LCD, &g2d_tv_output_bitblt);
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK,OK
//not necessary in 6238 because we use IRT3
#endif
tv_output_buffer_rotate=0;
}
else if (tv_output_buffer_rotate==2)
{
#if defined(DRV_TVOUT_6228_SERIES)
g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address2;
g2d_bitblt1(G2D_OWNER_LCD,&g2d_tv_output_bitblt);
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK,OK
//not necessary in 6238 because we use IRT3
#endif
tv_output_buffer_rotate=0;
}
#endif
#ifdef DUAL_LCD/*almost the same as the main LCD part, except TVout.*/
else if (current_update_lcd==SUB_LCD)
{
if (lcd_transfer_complete==KAL_TRUE)
{
if ((sub_lcd_operation_state==LCD_SW_UPDATE_STATE)||
(sub_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE))
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE)
sub_lcd_operation_state=LCD_STANDBY_STATE;
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
}
if (lcd_cmd_latch_complete==KAL_TRUE)
{
if (lcd_hw_trigger_flag==KAL_TRUE)
{
lcd_hw_trigger_flag=KAL_FALSE;
if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
for (j=0;j<100;j++);
DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl);
DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset);
DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size);
for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++)
DRV_WriteReg32(LCD_CMD_PARAMETER_ADDR+(i<<2),lcd_hw_trigger_para[i]);
#ifdef __SYNC_LCM_SW_SUPPORT__
if ((sync_lcm_enable_mode==KAL_TRUE)&&
((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
else
{
START_LCD_TRANSFER;
for (j=0;j<30;j++);
}
#else
START_LCD_TRANSFER;
for (j=0;j<30;j++);
#endif
}
else
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner!=TV_OUT_OWNER_LCD) {
DISABLE_LCD_TRANSFER_COMPLETE_INT;
}
#else
DISABLE_LCD_TRANSFER_COMPLETE_INT;
#endif
}
else
{
if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
}
}
#endif /* DUAL_LCD */
IRQUnmask(IRQ_LCD_CODE);
#endif /* MT6219 */
#endif /* MT6219 */
} /* lcd_HISR() */
/*****************************************************************************
* FUNCTION
* jpim_evtdb_handler
* DESCRIPTION
*
* PARAMETERS
* ilm_ptr [?] [?]
* RETURNS
*
*****************************************************************************/
kal_bool jpim_evtdb_handler(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
switch (ilm_ptr->msg_id)
{
case MSG_ID_MMI_EVTDB_JAVA_GET_ENTRY_RSP:
{
mmi_evtdb_java_get_entry_rsp_struct *p = (mmi_evtdb_java_get_entry_rsp_struct*) ilm_ptr->local_para_ptr;
if (jpim_evtdb_state == JPIM_EVTDB_STATE_GET_COUNT)
{
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_GET_COUNT_RSP);
jpim_evtdb_result = p->result;
jpim_evtdb_count = p->count;
kal_set_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_GETCOUNT, KAL_OR);
}
else if (jpim_evtdb_state == JPIM_EVTDB_STATE_GET_ENTRY)
{
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_GET_ENTRY_RSP);
jpim_evtdb_result = p->result;
kal_set_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_FETCH_INDEX, KAL_OR);
}
else
{
ASSERT(0);
}
jpim_evtdb_state = JPIM_EVTDB_STATE_IDLE;
break;
}
case MSG_ID_MMI_EVTDB_JAVA_SET_ENTRY_RSP:
{
mmi_evtdb_java_set_entry_rsp_struct *p = (mmi_evtdb_java_set_entry_rsp_struct*) ilm_ptr->local_para_ptr;
if (jpim_evtdb_state == JPIM_EVTDB_STATE_APPEND_ENTRY)
{
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_APPEND_ENTRY_RSP);
jpim_evtdb_result = p->result;
jpim_evtdb_index = p->index;
jpim_evtdb_handle = p->handle;
kal_set_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_APPEND_ENTRY, KAL_OR);
}
else if (jpim_evtdb_state == JPIM_EVTDB_STATE_UPDATE_ENTRY)
{
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_UPDATE_ENTRY_RSP);
jpim_evtdb_result = p->result;
jpim_evtdb_index = p->index;
jpim_evtdb_handle = p->handle;
kal_set_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_UPDATE_ENTRY, KAL_OR);
}
else if (jpim_evtdb_state == JPIM_EVTDB_STATE_DELETE_ENTRY)
{
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_DELETE_ENTRY_RSP);
jpim_evtdb_result = p->result;
kal_set_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_DELETE_ENTRY, KAL_OR);
}
else
{
ASSERT(0);
}
jpim_evtdb_state = JPIM_EVTDB_STATE_IDLE;
break;
}
default:
return KAL_FALSE;
}
return KAL_TRUE;
}
void L1Audio_SetEvent( uint16 audio_id, void *data )
{
l1audio.evData[audio_id] = data;
kal_set_eg_events( l1audio.aud_events, 1 << audio_id, KAL_OR ); /* Activate L1Audio Task */
}
/* GPT timer callback */
void e_compass_sample_cb(void *parameter)
{
kal_set_eg_events(e_compass_sensor_data.event,1,KAL_OR);
}
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;
}
