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); } }