void FT_Custom_Operation(ilm_struct *ptrMsg) { ilm_struct ilm_ptr; kal_uint16 pdu_length; kal_uint8 *pdu_ptr = NULL; kal_uint16 pdu_length_new; kal_uint8 *pdu_ptr_new; peer_buff_struct *peer_buff_new; FT_CUSTOMER_REQ *p_req = (FT_CUSTOMER_REQ *)ptrMsg->local_para_ptr; if(ptrMsg->peer_buff_ptr == NULL) // do nothing return; switch(p_req->type) { case FT_CUSTOMER_OP_BASIC: { pdu_ptr = get_peer_buff_pdu( ptrMsg->peer_buff_ptr, &pdu_length ); // construct a peer buffer to send to NVRAM if( NULL != (peer_buff_new=construct_peer_buff(pdu_length, 0, 0, TD_CTRL)) ) { pdu_ptr_new = get_peer_buff_pdu( peer_buff_new, &pdu_length_new ); kal_mem_cpy(pdu_ptr_new, pdu_ptr, pdu_length); peer_buff_new->pdu_len = pdu_length; } FT_ALLOC_OTHER_MSG(&ilm_ptr, sizeof(ftc_basic_req_struct)); ilm_ptr.peer_buff_ptr = peer_buff_new; FT_SEND_MSG(MOD_FT, MOD_FTC, FT_FTC_SAP , (msg_type)MSG_ID_FTC_BASIC_REQ, &ilm_ptr); peer_buff_new=NULL;/* make sure FTC will release the mem*/ break; } default: break; } //peer_buff_struct *p_peer_buff_ptr = ptrMsg->peer_buff_ptr; // get the parameter from peer buffer //kal_int8 *data_in = (kal_int8*) get_peer_buff_pdu( p_peer_buff_ptr, &pdu_length ); //ilm_ptr->peer_buff_ptr = ptrMsg->peer_buff_ptr; }
/***************************************************************************** * FUNCTION * l4c_wap_prof_access_cnf_hdlr * DESCRIPTION * This function is just for template. * PARAMETERS * local_para_ptr [?] * peer_buff_ptr [?] * a(?) [IN/OUT] First variable, used as returns * b(?) [IN] Second variable * RETURNS * the description of return value, if any.(?) *****************************************************************************/ void l4c_wap_prof_access_cnf_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr) { l4cwap_prof_access_cnf_struct *msg_ptr = NULL; kal_uint8 src_id; msg_ptr = (l4cwap_prof_access_cnf_struct*) local_para_ptr; src_id = msg_ptr->src_id; if (L4C_PTR->cc_current_action[src_id] == CWAP_ACCESS) { if (peer_buff_ptr != NULL) { kal_uint16 packed_peer_buff_len; kal_uint8 *pdu_ptr; pdu_ptr = get_peer_buff_pdu(peer_buff_ptr, &packed_peer_buff_len); } L4C_PTR->cc_current_action[src_id] = L4C_NO_ACTION; //l4c_wap_prof_access_req_rrsp(msg_ptr->result, pdu_ptr); } else { /* wrong msg error */ } return; }
/***************************************************************************** * FUNCTION * rmmi_msgbased_write_data * DESCRIPTION * This function is used to send AT data back to the task who register channels * * PARAMETERS * buffer [IN] output data * length [IN] the length of output data * stuff [IN] if we need to add <CR><LF> to the header and tailer or not * src_id [IN] the output source ID * type [IN] output is URC or response * * RETURNS * void *****************************************************************************/ static void rmmi_msgbased_write_data(kal_uint8 *buffer, kal_uint16 length, kal_bool stuff, kal_uint8 src_id, rmmi_msgbased_ind_type type) { kal_uint16 pdu_len, tmp_len; peer_buff_struct *peer_ptr; kal_uint8 *data, offset, port; rmmi_response_at_ind_struct *resposne_ptr; rmmi_urc_at_ind_struct *urc_ptr; void *local_ptr; msg_type msg; peer_ptr = (peer_buff_struct*) construct_peer_buff(length+5, 0, 0, TD_RESET); // +5: <CR>*2,<LF>*2,'\0'*1 data = (kal_uint8 *)get_peer_buff_pdu(peer_ptr, &pdu_len); port = rmmi_msgbased_cid_2_port(rmmi_msgbased_srcid_2_cid(src_id)); tmp_len = length; if (stuff == KAL_TRUE) { offset = 2; data[0] = RMMI_MSGBASED_CR; data[1] = RMMI_MSGBASED_LF; data[length+offset] = RMMI_MSGBASED_CR; data[length+offset+1] = RMMI_MSGBASED_LF; data[length+offset+2] = '\0'; length += 4; } else { offset = 0; data[length] = '\0'; } kal_mem_cpy(data+offset, buffer, tmp_len); if (type == RMMI_MSGBASED_RESPONSE) { resposne_ptr = (rmmi_response_at_ind_struct*) construct_local_para((kal_uint16) sizeof(rmmi_response_at_ind_struct), TD_RESET); resposne_ptr->length = length; resposne_ptr->port_id = port; local_ptr = resposne_ptr; msg = MSG_ID_RMMI_RESPONSE_AT_IND; } else { urc_ptr = (rmmi_urc_at_ind_struct*) construct_local_para((kal_uint16) sizeof(rmmi_urc_at_ind_struct), TD_RESET); urc_ptr->length = length; local_ptr = urc_ptr; msg = MSG_ID_RMMI_URC_AT_IND; } rmmi_msgbased_send_ilm( RMMI_MSG_BASED_REQUEST_MODULE, msg, local_ptr, peer_ptr); }
void FTC_DispatchMessage(ilm_struct* ptrMsg) { kal_uint16 pdu_length; kal_uint8* pdu_ptr = NULL; kal_uint16 pdu_length_new; kal_uint8* pdu_ptr_new; peer_buff_struct* peer_buff_new; if( (ptrMsg->src_mod_id == MOD_FT) ) { if(ptrMsg->peer_buff_ptr == NULL) { return; } pdu_ptr = get_peer_buff_pdu( ptrMsg->peer_buff_ptr, &pdu_length ); switch (ptrMsg->msg_id) { case MSG_ID_FTC_BASIC_REQ: { // do the echo operation ftc_basic_cnf_struct *ftc_ptr_loc_para; // construct a peer buffer to send to FT task if( NULL != (peer_buff_new=construct_peer_buff(pdu_length, 0, 0, TD_CTRL)) ) { pdu_ptr_new = get_peer_buff_pdu( peer_buff_new, &pdu_length_new ); kal_mem_cpy(pdu_ptr_new, pdu_ptr , pdu_length); peer_buff_new->pdu_len = pdu_length; } ilm_struct ilm_ptr; FTC_ALLOC_MSG(&ilm_ptr, sizeof(ftc_basic_cnf_struct)); ftc_ptr_loc_para=(ftc_basic_cnf_struct *)(ilm_ptr.local_para_ptr); ftc_ptr_loc_para->status = FTC_CNF_OK; ilm_ptr.peer_buff_ptr = peer_buff_new; FTC_SEND_MSG(MOD_FTC ,MOD_FT, FTC_FT_SAP, MSG_ID_FTC_BASIC_CNF, &ilm_ptr); break; } default: break; } } else if( (ptrMsg->src_mod_id == MOD_NVRAM) ) { } }
/***************************************************************************** * FUNCTION * tp_ps_urc_at_ind_hdlr * DESCRIPTION * This function is used to handle the message MSG_ID_RMMI_URC_AT_IND * * PARAMETERS * local_para_ptr [IN] * peer_buff_ptr [IN] * * RETURNS * void *****************************************************************************/ static void tp_ps_urc_at_ind_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr) { rmmi_urc_at_ind_struct *cnf_ptr; kal_uint16 data_length; kal_char *pdu_ptr; cnf_ptr = (rmmi_urc_at_ind_struct*) local_para_ptr; pdu_ptr = (kal_char*) get_peer_buff_pdu(peer_buff_ptr, &data_length); tp_ps_handling_at_indication( RMMI_MSG_BASED_URC_CHANNEL, pdu_ptr, cnf_ptr->length); }
/***************************************************************************** * FUNCTION * tp_ps_response_at_ind_hdlr * DESCRIPTION * This function is used to handle the message MSG_ID_RMMI_RESPONSE_AT_IND * * PARAMETERS * local_para_ptr [IN] * peer_buff_ptr [IN] * * RETURNS * void *****************************************************************************/ static void tp_ps_response_at_ind_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr) { rmmi_response_at_ind_struct *cnf_ptr; kal_uint16 data_length; kal_char *pdu_ptr; cnf_ptr = (rmmi_response_at_ind_struct*) local_para_ptr; pdu_ptr = (kal_char*) get_peer_buff_pdu(peer_buff_ptr, &data_length); tp_ps_handling_at_indication( cnf_ptr->port_id - tp_port_begin, pdu_ptr, cnf_ptr->length); }
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); }
bool ft_misc_cal_data_write_to_nvram(void) { #if !defined(NVRAM_NOT_PRESENT) ft_nvram_write_req_struct_T req; peer_buff_struct *peer_buff = NULL; kal_char *pdu_ptr = NULL; kal_uint16 pdu_length = 0; req.file_idx = NVRAM_EF_CAL_DATA_CHECK_LID; req.para = NVRAM_EF_CAL_DATA_CHECK_TOTAL; // 1 #ifdef __NVRAM_SECRET_DATA__ req.msg_num = 1; req.msg_idx = 0; #endif // #ifdef __NVRAM_SECRET_DATA__ // allocate a peer buffer if( NULL != (peer_buff=construct_peer_buff(NVRAM_EF_CAL_DATA_CHECK_SIZE, 0, 0, TD_CTRL)) ) { pdu_ptr = get_peer_buff_pdu( peer_buff, &pdu_length ); kal_mem_cpy(pdu_ptr,p_ft_misc_buf , NVRAM_EF_CAL_DATA_CHECK_SIZE); peer_buff->pdu_len = NVRAM_EF_CAL_DATA_CHECK_SIZE; g_b_ft_nvram_proc_locally = true; // send message to NVRAM FT_WriteTo_NVRAM(&req, peer_buff, NULL); peer_buff = NULL;/* the NVRAM will release the mem*/ return true; } else { return false; } #else // #if !defined(NVRAM_NOT_PRESENT) return true; #endif // #if defined(NVRAM_NOT_PRESENT) }
/***************************************************************************** * 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 * FT_ReadFrom_NVRAM() * * DESCRIPTION * Handle the read request of FT to NVRAM * * CALLS * None * * PARAMETERS * * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_ReadFrom_NVRAM(ft_nvram_read_req_struct_T* req) { ilm_struct ilm_ptr; nvram_read_req_struct *ptrMsg; #ifdef __NVRAM_SECRET_DATA__ kal_uint8 key[256]; // at most 256 bytes kal_int32 real_key_len; kal_uint8 input_data[4]; kal_uint8 output_data[4]; kal_uint8 i; RC4_CNXT cnxt; kal_uint32 err_code = 0xFE; kal_bool bPassCheck = KAL_FALSE; real_key_len = custom_nvram_get_database_key(key, sizeof(key)); kal_mem_set(output_data, 0x0, sizeof(output_data)); // make sure if the authenticaion pass if(req->ciphered_data_valid && real_key_len > 0 ) // the load need to be checked, and user send ciphered data { kal_mem_cpy(input_data, &(req->file_idx), 2); kal_mem_cpy(input_data+2, &(req->para), 2); // deciphered the input data che_rc4_set_key((RC4_CNXT *)&cnxt, (kal_uint32)real_key_len, (kal_uint8 *)key); che_rc4((RC4_CNXT *)&cnxt, input_data , 4, key, real_key_len, CHE_MODE_NULL, output_data); for(i=0; i<4; i++) { if(output_data[i] != req->ciphered_data[i]) { err_code = 0xFD; break; } } if(i == 4) bPassCheck = KAL_TRUE; } else // ciphered data invalid { if(real_key_len == 0 || g_b_ft_nvram_proc_locally == true) // no need to checked bPassCheck = KAL_TRUE; else // need check, but user doesn't send data err_code = 0xFB; } if(!bPassCheck) { // invoke: kal_uint16 pdu_length_new = 0; kal_uint8 *pdu_ptr_new; peer_buff_struct *peer_buff_new; nvram_read_cnf_struct cnf_result; cnf_result.file_idx = req->file_idx; cnf_result.para = req->para; cnf_result.result = err_code; // allocate a peer buffer to stored the output data for debug if( NULL != (peer_buff_new=construct_peer_buff(4, 0, 0, TD_CTRL)) ) { pdu_ptr_new = get_peer_buff_pdu( peer_buff_new, &pdu_length_new ); kal_mem_cpy(pdu_ptr_new, output_data , 4); peer_buff_new->pdu_len = 4; } FT_ReadFrom_NVRAM_CNF(&cnf_result, peer_buff_new); return; } #endif // #ifdef __NVRAM_SECRET_DATA__ FT_ALLOC_OTHER_MSG(&ilm_ptr, sizeof(nvram_read_req_struct)); /* if ptrMsg != NULL*/ ptrMsg = (nvram_read_req_struct *)ilm_ptr.local_para_ptr; ptrMsg->file_idx=req->file_idx; ptrMsg->access_id=0; ptrMsg->para=req->para; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_READ_REQ, &ilm_ptr);// wait READ_CNF }
void FT_WriteTo_NVRAM(ft_nvram_write_req_struct_T* req, peer_buff_struct* peer_buff, ilm_struct* ptrMsg) { ilm_struct ilm_ptr; nvram_write_req_struct *nvram_ptr_loc_para; kal_uint16 pdu_length; kal_uint8 *pdu_ptr = get_peer_buff_pdu( peer_buff, &pdu_length ); #ifdef __NVRAM_SECRET_DATA__ kal_bool bPassCheck = KAL_FALSE; kal_int32 err_code = 0xFE; kal_uint8 key[256]; // at most 256 bytes kal_int32 real_key_len; real_key_len = custom_nvram_get_database_key(key, sizeof(key)); if(req->msg_num == 2 && real_key_len >0) // we must wait until we collect all { if(req->msg_idx == 0) // allocate a peer buffer to store it. { if(p_g_pbs_ft_nvram != NULL) // free previous buffer { free_peer_buff(p_g_pbs_ft_nvram); p_g_pbs_ft_nvram = NULL; } // allocate a new peer buffer if( NULL != (p_g_pbs_ft_nvram=construct_peer_buff(pdu_length, 0, 0, TD_CTRL)) ) { p_g_u1_ft_nvram_pdu_ptr = get_peer_buff_pdu( p_g_pbs_ft_nvram, &g_u2_ft_nvram_pdu_length ); kal_mem_cpy(p_g_u1_ft_nvram_pdu_ptr, pdu_ptr , pdu_length); p_g_pbs_ft_nvram->pdu_len = pdu_length; } return; // wait for next message } else // the second message with encrpted data { kal_int32 i; RC4_CNXT cnxt; kal_uint8 *output_data = (kal_uint8*) get_ctrl_buffer(g_u2_ft_nvram_pdu_length); // since at most 2k bytes if(p_g_u1_ft_nvram_pdu_ptr!=NULL) { // get the key //real_key_len = custom_nvram_get_database_key(key, sizeof(key)); if(real_key_len >0) // get the key { // deciphered the input data che_rc4_set_key((RC4_CNXT *)&cnxt, (kal_uint32)real_key_len, (kal_uint8 *)key); che_rc4((RC4_CNXT *)&cnxt, p_g_u1_ft_nvram_pdu_ptr , g_u2_ft_nvram_pdu_length, key, real_key_len, CHE_MODE_NULL, output_data); for(i=0; i<g_u2_ft_nvram_pdu_length; i++) { if(output_data[i] != pdu_ptr[i]) { err_code = 0xFD; break; } } if(i == g_u2_ft_nvram_pdu_length) { bPassCheck = true; } } } else { err_code = 0xFC; } free_ctrl_buffer(output_data); } } else { if(real_key_len == 0 || g_b_ft_nvram_proc_locally == true) // sec not ON bPassCheck = true; } if(!bPassCheck) { // invoke: nvram_write_cnf_struct cnf_result; cnf_result.file_idx = req->file_idx; cnf_result.para = req->para; cnf_result.result = err_code; // allocate a peer buffer to stored the output data for debug FT_WriteTo_NVRAM_CNF(&cnf_result); return; } if(real_key_len >0 && req->msg_num == 2 && p_g_pbs_ft_nvram != NULL) // re-assign the pdu_ptr, and free the buffer { kal_mem_cpy(pdu_ptr, p_g_u1_ft_nvram_pdu_ptr,pdu_length); free_peer_buff(p_g_pbs_ft_nvram); p_g_pbs_ft_nvram = NULL; } #endif // #ifdef __NVRAM_SECRET_DATA__ FT_ALLOC_OTHER_MSG(&ilm_ptr ,sizeof(nvram_write_req_struct)); nvram_ptr_loc_para=(nvram_write_req_struct *)(ilm_ptr.local_para_ptr); nvram_ptr_loc_para->file_idx=req->file_idx;/* LID */ nvram_ptr_loc_para->para=req->para; nvram_ptr_loc_para->access_id=0 ; // change it! #ifdef _LOW_COST_SINGLE_BANK_FLASH_ { // stop RF L1TST_Stop(); } #endif // #ifdef _LOW_COST_SINGLE_BANK_FLASH_ // keep a runtime buffer of the written value for updating L1 runtime // FIX: ACCESS OUT-OF BOUND if(pdu_length > sizeof(ft_rf_data_pt)) { kal_mem_cpy(&ft_rf_data_pt, pdu_ptr, sizeof(ft_rf_data_pt)); } else { kal_mem_cpy(&ft_rf_data_pt, pdu_ptr, pdu_length); } ilm_ptr.peer_buff_ptr = peer_buff; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_WRITE_REQ, &ilm_ptr); if(ptrMsg != NULL) ptrMsg->peer_buff_ptr=NULL;/* make sure the NVRAM will release the mem*/ }
/***************************************************************************** * FUNCTION * tp_ps_Send * DESCRIPTION * This function is used to send AT command to MOD_ATCI * Return success means that the command is sent, not the command is executed successfully * PARAMETERS * iFlag [IN] always be 1 * channelId [IN] * pDataPtr [IN] * iDataLen [IN] * * RETURNS * TP_SUCCESS or TP_ERROR *****************************************************************************/ kal_int32 tp_ps_Send(kal_uint8 iFlag, kal_uint8 channelId, kal_uint8 *pDataPtr, kal_uint16 iDataLen) { kal_uint16 i; kal_int32 result = TP_ERROR; module_type type; tp_queue_struct *buffer; rmmi_exe_at_req_struct *req_ptr; peer_buff_struct *peer_ptr; kal_uint8 *data_ptr; kal_uint8 cmd_string[10]; kal_char input_hint_string[] = "\r\n> "; type = stack_get_active_module_id(); if (iFlag != 1) { kal_prompt_trace( type, "[Send] Warning: iFlag shoulbe be 1: %d", iFlag); } if (tp_port_begin == -1) { kal_prompt_trace( type, "[Send] ERROR: havn't start PS, please call tp_ps_start first"); } else if(pDataPtr == NULL) { kal_prompt_trace( type, "[Send] ERROR: input data pointer is NULL!!!"); } else if (tp_callback == NULL) { kal_prompt_trace( type, "[Send] ERROR: havn't register TP callback function"); } else if(channelId >= tp_channelNum) { kal_prompt_trace( type, "[Send] ERROR: invalid channelID: ch:%d, max:%d ", channelId, tp_channelNum); } else { buffer = &tp_buffer[channelId]; if ( (buffer->length + iDataLen) > MAX_TP_QUEUE_LENGTH) { kal_prompt_trace( type, "[Send] ERROR: buffer[%d] is full, clean the buffer!!! Org:%d, New:%d, Max: %d", channelId, buffer->length, iDataLen, MAX_TP_QUEUE_LENGTH); buffer->length = 0; buffer->is_sms_cmd = KAL_FALSE; } else { result = TP_SUCCESS; //Put the data into the buffer kal_mem_cpy(buffer->data+buffer->length, pDataPtr, iDataLen); //Update buffer length buffer->length += iDataLen; //check if the data is a complete command according to the <CR><LF> for(i=0; i<buffer->length;i++) { if (buffer->is_sms_cmd == KAL_FALSE && (buffer->data[i] == RMMI_MSGBASED_CR || buffer->data[i] == RMMI_MSGBASED_LF) ) { kal_mem_cpy(cmd_string, buffer->data, 10); toUpper(cmd_string); if (is_sms_command(cmd_string, 10) == KAL_TRUE) { buffer->is_sms_cmd = KAL_TRUE; // send hint string tp_callback(channelId, input_hint_string, strlen(input_hint_string), 1); buffer->data[i] = RMMI_MSGBASED_LF; kal_prompt_trace( type, "[Send] INFO: Enter SMS input mode"); } break; } else if (buffer->is_sms_cmd == KAL_TRUE && (buffer->data[i] == RMMI_MSGBASED_CTRLZ || buffer->data[i] == RMMI_MSGBASED_ESC) ) { kal_prompt_trace( type, "[Send] INFO: Leave SMS input mode"); buffer->is_sms_cmd = KAL_FALSE; if (buffer->data[i] == RMMI_MSGBASED_ESC) { tp_callback(channelId, "\r\nOK\r\n", 6, 1); //clean the buffer buffer->length = 0; return; } break; } } if (i != buffer->length) { if (buffer->is_sms_cmd == KAL_TRUE) { kal_prompt_trace( type, "[Send] INFO: in SMS input mode, length: %d", buffer->length); } else { // send the command req_ptr = (rmmi_exe_at_req_struct*) construct_local_para((kal_uint16) sizeof(rmmi_exe_at_req_struct), TD_RESET); peer_ptr = (peer_buff_struct*) construct_peer_buff(buffer->length, 0, 0, TD_RESET); data_ptr= (kal_uint8 *)get_peer_buff_pdu(peer_ptr, &i); req_ptr->length = buffer->length; req_ptr->port_id = channelId + tp_port_begin; kal_mem_cpy(data_ptr, buffer->data, buffer->length); rmmi_msgbased_send_ilm( RMMI_MSG_BASED_HANDLER_MODULE, MSG_ID_RMMI_EXE_AT_REQ, req_ptr, peer_ptr); //clean the buffer buffer->length = 0; } } } } return result; }
/***************************************************************************** * FUNCTION * med_nvram_read_data_cnf_hdlr * DESCRIPTION * This function is to handle nvram read data confirm. * PARAMETERS * local_para_ptr [?] * peer_buff_ptr [?] * RETURNS * void *****************************************************************************/ void med_nvram_read_data_cnf_hdlr(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr) { /*----------------------------------------------------------------*/ /* Local Variables */ /*----------------------------------------------------------------*/ nvram_read_cnf_struct *parm_ptr = NULL; kal_uint16 pdu_len; kal_uint8 *pdu_ptr; audio_param_struct *nvram_param_p; /*----------------------------------------------------------------*/ /* Code Body */ /*----------------------------------------------------------------*/ /* MED_FUNC_ENTRY(MED_NVRAM_READ_DATA_CNF_HDLR) */ parm_ptr = (nvram_read_cnf_struct*) local_para_ptr; pdu_ptr = get_peer_buff_pdu(peer_buff_ptr, &pdu_len); switch (parm_ptr->file_idx) { case NVRAM_EF_CUST_ACOUSTIC_DATA_LID: { if (parm_ptr->length != sizeof(custom_acoustic_struct)) { /* error reading length */ ASSERT(0); return; } kal_mem_cpy( &(aud_context_p->acoustic_data), (custom_acoustic_struct*) pdu_ptr, sizeof(custom_acoustic_struct)); if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { #if defined(__SPEECH_MODE_TABLE_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_SPEECH_MODE_TABLE_LID, 0, 0); #elif defined(__AMRWB_LINK_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID, 0, 0); #elif defined(__DUAL_MIC_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID, 0, 0); #else aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_PARAM_LID, 0, 0); #endif } break; } #ifdef __SPEECH_MODE_TABLE_SUPPORT__ case NVRAM_EF_AUDIO_SPEECH_MODE_TABLE_LID: kal_mem_cpy( speech_mode_table_nvram, (nvram_speech_mode_table_struct*) pdu_ptr, sizeof(nvram_speech_mode_table_struct)); if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { #if defined(__AMRWB_LINK_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID, 0, 0); #elif defined( __DUAL_MIC_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID, 0, 0); #else aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_PARAM_LID, 0, 0); #endif } break; #endif /* __SPEECH_MODE_TABLE_SUPPORT__ */ #ifdef __AMRWB_LINK_SUPPORT__ case NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID: ASSERT(parm_ptr->length == sizeof(audio_wb_speech_fir_struct)); /*set to L1SP directly*/ L1SP_SetNvramInfoByIndex(L1SP_NVRAM_INFO_INDEX_WB_SPEECH_INPUT_FIR,(kal_uint8*) pdu_ptr, parm_ptr->length); if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID, 0, 0); } break; case NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID: ASSERT(parm_ptr->length == sizeof(audio_wb_speech_fir_struct)); /*set to L1SP directly*/ L1SP_SetNvramInfoByIndex(L1SP_NVRAM_INFO_INDEX_WB_SPEECH_OUTPUT_FIR,(kal_uint8*) pdu_ptr, parm_ptr->length); if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID, 0, 0); } break; case NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID: ASSERT(parm_ptr->length == sizeof(audio_wb_speech_mode_struct)); /*set to L1SP directly*/ L1SP_SetNvramInfoByIndex(L1SP_NVRAM_INFO_INDEX_WB_SPEECH_MODE_PARAM,(kal_uint8*) pdu_ptr, parm_ptr->length); if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { #if defined(__DUAL_MIC_SUPPORT__) aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID, 0, 0); #else aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_PARAM_LID, 0, 0); #endif } break; #endif /* __AMRWB_LINK_SUPPORT__ */ #ifdef __DUAL_MIC_SUPPORT__ case NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID: { audio_dual_mic_param_struct* dm_param_p; ASSERT(parm_ptr->length == sizeof(audio_dual_mic_param_struct)); dm_param_p = (audio_dual_mic_param_struct*)pdu_ptr; L1SP_SetDMNRPara((kal_int16 *)(&dm_param_p->nb_param)); #ifdef __AMRWB_LINK_SUPPORT__ L1SP_SetWbDMNRPara((kal_int16 *)(&dm_param_p->wb_param)); #endif // loud speaker mode DMNR L1SP_SetLSpkDMNRPara((kal_int16 *)(&dm_param_p->lspk_nb_param)); #ifdef __AMRWB_LINK_SUPPORT__ L1SP_SetLSpkWbDMNRPara((kal_int16 *)(&dm_param_p->lspk_wb_param)); #endif if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { aud_send_msg_to_nvram(MSG_ID_NVRAM_READ_REQ, NVRAM_EF_AUDIO_PARAM_LID, 0, 0); } break; } #endif case NVRAM_EF_AUDIO_PARAM_LID: /*set to L1SP directly*/ L1SP_SetNvramInfoByIndex(L1SP_NVRAM_INFO_INDEX_PARAM,(kal_uint8*) pdu_ptr, parm_ptr->length); nvram_param_p = (audio_param_struct*)pdu_ptr; if (med_context_p->nvram_state == MED_POWERON_READING_NVRAM) { /* Other param will be set once when bootup, no need to keep in global context */ L1SP_LoadCommonSpeechPara(nvram_param_p->speech_common_para); Media_SetMelodyFilter(MELODY_FIR_COEFF_NUM, nvram_param_p->Melody_FIR_Coeff_Tbl); aud_set_aud_path_volume(aud_context_p->audio_mode); /* Set compensation filter to driver */ aud_send_startup_cnf(MED_RES_OK); med_context_p->nvram_state = MED_POWERON_READING_NVRAM_FINISH; } else if(med_context_p->nvram_state == MED_POWERON_READING_NVRAM_FINISH) { aud_get_audio_param_from_nvram_rsp((void*)nvram_param_p); } else { ASSERT(0); } break; default: break; } }
bool ft_misc_cal_data_read_from_nvram_cnf(nvram_read_cnf_struct* cnf_result, peer_buff_struct* peer_buff ) { #if !defined(NVRAM_NOT_PRESENT) FT_MISC_CNF misc_cnf; //peer_buff_struct *peer_buff_ret = NULL; // default value kal_char *pdu_ptr = NULL; kal_uint16 pdu_length = 0; kal_bool b_ret_cnf_to_pc = KAL_FALSE; misc_cnf.type = (FT_MISC_CMD_TYPE)i4_ft_cur_misc_op; misc_cnf.status = FT_CNF_FAIL; // default value g_b_ft_nvram_proc_locally = false; if(!ft_misc_cal_data_allocate_buf()) return false; pdu_ptr = get_peer_buff_pdu( peer_buff, &pdu_length ); // copy the content from nvram to local buffer kal_mem_cpy(p_ft_misc_buf, pdu_ptr, NVRAM_EF_CAL_DATA_CHECK_SIZE); switch(i4_ft_cur_misc_op) { case FT_MISC_OP_CALDATA_INTEGRITY_START_REC: { nvram_cal_data_check_struct *cal_data = (nvram_cal_data_check_struct*) p_ft_misc_buf; g_b_ft_nvram_rec = true; // true: get the checksum of the nvram LID, rid misc_cnf.result.m_u1CurRecNum = cal_data->u1ValidNum; misc_cnf.status = FT_CNF_OK; b_ret_cnf_to_pc = true; break; } case FT_MISC_OP_CALDATA_INTEGRITY_ADD_ONE: { bool ret; ret = ft_misc_cal_data_get_checksum( ft_misc_cal_data_proc_one.u2LidEnumVal, ft_misc_cal_data_proc_one.u2LidRec, &ft_misc_cal_data_proc_one.u2CheckVal); if(ret) { // update the misc_buffer ft_misc_cal_data_update_local_buf(ft_misc_cal_data_proc_one.u2LidEnumVal, ft_misc_cal_data_proc_one.u2LidRec, ft_misc_cal_data_proc_one.u2CheckVal); // write to nvram ft_misc_cal_data_write_to_nvram(); } else { misc_cnf.status = FT_CNF_FAIL; b_ret_cnf_to_pc = true; } } break; case FT_MISC_OP_CALDATA_INTEGRITY_DEL_ONE: case FT_MISC_OP_CALDATA_INTEGRITY_DEL_ALL: { bool bOne = i4_ft_cur_misc_op == FT_MISC_OP_CALDATA_INTEGRITY_DEL_ONE? true: false; if(!ft_misc_cal_data_del_from_local_buf(bOne)) { misc_cnf.status = FT_CNF_FAIL; b_ret_cnf_to_pc = true; } else // delete success; { // write to nvram ft_misc_cal_data_write_to_nvram(); } break; } case FT_MISC_OP_CALDATA_INTEGRITY_CHECK_ONE: case FT_MISC_OP_CALDATA_INTEGRITY_CHECK_ALL: { bool bret; bool bOne = i4_ft_cur_misc_op == FT_MISC_OP_CALDATA_INTEGRITY_CHECK_ONE? true: false; bret = ft_misc_cal_data_check(bOne); if(bOne) { if(!bret) misc_cnf.status = FT_CNF_FAIL; else { misc_cnf.status = FT_CNF_OK; } } else// if(!bOne) { misc_cnf.result.m_rCalCheckAll.bAllPass = bret; misc_cnf.result.m_rCalCheckAll.u2LastLID = ft_misc_cal_data_proc_one.u2LidEnumVal ; misc_cnf.result.m_rCalCheckAll.u2LastRID = ft_misc_cal_data_proc_one.u2LidRec; misc_cnf.status = FT_CNF_OK; } b_ret_cnf_to_pc = true; // release allocate buffer ft_misc_cal_data_free_alloc_buf(); break; } default: // exFT_MISC_OP_CALDATA_INTEGRITY_STOP_REC: return true; // do nothing } if(b_ret_cnf_to_pc) FT_MISC_SendCnf(&misc_cnf, NULL); // send confirm to PC side #endif // #if !defined(NVRAM_NOT_PRESENT) return true; }
void FT_MISC_Operation(ilm_struct *ptrMsg) { kal_wchar wpath[128]; FT_MISC_REQ *p_req = (FT_MISC_REQ *)ptrMsg->local_para_ptr; FT_MISC_CNF misc_cnf; memset(&misc_cnf, 0x0, sizeof(misc_cnf)); peer_buff_struct *peer_buff_ret = NULL; // default value kal_char *pdu_ptr = NULL; kal_uint16 pdu_length = 0; misc_cnf.type = p_req->type; misc_cnf.status = FT_CNF_FAIL; // default value ft_gl_misc_token = p_req->header.token; switch(p_req->type) { case FT_MISC_OP_GET_IMEI_LOC: { misc_cnf.result.m_u1IMEILoc = nvram_get_imei_type(); misc_cnf.status = FT_CNF_OK; break; } case FT_MISC_OP_GET_IMEI_VALUE: { // check the record index (because tools before 0912 causes assertion) kal_uint16 rec_num = nvram_get_imei_record_num(); if(p_req->cmd.m_u1RecordIndex < 1 || p_req->cmd.m_u1RecordIndex > rec_num) { // set the record index to 1 (the behavior will be confrom to that of target load before 0909) p_req->cmd.m_u1RecordIndex = 1; } if(KAL_TRUE == nvram_get_imei_value(NVRAM_EF_IMEI_IMEISV_SIZE, misc_cnf.result.m_rIMEIData.buf, p_req->cmd.m_u1RecordIndex)) { misc_cnf.result.m_rIMEIData.buf_len = NVRAM_EF_IMEI_IMEISV_SIZE; misc_cnf.status = FT_CNF_OK; } else misc_cnf.status = FT_CNF_FAIL; break; } #if defined(__MTK_INTERNAL__) /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ #endif //#if defined(__MTK_INTERNAL__) case FT_MISC_OP_GET_IMEI_REC_NUM: { misc_cnf.result.m_u2IMEIRecords = nvram_get_imei_record_num(); misc_cnf.status = FT_CNF_OK; break; } case FT_MISC_OP_VERIFY_TEMP_SML_FILE: { //kal_char *pdu_ptr; //kal_uint16 pdu_length; kal_wchar *w_filepath; // get the file path from peer_buffer if(ptrMsg->peer_buff_ptr != NULL) { pdu_ptr = get_peer_buff_pdu( ptrMsg->peer_buff_ptr, &pdu_length ); // cast to kal_wchar w_filepath = (kal_wchar *)pdu_ptr; misc_cnf.status = FT_CNF_OK; // ask nvram task to check the SML file if(NVRAM_IO_ERRNO_OK == nvram_validate_file(NVRAM_EF_SML_LID, w_filepath)) misc_cnf.result.m_u1VerifyResult = FT_SML_VALID; else misc_cnf.result.m_u1VerifyResult = FT_SML_INVALID; } else // peer buffer is null { misc_cnf.status = FT_CNF_FAIL; misc_cnf.result.m_u1VerifyResult = FT_SML_NO_FILENAME; } break; } case FT_MISC_OP_GET_CAL_INFO: { ft_misc_op_collect_cal_info(&misc_cnf); return; } case FT_MISC_OP_QUERY_NVRAM_FOLDER: { kal_uint16 length; kal_char* buf; kal_uint8 folder_total_amount = nvram_get_folder_total_amount(); kal_int16 total_length = 0; kal_int8 i; misc_cnf.status = FT_CNF_OK; // allocate peer buffer if(NULL == peer_buff_ret) {//FT_MISC_MAX_FRAME_SIZE peer_buff_ret = construct_peer_buff(FT_MISC_MAX_FRAME_SIZE, 0, 0, TD_CTRL); if(NULL == peer_buff_ret) return; peer_buff_ret->pdu_len = 0 ; } pdu_ptr = get_peer_buff_pdu( peer_buff_ret, &pdu_length ); for(i = 0;i<folder_total_amount;i++) { buf = nvram_get_work_path(i); kal_wsprintf(wpath, "%s", buf); if(nvram_check_hidden_file(wpath, true)) { continue; } length = (strlen(buf)+1); kal_mem_cpy(pdu_ptr+pdu_length+total_length, (buf), length ); *(pdu_ptr+pdu_length+total_length+length-1) = '?'; total_length += length; } // update pdu_len peer_buff_ret->pdu_len += (total_length); break; } case FT_MISC_OP_VERIFY_NVRAM_ATTR_SETTING_COMPLETE: { kal_uint16 stop_index = custom_meta_check_must_backup_lid_array(p_req->cmd.m_bcheckImeiFlag); if(stop_index == custom_meta_get_check_lid_num()) // check successfully! { misc_cnf.status = FT_CNF_OK; misc_cnf.result.m_rNvramVerifyResult.m_stop_enum_value = custom_meta_get_enum_by_index(stop_index-1); // pass the imei_enum misc_cnf.result.m_rNvramVerifyResult.m_total_lid_num = custom_meta_get_check_lid_num(); misc_cnf.result.m_rNvramVerifyResult.m_stop_index = stop_index; } else { misc_cnf.status = FT_CNF_FAIL; misc_cnf.result.m_rNvramVerifyResult.m_stop_enum_value = custom_meta_get_enum_by_index(stop_index); misc_cnf.result.m_rNvramVerifyResult.m_total_lid_num = custom_meta_get_check_lid_num(); misc_cnf.result.m_rNvramVerifyResult.m_stop_index = stop_index; } break; } case FT_MISC_OP_ENABLE_PATH_LIMITION: case FT_MISC_OP_DISABLE_PATH_LIMITION: { ft_gl_path_check_flag = (p_req->type == FT_MISC_OP_ENABLE_PATH_LIMITION)?true:false; misc_cnf.status = FT_CNF_OK; break; } case FT_MISC_OP_GET_NVRAM_FOLDER_AMOUNT: { kal_uint8 i; misc_cnf.result.m_u1NVRAMFolderAmount = nvram_get_folder_total_amount(); for(i = 0;i<nvram_get_folder_total_amount();i++) { kal_wsprintf(wpath, "%s", nvram_get_work_path(i)); if(nvram_check_hidden_file(wpath, true)) { misc_cnf.result.m_u1NVRAMFolderAmount--; } } misc_cnf.status = FT_CNF_OK; } break; #ifndef SIM_NOT_PRESENT case FT_MISC_OP_CHECK_SIM1_INSERTED: { // Send reset request to MOD_SIM ilm_struct ilm_ptr; sim_reset_req_struct* ptr_loc_para; FT_ALLOC_OTHER_MSG(&ilm_ptr, sizeof(sim_reset_req_struct)); ptr_loc_para = (sim_reset_req_struct*) (ilm_ptr.local_para_ptr); ptr_loc_para->src_id = 0xff; // set sim cmd type to global variable ft_gl_sim_cmd_type = FT_MISC_OP_CHECK_SIM1_INSERTED; FT_SEND_MSG(MOD_FT, MOD_SIM, PS_SIM_SAP, MSG_ID_SIM_RESET_REQ, &ilm_ptr); // wait for SIM task CNF message return; } #ifdef __GEMINI__ case FT_MISC_OP_CHECK_SIM2_INSERTED: { // Send reset request to MOD_SIM_2 ilm_struct ilm_ptr; sim_reset_req_struct* ptr_loc_para; FT_ALLOC_OTHER_MSG(&ilm_ptr, sizeof(sim_reset_req_struct)); ptr_loc_para = (sim_reset_req_struct*) (ilm_ptr.local_para_ptr); ptr_loc_para->src_id = 0xff; // set sim cmd type to global variable ft_gl_sim_cmd_type =FT_MISC_OP_CHECK_SIM2_INSERTED; FT_SEND_MSG(MOD_FT, MOD_SIM_2, PS_SIM_SAP, MSG_ID_SIM_RESET_REQ, &ilm_ptr); // wait for SIM task CNF message return; } #endif // __GEMINI__ #ifdef GEMINI_PLUS case FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED: { // Send reset request to MOD_SIM_N ilm_struct ilm_ptr; sim_reset_req_struct* ptr_loc_para; // if index out of range, break and then send error status CNF if(p_req->cmd.m_u1SimIndex >= GEMINI_PLUS) { break; } FT_ALLOC_OTHER_MSG(&ilm_ptr, sizeof(sim_reset_req_struct)); ptr_loc_para = (sim_reset_req_struct*) (ilm_ptr.local_para_ptr); ptr_loc_para->src_id = 0xff; // set sim cmd type to global variable ft_gl_sim_cmd_type = FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED; FT_SEND_MSG(MOD_FT, (module_type)(MOD_SIM + p_req->cmd.m_u1SimIndex), PS_SIM_SAP, MSG_ID_SIM_RESET_REQ, &ilm_ptr); // wait for SIM task CNF message return; } #endif // GEMINI_PLUS #endif // SIM_NOT_PRESENT case FT_MISC_OP_SET_MUIC_CHARGER_MODE: { #ifdef __DRV_EXT_CHARGER_DETECTION__ MU_BQ25040_Charger_Mode(p_req->cmd.m_u1ChargerMode); misc_cnf.status = FT_CNF_OK; #else misc_cnf.status = FT_CNF_FAIL; #endif break; } #if !defined(NVRAM_NOT_PRESENT) case FT_MISC_OP_CALDATA_INTEGRITY_START_REC: { if(g_b_ft_nvram_rec) { misc_cnf.status = FT_CNF_FAIL; break; } i4_ft_cur_misc_op = p_req->type; ft_misc_cal_data_read_from_nvram(); return; } case FT_MISC_OP_CALDATA_INTEGRITY_STOP_REC: { if(!g_b_ft_nvram_rec) { misc_cnf.status = FT_CNF_FAIL; break; } g_b_ft_nvram_rec = false; // stop record i4_ft_cur_misc_op = p_req->type; ft_misc_cal_data_write_to_nvram(); return; } case FT_MISC_OP_CALDATA_INTEGRITY_ADD_ONE: case FT_MISC_OP_CALDATA_INTEGRITY_DEL_ONE: case FT_MISC_OP_CALDATA_INTEGRITY_CHECK_ONE: ft_misc_cal_data_proc_one.u2LidEnumVal = p_req->cmd.m_rCalDataOne.u2LidEnum; ft_misc_cal_data_proc_one.u2LidRec = p_req->cmd.m_rCalDataOne.u2RID; ft_misc_cal_data_proc_one.u2CheckVal = 0; // note: don't break, keep going case FT_MISC_OP_CALDATA_INTEGRITY_DEL_ALL: case FT_MISC_OP_CALDATA_INTEGRITY_CHECK_ALL: { if(g_b_ft_nvram_rec) { misc_cnf.status = FT_CNF_FAIL; break; } i4_ft_cur_misc_op = p_req->type; ft_misc_cal_data_read_from_nvram(); return; } #endif // #if !defined(NVRAM_NOT_PRESENT) case FT_MISC_OP_GET_ADC_FROM_EFUSE: { kal_bool b_ret_code; kal_uint8 i; kal_uint8 adc_max_channel; DCL_HANDLE adc_handle; ADC_CTRL_READ_CALIBRATION_DATA_T prReadCalibrationData; adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE); adc_max_channel = FT_GetAdcMaxChannel(); b_ret_code = (STATUS_OK == DclSADC_Control(adc_handle, ADC_CMD_READ_CALIBRATION_DATA, (DCL_CTRL_DATA_T*)&prReadCalibrationData)) ? KAL_TRUE : KAL_FALSE; misc_cnf.status = FT_CNF_OK; misc_cnf.result.m_rGetAdcFromEfuse.bADCStoredInEfuse = b_ret_code; misc_cnf.result.m_rGetAdcFromEfuse.u2ADCChnNum = b_ret_code ? adc_max_channel : 0; // if channel number > 0, construct peer buffer if(misc_cnf.result.m_rGetAdcFromEfuse.u2ADCChnNum > 0) // i.e. FT_GetAdcMaxChannel() { if( NULL != (peer_buff_ret=construct_peer_buff(adc_max_channel*8, 0, 0, TD_CTRL)) ) { pdu_ptr = get_peer_buff_pdu( peer_buff_ret, &pdu_length ); peer_buff_ret->pdu_len = adc_max_channel *8; for(i =0; i< adc_max_channel; i++) // append slope first { kal_mem_cpy(pdu_ptr+(i*4), &(prReadCalibrationData.i4ADCSlope[i]), sizeof(kal_int32)); } for(i =0; i<adc_max_channel; i++) // append offset second { kal_mem_cpy(pdu_ptr+((adc_max_channel+i)*4), &(prReadCalibrationData.i4ADCOffset[i]), sizeof(kal_int32)); } } } break; } case FT_MISC_OP_GET_CALFLAG_ENUM: { misc_cnf.result.m_u2CalFlagEnum = custom_ft_get_calflag_enum(); misc_cnf.status = FT_CNF_OK; } break; case FT_MISC_OP_GET_ADC_MAX_CHANNEL: { // HAL modification misc_cnf.status = FT_CNF_OK; misc_cnf.result.m_u1ADCMaxChannel = FT_GetAdcMaxChannel(); break; } case FT_MISC_OP_GET_TADC_INDEX: { // HAL modification //misc_cnf.result.m_u1TADCChannelIndex = custom_adc_get_channel(rftmp_adc_channel); DCL_HANDLE adc_handle; ADC_CTRL_GET_PHYSICAL_CHANNEL_T adc_ch; misc_cnf.status = FT_CNF_OK; adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE); adc_ch.u2AdcName = DCL_RFTMP_ADC_CHANNEL; if(DclSADC_Control( adc_handle, ADC_CMD_GET_CHANNEL, (DCL_CTRL_DATA_T *)& adc_ch) != STATUS_OK) { misc_cnf.status = FT_CNF_FAIL; } misc_cnf.result.m_u1TADCChannelIndex = adc_ch.u1AdcPhyCh; if(DclSADC_Close(adc_handle) != STATUS_OK) { misc_cnf.status = FT_CNF_FAIL; } break; } case FT_MISC_OP_GET_RF_CAL_ENV_ENUM: misc_cnf.result.m_u2Enum = custom_ft_get_rf_cal_env_enum(); misc_cnf.status = FT_CNF_OK; break; case FT_MISC_OP_GET_RF_CAL_LOSS_SETTING_ENUM: misc_cnf.result.m_u2Enum = custom_ft_get_rf_loss_setting_enum(); misc_cnf.status = FT_CNF_OK; break; case FT_MISC_OP_GET_RF_TEST_POWER_RESULT_ENUM: misc_cnf.result.m_u2Enum = custom_ft_get_rf_test_power_result_enum(); misc_cnf.status = FT_CNF_OK; break; case FT_MISC_OP_GET_RID: { if(KAL_TRUE == SST_Get_ChipRID((kal_char*)misc_cnf.result.m_rRIDData.buf, (p_req->cmd.m_RIDLength*8))) { misc_cnf.result.m_rRIDData.buf_len = p_req->cmd.m_RIDLength; // return RID length in bytes } else { misc_cnf.result.m_rRIDData.buf_len = 0; // return length = 0 for error check } misc_cnf.status = FT_CNF_OK; break; } case FT_MISC_OP_GET_BARCODE_VALUE: { if(p_req->cmd.m_u1RecordIndex < 1 || p_req->cmd.m_u1RecordIndex > NVRAM_EF_BARCODE_NUM_TOTAL) { p_req->cmd.m_u1RecordIndex = 1; } if( NULL != (peer_buff_ret=construct_peer_buff(NVRAM_EF_BARCODE_NUM_SIZE, 0, 0, TD_CTRL))) { peer_buff_ret->pdu_len = NVRAM_EF_BARCODE_NUM_SIZE; pdu_ptr = get_peer_buff_pdu( peer_buff_ret, &pdu_length ); if(KAL_TRUE == nvram_external_read_data(NVRAM_EF_BARCODE_NUM_LID, p_req->cmd.m_u1RecordIndex, (kal_uint8*)pdu_ptr, NVRAM_EF_BARCODE_NUM_SIZE)) { misc_cnf.status = FT_CNF_OK; } } break; } default: return; } // send confirm to PC side FT_MISC_SendCnf(&misc_cnf, peer_buff_ret); }
kal_uint8 ft_misc_op_collect_cal_info(FT_MISC_CNF *misc_cnf) { kal_char *pcStrPrefix; kal_char *pcStrVerNo; kal_uint8 flag; peer_buff_struct *peer_buff_ret = NULL; kal_char *pdu_ptr = NULL; kal_uint16 pdu_length = 0; kal_uint16 cur_pos = 0; nvram_ltable_entry_struct *entry = NULL; // find the first enrty when the input pointer is NULL pointer nvram_util_next_data_item(&entry); do { if(NVRAM_IO_ERRNO_OK != nvram_check_backup(entry->LID, &pcStrPrefix, &pcStrVerNo)) { continue; } flag = FT_OTHER_INFO_FLAG; if(entry->LID == NVRAM_EF_IMEI_IMEISV_LID) { flag = FT_IMEI_INFO_FLAG; } else if(entry->LID==NVRAM_EF_SML_LID) { flag = FT_SML_INFO_FLAG; } allocate_peer_buf: if(NULL == peer_buff_ret) // allocate peer buffer { peer_buff_ret=construct_peer_buff(FT_MISC_MAX_FRAME_SIZE, 0, 0, TD_CTRL); if(NULL == peer_buff_ret) { return 1; } /* Set the pdu_len to 0 to keep track of the current position and updated at each iteration */ peer_buff_ret->pdu_len = 0 ; } if( FT_MISC_MAX_FRAME_SIZE < (peer_buff_ret->pdu_len+3+strlen(pcStrPrefix)+strlen(pcStrVerNo)+1) ) { misc_cnf->result.m_u1LastFrame = 0; // set last_frame = 0 misc_cnf->status = FT_CNF_OK; // send confirm FT_MISC_SendCnf(misc_cnf, peer_buff_ret); // sleep to wait for tst flush out data kal_sleep_task(50); // allocate peer buffer again peer_buff_ret = NULL; cur_pos = 0; goto allocate_peer_buf; } pdu_ptr = get_peer_buff_pdu( peer_buff_ret, &pdu_length ); // copy to peer buffer cur_pos = 0; // copy lid_value (Assertion check to guarantee that the protocol stays unchange) { ASSERT(sizeof(kal_uint16) == sizeof(nvram_lid_enum)); kal_mem_cpy(pdu_ptr+pdu_length, &(entry->LID), sizeof(kal_uint16)); cur_pos += sizeof(kal_uint16); } // copy file flag { kal_mem_cpy(pdu_ptr+pdu_length+cur_pos, &flag, sizeof(kal_uint8)); cur_pos += sizeof(kal_uint8); } // copy file prefix (Assertion check to guarantee that the protocol stays unchange) { ASSERT(strlen(pcStrPrefix) == 4); kal_mem_cpy(pdu_ptr+pdu_length+cur_pos, pcStrPrefix, strlen(pcStrPrefix)); cur_pos +=(strlen(pcStrPrefix)); } // copy lid Ver No (Assertion check to guarantee that the protocol stays unchange) { ASSERT(strlen(pcStrVerNo) == 3); kal_mem_cpy(pdu_ptr+pdu_length+cur_pos, pcStrVerNo, strlen(pcStrVerNo)+1); cur_pos += (strlen(pcStrVerNo)+1); } // update pdu_len peer_buff_ret->pdu_len += cur_pos; }while(nvram_util_next_data_item(&entry) == KAL_TRUE); misc_cnf->result.m_u1LastFrame = 1; misc_cnf->status = FT_CNF_OK; FT_MISC_SendCnf(misc_cnf, peer_buff_ret); return 0; }