kal_bool l4crac_get_roaming_setting(roaming_setting_enum setting)
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
switch (setting)
{
case DISABLE_INTERNATIONAL_ROAMING_SETTING:
{
kal_brief_trace(TRACE_INFO, RAC_INTERNATIONAL_ROAMING_SUPPORT_SETTING, rac_ptr_g->disable_international_roaming_support);
return rac_ptr_g->disable_international_roaming_support;
}
case DISABLE_NATIONAL_ROAMING_SETTING:
{
kal_brief_trace(TRACE_INFO, RAC_NATIONAL_ROAMING_SUPPORT_SETTING, rac_ptr_g->disable_national_roaming_support);
return rac_ptr_g->disable_national_roaming_support;
}
case DISABLE_HPPLMN_SEARCH_SETTING:
{
kal_brief_trace(TRACE_INFO, RAC_DISABLE_HPPLMN_SEARCH_SETTING, rac_ptr_g->disable_hhplmn_search_support);
return rac_ptr_g->disable_hhplmn_search_support;
}
default:
DEBUG_ASSERT(0);
break;
}
return KAL_FALSE;
}
/*****************************************************************************
* FUNCTION
* l4c_ctm_send_text_req
* DESCRIPTION
*
* PARAMETERS
* src_id [IN]
* num_of_char [IN]
* text [?]
* RETURNS
*
*****************************************************************************/
kal_bool l4c_ctm_send_text_req(kal_uint8 src_id, kal_uint16 num_of_char, kal_uint16 *text)
{
#ifndef MED_NOT_PRESENT
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
if (is_ctm_cmd_conflict(src_id, CTM_SEND_TEXT) == KAL_TRUE)
{
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_FALSE;
}
if (num_of_char == 0)
{
if (l4c_ptr->ctm_user == LMMI_SRC)
{
l4c_ctm_send_text_lrsp(KAL_TRUE);
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
RMMI_PTR->current_src = src_id;
l4c_ctm_send_text_rrsp(KAL_TRUE);
}
#endif
return KAL_TRUE;
}
aud_send_ctm_send_text_req(l4c_current_mod_id, num_of_char, text);
l4c_set_user_action(L4C_CTM, src_id, CTM_SEND_TEXT);
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
#endif /* MED_NOT_PRESENT */
return KAL_TRUE;
}
void l4crac_set_roaming_setting(roaming_setting_enum setting, kal_bool is_turn_on)
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
if(is_rac_activating())
return ;
switch (setting)
{
case DISABLE_INTERNATIONAL_ROAMING_SETTING:
{
rac_ptr_g->disable_international_roaming_support = is_turn_on;
kal_brief_trace(TRACE_INFO, RAC_INTERNATIONAL_ROAMING_SUPPORT_SETTING, rac_ptr_g->disable_international_roaming_support);
break;
}
case DISABLE_NATIONAL_ROAMING_SETTING:
{
rac_ptr_g->disable_national_roaming_support = is_turn_on;
kal_brief_trace(TRACE_INFO, RAC_NATIONAL_ROAMING_SUPPORT_SETTING, rac_ptr_g->disable_national_roaming_support);
break;
}
case DISABLE_HPPLMN_SEARCH_SETTING:
{
rac_ptr_g->disable_hhplmn_search_support = is_turn_on;
kal_brief_trace(TRACE_INFO, RAC_DISABLE_HPPLMN_SEARCH_SETTING, rac_ptr_g->disable_hhplmn_search_support);
break;
}
default:
DEBUG_ASSERT(0);
break;
}
rac_save_preference();
}
/*****************************************************************************
* FUNCTION
* l4c_med_ctm_connected_ind_hdlr
* DESCRIPTION
*
* PARAMETERS
* local_para_ptr [?]
* peer_buff_ptr [?]
* RETURNS
* void
*****************************************************************************/
void l4c_med_ctm_connected_ind_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr)
{
//MAUI_02580295 media_ctm_connected_ind_struct *msg_ptr;
kal_bool ret_val = KAL_FALSE;
kal_uint8 temp_call_id;
l4c_call_entry_struct call_info;
kal_uint8 which_sim;
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
//MAUI_02580295 msg_ptr = (media_ctm_connected_ind_struct*) local_para_ptr;
kal_mem_set(&call_info,0,sizeof(l4c_call_entry_struct));
/* Currently, we always let L4C_1 to handle CTM */
#if defined(__GEMINI__)
/*
for GEMINI, find sim2...simN call
*/
for (which_sim = 0; which_sim < L4_MAX_SIM_NUM; which_sim++)
{
module_type this_l4c = L4_MODULE(MOD_L4C, which_sim);
l4c_context_struct* this_l4c_ptr = get_l4c_ptr_by_mod(this_l4c);
if (this_l4c_ptr->call_exist == KAL_TRUE)
{
kal_brief_trace(TRACE_INFO, INFO_SWITCH_CSM_CONTEXT, which_sim);
csmcc_context_selection(which_sim);
}
}
#endif
ret_val = l4ccsm_cc_get_active_call(&temp_call_id);
if((ret_val == KAL_TRUE) && (l4ccsm_cc_get_call_info(temp_call_id, &call_info, NULL) == KAL_TRUE))
{
if (call_info.src_id == LMMI_SRC)
{
l4c_ctm_connected_lind();
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
l4c_ctm_connected_rind();
}
#endif
l4c_ptr->is_ctm_connected = KAL_TRUE;
l4c_ptr->connected_src_id = call_info.src_id;
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
kal_brief_trace(L4C_CTM_TRC, CTM_CONTEXT, l4c_ptr->is_ctm_connected, l4c_ptr->connected_src_id, l4c_ptr->is_gpio_plug);
}
#if defined(__GEMINI__)
kal_brief_trace(TRACE_INFO, INFO_SWITCH_CSM_CONTEXT,SIM1);
csmcc_context_selection(SIM1);
#endif
}
/*****************************************************************************
* FUNCTION
* l4c_ctm_close_req
* DESCRIPTION
*
* PARAMETERS
* src_id [IN]
* RETURNS
*
*****************************************************************************/
kal_bool l4c_ctm_close_req(kal_uint8 src_id)
{
#ifndef MED_NOT_PRESENT
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
#if defined(__CTM_AT_CMD_SUPPORT__)
rmmi_context_struct *rmmi_ptr = RMMI_PTR; //for slim
#endif
if (is_ctm_cmd_conflict(src_id, CTM_CLOSE) == KAL_TRUE)
{
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_FALSE;
}
/* Johnny: for LMMI_SRC, L4C should send MMI_CTM_CONNECT_CNF to MMI before MEDIA_CTM_CLOSE_REQ */
if (l4c_ptr->ctm_current_action == CTM_CONNECT)
{
if (l4c_ptr->ctm_user == LMMI_SRC)
{
l4c_ctm_connect_lrsp(KAL_FALSE);
}
/*
* else
* {
* l4c_ctm_connect_rrsp(KAL_FALSE);
* }
*/
}
aud_send_ctm_close_req(l4c_current_mod_id);
//l4c_set_user_action(L4C_CTM, src_id, CTM_CLOSE);
/* Johnny: CTM_CLOSE always success, L4C send CLOSE_CNF immediately */
if (src_id == LMMI_SRC)
{
l4c_ctm_close_lrsp(KAL_TRUE);
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
rmmi_ptr->current_src = src_id;
l4c_ctm_close_rrsp(KAL_TRUE);
}
#endif
l4c_ptr->is_ctm_connected = KAL_FALSE;
l4c_ptr->connected_src_id = L4C_NO_USER;
l4c_set_user_action(L4C_CTM, L4C_NO_USER, L4C_NO_ACTION);
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
#endif /* MED_NOT_PRESENT */
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* l4crac_get_irat_preference
* DESCRIPTION
*
* to get Inter-RAT preference
*
* PARAMETERS
* none
*
* RETURNS
* TRUE or FALSE
* GLOBALS AFFECTED
*
******************************************************************************/
rat_enum l4crac_get_irat_preference(void)
{
#if defined(__UMTS_RAT__) && defined(__GSM_RAT__)
kal_brief_trace(TRACE_INFO, RAC_IRAT_PREFERENCE, rac_ptr_global->irat);
return rac_ptr_global->irat;
#elif defined(__GSM_RAT__)
kal_brief_trace(TRACE_INFO, RAC_IRAT_PREFERENCE, RAT_GSM);
return RAT_GSM;
#else
kal_brief_trace(TRACE_INFO, RAC_IRAT_PREFERENCE, RAT_UMTS);
return RAT_UMTS;
#endif
}
/*****************************************************************************
* FUNCTION
* l4c_ctm_set_default_req
* DESCRIPTION
*
* PARAMETERS
* src_id [IN]
* is_turn_on [IN]
* ctm_interface [IN]
* RETURNS
*
*****************************************************************************/
kal_bool l4c_ctm_set_default_req(kal_uint8 src_id, kal_bool is_turn_on, kal_uint8 ctm_interface)
{
nvram_write_req_struct *param_ptr;
l4c_ctm_default_settings_struct ctm_default_settings;
sim_interface_enum access_simId;
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
if (is_ctm_cmd_conflict(src_id, CTM_SET_DEFAULT) == KAL_TRUE) //MAUI_02602044
{
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_FALSE;
}
access_simId = l4c_gemini_get_actual_sim_id(l4c_current_mod_id - MOD_L4C);
param_ptr = (nvram_write_req_struct *)l4c_construct_nvram_write_local_para(src_id,
NVRAM_EF_CTM_DEFAULT_SETTINGS_LID,
(1+access_simId));
ctm_default_settings.is_turn_on = (kal_uint8) is_turn_on;
ctm_default_settings.ctm_interface = ctm_interface;
kal_mem_cpy(&(ctm_default_settings.ctm_param), &(l4c_ptr->ctm_default_settings.ctm_param), sizeof(ctm_param_struct));
l4c_send_msg_to_nvm(
MSG_ID_NVRAM_WRITE_REQ,
param_ptr,
(kal_uint8*) & ctm_default_settings,
sizeof(l4c_ctm_default_settings_struct));
//write nvram must success
if (l4c_ptr->is_gpio_plug == KAL_TRUE)
{
if (l4c_ptr->ctm_default_settings.is_turn_on == (kal_uint8) KAL_TRUE && is_turn_on == KAL_FALSE)
{
l4c_ctm_tty_plug_lind(KAL_FALSE);
}
if (l4c_ptr->ctm_default_settings.is_turn_on == (kal_uint8) KAL_FALSE && is_turn_on == KAL_TRUE)
{
l4c_ctm_tty_plug_lind(KAL_TRUE);
}
}
l4c_ptr->ctm_default_settings.is_turn_on = (kal_uint8) is_turn_on;
l4c_ptr->ctm_default_settings.ctm_interface = ctm_interface;
l4c_set_user_action(L4C_CTM, src_id, CTM_SET_DEFAULT);
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_TRUE;
}
void tcm_update_old_call_history_when_enter_data_plane_deconfigured_state( SESSION_INFO_PTR si_db_ptr, ilm_struct *ilm_ptr )
{
tcm_ratdm_deconfig_cnf_struct * tcm_ratdm_deconfig_cnf_ptr;
if(NULL != ilm_ptr)
{
#ifdef __TCM_NEW_ARCH_DEBUG__
ASSERT(MSG_ID_TCM_RATDM_DECONFIG_CNF == ilm_ptr->msg_id);
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_UPDATE_OLD_CALL_HISTORY_WHEN_ENTER_DATA_PLANE_DECONFIGURED_STATE);
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
tcm_ratdm_deconfig_cnf_ptr = (tcm_ratdm_deconfig_cnf_struct *)ilm_ptr->local_para_ptr;
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_TOTAL_TX_DATA_CHANGE,
(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->tx_data_octets),
TCM_PTR(total_tx_data)+(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->tx_data_octets));
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(total_tx_data) += (kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->tx_data_octets);
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_TOTAL_RX_DATA_CHANGE,
(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->rx_data_octets),
TCM_PTR(total_rx_data)+(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->rx_data_octets));
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(total_rx_data) += (kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->rx_data_octets);
if(si_db_ptr->context_id == TCM_PTR(last_context_id))
{
// This context id is the last established context id
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_LAST_TX_DATA_CHANGE,
TCM_PTR(last_tx_data),
(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->tx_data_octets));
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(last_tx_data) = (kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->tx_data_octets);
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_LAST_RX_DATA_CHANGE,
TCM_PTR(last_rx_data),
(kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->rx_data_octets));
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(last_rx_data) = (kal_uint32)(tcm_ratdm_deconfig_cnf_ptr->rx_data_octets);
}
// write call history to NVRAM
tcm_update_old_call_history_to_nvram();
}
}
void tcm_change_statistic_needs_update( kal_bool new_value )
{
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_STATISTICS_NEEDS_UPDATE_CHANGE, TCM_PTR(statistic_needs_update), new_value);
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(statistic_needs_update) = new_value;
}
kal_uint32 AVB_WriteSilence(kal_uint32 uSampleCount)
{
kal_uint32 uCopyWord=0, uOutByte=0, i, j, uOrigSrcWord, uChannelNumber, uOutWord;
kal_uint8 *pDst;
if(AVB.uState != AVB_STATE_RUNING)
{
return 0;
}
uOrigSrcWord = uSampleCount;
for(i=0;i<2;i++)
{
kal_int16 *pBuf;
rbGetWriteBuffer(&AVB.PCM, &pDst, &uOutByte);
uOutWord = uOutByte >> 1;
if(uOutWord > uSampleCount)
{
uOutWord = uSampleCount;
}
memset( pDst, 0, uOutWord*sizeof(kal_uint16) );
rbWriteDataDone(&AVB.PCM, uOutWord<<1);
uCopyWord += uOutWord;
uSampleCount -= uOutWord;
}
kal_brief_trace( TRACE_GROUP_SCO, L1AUDIO_AVB_WRITE_ZERO, uOrigSrcWord, uCopyWord, uOrigSrcWord-uCopyWord);
return uCopyWord;
}
static void CHR_USB_PLUG_OUT(void)
{
//kal_prompt_trace(MOD_BMT,"CHR_USB OUT");
kal_brief_trace( TRACE_STATE,BMT_CABLE_OUT_TRC);
if (chr_usb_detect.chr_usb_present == USB_PRESENT)
{
CHRDET_HISR();
#if defined(__USB_ENABLE__)
chr_usb_det_mgr.usb_det_hisr();
#endif // #if defined(__USB_ENABLE__)
}
else if (chr_usb_detect.chr_usb_present == CHARGER_PRESENT || chr_usb_detect.chr_usb_present == CHARGER_PRESENT_NON)
{
CHRDET_HISR();
}
else
{
ASSERT(0);
}
chr_usb_detect.chr_usb_present = NO_PRESENT;
pw_chr_type = PW_NO_CHR;
CHR_USB_EINT_UnMask(CHR_DET_EINT_OWNER_BMT); // EINT_UnMask(chr_usb_detect.chr_usb_eint);
}
void AFE_TurnOffLoopback( void )
{
*AFE_VLB_CON &= ~0x62; // for digital loopback
afe.loopback = KAL_FALSE;
kal_brief_trace(TRACE_STATE, AFE_SWITCH_LOOPBACK, '-');
}
void AFE_TurnOffLoopback( void )
{
*AFE_PCM_CON0 &= ~0x20000000;
afe.loopback = KAL_FALSE;
kal_brief_trace(TRACE_STATE, AFE_SWITCH_LOOPBACK, '-');
}
/*****************************************************************************
* FUNCTION
* l4c_med_ctm_recv_text_ind_hdlr
* DESCRIPTION
*
* PARAMETERS
* local_para_ptr [?]
* peer_buff_ptr [?]
* RETURNS
* void
*****************************************************************************/
void l4c_med_ctm_recv_text_ind_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr)
{
media_ctm_recv_text_ind_struct *msg_ptr;
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
msg_ptr = (media_ctm_recv_text_ind_struct*) local_para_ptr;
if (l4c_ptr->is_ctm_connected == KAL_TRUE)
{
if (l4c_ptr->connected_src_id == LMMI_SRC)
{
l4c_ctm_recv_text_lind(msg_ptr->num_of_char, msg_ptr->text);
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
l4c_ctm_recv_text_rind(msg_ptr->num_of_char, msg_ptr->text);
}
#endif
}
else
{
; //error, ignore it.
}
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
}
kal_bool l4crac_get_roaming_mode(void)
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
kal_brief_trace(TRACE_INFO, RAC_ROAMING_SUPPORT_SETTING, rac_ptr_g->is_supporting_roaming);
return rac_ptr_g->is_supporting_roaming;
}
/// Caller: Task
void AFE_TurnOnLoopback( void )
{
*AFE_VLB_CON |= 0x0022; // for digital loopback
*AFE_VLB_CON |= 0x0002;
afe.loopback = KAL_TRUE;
kal_brief_trace(TRACE_STATE, AFE_SWITCH_LOOPBACK, '+');
}
void tcm_change_statistic_is_writing( kal_bool new_value )
{
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_STATISTICS_IS_WRITING_CHANGE, TCM_PTR(statistic_is_writing), new_value);
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
TCM_PTR(statistic_is_writing) = new_value;
}
/* mtk02475:
* get/set function for GEMINI 2.0 feature
*/
kal_bool l4crac_get_peer_gprs_transfer_preference(void)
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
kal_brief_trace(TRACE_INFO, RAC_PEER_GPRS_TRANSFER_PREFERENCE, rac_ptr_g->peer_gprs_transfer_preference);
return rac_ptr_g->peer_gprs_transfer_preference;
}
hspa_preference_enum l4crac_get_hspa_preference()
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
kal_brief_trace(TRACE_INFO, RAC_HSPA_PREFERENCE, rac_ptr_g->hspa_preference);
return rac_ptr_g->hspa_preference;
}
plmn_list_preference_enum l4crac_get_plmn_list_preference()
{
rac_context_struct * rac_ptr_g = rac_ptr_global;
kal_brief_trace(TRACE_INFO, RAC_PLMN_LIST_PREFERENCE, rac_ptr_g->plmn_list_preference);
return rac_ptr_g->plmn_list_preference;
}
void DTMF_MCU_ReadDataDone(kal_uint32 uDataWord)
{
kal_brief_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_READ_DATA_DONE, uDataWord);
if(DTMF_SW.pHandle)
{
rbReadDataDone(&DTMF_SW.RingBuffer, uDataWord<<1);
}
}
/*****************************************************************************
* FUNCTION
* l4c_med_ctm_connect_cnf_hdlr
* DESCRIPTION
*
* PARAMETERS
* local_para_ptr [?]
* peer_buff_ptr [?]
* RETURNS
* void
*****************************************************************************/
void l4c_med_ctm_connect_cnf_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr)
{
media_ctm_connect_cnf_struct *msg_ptr;
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
msg_ptr = (media_ctm_connect_cnf_struct*) local_para_ptr;
if (msg_ptr->result == MED_RES_OK)
{
if (l4c_ptr->ctm_user == LMMI_SRC)
{
l4c_ctm_connect_lrsp(KAL_TRUE);
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
l4c_ctm_connect_rrsp(KAL_TRUE);
}
#endif
l4c_ptr->is_ctm_connected = KAL_TRUE;
l4c_ptr->connected_src_id = l4c_ptr->ctm_user;
}
else
{
if (l4c_ptr->ctm_user == LMMI_SRC)
{
l4c_ctm_connect_lrsp(KAL_FALSE);
}
#if defined(__CTM_AT_CMD_SUPPORT__)
else
{
l4c_ctm_connect_rrsp(KAL_FALSE);
}
#endif
}
if (l4c_check_user_action(L4C_CTM, (kal_uint8) l4c_ptr->ctm_user, CTM_CONNECT))
{
l4c_set_user_action(L4C_CTM, L4C_NO_USER, L4C_NO_ACTION);
}
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
kal_brief_trace(L4C_CTM_TRC, CTM_CONTEXT, l4c_ptr->is_ctm_connected, l4c_ptr->connected_src_id, l4c_ptr->is_gpio_plug);
}
void rbReadDataDone( AUD_RB_INFO *rb, kal_uint32 len ) // in bytes
{
rb->read += len;
ASSERT(rb->read <= rb->rb_size);
if( rb->read == rb->rb_size )
rb->read = 0;
kal_brief_trace( TRACE_GROUP_AUD_PROCESS, L1AUDIO_READ_BYTE, len );
}
/*****************************************************************************
* FUNCTION
* l4c_ctm_connect_req
* DESCRIPTION
*
* PARAMETERS
* src_id [IN]
* RETURNS
*
*****************************************************************************/
kal_bool l4c_ctm_connect_req(kal_uint8 src_id)
{
#ifndef MED_NOT_PRESENT
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
if (is_ctm_cmd_conflict(src_id, CTM_CONNECT) == KAL_TRUE)
{
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_FALSE;
}
aud_send_ctm_connect_req(l4c_current_mod_id);
l4c_set_user_action(L4C_CTM, src_id, CTM_CONNECT);
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
#endif /* MED_NOT_PRESENT */
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* l4c_root_set_pending_password_id
* DESCRIPTION
* link_SML
* PARAMETERS
* sim_id [IN] protocol stack ID
* password [IN] password
* RETURNS
* void
*****************************************************************************/
void l4c_root_set_pending_password_id(sim_interface_enum sim_id, smu_pending_password_id_enum password)
{
kal_uint8 actual_sim_id = l4c_gemini_get_actual_sim_id(sim_id);
kal_brief_trace(TRACE_FUNC,
FUNC_L4C_ROOT_GET_PENDING_PASSWORD_ID_ENTRY,
sim_id,
password);
L4C_ROOT_PTR->root_pending_password[actual_sim_id] = password;
}
/*****************************************************************************
* FUNCTION
* l4c_ctm_open_req
* DESCRIPTION
*
* PARAMETERS
* src_id [IN]
* ctm_interface [IN]
* RETURNS
*
*****************************************************************************/
kal_bool l4c_ctm_open_req(kal_uint8 src_id, kal_uint8 ctm_interface)
{
#ifndef MED_NOT_PRESENT
l4c_context_struct *l4c_ptr = L4C_PTR; //for slim
if (is_ctm_cmd_conflict(src_id, CTM_OPEN) == KAL_TRUE)
{
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
return KAL_FALSE;
}
/*
* if (L4C_PTR->ctm_default_settings.ctm_interface == CTM_DIRECT_MODE && L4C_PTR->is_gpio_plug == KAL_TRUE)
* {
* aud_send_ctm_open_req(l4c_current_mod_id, CTM_BAUDOT_MODE, &(L4C_PTR->ctm_default_settings.ctm_param));
* }
* else
* {
* aud_send_ctm_open_req(l4c_current_mod_id, L4C_PTR->ctm_default_settings.ctm_interface, &(L4C_PTR->ctm_default_settings.ctm_param));
* }
*/
if (src_id == LMMI_SRC)
{
/* Johnny: for LMMI_SRC, ctm_interface should == L4C_PTR->ctm_default_settings.ctm_interface */
aud_send_ctm_open_req(l4c_current_mod_id, ctm_interface, &(l4c_ptr->ctm_default_settings.ctm_param));
}
else
{
aud_send_ctm_open_req(
l4c_current_mod_id,
l4c_ptr->ctm_default_settings.ctm_interface,
&(l4c_ptr->ctm_default_settings.ctm_param));
}
l4c_set_user_action(L4C_CTM, src_id, CTM_OPEN);
kal_brief_trace(L4C_CTM_TRC, CTM_CURRENT, l4c_ptr->ctm_current_action, l4c_ptr->ctm_user);
#endif /* MED_NOT_PRESENT */
return KAL_TRUE;
}
/*******************************************************************************
* FUNCTION
* RMMI_UART_is_usb_active
* DESCRIPTION
* 1. to check if USB is still plug-in or not.
* If USB is in the suspend mode, it will send plug-out indication, too.
* So we need this API to check it.
* 2. only support by USB COM driver
* 3. Called when we want to close UART port
* 4. If the port is not USB port, default is KAL_FALSE
* 5. This function could be used only when handling plug-out
* PARAMETERS
*
* RETURNS
* KAL_TRUE : USB is reset and in the suspend mode
* KAL_FALSE : USB is plugout
*
*******************************************************************************/
kal_bool RMMI_UART_is_usb_active(UART_PORT port)
{
USB_DRV_CTRL_COM_TYPE_QUERY_T data;
DCL_HANDLE handle = DclSerialPort_Open(port,0);
data.is_cdcacm = KAL_FALSE;
DclSerialPort_Control(handle, USB_CMD_IS_CDCACM_ACTIVE, (DCL_CTRL_DATA_T*) &data);
kal_brief_trace(TRACE_INFO, INFO_RMMI_USB_ACTIVE, port, data.is_cdcacm);
return ((data.is_cdcacm==DCL_TRUE)?(KAL_TRUE):(KAL_FALSE));
} /* MAUI_02738549: 2011/03/02, avoid dialup on 1T1R USB COM */
static void AVB_HISR(void *data)
{
kal_brief_trace( TRACE_GROUP_SCO, L1AUDIO_AVB_HISR, AVB.uState, AVB.uSegment_W, AVB.uSegment_R);
AVB.uHisrRunning = KAL_TRUE;
if(AVB.uState == AVB_STATE_ENDING || AVB.uState == AVB_STATE_IDLE )
{
return;
}
if( *DSP_TONE_CTRL1 != 0 || *DSP_TONE_CTRL2 != 0 ) //playing speech tone, drop one frame
{
if(AVB.uSegment_W > AVB.uSegment_R)
{
AVB.uSegment_R++;
}
}
else
{
kal_uint16 uDSPAddr;
kal_int32 i;
kal_int16 *pDst, *pSrc;
uDSPAddr = *DSP_DM_ADDR(BT_AUDIO_PLAYBACK_SD_PAGE_NUM, BT_AUDIO_PLAYBACK_SD_PTR_ADDR);
pDst = (volatile kal_uint16 *)DSP_DM_ADDR(BT_AUDIO_PLAYBACK_SD_PAGE_NUM, uDSPAddr);
if(AVB.uSegment_W == AVB.uSegment_R || AVB.fSilence)
{ //fill silence
for(i=AVB_FRAME_SAMPLE-1;i>=0;i--)
{
*pDst++ = 0;
}
if(AVB_STATE_FLUSH_PING == AVB.uState)
{
AVB.uState = AVB_STATE_FLUSH_PONG;
}
else if(AVB_STATE_FLUSH_PONG == AVB.uState)
{
AVB.uState = AVB_STATE_ENDING;
}
}
else
{ //fill data
pSrc = AVB.pBuffer + (AVB.uSegment_R & AVB_SEGMENT_MASK) * AVB_FRAME_SAMPLE;
for(i=AVB_FRAME_SAMPLE-1;i>=0;i--)
{
*pDst++ = *pSrc++;
}
}
if(AVB.uSegment_W > AVB.uSegment_R)
{
AVB.uSegment_R++;
}
}
L1Audio_SetEvent( AVB.uAudID, NULL );
}
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();
}
void tcm_update_old_call_history_to_nvram( void )
{
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_UPDATE_OLD_CALL_HISTORY_TO_NVRAM);
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
if(TCM_PTR(statistic_is_writing) == KAL_FALSE)
{
tcm_send_write_statistic_to_nvram();
}
else
{
tcm_change_statistic_needs_update(KAL_TRUE);
}
}
