static void _ies_task_job_respond(srv_ies_job *pJob, kal_uint32 seqNum, srv_ies_result result) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ srv_ies_ilm_job_response *pResp; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ pResp = (srv_ies_ilm_job_response*)construct_local_para(sizeof(srv_ies_ilm_job_response), TD_CTRL); ASSERT(NULL != pResp); pResp->pJob = pJob; pResp->seqNum = seqNum; pResp->result = result; msg_send5(MOD_IES, pJob->modID, MMI_MMI_SAP, MSG_ID_IES_JOB_RSP, (local_para_struct*)pResp); }
/***************************************************************************** * FUNCTION * bpp_adp_progress_ind * DESCRIPTION * This function send progress to bpp app(mmi) * PARAMETERS * printer [?] [?] * RETURNS * void *****************************************************************************/ static void bpp_adp_progress_ind(bt_bpp_progress_status *prog_status) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ //float precent = 0.0; bt_bpp_progress_ind_struct *progress_ind = (bt_bpp_progress_ind_struct*) construct_local_para(sizeof(bt_bpp_progress_ind_struct), TD_CTRL); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ progress_ind->hprinter = g_bpp_adp_cntx.printer_handle; progress_ind->progress_status.sent_data_len = prog_status->sent_data_len; progress_ind->progress_status.total_data_len = prog_status->total_data_len; bpp_adp_send_msg2app(MSG_ID_BT_BPP_PROGRESS_IND, (local_para_struct*) progress_ind); }
/***************************************************************************** * FUNCTION * phb_sat_file_change_confirm * DESCRIPTION * This is phb_sat_file_change_confirm function of PHB module. * PARAMETERS * result [IN] * src_id [IN] * control_block [?] * ilm_ptr(?) [IN] The primitives * RETURNS * void *****************************************************************************/ void phb_sat_file_change_confirm(phb_errno_enum result, kal_uint8 src_id, control_block_type *control_block) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ local_para_struct *local_param_ptr = NULL; sat_file_change_res_struct *sat_file_change_res; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, FUNC_PHB_SAT_FILE_CHANGE_CNF, result, src_id); sat_file_change_res = (sat_file_change_res_struct*) construct_local_para( sizeof(sat_file_change_res_struct), TD_CTRL); sat_file_change_res->src_id = src_id; local_param_ptr = (local_para_struct*) sat_file_change_res; /* Reject newly received request */ if (result == PHB_ERRNO_BUSY) { sat_file_change_res->is_successful = KAL_FALSE; } else { sat_file_change_res->is_successful = (result == PHB_ERRNO_SUCCESS) ? KAL_TRUE : KAL_FALSE; if (control_block) { phb_free_control_block(control_block); } } phb_send_ilm(MOD_SIM, MSG_ID_SAT_FILE_CHANGE_RES, local_param_ptr, NULL); } /* end of phb_sat_file_change_confirm */
/***************************************************************************** * FUNCTION * bpp_adp_get_attr_confirm * DESCRIPTION * This function send get attr confirm to bpp app (mmi) * PARAMETERS * printer [?] [?] * err_code [IN] * RETURNS * void *****************************************************************************/ static void bpp_adp_get_attr_confirm(BPP_ERROR_CODE err_code, bt_bpp_printer_attributes *attr) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_bpp_get_printer_attr_cnf_struct *get_attr_cnf = NULL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO_ARG1(BPP_ADP_GET_ATTR_CONFIRM,err_code); get_attr_cnf = (bt_bpp_get_printer_attr_cnf_struct*) construct_local_para(sizeof(bt_bpp_get_printer_attr_cnf_struct), TD_CTRL); OS_MemSet((U8*)&get_attr_cnf->printer_attributes, 0, sizeof(get_attr_cnf->printer_attributes)); get_attr_cnf->hprinter = g_bpp_adp_cntx.printer_handle; get_attr_cnf->cnf_code = err_code; if (attr != NULL) { get_attr_cnf->printer_attributes.printer_state = attr->printer_state; get_attr_cnf->printer_attributes.state_reason = attr->state_reason; } if (err_code == BPP_SUCCESS) { OS_MemCopy((U8*)&get_attr_cnf->printer_attributes.capability, (U8*)&attr->capability, sizeof(bt_bpp_printer_capability)); } if (g_bpp_adp_cntx.cur_req == BPP_REQ_GETPRINTERATTR) { g_bpp_adp_cntx.cur_req = BPP_REQ_NONE; } bpp_adp_send_msg2app(MSG_ID_BT_BPP_GET_PRINTER_ATTR_CNF, (local_para_struct*) get_attr_cnf); }
void tcm_send_write_statistic_to_nvram( void ) { nvram_write_req_struct *msg_ptr = NULL; peer_buff_struct *pPeerBuf = NULL; #ifndef __MASE__ nvram_ef_tcm_statistics_struct *pbPdu = NULL; #endif kal_uint16 wPeerLen = 0; /* Send message to nvram */ msg_ptr = (nvram_write_req_struct *)construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL); ASSERT(NULL != msg_ptr); msg_ptr->file_idx = NVRAM_EF_TCM_STATISTICS_LID; msg_ptr->para = (tcm_get_actual_sim_id()+1); //for SIM1, para == 1, for SIM2, para == 2, for SIM3, para == 3, for SIM4, para == 4 msg_ptr->access_id = 0xFF; /* Indicate NVRAM writing is trigerred from TCM not L4C */ pPeerBuf = construct_peer_buff(NVRAM_EF_TCM_STATISTICS_SIZE, 0, 0, TD_CTRL); #ifndef __MASE__ pbPdu = (nvram_ef_tcm_statistics_struct *) get_peer_buff_pdu(pPeerBuf, &wPeerLen); TCM_INTERNAL_DEBUG_ASSERT(sizeof(nvram_ef_tcm_statistics_struct) == wPeerLen && NULL != pbPdu); pbPdu->total_rx_data = TCM_PTR(total_rx_data); pbPdu->total_tx_data = TCM_PTR(total_tx_data); pbPdu->last_rx_data = TCM_PTR(last_rx_data); pbPdu->last_tx_data = TCM_PTR(last_tx_data); #endif #ifdef __TCM_NEW_ARCH_DEBUG__ kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_CONTENT, TCM_PTR(total_tx_data), TCM_PTR(total_rx_data), TCM_PTR(last_tx_data), TCM_PTR(last_rx_data)); #endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__ tcm_send_msg_to_nvram(MSG_ID_NVRAM_WRITE_REQ, (local_para_struct*)msg_ptr, pPeerBuf); /* Update the statisti flag */ tcm_change_statistic_is_writing(KAL_TRUE); tcm_change_statistic_needs_update(KAL_FALSE); }
static void bpp_adp_disconnect_ind(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_bpp_disconnect_ind_struct *disc_ind; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO(BPP_ADP_DISC_IND); if(g_bpp_adp_cntx.cm_conn_id != BPP_INVALID_CMID) { BT_BPP_TRACE_INFO_ARG1(BPP_ADP_RELEASE_CM_CONNID, g_bpp_adp_cntx.cm_conn_id); BTBMProfileReleaseConnIndex(g_bpp_adp_cntx.cm_conn_id); g_bpp_adp_cntx.cm_conn_id = (U8)BPP_INVALID_CMID; } if (g_bpp_adp_cntx.cur_req == BPP_REQ_CANCEL) { bpp_adp_cancel_confirm(BPP_SUCCESS); } disc_ind = (bt_bpp_disconnect_ind_struct*) construct_local_para(sizeof(bt_bpp_disconnect_ind_struct), TD_CTRL); disc_ind->hprinter = g_bpp_adp_cntx.printer_handle; //disc_ind->cm_conn_id = g_bpp_adp_cntx.cm_conn_id; g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE; g_bpp_adp_cntx.cur_req = BPP_REQ_NONE; bpp_adp_send_msg2app(MSG_ID_BT_BPP_DISCONNECT_IND, (local_para_struct*) disc_ind); }
/***************************************************************************** * FUNCTION * bpp_adp_status_ind * DESCRIPTION * This function send printer status msg to bpp app(mmi) * PARAMETERS * printer [?] [?] * prt_status [?] * status_ind [?](?) * RETURNS * void *****************************************************************************/ static void bpp_adp_status_ind(bt_bpp_job_status *prt_status) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO(BPP_ADP_STATUS_IND); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ if (prt_status) { bt_bpp_job_status_ind_struct *status_ind = (bt_bpp_job_status_ind_struct*) construct_local_para(sizeof(bt_bpp_job_status_ind_struct), TD_CTRL); status_ind->hprinter = g_bpp_adp_cntx.printer_handle; status_ind->job_status.printer_state = prt_status->printer_state; status_ind->job_status.job_state = prt_status->job_state; status_ind->job_status.state_reason = prt_status->state_reason; bpp_adp_send_msg2app(MSG_ID_BT_BPP_JOB_STATUS_IND, (local_para_struct*) status_ind); } }
static void UART_HISR(void) { ilm_struct *UART_ilm; uart_ready_to_write_ind_struct* _data; if(g_msgid == MSG_ID_UART_READY_TO_WRITE_IND) { _data = (uart_ready_to_write_ind_struct *) construct_local_para(sizeof(uart_ready_to_write_ind_struct),TD_UL); _data->port = g_port; } else { _data = NULL; } DRV_BuildPrimitive(UART_ilm, UARTPort[g_port].UART_id, UARTPort[g_port].ownerid, g_msgid, _data); msg_send_ext_queue(UART_ilm); }
/***************************************************************************** * FUNCTION * mmi_da_wps_send_cancel_req * DESCRIPTION * Send "cancel request" to WAP task to cancel an action. * PARAMETERS * request_id IN action, reference to mmi_da_oma_request_id_enum * RETURNS * MMI_TRUE: OK * MMI_FALSE: false *****************************************************************************/ static BOOL mmi_da_wps_send_cancel_req(U8 request_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ wps_cancel_req_struct *abort_req; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_CANCEL_REQ); ASSERT(_da_wps_is_ready()); abort_req = (wps_cancel_req_struct *) construct_local_para(sizeof(wps_cancel_req_struct), TD_CTRL); abort_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE; abort_req->channel_id = da_wps_context.channel_id; mmi_da_send_ilm(abort_req, NULL, MSG_ID_WPS_CANCEL_REQ, MOD_WPS); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_cancel_rsp, MSG_ID_WPS_CANCEL_RSP); return MMI_TRUE; }
void l4ctcm_get_gprs_statistics_info_req_hdlr( ilm_struct *ilm_ptr ) { #ifndef __MASE__ l4ctcm_get_gprs_statistics_info_req_struct * rcv_msg_ptr; tcm_ratdm_query_ps_statistics_req_struct * sent_msg_ptr; rcv_msg_ptr = (l4ctcm_get_gprs_statistics_info_req_struct *)ilm_ptr->local_para_ptr; sent_msg_ptr = (tcm_ratdm_query_ps_statistics_req_struct *)construct_local_para (sizeof(tcm_ratdm_query_ps_statistics_req_struct), TD_RESET ); TCM_PTR(query_serial_number) = rcv_msg_ptr->query_id; sent_msg_ptr->query_serial_number = TCM_PTR(query_serial_number); #ifdef __UGTCM__ tcm_send_msg_to_ratdm(MSG_ID_TCM_RATDM_QUERY_PS_STATISTICS_REQ, (local_para_struct *)sent_msg_ptr, NULL); #endif /* __UGTCM__ */ #endif /* __MASE__ */ }
/***************************************************************************** * FUNCTION * bpp_adp_disconnect_confirm * DESCRIPTION * This function is send close confirm msg to bpp app * PARAMETERS * printer [?] [?] * err_code [IN] * RETURNS * void *****************************************************************************/ static void bpp_adp_disconnect_confirm(BPP_ERROR_CODE err_code) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_bpp_disconnect_cnf_struct *close_cnf = (bt_bpp_disconnect_cnf_struct*) construct_local_para(sizeof(bt_bpp_disconnect_cnf_struct), TD_CTRL); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO_ARG1(BPP_ADP_DISC_CONFIRM, err_code); if (err_code == BPP_SUCCESS) { if(g_bpp_adp_cntx.cm_conn_id != BPP_INVALID_CMID) { BT_BPP_TRACE_INFO_ARG1(BPP_ADP_RELEASE_CM_CONNID, g_bpp_adp_cntx.cm_conn_id); BTBMProfileReleaseConnIndex(g_bpp_adp_cntx.cm_conn_id); g_bpp_adp_cntx.cm_conn_id = (U8)BPP_INVALID_CMID; } } close_cnf->hprinter = g_bpp_adp_cntx.printer_handle; close_cnf->cnf_code = err_code; if (err_code == BPP_SUCCESS) { g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE; g_bpp_adp_cntx.cur_req = BPP_REQ_NONE; } bpp_adp_send_msg2app(MSG_ID_BT_BPP_DISCONNECT_CNF, (local_para_struct*) close_cnf); }
/***************************************************************************** * FUNCTION * mmi_bt_avrcp_tst_only_down_cmd * DESCRIPTION * Test when only down cmd comes witout up cmd * PARAMETERS * void * RETURNS * void *****************************************************************************/ void mmi_bt_avrcp_tst_only_down_cmd() { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_avrcp_cmd_frame_ind_res_struct* msg_p = (bt_avrcp_cmd_frame_ind_res_struct*) construct_local_para(sizeof(bt_avrcp_cmd_frame_ind_res_struct), TD_CTRL); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ msg_p->chnl_num = BT_AVRCP_TG ; msg_p->profile_id = 0; msg_p->seq_id = 0; msg_p->c_type = 0; msg_p->data_len = 1; /*assign a value that's larger than 0*/ msg_p->subunit_id = BT_AVRCP_SUBUNIT_ID_PASS_THROUGH; msg_p->subunit_type = BT_AVRCP_SUBUNIT_TYPE_PASS_THROUGH; msg_p->frame_data[0] = BT_AVRCP_OP_PASS_THROUGH; msg_p->frame_data[1] = MMI_AVRCP_POP_STOP; //MMI_AVRCP_POP_PLAY ; /*play button down*/ /*send msg*/ { ilm_struct *ilm_ptr = allocate_ilm(MOD_MMI); ilm_ptr->src_mod_id = MOD_MMI; ilm_ptr->dest_mod_id = MOD_MMI; ilm_ptr->sap_id = BT_AVRCP_SAP; ilm_ptr->msg_id = (msg_type)MSG_ID_BT_AVRCP_CMD_FRAME_IND; ilm_ptr->local_para_ptr = (local_para_struct*)msg_p; ilm_ptr->peer_buff_ptr = NULL; msg_send_ext_queue(ilm_ptr); } }
/***************************************************************************** * FUNCTION * jpim_evtdb_deleteEntry * DESCRIPTION * This function deletes an entry from the event database. * PARAMETERS * handle [IN] * RETURNS * jpim_error_code_enum *****************************************************************************/ kal_int32 jpim_evtdb_deleteEntry(kal_uint16 handle, kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_set_entry_req_struct *p = (mmi_evtdb_java_set_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_set_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_DELETEENTRY); p->entry_ptr = NULL; p->index = handle; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_state = JPIM_EVTDB_STATE_DELETE_ENTRY; if (jpim_check_vm_state(1, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_SET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_DELETE_ENTRY, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); } else { free_local_para((local_para_struct*) p); } return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result); }
/***************************************************************************** * FUNCTION * vis_send_seek_cnf * DESCRIPTION * This function is to send visual seek confirm message. * PARAMETERS * result [IN] * RETURNS * void *****************************************************************************/ void vis_send_seek_cnf(kal_int16 result) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ media_visual_seek_cnf_struct *msg_p = NULL; ilm_struct *ilm_ptr = NULL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ msg_p = (media_visual_seek_cnf_struct*) construct_local_para(sizeof(media_visual_seek_cnf_struct), TD_CTRL); ilm_ptr = allocate_ilm(MOD_MED_V); ilm_ptr->src_mod_id = MOD_MED_V; ilm_ptr->dest_mod_id = MOD_MED; ilm_ptr->sap_id = MED_SAP; ilm_ptr->msg_id = (msg_type) MSG_ID_MEDIA_VISUAL_SEEK_CNF; ilm_ptr->local_para_ptr = (local_para_struct*) msg_p; ilm_ptr->peer_buff_ptr = NULL; msg_send_ext_queue(ilm_ptr); }
/***************************************************************************** * FUNCTION * mmi_da_wps_send_unset_channel_req * DESCRIPTION * Send "Unset channel" request to wap to destory channel * PARAMETERS * void * RETURNS * MMI_TRUE: OK * MMI_FALSE: FAIL *****************************************************************************/ static BOOL mmi_da_wps_send_unset_channel_req(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ wps_unset_channel_req_struct *unset_channel_req = NULL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_UNSET_CHANNEL_REQ); if(da_wps_context.busy_flag != MMI_DA_WPS_STATE_FREE) return MMI_FALSE; /* only unset when no session */ ASSERT(!da_wps_context.session_num); if (da_wps_context.channel_id != MMI_DA_WPS_INVALID_CHANNEL) { unset_channel_req = (wps_unset_channel_req_struct *) construct_local_para(sizeof(wps_unset_channel_req_struct), TD_CTRL); unset_channel_req->channel_id = da_wps_context.channel_id; mmi_da_send_ilm(unset_channel_req, NULL, MSG_ID_WPS_UNSET_CHANNEL_REQ, MOD_WPS); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_unset_channel_rsp, MSG_ID_WPS_UNSET_CHANNEL_RSP); da_wps_context.busy_flag = MMI_DA_WPS_STATE_BUSY_UNSET; return MMI_TRUE; } else { ASSERT(0); } return MMI_FALSE; }
/***************************************************************************** * FUNCTION * drmt_mmi_send_alert_user_ind * DESCRIPTION * PARAMETERS * type [IN] * info [IN] * callback [IN] * RETURNS *****************************************************************************/ kal_bool drmt_mmi_send_alert_user_ind(kal_int8 type, const kal_wchar *info, drmt_mmi_alert_user_cb callback) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ drmt_alert_user_ind_struct *msg; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ msg = (drmt_alert_user_ind_struct*) construct_local_para(sizeof(drmt_alert_user_ind_struct), TD_RESET); msg->type = type; if (info) { app_ucs2_strncpy((kal_int8*) msg->msg, (kal_int8*) info, 31); } drmt_mmi_send_ilm(msg, NULL, MSG_ID_DRMT_ALERT_USER_IND); return KAL_TRUE; }
/***************************************************************************** * FUNCTION * bpp_adp_open_confirm * DESCRIPTION * This function is to send open confirm msg to bpp app(MMI) * PARAMETERS * printer [?] Address * err_code [IN] Error code * RETURNS *****************************************************************************/ static void bpp_adp_connect_confirm(BPP_ERROR_CODE cnf_code) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_bpp_connect_cnf_struct *open_cnf = (bt_bpp_connect_cnf_struct*) construct_local_para(sizeof(bt_bpp_connect_cnf_struct), TD_CTRL); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO_ARG1(BPP_ADP_CONNECT_CONFIRM,cnf_code); if (cnf_code == BPP_SUCCESS) { g_bpp_adp_cntx.cm_conn_id = BTBMProfileAllocateConnIndex(BT_BASIC_PRINTING, g_bpp_adp_cntx.bt_addr); open_cnf->cm_conn_id = g_bpp_adp_cntx.cm_conn_id; BT_BPP_TRACE_INFO_ARG1(BPP_ADP_ALLOC_CM_CONNID, g_bpp_adp_cntx.cm_conn_id); } open_cnf->hprinter = g_bpp_adp_cntx.printer_handle; open_cnf->cnf_code = cnf_code; if (cnf_code != BPP_SUCCESS) { g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE; } g_bpp_adp_cntx.cur_req = BPP_REQ_NONE; bpp_adp_send_msg2app(MSG_ID_BT_BPP_CONNECT_CNF, (local_para_struct*) open_cnf); }
/***************************************************************************** * FUNCTION * drmt_mmi_send_open_url_req * DESCRIPTION * PARAMETERS * option [IN] * url [IN] * callback [IN] * RETURNS *****************************************************************************/ kal_bool drmt_mmi_send_open_url_req(kal_uint8 option, const kal_char *url, drmt_mmi_open_url_cb callback) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ drmt_open_url_req_struct *msg; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ msg = (drmt_open_url_req_struct*) construct_local_para(sizeof(drmt_open_url_req_struct), TD_RESET); if (url) { app_asc_str_n_to_ucs2_str((kal_int8*) msg->url, (kal_int8*) url, 767); } msg->option = option; open_url_callback = callback; drmt_mmi_send_ilm(msg, NULL, MSG_ID_DRMT_OPEN_URL_REQ); return KAL_TRUE; }
/***************************************************************************** * FUNCTION * bpp_adp_cancel_confirm * DESCRIPTION * This function is send close confirm msg to bpp app * PARAMETERS * printer [?] [?] * err_code [IN] * RETURNS * void *****************************************************************************/ static void bpp_adp_cancel_confirm(BPP_ERROR_CODE err_code) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ bt_bpp_cancel_cnf_struct *cancel_cnf = (bt_bpp_cancel_cnf_struct*) construct_local_para(sizeof(bt_bpp_cancel_cnf_struct), TD_CTRL); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ BT_BPP_TRACE_INFO_ARG1(BPP_ADP_CANCEL_CONFIRM, err_code); cancel_cnf->hprinter = g_bpp_adp_cntx.printer_handle; cancel_cnf->cnf_code = err_code; if (err_code == BPP_SUCCESS) { g_bpp_adp_cntx.cur_req = BPP_REQ_NONE; } bpp_adp_send_msg2app(MSG_ID_BT_BPP_CANCEL_CNF, (local_para_struct*) cancel_cnf); }
/***************************************************************************** * FUNCTION * nvram_send_L1_cal * DESCRIPTION * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void nvram_send_L1_cal(void) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ /** * file_idx should be the first L1 element in the logical data item ID enum * Currently, L1 calibration data element is as following: * NVRAM_EF_L1_AGCPATHLOSS_LID, NVRAM_EF_L1_RAMPTABLE_GSM900_LID, * NVRAM_EF_L1_RAMPTABLE_DCS1800_LID, NVRAM_EF_L1_RAMPTABLE_PCS1900_LID, * NVRAM_EF_L1_AFCDATA_LID, VRAM_EF_L1_L1SPFC_LID, */ nvram_lid_enum file_idx; ltable_entry_struct *ldi; peer_buff_struct *peer_buf_ptr; kal_uint8 *pdu_ptr; kal_uint16 pdu_length; nvram_read_req_struct *local_data; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ local_data = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL); for (file_idx = NVRAM_EF_L1_START; file_idx <= NVRAM_EF_L1_END; file_idx++) { if (!NVRAM_IS_LID_VALID(file_idx)) { continue; } switch(file_idx) { case NVRAM_EF_L1_AGCPATHLOSS_LID: case NVRAM_EF_L1_RAMPTABLE_GSM850_LID: case NVRAM_EF_L1_RAMPTABLE_GSM900_LID: case NVRAM_EF_L1_RAMPTABLE_DCS1800_LID: case NVRAM_EF_L1_RAMPTABLE_PCS1900_LID: #if defined(__EPSK_TX__) case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM850_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM900_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_DCS1800_LID: case NVRAM_EF_L1_EPSK_RAMPTABLE_PCS1900_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM850_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM900_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_DCS1800_LID: case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_PCS1900_LID: #endif /* __EPSK_TX__ */ case NVRAM_EF_L1_AFCDATA_LID: case NVRAM_EF_L1_TXIQ_LID: case NVRAM_EF_L1_RFSPECIALCOEF_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_GSM850_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_GSM900_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_DCS1800_LID: case NVRAM_EF_L1_INTERSLOT_RAMP_PCS1900_LID: case NVRAM_EF_L1_CRYSTAL_AFCDATA_LID: case NVRAM_EF_L1_CRYSTAL_CAPDATA_LID: { nvram_get_data_item(ldi, file_idx); local_data->access_id = 0; local_data->file_idx = file_idx; local_data->para = 1; pdu_length = ldi->size; peer_buf_ptr = construct_peer_buff(pdu_length, 0, 0, TD_CTRL); ASSERT(peer_buf_ptr != NULL); pdu_ptr = get_pdu_ptr(peer_buf_ptr, &pdu_length); ASSERT(pdu_ptr != NULL); nvram_read_confirm (MOD_L1, nvram_read_data_item(ldi, 1, 1, pdu_ptr, pdu_length), local_data, ldi->size, peer_buf_ptr); break; } } } free_local_para((local_para_struct*) local_data); } /* end of nvram_send_L1_cal function */
/***************************************************************************** * FUNCTION * jpim_evtdb_fetchByIndex * DESCRIPTION * This function retrieves an entry from the event database. The data is filled into "entry" parameter. * PARAMETERS * entry [OUT] * index [IN] 0~n-1 * sort_type [IN] jpim_evtdb_sort_enum * db_type [IN] jpim_evtdb_db_enum * RETURNS * jpim_error_code_enum *****************************************************************************/ kal_int32 jpim_evtdb_fetchByIndex(mmi_evtdb_java_entry_struct *entry, kal_uint16 index, kal_uint8 sort_type, kal_uint8 db_type, kal_int32 vm_id) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint32 event_group; mmi_evtdb_java_get_entry_req_struct *p = (mmi_evtdb_java_get_entry_req_struct*) construct_local_para( sizeof(mmi_evtdb_java_get_entry_req_struct), TD_CTRL | TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ p->entry_ptr = entry; p->index = index; p->sort_type = MMI_EVTDB_SORT_BY_TIME; p->db_index = jpim_evtdb_transfer_tdl_db(db_type); p->count = 1; jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR; jpim_evtdb_state = JPIM_EVTDB_STATE_GET_ENTRY; if (jpim_check_vm_state(0, vm_id)) { jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_GET_ENTRY_REQ); kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_FETCH_INDEX, KAL_OR_CONSUME, &event_group, KAL_SUSPEND); JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_FETCHBYINDEX, entry->handle, entry->index); } else { free_local_para((local_para_struct*) p); } if(jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result) == JPIM_SUCCESS) { #ifdef JSR_75_PIM_EXTRA_ALARM_TIME_USER_DEFINE jpim_evtdb_adjustAlarmTime(entry, db_type, KAL_FALSE); #endif #ifndef __COSMOS_MMI_PACKAGE__ if (db_type == JPIM_EVTDB_REMINDER || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_COURSE || db_type == JPIM_EVTDB_DATE || db_type == JPIM_EVTDB_CALL|| db_type == JPIM_EVTDB_ANNIVERSARY || db_type == JPIM_EVTDB_ALL) #else if (db_type == JPIM_EVTDB_PERSONAL || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_SPECIALDAY || db_type == JPIM_EVTDB_BIRTHDAY || db_type == JPIM_EVTDB_OTHERS || db_type == JPIM_EVTDB_ALL) #endif { if (applib_dt_compare_time(&(entry->endTime), &(entry->startTime), NULL) == DT_TIME_LESS) { memcpy(&(entry->endTime), &(entry->startTime), sizeof(applib_time_struct)); } } if (db_type == JPIM_EVTDB_TASK) { #ifdef JSR_75_PIM_EXTRA_TODO if (entry->status == SRV_TDL_STATUS_UNDONE) { entry->complete_time.nYear = 0; entry->complete_time.nMonth = 0; entry->complete_time.nDay = 0; } #endif } } return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result); }
static BOOL mmi_da_wps_send_http_req(U8 request_id, U8 http_method, S8 * url, S8 * post_data, PU16 file_path) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ wps_http_req_struct *http_req; wps_http_req_var_struct http_req_var; peer_buff_struct *peer_buff_ptr = NULL; U16 pdu_length; U16 len; FS_HANDLE hd; static S8 range_header[30]; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_HTTP_REQ, request_id); ASSERT(_da_wps_is_ready()); ASSERT(request_id < MMI_DA_WPS_REQUEST_ID_RANGE); http_req = (wps_http_req_struct *) construct_local_para(sizeof(wps_http_req_struct), TD_CTRL); http_req->channel_id = da_wps_context.channel_id; http_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE; http_req->method = http_method; http_req->option = WPS_HTTP_OPTION_NO_CACHE; http_req_var.request_url_len = (kal_uint32) strlen(url); http_req_var.request_url = (kal_uint8 *) url; http_req_var.request_header_len = 0; http_req_var.request_header = NULL; if (http_method == WPS_HTTP_METHOD_POST) { ASSERT(post_data != NULL); http_req->reply_type = WPS_DATA_TYPE_BUFFER; http_req->reply_segment_len = 0; /* no use here */ http_req->post_type = WPS_DATA_TYPE_BUFFER; http_req->post_path[0] = '\0'; http_req->post_path[1] = '\0'; http_req->post_total_len = strlen(post_data); http_req->more_post = MMI_FALSE; http_req_var.post_segment_len = strlen(post_data); http_req_var.post_segment = (kal_uint8 *) post_data; http_req_var.request_header_len = strlen("Content-Type: text/plain; charset=UTF-8\r\n"); http_req_var.request_header = (kal_uint8 *)"Content-Type: text/plain; charset=UTF-8\r\n"; } else { ASSERT(file_path != NULL && mmi_ucs2strlen((S8 *) file_path) < 256); http_req->reply_type = WPS_DATA_TYPE_FILE; mmi_ucs2cpy((S8 *) http_req->reply_path, (S8 *) file_path); http_req->reply_segment_len = 0; /* no use here */ http_req->post_type = WPS_DATA_TYPE_BUFFER; http_req->post_path[0] = '\0'; http_req->post_path[1] = '\0'; http_req->post_total_len = 0; http_req->more_post = MMI_FALSE; http_req_var.post_segment_len = 0; http_req_var.post_segment = NULL; // If the target file exist, it means RESUME if ((hd = FS_Open((PU16)file_path, FS_READ_ONLY)) >= 0) { UINT file_size; FS_GetFileSize(hd, &file_size); sprintf(range_header, "Range:bytes=%d-", file_size); FS_Close(hd); http_req_var.request_header_len = strlen(range_header); http_req_var.request_header = (kal_uint8 *)range_header; } } pdu_length = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WPS_HTTP_REQ, &http_req_var, NULL); if (pdu_length > 0) { peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET); if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_HTTP_REQ, &http_req_var, get_pdu_ptr(peer_buff_ptr, &len)) != pdu_length) { free_peer_buff(peer_buff_ptr); peer_buff_ptr = NULL; } } mmi_da_send_ilm(http_req, peer_buff_ptr, MSG_ID_WPS_HTTP_REQ, MOD_WPS); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_rsp, MSG_ID_WPS_HTTP_RSP); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_dl_progress_ind, MSG_ID_WPS_DL_PROGRESS_IND); SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_auth_ind, MSG_ID_WPS_HTTP_AUTH_IND); return MMI_TRUE; }
/***************************************************************************** * FUNCTION * rmmi_general_command_parsing() * DESCRIPTION * This function should parse general proprietary AT command request. * Each owner should maintain and modify the code. * PARAMETERS * kal_uint32 op * kal_uint32 data_len * kal_uint8 *data_str * RETURNS * KAL_TRUE or KAL_FALSE *****************************************************************************/ kal_bool rmmi_general_command_parsing(kal_uint32 op, kal_uint32 data_len, kal_uint8 *data_str) { kal_bool ret_val = KAL_FALSE; #ifndef L4_NOT_PRESENT switch(op) { case 2: /* add by stanley 2006-07-03*/ { #if defined(__BTMTK__) bt_test_cmd_req_struct *param_ptr; param_ptr = (bt_test_cmd_req_struct *)construct_local_para( (kal_uint16)sizeof(bt_test_cmd_req_struct), TD_CTRL); kal_mem_cpy(param_ptr->test_cmd_content, data_str, data_len); rmmi_send_msg_to_bt(MSG_ID_BT_TEST_CMD_REQ, param_ptr); ret_val = KAL_TRUE; #endif /* __BTMTK__ */ break; } case 6: { #ifdef __UMTS_RAT__ kal_char *pp, *strModuleName, *strTstInject, *tt; kal_uint32 module_enum = 0, input_str_data_len = 0; input_str_data_len = strlen((kal_char*)data_str); if( input_str_data_len > 0 && input_str_data_len < 255) { strModuleName = (kal_char*) kal_strtok_r((kal_char*)data_str, "_", &pp); tt = (kal_char*) kal_strtok_r(NULL, "", &pp); if(NULL != tt) { strTstInject = tt; } else { strTstInject = ""; } /* Length of module name should be less than 8 bytes and Length of TST inject string shall be less than 128 bytes */ if((CUSTOM_MAX_MOD_NAME > strlen(strModuleName)) && (128 > strlen(strTstInject))) { kal_uint8 idx; static const module_name_enum_map_struct mod_map[MAX_MODULE_MAP_SIZE] = { {"MEME", MOD_MEME},//0 {"CSE", MOD_CSE}, {"CSCE", MOD_CSCE}, {"SIBE", MOD_SIBE}, {"USIME", MOD_USIME}, {"RRCE", MOD_RRCE},//5 {"SLCE", MOD_SLCE}, {"ADR", MOD_ADR}, {"URR", MOD_URR}, {"URLC", MOD_URLC}, {"UMAC", MOD_UMAC},//10 {"UL2", MOD_UL2}, {"MM", MOD_MM}, {"CC", MOD_CC}, {"CISS", MOD_CISS}, {"SMS", MOD_SMS},//15 {"SIM", MOD_SIM}, {"L4C", MOD_L4C}, {"TCM", MOD_TCM}, {"SMSAL", MOD_SMSAL}, {"UEM", MOD_UEM},//20 {"RAC", MOD_RAC}, {"SMU", MOD_SMU}, {"USAT", MOD_USAT}, {"CSM", MOD_CSM}, {"ENG", MOD_ENG},//25 {"PHB", MOD_PHB}, {"RRM", MOD_RRM}, {"RLC", MOD_RLC}, {"MAC", MOD_MAC}, {"LAPDM", MOD_LAPDM}, //30 {"MPAL", MOD_MPAL}, {"SNDCP", MOD_SNDCP}, {"SM", MOD_SM}, {"LLC", MOD_LLC}//34 }; for(idx = 0; idx < MAX_MODULE_MAP_SIZE; idx++) { if(strcmp(strModuleName, mod_map[idx].ModuleName) == 0) { module_enum = mod_map[idx].ModuleEnum; break; } } if(idx != MAX_MODULE_MAP_SIZE) { /* The target module is found, and send the TST to the module */ tst_module_string_inject_struct *tst_inject; tst_inject = (tst_module_string_inject_struct *) construct_local_para((kal_uint16)sizeof(tst_module_string_inject_struct), TD_RESET); strcpy((kal_char*)tst_inject->string, strTstInject); tst_inject->index = data_len; { msg_send5(MOD_L4C, (module_type)module_enum, 0, MSG_ID_TST_INJECT_STRING, (local_para_struct*)tst_inject); } } } ret_val = KAL_TRUE; } #endif /* __UMTS_RAT__ */ } break; #if defined(__AGPS_CONTROL_PLANE__) case 14: { l4c_agps_reset_positioning_lind(); ret_val = KAL_TRUE; break; } #endif /************************sample code begin************************/ // case op: /*owner_date: purpose*/ // { // /*call proprietary parsing function here and AT will give result */ // /*code OK/ERROR according to return value of parsing function*/ // // break; // } /************************sample code end*************************/ #ifdef __CTP_GOODIX_GT818_TRUE_MULTIPLE__ case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: { ret_val = process_gt818_ctp_cmd( (kal_uint8)(op - 15), data_len, data_str ); break; } #endif #if defined(__AGPS_SUPPORT__) /* below codes are for auto-test */ case 25: case 26: { /*agps_auto_test_ind_struct *param_ptr = construct_local_para( (kal_uint16)sizeof(agps_auto_test_ind_struct), TD_RESET); param_ptr->mode = (op == 25)? 1 : 0;*/ /* Send the message to the module in AP */ //ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_AUTO_TEST_IND, param_ptr); agps_md_auto_test_ind data; data.mode = (op == 25)? 1 : 0; rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_TEST_IND, (kal_uint8*)&data, sizeof(data)); break; } case 27: case 28: case 29: case 30: case 31: case 32: { /*agps_cp_up_status_ind_struct *param_ptr = construct_local_para( (kal_uint16)sizeof(agps_cp_up_status_ind_struct), TD_RESET); param_ptr->mode = (op-27);*/ /* Send the message to the module in AP */ //ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_CP_UP_STATUS_IND, param_ptr); agps_md_auto_cp_up_status_ind data; data.mode = (op-27); rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_CP_UP_STATUS_IND, (kal_uint8*)&data, sizeof(data)); break; } case 33: case 34: { /* Send the message to the module in AP */ //ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_MOLR_START_IND+(op-33), NULL); rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_MOLR_START_IND+(op-33), NULL, 0); break; } case 35: case 36: { /*agps_mtlr_response_ind_struct *param_ptr = construct_local_para( (kal_uint16)sizeof(agps_mtlr_response_ind_struct), TD_RESET); param_ptr->response = (op-35);*/ /* Send the message to the module in AP */ //ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_MTLR_RESPONSE_IND, param_ptr); agps_md_auto_mtlr_response_ind data; data.response = (op-35); rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_MTLR_RESPONSE_IND, (kal_uint8*)&data, sizeof(data)); break; } #endif /* Sleep Mode Stress Test */ case 37: { ret_val = custom_send_sm_stress_inject_msg( "2GStressEnable", MOD_L1); break; } #ifdef __UMTS_FDD_MODE__ case 38: { ret_val = custom_send_sm_stress_inject_msg( "3GStressEnable", MOD_UL1); break; } #endif case 39: { ret_val = custom_send_sm_stress_inject_msg( "RTOSStressEnable", MOD_L1); break; } case 40: { ret_val = custom_send_sm_stress_inject_msg( "2GStressDisable", MOD_L1); break; } #ifdef __UMTS_FDD_MODE__ case 41: { ret_val = custom_send_sm_stress_inject_msg( "3GStressDisable", MOD_UL1); break; } #endif case 42: { ret_val = custom_send_sm_stress_inject_msg( "RTOSStressDisable", MOD_L1); break; } /*Re Calibration Stress */ case 43: { ret_val = custom_send_sm_stress_inject_msg( "ReKEnable", MOD_L1); break; } case 44: { ret_val = custom_send_sm_stress_inject_msg( "ReKDisable", MOD_L1); break; } case 48: { ret_val = custom_send_sm_stress_inject_msg( "2GSleepEnable", MOD_L1); break; } case 49: { ret_val = custom_send_sm_stress_inject_msg( "2GSleepDisable", MOD_L1); break; } #ifdef __UMTS_FDD_MODE__ case 50: { ret_val = custom_send_sm_stress_inject_msg( "3GSleepEnable", MOD_UL1); break; } case 51: { ret_val = custom_send_sm_stress_inject_msg( "3GSleepDisable", MOD_UL1); break; } #endif case 54: { ret_val = custom_send_sm_stress_inject_msg( "OSTDSleepEnable", MOD_L1); break; } case 55: { ret_val = custom_send_sm_stress_inject_msg( "OSTDSleepDisable", MOD_L1); break; } default: break; } #endif // L4_NOT_PRESENT return ret_val; }
/***************************************************************************** * FUNCTION * aud_send_msg_to_nvram * DESCRIPTION * * PARAMETERS * msg_name [IN] * ef_id [IN] * data_ptr [?] * length [IN] * RETURNS * void *****************************************************************************/ void aud_send_msg_to_nvram(msg_type msg_name, kal_uint16 ef_id, void *data_ptr, kal_uint16 length) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ peer_buff_struct *data_stream; local_para_struct *parm_stream; kal_uint16 pdu_len; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ switch (msg_name) { case MSG_ID_NVRAM_WRITE_REQ: switch (ef_id) { case NVRAM_EF_CUST_ACOUSTIC_DATA_LID: case NVRAM_EF_AUDIO_PARAM_LID: case NVRAM_EF_AUDIO_DC_CALIBRATION_LID: #ifdef __AMRWB_LINK_SUPPORT__ case NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID: case NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID: case NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID: #endif /* __AMRWB_LINK_SUPPORT__ */ parm_stream = construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL); data_stream = construct_peer_buff(length, 0, 0, TD_CTRL); ((nvram_write_req_struct*) parm_stream)->file_idx = (kal_uint16) ef_id; ((nvram_write_req_struct*) parm_stream)->para = 1; ((nvram_write_req_struct*) parm_stream)->access_id = 0; pdu_len = length; kal_mem_cpy(get_peer_buff_pdu(data_stream, &pdu_len), data_ptr, length); aud_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_WRITE_REQ, parm_stream, data_stream); break; default: /* error write */ break; } break; case MSG_ID_NVRAM_READ_REQ: switch (ef_id) { case NVRAM_EF_CUST_ACOUSTIC_DATA_LID: case NVRAM_EF_AUDIO_PARAM_LID: case NVRAM_EF_AUDIO_DC_CALIBRATION_LID: #ifdef __GAIN_TABLE_SUPPORT__ case NVRAM_EF_AUDIO_GAIN_TABLE_LID: #endif /* __GAIN_TABLE_SUPPORT__ */ #ifdef __SPEECH_MODE_TABLE_SUPPORT__ case NVRAM_EF_AUDIO_SPEECH_MODE_TABLE_LID: #endif /* __SPEECH_MODE_TABLE_SUPPORT__ */ #ifdef __AMRWB_LINK_SUPPORT__ case NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID: case NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID: case NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID: #endif /* __AMRWB_LINK_SUPPORT__ */ #ifdef __DUAL_MIC_SUPPORT__ case NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID: #endif parm_stream = construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL); ((nvram_read_req_struct*) parm_stream)->file_idx = (kal_uint16) ef_id; ((nvram_read_req_struct*) parm_stream)->para = 1; aud_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_READ_REQ, parm_stream, NULL); break; default: /* error read */ break; } break; default: break; } /* End Switch */ return; }
/***************************************************************************** * FUNCTION * phb_search_confirm * DESCRIPTION * This is phb_search_confirm function of PHB module. * PARAMETERS * result [IN] * actual_count [IN] * src_id [IN] * cnf_msg_id [IN] * control_block [?] * ilm_ptr(?) [IN] The primitives * RETURNS * void *****************************************************************************/ static void phb_search_confirm( phb_errno_enum result, kal_uint16 actual_count, kal_uint8 src_id, msg_type cnf_msg_id, control_block_type *control_block) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ local_para_struct *local_param_ptr = NULL; peer_buff_struct *peer_buf_ptr = NULL; kal_uint16 msg_id = 0; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CNF, result, actual_count, src_id, cnf_msg_id); /* First we release local parameter. */ if ((result != PHB_ERRNO_BUSY) && (control_block->local_param_ptr != NULL)) { free_ctrl_buffer(control_block->local_param_ptr); } if ((result == PHB_ERRNO_BUSY) || (control_block->cnf_msg_id == MSG_ID_L4CPHB_SEARCH_REQ)) { l4cphb_search_cnf_struct *l4cphb_search_cnf; l4cphb_search_cnf = (l4cphb_search_cnf_struct*) construct_local_para( sizeof(l4cphb_search_cnf_struct), TD_CTRL); l4cphb_search_cnf->total = actual_count; l4cphb_search_cnf->src_id = src_id; l4cphb_search_cnf->result = result; /* Field `cause' is meaningful when I/O occured by using control blocks */ l4cphb_search_cnf->cause = control_block->cause; if (result == PHB_ERRNO_BUSY) { phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_SEARCH_CNF, (local_para_struct*) l4cphb_search_cnf, NULL); return; } local_param_ptr = (local_para_struct*) l4cphb_search_cnf; msg_id = MSG_ID_L4CPHB_SEARCH_CNF; } /** * Under ADN mode, only when is_retrieve is true and searching into * physical storage device is required will call search_continue(), which * in consequence results in this search_confirm() is invoked. * * Since it is ADN mode, no matter the search result is, * the approval result is ALWAYS success!! */ else if (control_block->cnf_msg_id == MSG_ID_L4CPHB_APPROVE_REQ) { l4cphb_approve_cnf_struct *l4cphb_approve_cnf; l4cphb_approve_cnf = (l4cphb_approve_cnf_struct*) construct_local_para( sizeof(l4cphb_approve_cnf_struct), TD_CTRL); l4cphb_approve_cnf->result = PHB_ERRNO_SUCCESS; /* Field `cause' is meaningful when I/O occured by using control blocks */ l4cphb_approve_cnf->cause = control_block->cause; l4cphb_approve_cnf->type = control_block->type; l4cphb_approve_cnf->src_id = control_block->src_id; local_param_ptr = (local_para_struct*) l4cphb_approve_cnf; msg_id = MSG_ID_L4CPHB_APPROVE_CNF; } /* EXCEPTION cannot reach here */ if (control_block->peer_buf_ptr != NULL) { if (control_block->actual_count > 0) { peer_buf_ptr = (peer_buff_struct*) control_block->peer_buf_ptr; control_block->peer_buf_ptr = NULL; } else { free_ctrl_buffer(control_block->peer_buf_ptr); peer_buf_ptr = NULL; } control_block->need_free_peer = KAL_FALSE; } phb_free_control_block(control_block); phb_send_ilm(MOD_L4C, msg_id, local_param_ptr, peer_buf_ptr); } /* end of phb_search_confirm */
/***************************************************************************** * FUNCTION * SimSrvCallback * DESCRIPTION * * PARAMETERS * Server [IN] * Parms [IN] * RETURNS * void *****************************************************************************/ void SimSrvCallback(SimServer *Server, SimCallbackParms *Parms) { SimCardReaderStatus cardRdrStatus; SimCardStatus statusChange = SIM_CARD_STATUS_UNKNOWN; SimResultCode result = SIM_RESULT_NO_REASON; BtStatus status; U8 *ptr; U16 len; switch (Parms->event) { case SAEVENT_SERVER_OPEN_IND: /* When receiving this event, SimServer will send CONNECT_RSP event back to client */ if ((status = SIM_ServerRespondOpenInd(Server, SIM_CONN_STATUS_OK)) != BT_STATUS_PENDING) { kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_NOT_ACCEPTED_IN_SRVCALLBACK, status); /* In this case means that sending of CONNECT_RSP is failed */ /* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */ status = SimApCloseRFCommChnl(&(Server->rfChannel)); if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS)) { /* Report(("SERVER_OPEN_IND and RF_CloseChannel error, status=%d",status)); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status); Assert(0); } } else { kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_ACCEPTED_IN_SRVCALLBACK); } break; case SAEVENT_SERVER_OPEN: kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_OPEN_IN_SRVCALLBACK, Parms->status); if (Parms->status == BT_STATUS_SUCCESS) { #if 0 // Reserved for MAUI bt_simap_connect_ind_struct *bt_simap_connect_ind = NULL; #endif SIMAPCallbackParms parms; /* Allocated a connection id for SIM Access Profile (SC_SIM_ACCESS: 0x112D) */ SIM(connect_id)[0] = BTBMProfileAllocateConnIndex(SC_SIM_ACCESS, Parms->ptrs.remDev->bdAddr); SIM(allocated_connect_id)[0] = KAL_TRUE; #if 0 // Reserved for MAUI bt_simap_connect_ind = construct_local_para(sizeof(bt_simap_connect_ind_struct), TD_UL); /* Reset lap,uap,nap to zero */ bt_simap_connect_ind->lap = 0; bt_simap_connect_ind->uap = 0; bt_simap_connect_ind->nap = 0; memcpy(&(bt_simap_connect_ind->lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3); bt_simap_connect_ind->uap = Parms->ptrs.remDev->bdAddr.addr[3]; memcpy(&(bt_simap_connect_ind->nap), (U16*) & Parms->ptrs.remDev->bdAddr.addr[4], 2); bt_simap_connect_ind->cid = SIM(connect_id)[0]; bt_send_msg( MSG_ID_BT_SIMAP_CONNECT_IND, MOD_MMI, BT_APP_SAP, (local_para_struct*) bt_simap_connect_ind, NULL); #endif parms.event = SIMAP_EVENT_CONNECT_IND; parms.dstMod = MOD_MMI; parms.p.simap_connect_ind.cid = SIM(connect_id)[0]; parms.p.simap_connect_ind.lap = 0; parms.p.simap_connect_ind.uap = 0; parms.p.simap_connect_ind.nap = 0; btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3); parms.p.simap_connect_ind.uap = Parms->ptrs.remDev->bdAddr.addr[3]; btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.nap), (U8 *) &Parms->ptrs.remDev->bdAddr.addr[4], 2); SIMAPCB(&parms); } else { /* Handle the failed OPEN Event */ /* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */ status = SimApCloseRFCommChnl(&(Server->rfChannel)); if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS)) { /* Report(("SERVER_OPEN and RF_CloseChannel err, status=%d",status)); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status); Assert(0); } } break; case SAEVENT_SERVER_CLOSE_IND: kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_CLOSED_IND_IN_SRVCALLBACK, Parms->status); break; case SAEVENT_SERVER_CLOSED: kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_IN_SRVCALLBACK, Parms->status); /* Determine that if is is necessary to notify SIM task to start recovery mechanism */ Report(("[BT SIMAP_svr]SAEVENT_SERVER_CLOSED: substate=%d", SIM(simServer)[0].substate)); //clear the RF channel cur_rfchannel = NULL; if (SIM(simServer)[0].substate & BT_REJECT_SECOND_CLIENT_SESSION) { SIM(simServer)[0].substate &= (~BT_REJECT_SECOND_CLIENT_SESSION); /* Report(("This closed event is due to SimServer is serving one client now, so reject another seesion")); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_EVENT_DUE_TO_REJECT_SECOND_CLIENT); return; } if ((SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT) && (SIM(simServer)[0].substate & BT_SIM_CONNECT_CNF_RECV) && (SIM(simServer)[0].atr.dataLen == 0)) { //Report(("CONNECT_CNF from SIM task is error, Send DISC_REQ to SIM task is not necessary when CLOSED in SimServer")); //Report(("Case0:In SimSrvCallback():SimServer is available again!")); kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_CASE0); SIM(simServer)[0].substate = 0; SIM(simServer)[0].available = TRUE; } else if (SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT) { /* Because the SIM task may notify other modules to enter remote SIM mode, it is necessary to recovery as normal mode */ /* Through sending disconnect_req to SIM task to notify it */ /* Check if timer for DISC_Graceful is still runing */ if (SIM(simServer)[0].substate & BT_APP_DISCONNECT_REQ_RECV) { /* Report(("In SimSrvCallback() recv CLOSED, check timer for DISC_Graceful type")); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_RECV_CLOSED_CHECK_TIMER); bt_simap_stop_timer(&SIM(simap_event_id)); } /* Send BT_SIM_DISCONNECT_REQ message to SIM task */ SIM(simServer)[0].substate |= BT_SIM_DISCONNECT_REQ_SENT; #if 0 #ifdef __SIMAP_TESTER_ if(SIM(simServer)[0].test_mode == 1) bt_fakesim_disconnect_req_hdlr(); else if(SIM(simServer)[0].test_mode == 2) bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL); #endif #endif /* 0 */ if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_DISCONNECT_REQ; parms.dstMod = MOD_SIM; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_disconnect_req_hdlr(); } #endif /* __SIMAP_UT_ */ } else { /* Note: substate field has two bytes, if U8 is used the substate (e.g., 0x1000) will be narrowed to 0x00 : 2006-12-28 */ U32 oldsubstate = SIM(simServer)[0].substate; kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSERVER_AVAILABLE_IN_SRVCALLBACK, oldsubstate); /* Report(("Case1:In SimSrvCallback():SimServer is available again, and Simserver substate=%d",oldsubstate)); */ /* * Check if this CLOSED Event is triggered due to receive MMI's DEACTIVATE_REQ in SimServer's CONNECT_PENDING state * If SimServer has not yet send CONNECT_REQ to SIM task, this case is matched (No necessary to notify SIM task) * The DEACTIVATE_CNF is returned here directly * At that time, we call RF_CloseChannel() to trigger this event */ if (SIM(simServer)[0].substate & BT_APP_DEACTIVATE_REQ_RECV) { #if 0 // Reserved for MAUI bt_simap_deactivate_cnf_struct *bt_simap_deactivate_cnf = construct_local_para(sizeof(bt_simap_deactivate_cnf_struct), TD_UL); #endif SIMAPCallbackParms parms; /* Using this func to deregister rfcomm server channel and sdp record of SIM Access Profile */ Assert(SIM_DeregisterServer(Server) == BT_STATUS_SUCCESS); /* Report(("This case is SimServer closed then RFCOMM closed due to MMI Deactivate Req, return Deactivate_CNF with ok")); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSRV_CLOSED_RFCOMM_CLOSED_DUE_TO_DEACTIVATE_REQ); SIM(simServer)[0].simserver_activate_status = SIM_SERVER_STATUS_DEACTIVATED; /* This means that SIM Access Profile connection is closed, check if conneciton_id is still allocated */ if (SIM(allocated_connect_id)[0] == KAL_TRUE) { BTBMProfileReleaseConnIndex(SIM(connect_id)[0]); SIM(allocated_connect_id)[0] = KAL_FALSE; /* Report(("Release SIM Acces Profile connect_id in Case 1")); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_RELEASE_SAP_CONID_CASE1); } #if 0 // Reserved for MAUI bt_simap_deactivate_cnf->result = TRUE; bt_send_msg( MSG_ID_BT_SIMAP_DEACTIVATE_CNF, MOD_MMI, BT_APP_SAP, (local_para_struct*) bt_simap_deactivate_cnf, NULL); #endif parms.event = SIMAP_EVENT_DEACTIVATE_CNF; parms.dstMod = MOD_MMI; parms.p.simap_deactivate_cnf.result = TRUE; SIMAPCB(&parms); } /* * [MAUI_02129303]: As the AUTH_REQ is not responded by MMI & remote device close the RFCOMM channel (timed-out), * we have to report this event to MMI to sync the status. */ else if (BT_MMI_AUTH_REQ_SENT == (SIM(simServer)[0].substate & BT_MMI_AUTH_REQ_SENT)) { SIMAPCallbackParms parms; btbm_bd_addr_t bd_addr; btmtk_os_memset((kal_uint8*) & bd_addr, 0, sizeof(btbm_bd_addr_t)); CONVERT_ARRAY2BDADDR(&bd_addr, Server->remDev->bdAddr.addr); parms.event = SIMAP_EVENT_AUTH_REQ_TIMEOUT_RFCLOSED_IND; parms.dstMod = MOD_MMI; parms.p.simap_auth_req_timeout_rfclose_ind.lap = bd_addr.lap; parms.p.simap_auth_req_timeout_rfclose_ind.uap = bd_addr.uap; parms.p.simap_auth_req_timeout_rfclose_ind.nap = bd_addr.nap; SIMAPCB(&parms); } SIM(simServer)[0].substate = 0; SIM(simServer)[0].available = TRUE; if (SIM_SERVER_STATUS_DEACTIVATING == SIM(simServer)[0].simserver_activate_status) { /* Deactivate now.*/ bt_simap_deactivate_req_hdlr(); } } break; case SAEVENT_SERVER_STATUS_REQ: if (Parms->status == BT_STATUS_SUCCESS) { if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) { statusChange = SIM_CARD_STATUS_RESET; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { statusChange = SIM_CARD_STATUS_INSERTED; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { statusChange = SIM_CARD_STATUS_REMOVED; } } else if (Parms->status == BT_STATUS_FAILED) { statusChange = SIM_CARD_STATUS_NOT_ACCESSIBLE; } if ((status = SIM_ServerSendStatus(Server, statusChange)) != BT_STATUS_PENDING) { kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_STATUS_IND_IN_SRVCALLBACK, status); } else { kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_STATUS_IND_IN_SRVCALLBACK); } break; case SAEVENT_SERVER_ATR_REQ: //kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMCARDREADER_STATUS, SIM(simServer)[0].current_simcardreader_status); Report(("[BT SIMAP]current_simcardreader_status=0x%x", SIM(simServer)[0].current_simcardreader_status)); if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { result = SIM_RESULT_OK; ptr = SIM(simServer)[0].atr.data; len = SIM(simServer)[0].atr.dataLen; } else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT) { /* Alread off : This case is POWERED_OFF but CARD_PRESENT */ result = SIM_RESULT_CARD_ALREADY_OFF; len = 0; ptr = NULL; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* No card inserted */ /* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */ result = SIM_RESULT_CARD_REMOVED; len = 0; ptr = NULL; } status = SIM_ServerAtrRsp(Server, len, ptr, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_ATR_RSP_IN_SRVCALLBACK, result, status); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } break; case SAEVENT_SERVER_APDU_REQ: if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_sim_apdu_req_struct *apdu_req = NULL; #else SIMAPCallbackParms parms; #endif SIM(simServer)[0].substate |= BT_SIM_APDU_REQ_SENT; kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_TO_SIM_IN_SRVCALLBACK); #ifdef __SIMAP_MAUI__ /* Send APDU request to SIM task */ apdu_req = construct_local_para(sizeof(bt_sim_apdu_req_struct), TD_UL); apdu_req->apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen; OS_MemSet(apdu_req->apdu_req, 0, APDU_REQ_MAX_LEN); OS_MemCopy(apdu_req->apdu_req, Parms->ptrs.msg->parm.apdu.data, apdu_req->apdu_req_len); apdu_req->transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type; bt_send_msg(MSG_ID_BT_SIM_APDU_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) apdu_req, NULL); #else parms.event = SIM_EVENT_APDU_REQ; parms.dstMod = MOD_SIM; parms.p.sim_apdu_req.apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen; btmtk_os_memset(parms.p.sim_apdu_req.apdu_req, 0, APDU_REQ_MAX_LEN); btmtk_os_memcpy(parms.p.sim_apdu_req.apdu_req, Parms->ptrs.msg->parm.apdu.data, parms.p.sim_apdu_req.apdu_req_len); parms.p.sim_apdu_req.transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_apdu_req_hdlr(Parms->ptrs.msg->parm.apdu.dataLen, Parms->ptrs.msg->parm.apdu.data); } #endif /* __SIMAP_UT_ */ } else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT) { /* Alread off : This case is POWERED_OFF but CARD_PRESENT */ result = SIM_RESULT_CARD_ALREADY_OFF; ptr = NULL; len = 0; status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 1); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* No card inserted */ /* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */ result = SIM_RESULT_CARD_REMOVED; ptr = NULL; len = 0; status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 2); if (status != BT_STATUS_SUCCESS) { Assert(0); } } break; case SAEVENT_SERVER_SIM_OFF_REQ: if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* In this case: must SIM_CRS_CARD_POWERED_ON and SIM_CRS_CARD_PRESENT are satisfied at the same time */ /* Send POWER_OFF_REQ to SIM task */ kal_trace(TRACE_GROUP_1, BT_SIM_SEND_POWER_OFF_TO_SIM_IN_SRVCALLBACK); SIM(simServer)[0].substate |= BT_SIM_POWER_OFF_REQ_SENT; if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_send_msg(MSG_ID_BT_SIM_POWER_OFF_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_POWER_OFF_REQ; parms.dstMod = MOD_SIM; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_poweroff_req_hdlr(); } #endif /* __SIMAP_UT_ */ return; } else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT) { /* Alread off : This case is POWERED_OFF but CARD_PRESENT */ result = SIM_RESULT_CARD_ALREADY_OFF; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* No card inserted */ /* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */ result = SIM_RESULT_CARD_REMOVED; } /* Send POWER_OFF_RSP to client */ status = SIM_ServerSimOffRsp(Server, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_POWER_OFF_RSP_TO_CLIENT, result, status); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } break; case SAEVENT_SERVER_SIM_ON_REQ: /* if current information is enough to return rsp, then sends rsp in this function */ /* POWE_ON_REQ only let client to request T at 0 (T=0) */ if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { result = SIM_RESULT_CARD_ALREADY_ON; } else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT) { /* * Because SIM card is already off, so current_transport_protocol_type is invalid * Set T=0 directly and send BT_SIM_RESET_REQ to sim task! */ if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2 || SIM(simServer)[0].supported_transport_protocol_type_capability == 0) { SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_POWER_ON; if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_sim_reset_req_struct *reset_req = NULL; reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL); reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */ bt_send_msg( MSG_ID_BT_SIM_RESET_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) reset_req, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_RESET_REQ; parms.dstMod = MOD_SIM; parms.p.sim_reset_req.transport_protocol_type = 0; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_poweron_req_hdlr(); } #endif /* __SIMAP_UT_ */ return; } else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1) { /* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */ result = SIM_RESULT_CARD_NOT_ACCESSIBLE; } } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */ result = SIM_RESULT_CARD_REMOVED; } else { kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_SIM_ON_REQ_IN_SRVCALLBACK); Assert(0); } /* Send SIM_POWER_ON_RSP to sim client with result code */ status = SIM_ServerSimOnRsp(Server, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_POWER_ON_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } break; case SAEVENT_SERVER_SET_TRANS_PROT_REQ: #if SET_T_SUPPORTED == TRUE /* if current information is enough to return rsp, then sends rsp in this function */ /* Set Transport Protocol Type Req will ask to reset the SIM Card */ SIM(simServer)[0].client_requested_transport_protocol_type = Parms->ptrs.msg->parm.protocolId; /* Report(("In SimSrvCallback(): client requested T type=%d",SIM(simServer)[0].client_requested_transport_protocol_type)); */ kal_trace( TRACE_GROUP_1, BT_SIMAP_CLIENT_REQ_T_TYPE, SIM(simServer)[0].client_requested_transport_protocol_type); if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2) { /* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */ if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId) { Assert((SIM(simServer)[0].current_transport_protocol_type == 0) || (SIM(simServer)[0].current_transport_protocol_type == 1)); SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T; if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_sim_reset_req_struct *reset_req = NULL; reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL); reset_req->transport_protocol_type = Parms->ptrs.msg->parm.protocolId; bt_send_msg( MSG_ID_BT_SIM_RESET_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) reset_req, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_RESET_REQ; parms.dstMod = MOD_SIM; parms.p.sim_reset_req.transport_protocol_type = Parms->ptrs.msg->parm.protocolId; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_set_transprotocol_type_req_hdlr(); } #endif /* __SIMAP_UT_ */ return; } else { /* Requested T type is the same as current T type, send rsp to sim client directly */ SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T; result = SIM_RESULT_OK; } } else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1 || SIM(simServer)[0].supported_transport_protocol_type_capability == 0) { /* In this case: SIM card only supports T=0 or T=1 and current_transport_protocol_type is equal to supported_transport_protocol_type_capability */ if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId) { /* Send REST_RSP with error code: Can't accessible to SIM Client */ /* * In this case: Send SET_T_RSP first * then in Open state PACKET_HANDLED EVENT: send STATUS_IND with card not accessible */ /* Report(("SET T=0/T=1 but only support T=1/T=0, Send SET_T_RSP first then STATUS_IND with card not accessible later")); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SET_T0_T1_NOT_SUPPORT_T1_T0); SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T; result = SIM_RESULT_NOT_SUPPORTED; } else { /* Requested T type is the same as current T type, send rsp to sim client directly */ result = SIM_RESULT_OK; } } } else if ((!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON)) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { result = SIM_RESULT_CARD_ALREADY_OFF; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { result = SIM_RESULT_CARD_REMOVED; } #else /* SET_T_SUPPORTED == TRUE */ result = SIM_RESULT_NOT_SUPPORTED; #endif /* SET_T_SUPPORTED == TRUE */ /* Send SIM_SET_TRANSPORT_PROTOCOL_TYPE_RSP to sim client with result code */ status = SIM_ServerSetTransProtRsp(Server, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_SET_T_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status); if (status != BT_STATUS_SUCCESS) { Assert(0); } break; case SAEVENT_SERVER_RESET_SIM_REQ: /* if current information is enough to return rsp, then sends rsp in this function */ /* RESET_REQ only let client to request T at 0 (T=0) */ if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) && (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* * The original following state is wrong! * Because as long as one bit (SIM_CRS_CARD_POWERED_ON or SIM_CRS_CARD_PRESENT) is set in current_simcardreader_status, condition is true! * if((SIM(simServer)[0].current_simcardreader_status & (SIM_CRS_CARD_POWERED_ON | SIM_CRS_CARD_PRESENT))) */ /* In this case, must POWERED_ON and CARD_PRESERT are statisfied at the same time */ if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2) { /* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */ Assert((SIM(simServer)[0].current_transport_protocol_type == 0) || (SIM(simServer)[0].current_transport_protocol_type == 1)); SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT; if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_sim_reset_req_struct *reset_req = NULL; reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL); reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */ bt_send_msg( MSG_ID_BT_SIM_RESET_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) reset_req, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_RESET_REQ; parms.dstMod = MOD_SIM; parms.p.sim_reset_req.transport_protocol_type = 0; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_reset_req_hdlr(); } #endif /* __SIMAP_UT_ */ return; } else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1) { /* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */ Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type); /* Send REST_RSP with error code: Can't accessible to SIM Client */ result = SIM_RESULT_CARD_NOT_ACCESSIBLE; } else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 0) { /* SIM Card only supports T=0: Send BT_SIM_RESET_REQ msg to SIM task */ Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type); SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT; if (SIM(simServer)[0].exec_mode == 0) { #ifdef __SIMAP_MAUI__ bt_sim_reset_req_struct *reset_req = NULL; reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL); reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */ bt_send_msg( MSG_ID_BT_SIM_RESET_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) reset_req, NULL); #else SIMAPCallbackParms parms; parms.event = SIM_EVENT_RESET_REQ; parms.dstMod = MOD_SIM; parms.p.sim_reset_req.transport_protocol_type = 0; SIMAPCB(&parms); #endif } #ifdef __SIMAP_UT_ else if (SIM(simServer)[0].exec_mode == 1) { bt_fakesim_reset_req_hdlr(); } #endif /* __SIMAP_UT_ */ return; } } else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT) { /* This case is SIM_CRS_CARD_PRESENT(0x40) with SIM_CRS_CARD_POWERED_OFF(0x00) */ /* Send REST_RSP with error code: Card powered off to SIM Client */ result = SIM_RESULT_CARD_ALREADY_OFF; } else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)) { /* Send REST_RSP with error code: Card Removed to SIM Client */ /* Note: it is impossible that POWERED_ON but CRS_NOT_PRESENT case, so this is CARD_NOT_PRESENT case */ result = SIM_RESULT_CARD_REMOVED; } else { kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_RESET_REQ_IN_SRVCALLBACK); Assert(0); } /* Send SIM_RESET_RSP to sim client with result code */ status = SIM_ServerResetSimRsp(Server, result); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_RESET_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } break; case SAEVENT_SERVER_CARD_READER_STATUS_REQ: cardRdrStatus = SIM(simServer)[0].current_simcardreader_status; status = SIM_ServerCardReaderStatusRsp(Server, cardRdrStatus, SIM_RESULT_OK); kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_CARD_RDS_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status); if (status != BT_STATUS_SUCCESS) { status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel)); Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS)); } break; case SAEVENT_SERVER_STATUS_SENT: kal_trace(TRACE_GROUP_1, BT_SIMAP_STATUS_IND_SENT_IN_SRVCALLBACK, Parms->status); /* Note that the STATUS_SENT Event may be failed, handle this case here */ if (Parms->status != BT_STATUS_SUCCESS) { if (Server->state == SIM_SERVER_STATE_CONN_PENDING) { /* In CONNECT_PENDING state, this means that STATUS_IND(with reset) is sent failed */ /* Close this SIM Access Profile connection */ /* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */ status = SimApCloseRFCommChnl(&(Server->rfChannel)); if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS)) { /* Report(("SERVER_STATUS_SENT and RF_CloseChannel err, status=%d",status)); */ kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status); Assert(0); } } else if (Server->state == SIM_SERVER_STATE_OPEN) { /* Ignore it */ } else { /* Send STATUS_IND in wrong SimServer's state and send this event fail */ Assert(0); } } break; } }
static void mmi_widget_send_notify_content_update_response(int instance_id, void *view_handle) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ widget_notify_content_update_cnf_struct *p = (widget_notify_content_update_cnf_struct*) construct_local_para( sizeof(widget_notify_content_update_cnf_struct), TD_RESET); /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ p->instance_id = instance_id; p->view_handle = view_handle; send_message(p, NULL, MSG_ID_WIDGET_NOTIFY_CONTENT_UPDATE_CNF, MOD_GADGET); }
/***************************************************************************** * FUNCTION * mmi_syncml_start_sync_req * DESCRIPTION * Protocol event handler * PARAMETERS * info [IN] message content * RETURNS * void *****************************************************************************/ void mmi_syncml_start_sync_req(U8 *imei) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ MYQUEUE Message; mmi_syncml_start_sync_req_struct *dataPtr; syncml_profile_struct active_profile; applib_mime_type_struct *mime; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ mmi_syncml_read_profile_from_nvram(g_syncml_context.active_profile, &active_profile); Message.oslSrcId = MOD_MMI; Message.oslDestId = MOD_SYNCML; Message.oslMsgId = MSG_ID_MMI_SYNCML_START_SYNC_REQ; dataPtr = (mmi_syncml_start_sync_req_struct*) construct_local_para(sizeof(mmi_syncml_start_sync_req_struct), TD_CTRL|TD_RESET); strcpy((S8*) dataPtr->server_uri, (S8*) active_profile.server_address); strcpy((S8*) dataPtr->server_username, (S8*) active_profile.server_username); strcpy((S8*) dataPtr->server_password, (S8*) active_profile.server_password); if (g_syncml_context.applications_to_sync & SYNCML_DB_PHONEBOOK) { strcpy((S8*) dataPtr->contact_database_uri, (S8*) active_profile.contact_address); strcpy((S8*) dataPtr->contact_database_username, (S8*) active_profile.contact_username); strcpy((S8*) dataPtr->contact_database_password, (S8*) active_profile.contact_password); mime = mime_type_look_up(NULL, NULL, 0, MIME_SUBTYPE_XVCARD); strcpy((S8*) dataPtr->contact_mime_type, mime->mime_string); dataPtr->contact_last_anchor = g_syncml_context.last_phb_anchor[g_syncml_context.active_profile - 1]; dataPtr->contact_next_anchor = g_syncml_context.next_phb_anchor; #ifdef __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ if (mmi_syncml_is_sync_started_from_server()) { /* replace the database URI by the specified one */ strcpy((S8*) dataPtr->contact_database_uri, (S8*) g_sas_context.sas_contact_database_uri); } #endif /* __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ */ g_syncml_context.contact_sync_state = 1; /* synchronizing */ } dataPtr->contact_free_id = MAX_PB_PHONE_ENTRIES - mmi_phb_get_phone_index_arrary(NULL); dataPtr->contact_free_mem = dataPtr->contact_free_id * mmi_phb_sync_get_record_size(); if (g_syncml_context.applications_to_sync & SYNCML_DB_TODOLIST) { strcpy((S8*) dataPtr->calendar_database_uri, (S8*) active_profile.calendar_address); strcpy((S8*) dataPtr->calendar_database_username, (S8*) active_profile.calendar_username); strcpy((S8*) dataPtr->calendar_database_password, (S8*) active_profile.calendar_password); mime = mime_type_look_up(NULL, NULL, 0, MIME_SUBTYPE_XVCALENDAR); strcpy((S8*) dataPtr->calendar_mime_type, mime->mime_string); dataPtr->calendar_last_anchor = g_syncml_context.last_tdl_anchor[g_syncml_context.active_profile - 1]; dataPtr->calendar_next_anchor = g_syncml_context.next_tdl_anchor; #ifdef __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ if (mmi_syncml_is_sync_started_from_server()) { /* replace the database URI by the specified one */ strcpy((S8*) dataPtr->calendar_database_uri, (S8*) g_sas_context.sas_calendar_database_uri); } #endif /* __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ */ g_syncml_context.calendar_sync_state = 1; /* synchronizing */ AlmDisableExpiryHandler(); /* disable alarm */ } dataPtr->calendar_free_id = NUM_OF_TDL - mmi_tdl_get_total_index(NULL); dataPtr->calendar_free_mem = dataPtr->calendar_free_id * NVRAM_TODO_LIST_RECORD_SIZE; memcpy(&dataPtr->imei[0], "IMEI:", 5); memcpy(&dataPtr->imei[5], imei, 15); dataPtr->imei[20] = 0; #ifdef __MMI_SYNCML_REFRESH_SYNC_SUPPORT__ if (g_syncml_context.sync_type == SYNCML_TYPE_BACKUP) { dataPtr->sync_type = SYNCML_SYNC_CLIENT_ONE_WAY_REFRESH; } else if (g_syncml_context.sync_type == SYNCML_TYPE_RESTORE) { dataPtr->sync_type = SYNCML_SYNC_SERVER_ONE_WAY_REFRESH; } else if (g_syncml_context.sync_type == SYNCML_TYPE_EXPORT) { dataPtr->sync_type = SYNCML_SYNC_CLIENT_ONE_WAY_SYNC; } else if (g_syncml_context.sync_type == SYNCML_TYPE_IMPORT) { dataPtr->sync_type = SYNCML_SYNC_SERVER_ONE_WAY_SYNC; } else { dataPtr->sync_type = SYNCML_SYNC_TWO_WAY_SYNC; } #else dataPtr->sync_type = SYNCML_SYNC_TWO_WAY_SYNC; #endif /* __MMI_SYNCML_REFRESH_SYNC_SUPPORT__ */ if (g_syncml_context.active_profile > MAX_SYNCML_SV_PROFILES) { dataPtr->transport_type = SYNCML_TRANS_USB + active_profile.net_id; } else { dataPtr->transport_type = (active_profile.conn_type == SYNCML_TRANS_HTTP) ? SYNCML_TRANS_HTTP : SYNCML_TRANS_WSP; dataPtr->net_id = active_profile.net_id; if (active_profile.use_proxy) { memcpy(dataPtr->proxy_server_ip, active_profile.proxy_ip, 4); dataPtr->proxy_server_port = (active_profile.conn_type == SYNCML_TRANS_HTTP) ? active_profile.proxy_port : 9201; strcpy((S8*) dataPtr->proxy_username, (S8*) active_profile.proxy_username); strcpy((S8*) dataPtr->proxy_password, (S8*) active_profile.proxy_password); } else { memset(dataPtr->proxy_server_ip, 0, 4); dataPtr->proxy_server_port = 0; memset(dataPtr->proxy_username, 0, MAX_SYNCML_PROXY_USERNAME); memset(dataPtr->proxy_password, 0, MAX_SYNCML_PROXY_PASSWORD); } } g_syncml_context.abort_state = 0; Message.oslDataPtr = (oslParaType*) dataPtr; Message.oslPeerBuffPtr = NULL; OslMsgSendExtQueue(&Message); }
/***************************************************************************** * FUNCTION * l4c_root_sim_support_mode_req * DESCRIPTION * link_SML * PARAMETERS * src_id [IN] * mode [IN] bitmap for SIM power-on mode * RETURNS * void *****************************************************************************/ kal_bool l4c_root_lock_status_ind(kal_uint8 src_id) { l4c_root_context_struct *l4c_root_ptr = L4C_ROOT_PTR; kal_bool need_unlock = KAL_FALSE; kal_uint8 i; l4csmu_security_req_struct *param_ptr; module_type temp_mod = l4c_current_mod_id; smu_pending_password_id_enum pending_password = l4csmu_get_pending_password_id(); kal_uint8 need_unlock_table[L4_MAX_SIM_NUM]; //represents the actual SIM id kal_bool notify_mmi = KAL_TRUE; #ifdef __GEMINI_3G_SWITCH__ kal_uint8 sim_id = L4C_PTR->cur_3g_switch_map; L4C_COMM_PTR->c3gs_ref_flag = KAL_TRUE; #else kal_uint8 sim_id = l4c_current_mod_id - MOD_L4C; #endif kal_mem_set(need_unlock_table, 0, L4_MAX_SIM_NUM); if (src_id != L4C_SRC) { need_unlock = custom_l4c_root_lock_verify(sim_id, pending_password, l4c_root_ptr->root_pending_password, need_unlock_table); } if (need_unlock == KAL_TRUE) { for (i=0; i<L4_MAX_SIM_NUM; i++) { sim_id = l4c_gemini_get_actual_sim_id(i); pending_password = l4csmu_get_pending_password_id_ext((sim_interface_enum)i); kal_brief_trace(TRACE_INFO, INFO_L4C_ROOT_PENDING_PASSWD, sim_id, l4c_root_ptr->root_pending_password[sim_id], need_unlock_table[sim_id]); if (need_unlock_table[sim_id] != 0) { if (i == (l4c_current_mod_id-MOD_L4C)) { notify_mmi = KAL_FALSE; } layer4_module_context_selection(MOD_L4C+i); param_ptr = (l4csmu_security_req_struct*) construct_local_para((kal_uint16) sizeof(l4csmu_security_req_struct), TD_RESET); if (l4csmu_get_pending_lock(pending_password, &(param_ptr->type)) == KAL_FALSE) { continue; } param_ptr->src_id = L4C_SRC; param_ptr->op = SUPER_VERIFY; l4c_send_msg_to_smu(MSG_ID_L4CSMU_SECURITY_REQ, param_ptr); } } layer4_module_context_selection(temp_mod); } return notify_mmi; }
/***************************************************************************** * FUNCTION * aud_media_play_by_id_req_hdlr * DESCRIPTION * * PARAMETERS * ilm_ptr [?] * RETURNS * void *****************************************************************************/ void aud_media_play_by_id_req_hdlr(ilm_struct *ilm_ptr) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ kal_uint8 audio_id; kal_uint8 audio_out_device; kal_uint8 volume; media_aud_play_by_id_req_struct *req_p = (media_aud_play_by_id_req_struct*) ilm_ptr->local_para_ptr; media_aud_play_by_id_cnf_struct *cnf_p = NULL; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ audio_id = req_p->audio_id; if (req_p->output_path == AUDIO_DEVICE_SPEAKER2) { /* Use default configuration */ aud_cfg_audio_out_device(audio_id, &audio_out_device); } else { /* Use user-specified path */ audio_out_device = req_p->output_path; } if (audio_id <= TONE_KEY_CLICK) { aud_keytone_stop(); /* Update keytone volume */ volume = aud_get_volume_gain(aud_context_p->audio_mode, AUD_VOLUME_KEY, req_p->volume); aud_keytone_set_output_volume(volume, 0); aud_keytone_play(audio_id, audio_out_device, req_p->play_style); } else if ((audio_id > TONE_KEY_CLICK) && (audio_id <= MAX_TONE_ID)) { /* if keytone is playing, stop it */ aud_keytone_stop(); if (req_p->play_style == DEVICE_AUDIO_PLAY_INFINITE) { aud_context_p->tone_playing = KAL_TRUE; } /* Update tone volume */ volume = aud_get_volume_gain(aud_context_p->audio_mode, AUD_VOLUME_CTN, req_p->volume); aud_tone_set_output_volume(volume, 0); aud_tone_play(audio_id, audio_out_device); } cnf_p = (media_aud_play_by_id_cnf_struct*) construct_local_para(sizeof(media_aud_play_by_id_cnf_struct), TD_CTRL); cnf_p->result = MED_RES_OK; aud_send_ilm(ilm_ptr->src_mod_id, MSG_ID_MEDIA_AUD_PLAY_BY_ID_CNF, cnf_p, NULL); }