kal_bool csmss_init(void)
{
kal_bool ret_val = KAL_TRUE;
kal_uint8 index = 0;
kal_int8 i = 0;
for (i = 0; i < MAX_SIM_NUM; i++)
{
csmss_ptr_g = &csmss_g[i];
csmss_cur_mod = MOD_CSM + i;
kal_set_active_module_id(csmss_cur_mod);
#if defined (__CPHS__) || defined (__REL4__)
csmss_ptr_g->cfu_flag_len = 0;
csmss_ptr_g->cfis_record_len = 0;
#endif
for (index = 0; index < MMI_CS_MAX_CALLS; index++)
{
csmss_g_call_id_pool[index] = KAL_FALSE;
//MAUI_02857408, [AGPS][UP CP conflict] Support Parallel SS
csmss_g_ss_id_pool[index] = SS_ID_INVALID;
}
}
csmss_essp = 0;
csmss_g_ussd_string = (kal_uint8 *)csmss_g_ussd_string_buf;
return ret_val;
}
/*****************************************************************************
* FUNCTION
* med_task_main
* DESCRIPTION
* This function is main function of media task.
* PARAMETERS
* task_entry_ptr [?]
* RETURNS
* void
*****************************************************************************/
void med_task_main(task_entry_struct *task_entry_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
ilm_struct current_ilm;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#if !defined(L1_NOT_PRESENT) && !defined(__UE_SIMULATOR__)
SP_Drv_Init_Task();
#endif
while (1)
{
msg_receive_extq(¤t_ilm);
kal_set_active_module_id(current_ilm.dest_mod_id);
med_main((void*)¤t_ilm);
destroy_ilm(¤t_ilm);
}
}
/* ------------------------------------------------------------------------------ */
void AUDL_Task(task_entry_struct * task_entry_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
ilm_struct current_ilm;
/*----------------------------------------------------------------*/
/* Initialization */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body (Wait Message) */
/*----------------------------------------------------------------*/
while (1)
{
#if VERIFY_DATA_TO_DSP
VERIFY_DATA_TO_DSP_SAVE_DATA();
#endif
msg_receive_extq(¤t_ilm);
kal_set_active_module_id(MOD_AUDL);
AUDL_Msg_Handler((void*)¤t_ilm);
destroy_ilm(¤t_ilm);
}
}
static void uart_core_task_main(task_entry_struct* task_entry_ptr)
{
ilm_struct current_ilm;
kal_uint32 rt_event, uart_event=0;
kal_uint32 count = 0;
kal_set_active_module_id(MOD_UARTCORE);
kal_mem_set(¤t_ilm, 0, sizeof(ilm_struct));
while(1)
{
//dbg_print("=========>uartcore_task_main\r\n");
// msg_receive_extq will block, therefore we poll if any message exist first
while(msg_get_extq_messages() > 0)
{
if(msg_receive_extq(¤t_ilm) != KAL_TRUE)
{
break;
}
switch (current_ilm.msg_id)
{
default:
break;
}
destroy_ilm(¤t_ilm);
}
// wait some open uart port first time;
if(uart_open_event <= 0){
uart_event = hmu_hifeg_wait(HIF_DRV_EG_UART_IND_EVENT);
}
if((HIF_DRV_EG_UART_IND_EVENT & uart_event) || uart_open_event>0){
// Wait someone notify HMU to wake up HIF.
rt_event = hmu_hifeg_wait(HIF_DRV_EG_HIF_TICK_EVENT_UART);
if((HIF_DRV_EG_HIF_TICK_EVENT_UART & rt_event))
{
count++;
if(0 == (count % 1) )
{
if(uart_tgpd_head[uart_port1] != uart_tgpd_tail[uart_port1])
uart_en_q_de_q_with_mutex(uart_port1, UART_TX, UART_DE_Q, NULL, NULL);
if(uart_rgpd_head[uart_port1] != uart_rgpd_tail[uart_port1])
uart_en_q_de_q_with_mutex(uart_port1, UART_RX, UART_DE_Q, NULL, NULL);
#if defined(__FLAVOR_MULTI_MODE_ROUTER__) || defined(__FLAVOR_SINGLE_MODE_ROUTER__)
//in Router product. SUART0 is AP own, so it should not be init here.
#else
if(uart_tgpd_head[uart_port2] != uart_tgpd_tail[uart_port2])
uart_en_q_de_q_with_mutex(uart_port2, UART_TX, UART_DE_Q, NULL, NULL);
if(uart_rgpd_head[uart_port2] != uart_rgpd_tail[uart_port2])
uart_en_q_de_q_with_mutex(uart_port2, UART_RX, UART_DE_Q, NULL, NULL);
#endif
}
}
}
}
}
/*****************************************************************************
* FUNCTION
* ies_task_main
* DESCRIPTION
* image viewer daemon task main function & MSG loop
* PARAMETERS
* *task_entry_ptr [IN] task entry structure
* RETURNS
* void
*****************************************************************************/
static void ies_task_main(task_entry_struct *task_entry_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
ilm_struct current_ilm;
kal_uint32 msg_count;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_set_active_module_id(MOD_IES);
while(1)
{
/* peek and check command */
msg_count = msg_get_extq_messages();
while(msg_count > 0)
{
msg_receive_extq_for_stack(¤t_ilm);
_ies_task_dispatch_message(¤t_ilm);
destroy_ilm(¤t_ilm);
// consume ext queue eagerly
msg_count = msg_get_extq_messages();
}
if(!g_ies_task_context.pJob)
{
// At this point, there may be pending jobs.
_ies_task_job_handle_queue();
if (!g_ies_task_context.pJob)
{
// We still have nothing to do
if ((LIST_EMPTY(&(g_ies_task_context.normal))) &&
(LIST_EMPTY(&(g_ies_task_context.lowest))))
{
msg_receive_extq_for_stack(¤t_ilm);
_ies_task_dispatch_message(¤t_ilm);
destroy_ilm(¤t_ilm);
}
}
}
else
{
/* after processed all commands,
perform job iteration if there are active jobs. */
if(_ies_task_job_handle_start(g_ies_task_context.pJob))
{
// job finished
g_ies_task_context.pJob = NULL;
_ies_task_job_handle_queue();
}
}
}
}
static void l1audio_main(task_entry_struct * task_entry_ptr)
{
kal_set_active_module_id(MOD_L1SP);
#if defined( __SMART_PHONE_MODEM__ ) || defined(MT6516) || defined(TK6516)
L1Audio_Task( task_entry_ptr );
#else
L1Audio_Task( 0, 0 );
#endif
}
/*******************************************************************************
* FUNCTION
* cmux_task_main
* DESCRIPTION
* dispatch primitives to modules
*
* PARAMETERS
* IN *task_entry_ptr
* RETURNS
* void
* GLOBALS AFFECTED
* None
*******************************************************************************/
static void cmux_task_main(task_entry_struct *task_entry_ptr)
{
ilm_struct current_ilm;
while (1)
{
// External Queue
msg_receive_extq(¤t_ilm);
kal_set_active_module_id(current_ilm.dest_mod_id);
do {
#ifdef __MBIM_SUPPORT__
if (mbim_ctrl_dispatchMsg(¤t_ilm)) break;
#endif
#ifdef __USB_TETHERING__
if (rndis_ctrl_dispatchMsg(¤t_ilm)) break;
#endif
#ifdef __CMUX_SUPPORT__
if (cmux_dispatchMsg(¤t_ilm)) break;
#endif
break;
}while(1);
destroy_ilm(¤t_ilm);
// Internal Queue
#ifdef __CMUX_SUPPORT__
while (msg_receive_intq(¤t_ilm))
{
kal_set_active_module_id(current_ilm.dest_mod_id);
cmux_dispatchMsg(¤t_ilm);
destroy_ilm(¤t_ilm);
}
#endif
}
} /* end of cmux_task_main() */
void l1audio_sph_srv_task_main(task_entry_struct *task_entry_ptr)
{
ilm_struct current_ilm;
while(1)
{
msg_receive_extq(¤t_ilm);
kal_set_active_module_id(current_ilm.dest_mod_id);
l1audio_sph_srv_main((void *)¤t_ilm);
destroy_ilm(¤t_ilm);
}
}
void cccisrv_task_main(task_entry_struct *task_entry_ptr)
{
ilm_struct current_ilm;
ccci_rpc_task_main_init();
ccci_ipc_task_main_init();
#if defined(__CCCIFS_SUPPORT__)
ccci_fs_task_main_init();
#endif
kal_set_active_module_id(MOD_CCCISRV);
while (1) {
/*Receive message from ext queue, this may suspend.*/
if (KAL_TRUE == msg_receive_extq(¤t_ilm)) {
cccisrv_task_on_ilm(¤t_ilm);
}
}
}
void cccisrv_task_on_ilm(ilm_struct *ilm)
{
kal_uint32 idx;
for (idx = 0; idx < CCCISRV_MOD_CNT; ++idx) {
if (ilm->dest_mod_id == cccisrv_module_list_g[idx]) {
/* Switch to active module. */
kal_set_active_module_id(ilm->dest_mod_id);
/* Dispatch ILM according to dest_mod_id. */
cccisrv_ilm_func_list_g[idx](ilm);
break;
}
}
if (CCCISRV_MOD_CNT == idx) {
hif_trace_error(CCCISRV_TR_ILM_WRONG_DEST_MOD, ilm->dest_mod_id);
}
/* Free the ILM. */
destroy_ilm(ilm);
}
static void FT_Initialization(task_entry_struct *task_entry_ptr)
{
// active module ID in task_active_module_g
kal_set_active_module_id(MOD_FT);
FtInitMemoryPool();
// custom init
FT_CustomInit();
#if !defined(__L1_STANDALONE__)
// enable main LCD backlight
custom_cfg_gpio_set_level(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
#endif // #if !defined(__L1_STANDALONE__)
#ifdef L1_CATCHER
// L1 logging initialization
Trc_Init();
#endif // #ifdef L1_CATCHER
L1TST_Init();
FT_InitCalibrationData(task_entry_ptr);
FT_InitFtData();
#if ( defined(__HSDPA_SUPPORT__) || defined(__HSUPA_SUPPORT__) ) && defined(__MODEM_CARD__)
/// clear USB download RTC bit for HSPA data card project
INT_SetCmdToSys(SYS_CMD_CLR_DL_FLAG);
#endif // #if ( defined(__HSDPA_SUPPORT__) || defined(__HSUPA_SUPPORT__) ) && defined(__MODEM_CARD__)
}
void usbc_cosim_core_task_main(task_entry_struct* task_entry_ptr)
{
kal_uint8 wait_count = 0;
ilm_struct current_ilm;
kal_uint32 rt_event;
kal_uint16 timer_index;
module_type dest_mod;
msg_type msg_id;
usbc_class_device_esl_connect_parm *rsp_msg_p;
usbc_core_t* pUsbCore = usbc_core_get_instance();
kal_set_active_module_id(MOD_USBCORE);
kal_mem_set(¤t_ilm, 0, sizeof(ilm_struct));
usbc_esl_printf("Start USBCORE task loop...\n");
while(1)
{
while ( msg_get_extq_messages() > 0 )
{
if ( msg_receive_extq(¤t_ilm) != KAL_TRUE )
{
break;
}
switch (current_ilm.msg_id)
{
case MSG_ID_TIMER_EXPIRY:
timer_index = evshed_get_index(¤t_ilm);
switch (timer_index)
{
case USBC_WK_NOTIFY_INDEX:
ASSERT(0);
evshed_timer_handler(pUsbCore->usbc_es_wk_notify_g);
break;
default:
break;
}
break;
default:
break;
}
destroy_ilm(¤t_ilm);
}
/* Wait someone notify HMU to wake up HIF. */
rt_event = hmu_hifeg_wait(HIF_DRV_EG_HIF_TICK_EVENT | HIF_DRV_EG_USBC_IND_EVENT);
if ((HIF_DRV_EG_HIF_TICK_EVENT & rt_event) &&
(pUsbCore->state != USBC_USB_STATE_SUSPENDED))
{
/* poll HIF queue data */
usbc_esl_printf("Start HIF USB poll queue...\n");
usbc_normal_hif_poll_queue();
usbc_esl_printf("End HIF USB poll queue...\n");
}
if ((HIF_DRV_EG_USBC_IND_EVENT & rt_event))
{
/* Handle indications */
usbc_normal_hif_process_indications();
}
// wait for IPCORE finishing handling ILMs in ipc_init
if (wait_count < 1)
{
wait_count++;
if(wait_count == 1)
{
usbc_esl_printf("Emulare USB enumeration...\n");
// Emulate USB plug-in for ESL COSIM
usbc_cosim_hif_attach();
usbc_esl_printf("Set USB class to connected state...\n");
// change USB classes state to transfer data
rsp_msg_p = (usbc_class_device_esl_connect_parm*)construct_local_para(sizeof(usbc_class_device_esl_connect_parm), TD_RESET);
ASSERT(rsp_msg_p);
rsp_msg_p->class_device_id = 0;
msg_id = MSG_ID_USBCLASS_USBCORE_ESL_ENTER_CONNECTED_STATE_REQ;
switch ((pUsbCore->class_device[0]).class_type)
{
#ifdef __USB_MBIM_SUPPORT__
case USB_CLASS_MBIM:
dest_mod = MOD_MBIM;
break;
#endif
#ifdef __USB_ECM_SUPPORT__
case USB_CLASS_ECM:
dest_mod = MOD_ECM;
break;
#endif
#ifdef __USB_RNDIS_SUPPORT__
case USB_CLASS_RNDIS:
dest_mod = MOD_RNDIS;
break;
#endif
default:
// We assume the first class device must be a NIC for ESL CO-SIM
ASSERT(0);
return;
break;
}
msg_send6(MOD_USBCORE, // src module
dest_mod, // dst module
0, // sap id
msg_id,
(local_para_struct*)rsp_msg_p,
0); //msg id
}
}
}
}
static void audl_main(task_entry_struct * task_entry_ptr)
{
kal_set_active_module_id(MOD_AUDL);
AUDL_Task( task_entry_ptr );
}
