/*****************************************************************************
* FUNCTION
* vid_init
* DESCRIPTION
* This function is used to init video module of media task.
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool vid_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
vid_context_p->state = VID_IDLE;
vid_context_p->aud_state = VID_AUD_IDLE;
vid_context_p->vid_event = kal_create_event_group("vid_events");
vid_context_p->vid_event_ext = kal_create_event_group("vid_events_ext");
vid_context_p->image_path_open = KAL_FALSE;
vid_context_p->em_mode = VID_EM_MODE_DISABLED;
#ifdef __MED_VID_MOD__
vid_context_p->audio_frame_num = 0;
vid_context_p->total_frame_num = 0;
vid_context_p->current_time = 0;
vid_context_p->total_time = 0;
vid_context_p->display_width = 0;
vid_context_p->display_height = 0;
vid_context_p->image_width = 0;
vid_context_p->image_height = 0;
vid_context_p->file_size = 0;
vid_context_p->storing_path[0] = 0;
vid_context_p->handle = NULL;
vid_context_p->data_idx = -1;
vid_context_p->play_speed = 100;
vid_context_p->vid_get_time_mutex = kal_create_mutex("VID_GET_TIME");
#endif /* __MED_VID_MOD__ */
#if defined(__MED_MJPG_MOD__)
vid_context_p->total_frame_num = 0;
vid_context_p->current_time = 0;
vid_context_p->total_time = 0;
vid_context_p->display_width = 0;
vid_context_p->display_height = 0;
vid_context_p->image_width = 0;
vid_context_p->image_height = 0;
vid_context_p->file_size = 0;
vid_context_p->storing_path[0] = 0;
vid_context_p->mjpeg_mutex = kal_create_mutex("VID_MJPEG");
vid_context_p->mjpeg_insert_frame_count = 1;
vid_context_p->mjpeg_is_jpg_encoding = KAL_FALSE;
/* init avi kernel */
med_avi_init();
#endif /* defined(__MED_MJPG_MOD__) */
#ifdef __MED_VID_EDT_MOD__
vid_context_p->edt_video_buff_p = NULL;
#endif /*__MED_VID_EDT_MOD__*/
return KAL_TRUE;
}
/*
* FUNCTION
* IMGPROC_Init
*
* DESCRIPTION
* Initialize the IMGPROC driver and it should be called only once.
*
* CALLS
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
kal_int32 API IMGPROC_Init(void)
{
#if (defined(DRV_IDP_6219_SERIES))
ASSERT(IMGPROC_Events == 0);
IMGPROC_Events = kal_create_event_group("IMGPROC Events");
VISUAL_Register_HISR(VISUAL_IMGPROC_HISR_ID,IMGPROC_HISR_Entry);
IRQ_Register_LISR(IRQ_IMGPROC_CODE, IMGPROC_LISR_Entry,"IMGPROC");
IRQSensitivity(IRQ_IMGPROC_CODE,LEVEL_SENSITIVE);
IRQUnmask(IRQ_IMGPROC_CODE);
kal_mem_set(&imgproc_dcb,0,sizeof(IMGPROC_DCB_STRUCT));
#elif (defined(DRV_IDP_6228_SERIES))
IMGPROC_Events = kal_create_event_group("IMGPROC Events");
VISUAL_Register_HISR(VISUAL_IMGPROC_HISR_ID,IMGPROC_HISR_Entry);
IRQ_Register_LISR(IRQ_IMGPROC_CODE, IMGPROC_LISR_Entry,"IMGPROC");
IRQSensitivity(IRQ_IMGPROC_CODE,LEVEL_SENSITIVE);
IRQUnmask(IRQ_IMGPROC_CODE);
#endif
return NO_ERROR;
}
/******************************************************************
* FUNCTION
* cam_init
* DESCRIPTION
* This function is used to init camera module of media task.
* PARAMETERS
*
*
* RETURNS
*
* GLOBALS AFFECTED
*
*
******************************************************************/
kal_bool cam_init(void)
{
mmi_trace(g_sw_CAMERA, "Excute func : cam_init()");
cam_context_p->state = CAM_IDLE;
cam_context_p->capture_buffer_p=0;
cam_context_p->cam_event = kal_create_event_group("cam_events");
cam_context_p->intmem_start_address=0;
cam_context_p->extmem_start_address=0;
cam_context_p->int_frame_buffer_p=0;
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* always_ask_register_app_chain_add
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
BOOL srv_cbm_create_sem(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
g_cbm_srv_cxt_ptr->nwk_srv.wait_event = kal_create_event_group("cbm_wait_events");
return TRUE;
}
void ICUSB_ICCD_Init(kal_uint8 iccd_index)
{
/* Initailize the information, Cannot create Event on HISR */
if(g_UsbHostIccd[iccd_index].event_id == 0)
g_UsbHostIccd[iccd_index].event_id = kal_create_event_group("USB_ICCD_EVEVT");
if(g_UsbHostIccd[iccd_index].mutex_id == 0)
g_UsbHostIccd[iccd_index].mutex_id = kal_create_mutex("USB_ICCD_MUTEX");
USB_GPTI_GetHandle(&(g_UsbHostIccd[iccd_index].sleep_timer_handle));// DclSGPT_Open(DCL_GPT_CB, 0);
// if (g_UsbHostIccd[iccd_index].sleep_timer_handle == 0)
// g_UsbHostIccd[iccd_index].sleep_timer_handle = USB_GPTI_GetHandle();// DclSGPT_Open(DCL_GPT_CB, 0);
// GPTI_GetHandle(&g_UsbHostIccd[iccd_index].sleep_timer_handle);
}
/*************************************************************************
* FUNCTION
* ec_task_main
*
* DESCRIPTION
* This function implements xyz task's entry function
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void ec_task_main( task_entry_struct * task_entry_ptr )
{
kal_uint32 event_group;
/*initialize function*/
if (e_compass_sensor_data.event == NULL)
e_compass_sensor_data.event = kal_create_event_group("ECEVT");
e_compass_init();
while (1)
{
kal_retrieve_eg_events(e_compass_sensor_data.event,1,KAL_OR_CONSUME,&event_group,KAL_SUSPEND);
e_compass_main_hdr();
}
/* Do component task's processing here */
}
void ccci_ipc_init(void)
{
kal_uint32 p_cache_aligned;
//Send message does not need callback
ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.send_channel , ccci_ipc_send_msg_cb);
//send mesage ack need to implement callback
// ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.send_ack_channel , ccci_ipc_error_cb);
//Receive mesage need to implement callback
ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.receive_channel , ccci_ipc_receive_msg_cb);
//Receive mesage ack does not need to implement callback
// ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.receive_ack_channel , ccci_ipc_error_cb);
//Initialize the event for usage
if (ccci_ipc_ch.event == 0){
ccci_ipc_ch.event = kal_create_event_group("CCCI_IPC");
}
//Initialize the semaphore for critical section
if (ccci_ipc_ch.semaphore == 0){
ccci_ipc_ch.semaphore = kal_create_sem("CCCI_IPC",1);
}
/* initialize polling mode GPD */
ASSERT(CCCI_IPC_POLLING_MODE_BUF_SZ >= 2*CPU_CACHE_LINE_SIZE);
/*make p_gpd aligned to CPU_CACHE_LINE_SIZE_MASK*/
p_cache_aligned = (kal_uint32)g_ccci_ipc_polling_buf;
if(p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = ((kal_uint32)(g_ccci_ipc_polling_buf)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
// The reason + QBM_HEAD_SIZE is for ROME E1, cldma needs to record this buff whether is cacheable or non-cacheable
ccci_ipc_ch.p_polling_gpd = (qbm_gpd *)(p_cache_aligned + QBM_HEAD_SIZE);
// register ccci debug get status cb funp
ccci_debug_get_status_register(CCCI_DEBUG_GET_STATUS_MODULE_CCCIIPC, ccci_ipc_get_debug_status);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_ipc_ch.p_polling_gpd,ccci_ipc_ch.p_polling_gpd);
#ifdef CCCI_IT_MODE_CONTROL_CCCI_IPC
ccci_ipc_it_create();
#endif
}
/*****************************************************************************
* FUNCTION
* img_init
* DESCRIPTION
* This function is used to init image module of media task.
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool img_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
img_context_p->state = IMG_IDLE;
img_context_p->file_buffer_address = NULL;
img_context_p->intmem_start_address = NULL;
img_context_p->extmem_start_address = NULL;
img_context_p->processing = KAL_FALSE;
img_context_p->img_event = kal_create_event_group("img_events");
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* webcam_init
* DESCRIPTION
* This function is used to init tv output module of media task.
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool webcam_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
webcam_context_p->state = WEBCAM_IDLE;
webcam_context_p->intmem_start_address = 0;
webcam_context_p->intmem_size = 0;
webcam_context_p->buffer_addr = 0;
webcam_context_p->buffer_size = 0;
webcam_context_p->webcam_event = kal_create_event_group("webcam_events");
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* vcall_init
* DESCRIPTION
* initiation function for vcall
* PARAMETERS
* void
* RETURNS
* TRUE
*****************************************************************************/
kal_bool vcall_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_GROUP_4, VCALL_TRC_VCALL_INIT);
kal_mem_set(&vcall_ctx, 0, sizeof(vcall_context_struct));
vcall_ctx.event = kal_create_event_group("vcall_event");
vcall_ctx.video_encoder.cfg.callback = vcall_video_encoder_event_callback;
vcall_ctx.video_decoder.cfg.callback = vcall_video_decoder_event_callback;
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* ies_task_init
* DESCRIPTION
* image viewer daemon task init function
* PARAMETERS
* *task_indx [IN] task index
* RETURNS
* KAL_TRUE init OK
*****************************************************************************/
static kal_bool ies_task_init(task_indx_type task_indx)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
stack_set_active_module_id(INDX_IES, MOD_IES);
g_ies_task_context.pJob = NULL;
LIST_INIT(&(g_ies_task_context.normal));
LIST_INIT(&(g_ies_task_context.lowest));
g_srv_ies_job_mutex = kal_create_mutex("IESJOBMX");
g_srv_ies_job_event = kal_create_event_group("ies_evt");
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* tvo_init
* DESCRIPTION
* This function is used to init tv output module of media task.
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
kal_bool tvo_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
tvo_context_p->state = TVO_IDLE;
tvo_context_p->tv_output = KAL_FALSE;
tvo_context_p->tv_connected = KAL_FALSE;
tvo_context_p->tv_output_width = 0;
tvo_context_p->tv_output_height = 0;
tvo_context_p->tv_output_buffer1_address = 0;
tvo_context_p->tv_output_buffer2_address = 0;
tvo_context_p->tv_output_buffer_size = 0;
tvo_context_p->tvo_event = kal_create_event_group("tvo_events");
return KAL_TRUE;
}
static kal_bool l1audio_init(void)
{
#if (defined( __SMART_PHONE_MODEM__ ) && defined(__DSP_FCORE4__))
{
kal_int32 ret;
ret = ccci_owner_init(CCCI_PCM_CHANNEL_ACK, kal_get_task_by_moduleID(MOD_L1SP), spc_A2M_hisr);
if (ret != CCCI_SUCCESS) {
ASSERT(0);
}
ret = ccci_owner_init(CCCI_PCM_CHANNEL, kal_get_task_by_moduleID(MOD_L1SP), spc_M2A_hisr);
if (ret != CCCI_SUCCESS) {
ASSERT(0);
}
}
#endif
#if (defined( __SMART_PHONE_MODEM__ ) && defined(__DSP_FCORE4__))
aud_events = kal_create_event_group("L1Audio");
L1Audio_SMP_MsgQueueInit();
audio_id = L1Audio_GetAudioID();
id_flag = (1<<audio_id);
L1Audio_SMP_Init(audio_id);
#endif
#if defined(__AUDIO_DSP_LOWPOWER__) || defined(__AUDIO_DSP_LOWPOWER_V2__)
AUDLP_Init();
#endif
#if defined(__MTK_TARGET__)
audioDsp_dump.regions = (kal_uint32*)audioDsp_dump_regions;
audioDsp_dump.num = sizeof(audioDsp_dump_regions) / (sizeof(kal_uint32) * 3);
audioDsp_dump.bbreg_dump_callback = NULL;
EX_REGISTER_BBREG_DUMP(&audioDsp_dump);
#endif /* __MTK_TARGET__ */
return KAL_TRUE;
}
kal_bool IC_USB_POWER_ON(kal_uint8 iccd_index,kal_bool blocking)
{
kal_uint8 index;
kal_uint32 event_group;
if(g_UsbHostIccd[iccd_index].start_event_id == 0)
{
g_UsbHostIccd[iccd_index].start_event_id = kal_create_event_group("ICUSB_ENUMERATION");
}
else
{
/* Receive all events that may exist after previous detatch */
kal_retrieve_eg_events(g_UsbHostIccd[iccd_index].start_event_id, EVENT_ICUSB_ENUMERATION_DONE|EVENT_ICUSB_ENUMERATION_FAIL,
KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);
}
// for (index = USB_EXT_IP_NUM; index< USB_IP_NUM; index++) // only enable ICUSB Drive
for (index = 0; index< USB_IP_NUM; index++)
USBD_Init(index);
ICUSB_Drv_Init();
if (blocking == KAL_TRUE)
{
kal_retrieve_eg_events(g_UsbHostIccd[iccd_index].start_event_id, EVENT_ICUSB_ENUMERATION_DONE|EVENT_ICUSB_ENUMERATION_FAIL,
KAL_OR_CONSUME, &event_group, KAL_SUSPEND);
if (event_group & EVENT_ICUSB_ENUMERATION_FAIL)
return KAL_FALSE;
else
return KAL_TRUE;
}
else
{
return KAL_TRUE;
}
}
/* Note that this function should be called when first detect ms device*/
void USB_Host_Ms_State_Start(kal_uint8 ms_index)
{
kal_uint32 index;
kal_bool result;
// SGPT_CTRL_START_T start;
/* Initailize the information */
if(g_UsbHostMs[ms_index].event_id == 0)
g_UsbHostMs[ms_index].event_id = kal_create_event_group("USB_MS_EVEVT");
if(g_UsbHostMs[ms_index].mutex_id == 0)
g_UsbHostMs[ms_index].mutex_id = kal_create_mutex("USB_MS_MUTEX");
USB_GPTI_GetHandle(&(g_UsbHostMs[ms_index].gpt_handle));//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
// if (g_UsbHostMs[ms_index].gpt_handle == 0)
// g_UsbHostMs[ms_index].gpt_handle = USB_GPTI_GetHandle();//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
USB_GPTI_GetHandle(&(g_UsbHostMs[ms_index].sleep_timer_handle));//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
// if (g_UsbHostMs[ms_index].sleep_timer_handle== 0)
// g_UsbHostMs[ms_index].sleep_timer_handle = USB_GPTI_GetHandle();//DclSGPT_Open(DCL_GPT_CB, 0);//GPTI_GetHandle(&g_UsbHostMs.gpt_handle);
/* Get LUN, it contains the error handling */
result = USB_Host_Ms_Comp_Get_LUN(ms_index);
if(result == KAL_TRUE)
{
/* The got LUN is total lun - 1 */
g_UsbHostMs[ms_index].total_lun++;
/* If LUN number is larger than we can support, onlt the first N can be detected */
if(g_UsbHostMs[ms_index].total_lun > USB_HOST_MS_SUPPORT_LUN)
g_UsbHostMs[ms_index].total_lun = USB_HOST_MS_SUPPORT_LUN;
}
else
{
/* when device not implement this command, it is only one LUN */
g_UsbHostMs[ms_index].dev_error_count = 0;
g_UsbHostMs[ms_index].total_lun = 1;
}
/* Reset all the LUN state to absent state */
for(index = 0; index < g_UsbHostMs[ms_index].total_lun; index++)
{
g_UsbHostMs[ms_index].media_info[index].state = USB_HOST_MS_MEDIA_STATE_ABSENT;
}
/* Get LUN is success, continue to query each LUN info */
result = USB_Host_Ms_Query_All_Media(ms_index);
/* If result is fail, ms has been detached */
if(result == KAL_TRUE)
{
/* Query each LUN is success, continue to check whether each LUN is in card slot or not */
result = USB_Host_Ms_Check_All_Media(ms_index);
/* If result is fail, ms has been detached */
}
drv_trace1(TRACE_FUNC, (kal_uint32)USB_HOST_MS_CHECK_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change);
USB_Dbg_Trace(USB_HOST_MS_REPORT_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change, (kal_uint32)g_UsbHostMs[ms_index].b_sending_change_ilm);
if(result == KAL_TRUE)
{
/* To prevent USB disconn intr coming during this moment */
IRQMask(USB_IRQ_MAP[g_UsbHostMs[ms_index].common_info.usb_ip_port]);
if((g_UsbHostMs[ms_index].media_state_change != 0)&&(g_UsbHostMs[ms_index].b_sending_change_ilm == KAL_FALSE))
{
USB_Host_Ms_Check_Media_State(ms_index);
}
/* If device is plugged out, do not send this message */
if(g_UsbHostMs[ms_index].dev_attatch == KAL_TRUE)
{
/* Start timer to query device state */
USB_GPTI_StartItem(g_UsbHostMs[ms_index].gpt_handle, USB_HOST_MS_QUERY_PERIOD,USB_Host_Ms_State_Timeout, &g_UsbHostMs);
// start.u2Tick =USB_HOST_MS_QUERY_PERIOD;
// start.pfCallback = USB_Host_Ms_State_Timeout;
// start.vPara = &g_UsbHostMs[ms_index];
// DclSGPT_Control((DCL_HANDLE)(g_UsbHostMs[ms_index].gpt_handle), SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start);
}
if(USBD_Get_UnMask_Irq(g_UsbHostMs[ms_index].common_info) == KAL_TRUE)
IRQUnmask(USB_IRQ_MAP[g_UsbHostMs[ms_index].common_info.usb_ip_port]);
}
else
{
drv_trace0(TRACE_FUNC, (kal_uint32)USB_HOST_MS_STATE_START_FAIL);
}
}
void _FT_SendFtMsgByToken(module_type src_mod, module_type dest_mod, sap_type sap, msg_type msg, ilm_struct *ilm_ptr, kal_uint16 token)
{
ilm_ptr->src_mod_id = src_mod;
ilm_ptr->dest_mod_id = dest_mod;
ilm_ptr->msg_id = msg;
ilm_ptr->sap_id = sap;
#if !defined(__DHL_MODULE__)
if (dest_mod == MOD_TST) {
#else
if (dest_mod == MOD_DHL) {
#endif // #if !defined(__DHL_MODULE__)
((FT_H *)(ilm_ptr->local_para_ptr))->token=token;
ilm_ptr->src_mod_id = (module_type)0xA1;
ilm_ptr->dest_mod_id = (module_type)0;
ilm_ptr->sap_id = (sap_type)0xA3;
ilm_ptr->msg_id = (msg_type)2;
#if !defined(__DHL_MODULE__)
// directly copy primitive to TST ring buffer
tst_log_primitive_without_filter_check(
ilm_ptr,
RS232_LOGGED_PRIMITIVE_TYPE,
MSG_ID_LOGGED_PRIMITIVE);
#else
dhl_FT_log_primitive(ilm_ptr);
#endif // #if !defined(__DHL_MODULE__)
// cancel ilm, because we directly access TST ring buffer, no need to send primitive to TST
destroy_ilm(ilm_ptr);
return;
}
msg_send6(src_mod, dest_mod, sap, msg, ilm_ptr->local_para_ptr, ilm_ptr->peer_buff_ptr);
}
/*******************************************************************************
*
* FT Module Initialization Functions
*
*******************************************************************************/
/*******************************************************************************
* FUNCTION
* FT_InitFtData
*
* DESCRIPTION
*
* CALLS
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*******************************************************************************/
extern kal_int8 FT_FAT_Handle_Clear(void);
void FT_InitFtData()
{
FT_FAT_Handle_Clear();
#if !defined(__LTE_SM__)
FT_L1RfDataInit();
#endif // #if !defined(__LTE_SM__)
// init event group
ft_event_group_ptr = (kal_uint32) kal_create_event_group("FtEvent");
}
void hif_init(void)
{
// Init structure.
memset(hif_internal_handle, 0, sizeof(hif_internal_handle));
#if defined (HIF0_CHANNEL_SUPPORT)
// Init HIF interrupr
IRQ_Register_LISR(IRQ_HIF_CODE, hif0_lisr, "HIF0 ISR");
IRQSensitivity(IRQ_HIF_CODE, LEVEL_SENSITIVE);
//hif_hisr_id[0] = kal_create_hisr("HIF0_HISR", 0, 1024, hif0_hisr, KAL_TRUE);
DRV_Register_HISR(DRV_HIF0_HISR_ID, hif0_hisr);
IRQUnmask(IRQ_HIF_CODE);
#endif
#if defined (HIF1_CHANNEL_SUPPORT)
IRQ_Register_LISR(IRQ_HIF_1_CODE, hif1_lisr, "HIF1 ISR");
IRQSensitivity(IRQ_HIF_1_CODE, LEVEL_SENSITIVE);
//hif_hisr_id[1] = kal_create_hisr("HIF1_HISR", 0, 1024, hif1_hisr, KAL_TRUE);
DRV_Register_HISR(DRV_HIF1_HISR_ID, hif1_hisr);
IRQUnmask(IRQ_HIF_1_CODE);
#endif
/* DMA initialization */
#if defined (HIF0_CHANNEL_SUPPORT)
hif_sysdma_id[0] = DMA_GetChannel(DMA_HIF0);
hif_dma_menu[0].TMOD.burst_mode = KAL_FALSE;
hif_dma_menu[0].master = DMA_HIF0;
hif_dma_menu[0].addr = 0;
#endif
#if defined (HIF1_CHANNEL_SUPPORT)
hif_sysdma_id[1] = DMA_GetChannel(DMA_HIF1);
hif_dma_menu[1].TMOD.burst_mode = KAL_FALSE;
hif_dma_menu[1].master = DMA_HIF1;
hif_dma_menu[1].addr = 0;
#endif
// Configure DMA
//hif_dma_input.size = DMA_SHORT;
hif_dma_input[0].count = 0;
hif_dma_input[0].callback = NULL;
hif_dma_input[1].count = 0;
hif_dma_input[1].callback = NULL;
//hif_dma_input.menu = (void*) &hif_dma_menu;
//define ECO solution for MT6256E4,MT6575E2, MT6255E2 or MTK later chips
#if defined(MT6255) || defined(MT6256)//MT6255 and MT6256 support query chip version
chip_version = INT_SW_SecVersion(); //Query chip version
#endif
#if defined(__AST_TL1_TDD__) //HIF ECO only support for TDD project
#if defined(MT6575_S01)
hif_eco_support = KAL_FALSE;
#elif defined(MT6752)
hif_eco_support = KAL_TRUE;
#elif defined(MT6255) //MT6255E2 support HIF ECO
if(SW_SEC_0 != chip_version)
{
hif_eco_support = KAL_TRUE;
}
#elif defined(MT6256) //MT6256E4,MT6256E5 support HIF ECO
if(SW_SEC_1 == chip_version) //SW_SEC_0: MT6256E2,E3,E4, SW_SEC_1: MT6256E5
{
hif_eco_support = KAL_TRUE;
}
#endif
#endif
hif_events = kal_create_event_group("HIFDrv");
}
/* ------------------------------------------------------------------------------ */
void L1Audio_Task(unsigned argc, void *argv)
{
uint32 retrieved_events;
uint32 I;
uint16 tempID;
l1audio.aud_events = kal_create_event_group("L1Audio");
l1audio.hisr = kal_init_hisr(L1AUDIO_HISR);
GET_SLEEP_HANDLE();
#if ( defined( __CENTRALIZED_SLEEP_MANAGER__ ) && defined(MTK_SLEEP_ENABLE) && !defined(__AUDIO_POWERON_RESET_DSP__) )
l1audio.md2g_pdn_handle = L1D_MD2G_PWD_GetHandle();
l1audio.l1sm_handle = L1SM_IntGetHandle();
#endif
l1audio.runningState = 0;
l1audio.disallowSleepState = 0;
l1audio.dsp_slow_idle_counter = 0;
l1audio.event_flag = 0;
l1audio.id_flag = 0;
l1audio.media_flag = 0;
l1audio.postHisrHandler = (L1Audio_EventHandler)0;
l1audio.sema = kal_create_sem( "Aud_Sema", 1 );
l1audio.hisrMagicFlag = 0;
for( I = 0; I < MAX_HISR_HANDLER; I++ )
l1audio.hisrMagicNo[I] = 0;
tempID = L1Audio_GetAudioID();
L1Audio_SetFlag(tempID);
DSP_DynamicDownload_Init();
#ifndef L1D_TEST
/// Dynamic download for A/V sync
#if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__)
DSP_DynamicDownload( DDID_WAVETABLE );
#endif
#endif
AM_Init();
#if APM_SUPPORT
APM_Init();
#endif
/// AFE_Init will invoke L1Audio_GetAudioID
/// and expect to get the id 0 to make sure
/// it has the highest priority in the event group
AFE_Init();
#if !defined(__SMART_PHONE_MODEM__) && !defined(__L1_STANDALONE__) && !defined( MED_MODEM )
AVsync_Init();
#endif
#if defined(__AUDIO_POWERON_RESET_DSP__)
{
uint32 _savedMask;
_savedMask = SaveAndSetIRQMask();
AFE_Init_status(KAL_TRUE);
AFE_RegisterBackup();
RestoreIRQMask(_savedMask);
}
#endif
L1SP_Init();
ktInit( L1Audio_GetAudioID() );
toneInit( L1Audio_GetAudioID() );
mediaInit( L1Audio_GetAudioID() );
#if defined(VR_CYBERON)
vrsdInit();
#elif defined(VRSI_CYBERON)
vrsiInit();
#endif
toneLoopbackRecInit();
#if ( defined(__BT_A2DP_PROFILE__) || defined(SBC_UNIT_TEST) ) //&& !(APM_SUPPORT)
SBC_Init();
#endif
#if defined(__BES_TS_SUPPORT__)
AudioPP_TS_Init();
#endif
#ifdef __CTM_SUPPORT__
l1ctm_init();
#endif
#ifdef __TWOMICNR_SUPPORT__
Two_Mic_NR_chip_Init();
#endif
#if VMI_SUPPORT || defined(VORTP_UNIT_TEST)
VMI_Init();
#endif
#if VORTP_SUPPORT || defined(VORTP_UNIT_TEST)
VoRTP_Init();
#endif
#if defined(CYBERON_DIC_TTS) || defined(IFLY_TTS) || defined(SINOVOICE_TTS)
ttsInit();
#endif
#if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__)
DSPSYN_HW_Init();
#endif
#if defined( __I2S_INPUT_MODE_SUPPORT__ )
I2S_init();
#endif
#if defined(__VOICE_CHANGER_SUPPORT__)
VCHG_Initialize();
#endif
#if defined(__AUDIO_COMPONENT_SUPPORT__) && !defined(__L1_STANDALONE__) && !defined(MED_MODEM)
// KH : for audio component
ACU_Init();
#endif
#if defined(__CVSD_CODEC_SUPPORT__)
{
extern void BT_SCO_Init(void);
BT_SCO_Init();
}
#endif
memset( &(l1audio.debug_info), 0, sizeof(l1audio.debug_info) );
AFE_TurnOnFIR( L1SP_SPEECH );
AFE_TurnOnFIR( L1SP_VOICE );
L1Audio_ClearFlag(tempID);
L1Audio_FreeAudioID(tempID);
l1audio.isInitiated = KAL_TRUE;
while( 1 ) {
#if VERIFY_DATA_TO_DSP
VERIFY_DATA_TO_DSP_SAVE_DATA();
#endif
kal_retrieve_eg_events(l1audio.aud_events,0xFFFF,KAL_OR_CONSUME,&retrieved_events,KAL_SUSPEND);
l1audio.retrieved_events = retrieved_events;
l1audio.events_l1FN = L1I_GetTimeStamp();
for( I = 0; I < MAX_AUDIO_FUNCTIONS; I++ ) {
if ( l1audio.retrieved_events & (1<<I) ) {
l1audio.evHandler[I]( l1audio.evData[I] );
}
}
//if( (l1audio.runningState & l1audio.disallowSleepState) == 0 )
if( l1audio.runningState == 0 )
SLEEP_UNLOCK();
}
}
/*************************************************************************
* FUNCTION
* mdci_read
*
* DESCRIPTION
* This function reads data through either mailbox channel or stream
* channel.
*
* PARAMETERS
* channel - logical channel
* buff - pointer to channel buffer
*
* RETURNS
* MDIF error code.
*
*************************************************************************/
kal_int32 mdci_read(MDCI_CHANNEL_T channel, MDCI_BUFF_T *buff)
{
kal_uint32 owner, mask, ret, event;
kal_char event_name[20];
#ifdef __IVP__
dbg_print("Error.... can not use mdci_read in IVP\n\r");
while(1);
#endif
/* check if a LISR is running */
if (kal_if_lisr())
return MDCI_IN_LISR;
/* check parameters */
if (channel >= MDCI_MAX_CHANNEL)
return MDCI_INVALID_PARAM;
if (buff == NULL)
return MDCI_INVALID_PARAM;
/* get the current task */
owner = (kal_uint32)kal_get_current_thread_ID();
/* check owner */
if (mdci_ctrl_pool[channel].owner != owner && mdci_is_chanel_need_check_owner(channel)) {
return MDCI_NOT_OWNER;
}
/* create an event for the first use */
if (mdci_ctrl_pool[channel].event == NULL) {
sprintf(event_name, "MDIF%d event", channel);
mdci_ctrl_pool[channel].event = kal_create_event_group(event_name);
if (mdci_ctrl_pool[channel].event == NULL)
ASSERT(0);
}
/* check state */
ret = MDCI_SUCCESS;
mask = SaveAndSetIRQMask();
if (mdci_ctrl_pool[channel].state != MDCI_IDLE) {
ret = MDCI_IN_USE;
} else {
/* set ACTIVE_WRITE */
mdci_ctrl_pool[channel].state = MDCI_ACTIVE_READ;
}
RestoreIRQMask(mask);
if (ret != MDCI_SUCCESS)
return ret;
#ifndef __IVP__
/* wait for the event */
kal_retrieve_eg_events(mdci_ctrl_pool[channel].event, 1, KAL_OR_CONSUME, &event, KAL_SUSPEND);
#endif
if (event != 1) {
ASSERT(0);
}
/* read channel buffer */
memcpy(buff, &(mdci_ctrl_pool[channel].buff), sizeof(MDCI_BUFF_T));
/* set ACTIVE_IDLE */
mdci_ctrl_pool[channel].state = MDCI_IDLE;
return MDCI_SUCCESS;
}
