void FT_Handle_FTC_CNF(ilm_struct *ptrMsg) { ilm_struct ilm_ptr; FT_CUSTOMER_CNF *ptrMsg2; // send back to PC switch (ptrMsg->msg_id) { case MSG_ID_FTC_BASIC_CNF: { ftc_basic_cnf_struct *tmp_local_para = NULL; // from FTC Task tmp_local_para = (ftc_basic_cnf_struct*)ptrMsg->local_para_ptr; FT_ALLOC_MSG(&ilm_ptr ,sizeof(FT_CUSTOMER_CNF)); ilm_ptr.peer_buff_ptr = ptrMsg->peer_buff_ptr; ptrMsg2 = (FT_CUSTOMER_CNF*)ilm_ptr.local_para_ptr; ptrMsg2->header.ft_msg_id = FT_CUSTOM_CNF_ID; ptrMsg2->type = FT_CUSTOMER_OP_BASIC; ptrMsg2->status = tmp_local_para->status; //FTC_CNF_OK; // for debug sprintf((kal_char *)g_FT_debug_buf, "recv message from ftc"); tst_sys_trace(g_FT_debug_buf); } break; default: return; } // send confirm to PC FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr); }
/******************************************************************************* * * FT task check if function exist * *******************************************************************************/ kal_uint8 FT_UTIL_SendCnf(const FT_UTILITY_COMMAND_CNF *cnf, peer_buff_struct *p_peer_buff) { ilm_struct *ilm_ptr; FT_UTILITY_COMMAND_CNF *ptrMsg; if( NULL == (ilm_ptr=FT_ALLOC_MSG(sizeof(FT_UTILITY_COMMAND_CNF))) ) { return 1; } // if ptrMsg != NULL ptrMsg = (FT_UTILITY_COMMAND_CNF *)ilm_ptr->local_para_ptr; // assign primitive id ptrMsg->header.ft_msg_id = FT_UTILITY_COMMAND_CNF_ID; // assign return structure ptrMsg->type = cnf->type; ptrMsg->result = cnf->result; ptrMsg->status = cnf->status; // assign peer buffer if( NULL != p_peer_buff ) { ilm_ptr->peer_buff_ptr = p_peer_buff; } // FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, ilm_ptr); return 0; }
/******************************************************************************* * FUNCTION * FT_WriteTo_NVRAM_CNF * * DESCRIPTION * Handle the confirmation of writting * * CALLS * * * PARAMETERS * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_WriteTo_NVRAM_CNF(nvram_write_cnf_struct* cnf_result) { ilm_struct ilm_ptr; ft_nvram_write_cnf_struct_T *ptrMsg ; kal_uint8 ok; if (cnf_result->result ==0) ok = FT_CNF_OK; else ok = FT_CNF_FAIL; if(ok==FT_CNF_OK) { switch(cnf_result->file_idx) { default: /**V \brief 2G update runtime value after wrote nvram */ L1TST_UpdateCalibrationData( cnf_result->file_idx ); #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) /**V \brief 3G WCDMA update runtime value after wrote nvram */ FT_UL1TST_UpdateRuntimeReq( cnf_result->file_idx ); #endif // #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) break; } } if(!g_b_ft_nvram_proc_locally || cnf_result->file_idx != NVRAM_EF_CAL_DATA_CHECK_LID) { FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_nvram_write_cnf_struct_T)); /* if ptrMsg != NULL*/ ptrMsg = (ft_nvram_write_cnf_struct_T *)ilm_ptr.local_para_ptr; ptrMsg->header.ft_msg_id = FT_NVRAM_WRITE_CNF_ID; ptrMsg->file_idx=cnf_result->file_idx; ptrMsg->para=cnf_result->para; ptrMsg->status = cnf_result->result; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr); } else // write locally complete, return misc confirm to PC side { #if !defined(NVRAM_NOT_PRESENT) ft_misc_cal_data_write_to_nvram_cnf(cnf_result); #endif // #if !defined(NVRAM_NOT_PRESENT) } if(ok == FT_CNF_OK && g_b_ft_nvram_rec) { // get the nvram checksum from nvram kal_uint16 u2_checksum; bool bValid = ft_misc_cal_data_get_checksum((kal_uint16)cnf_result->file_idx, cnf_result->para,&u2_checksum); if(bValid) { // update the misc_buffer ft_misc_cal_data_update_local_buf((kal_uint16)cnf_result->file_idx, cnf_result->para, u2_checksum); } } }
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 * FT_ReadFrom_NVRAM_CNF * * DESCRIPTION * Handle the confirmation of reading * * CALLS * * * PARAMETERS * local_para_struct * local_para_ptr, //( force to nvram_read_cnf_struct* cnf ) * peer_buff_struct * peer_buff_ptr * * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_ReadFrom_NVRAM_CNF(nvram_read_cnf_struct* cnf_result, peer_buff_struct* peer_buff ) { ilm_struct ilm_ptr; ft_nvram_read_cnf_struct_T *ft_cnf; if(!g_b_ft_nvram_proc_locally || cnf_result->file_idx != NVRAM_EF_CAL_DATA_CHECK_LID) { FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_nvram_read_cnf_struct_T)); ft_cnf = (ft_nvram_read_cnf_struct_T *)ilm_ptr.local_para_ptr; ft_cnf->header.ft_msg_id = FT_NVRAM_READ_CNF_ID; ft_cnf->file_idx=cnf_result->file_idx; ft_cnf->para=cnf_result->para; #if defined(__MOD_NVRAM__) if( nvram_test_lock() && (NVRAM_EF_SML_LID==cnf_result->file_idx) ) { ft_cnf->status = 0xFF; ilm_ptr.peer_buff_ptr = NULL; free_peer_buff(peer_buff); } else { ft_cnf->status = cnf_result->result; ilm_ptr.peer_buff_ptr=peer_buff; } #endif // #if defined(__MOD_NVRAM__) /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr); } else { #if !defined(NVRAM_NOT_PRESENT) ft_misc_cal_data_read_from_nvram_cnf(cnf_result,peer_buff); free_peer_buff(peer_buff); #endif // #if !defined(NVRAM_NOT_PRESENT) } }
/******************************************************************************* * 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*/ }
void FT_DispatchMessage(ilm_struct* ptrMsg) { FT_H *ft_header; ft_header=(FT_H *)(ptrMsg->local_para_ptr); if( (ptrMsg->src_mod_id == MOD_TST_READER) ) { ft_gl_token=ft_header->token; #ifdef __TOOL_ACCESS_CTRL__ // if it's not basic META mode operation, check the limited operation state if(!FT_META_IsBasicOperation(ft_header->ft_msg_id)) { // check if the operation is allowed if(KAL_TRUE != Custom_META_IsAllowedLimitedStateOperation(ptrMsg)) { return; } } #endif // #ifdef __TOOL_ACCESS_CTRL__ switch (ft_header->ft_msg_id) { /******************************************** * L1 RF test functionality ********************************************/ case FT_RF_TEST_REQ_ID: { FT_FtRfTestReq((ft_rf_test_req_T*)ptrMsg->local_para_ptr, ptrMsg->peer_buff_ptr); break; } /******************************************** * BB test functionality ********************************************/ case FT_REG_READ_ID: { FT_FtRegisterRead((ft_RegisterRead_req_T*)ptrMsg->local_para_ptr,FT_BaseBandReg); break; } case FT_REG_WRITE_ID: { FT_FtRegisterWrite((ft_RegisterWrite_req_T*)ptrMsg->local_para_ptr,FT_BaseBandReg); break; } case FT_PMIC_REG_READ_ID: { FT_FtPMICRegisterRead((ft_PMICRegisterRead_req_T*)ptrMsg->local_para_ptr,FT_PMICReg); break; } case FT_PMIC_REG_WRITE_ID: { FT_FtPMICRegisterWrite((ft_PMICRegisterWrite_req_T*)ptrMsg->local_para_ptr,FT_PMICReg); break; } case FT_ADC_GETMEADATA_ID: { FT_FtADC_GetMeaData((ft_FtADC_GetMeaData_req_T*)ptrMsg->local_para_ptr); break; } /******************************************** * UL1 RF test functionality ********************************************/ #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) case FT_URF_TEST_REQ_ID: { if(KAL_TRUE == UL1_IS_3G_FDD_EXIST()) //20130206 { FT_FtURfTestReq( (ft_urf_test_req_T*)ptrMsg->local_para_ptr, ptrMsg->peer_buff_ptr ); } else { sprintf(g_FT_debug_buf, "[FT_DispatchMessage][FT_URF_TEST_REQ_ID] HW FDD does not exist."); tst_sys_trace(g_FT_debug_buf); } break; } #endif // #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) /******************************************** * * NVRAM functionality * ********************************************/ case FT_NVRAM_GET_DISK_INFO_REQ_ID: { ilm_struct ptr_ilm; FT_NVRAM_GET_DISK_INFO_CNF *ptr_loc_para; // store nvram token id, because any of NVRAM command won't return immediately. ft_gl_nvram_token = ft_header->token; FT_ALLOC_OTHER_MSG(&ptr_ilm,sizeof(FT_NVRAM_GET_DISK_INFO_CNF)); ptr_loc_para=(FT_NVRAM_GET_DISK_INFO_CNF *)(ptr_ilm.local_para_ptr); /* if ptr_ilm != NULL*/ ptr_loc_para->header.ft_msg_id=FT_NVRAM_GET_DISK_INFO_CNF_ID; #if defined(__MOD_NVRAM__) if(nvram_get_disk_file_info(&(ptr_loc_para->diskfilesize), &(ptr_loc_para->freespace), &(ptr_loc_para->overhead))) { ptr_loc_para->status = 0; } else { ptr_loc_para->diskfilesize = 0; ptr_loc_para->freespace = 0; ptr_loc_para->overhead = 0; ptr_loc_para->status = 1; } #endif // #if defined(__MOD_NVRAM__) /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ptr_ilm); break; } case FT_NVRAM_RESET_REQ_ID: { ilm_struct ptr_ilm; nvram_reset_req_struct *ptr_loc_para; // store nvram token id, because any of NVRAM command won't return immediately. ft_gl_nvram_token = ft_header->token; FT_ALLOC_OTHER_MSG(&ptr_ilm,sizeof( nvram_reset_req_struct)); /* if ptr_ilm != NULL*/ ptr_loc_para=(nvram_reset_req_struct *)(ptr_ilm.local_para_ptr); if( ((ft_nvram_reset_req_struct_T*)ptrMsg->local_para_ptr)->reset_category == 0) // reset all { ptr_loc_para->reset_category= NVRAM_RESET_ALL; } else if( ((ft_nvram_reset_req_struct_T*)ptrMsg->local_para_ptr)->reset_category == 3) // reset certain { ptr_loc_para->reset_category= NVRAM_RESET_CERTAIN; } else if( ((ft_nvram_reset_req_struct_T*)ptrMsg->local_para_ptr)->reset_category == 4) // reset factory { ptr_loc_para->reset_category= NVRAM_RESET_FACTORY; } else { destroy_ilm(&ptr_ilm); break; // directly break!, Let PC side timeout! } ptr_loc_para->app_id = NVRAM_APP_RESERVED; ptr_loc_para->LID=((ft_nvram_reset_req_struct_T*)ptrMsg->local_para_ptr)->file_idx; /* 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_RESET_REQ, &ptr_ilm); break; } case FT_NVRAM_READ_REQ_ID: { // store nvram token id, because any of NVRAM command won't return immediately. ft_gl_nvram_token = ft_header->token; FT_ReadFrom_NVRAM((ft_nvram_read_req_struct_T*)ptrMsg->local_para_ptr); break; } case FT_NVRAM_WRITE_REQ_ID: { ft_nvram_write_req_struct_T *ptr_msg = (ft_nvram_write_req_struct_T*)( ptrMsg->local_para_ptr ); // store nvram token id, because any of NVRAM command won't return immediately. ft_gl_nvram_token = ft_header->token; FT_WriteTo_NVRAM(ptr_msg,ptrMsg->peer_buff_ptr, ptrMsg); // ptrMsg->peer_buff_ptr=NULL;/* make sure the NVRAM will release the mem*/ break; } case FT_NVRAM_LOCK_REQ_ID: { ilm_struct ptr_ilm; nvram_set_lock_req_struct *ptr_loc_para; ft_nvram_lock_req_struct_T *ptr_msg = (ft_nvram_lock_req_struct_T *)(ptrMsg->local_para_ptr); // store nvram token id, because NVRAM command won't return immediately. ft_gl_nvram_token = ft_header->token; FT_ALLOC_OTHER_MSG(&ptr_ilm, sizeof(nvram_set_lock_req_struct)); /* if ptr_ilm != NULL*/ ptr_loc_para=(nvram_set_lock_req_struct *)(ptr_ilm.local_para_ptr); // if OTP lock or NVRAM lock if( NVRAM_LOCK_OTP == ptr_msg->lock_en ) { ptr_loc_para->lock_en = NVRAM_LOCK_OTP; } else { ptr_loc_para->lock_en = NVRAM_LOCK_ENABLE; } /* 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_SET_LOCK_REQ, &ptr_ilm); break; } /******************************************** * * FAT functionality * ********************************************/ case FT_FAT_OPERATION_ID: { FT_FAT_Operation((FT_FAT_OPERATION *)ptrMsg->local_para_ptr, ptrMsg->peer_buff_ptr); break; } /******************************************** * * Version Info functionality * ********************************************/ case FT_VER_INFO_REQ_ID: { FT_GetVersionInfo(); break; } /******************************************** * * FT task test alive * ********************************************/ case FT_IS_ALIVE_REQ_ID: { FT_TestAlive(); break; } /******************************************** * * FT task Power Off * ********************************************/ case FT_POWER_OFF_REQ_ID: { FT_PowerOff(); break; } /******************************************** * * FT task utility command * ********************************************/ case FT_UTILITY_COMMAND_REQ_ID: { FT_UtilityCommand(ptrMsg); break; } /******************************************** * * Misc utility command * ********************************************/ case FT_MISC_CMD_REQ_ID: { FT_MISC_Operation(ptrMsg); break; } /******************************************** * * Misc EX utility command * ********************************************/ case FT_MISC_EX_CMD_REQ_ID: { FT_MISC_EX_Operation(ptrMsg); break; } case FT_CUSTOM_REQ_ID: { // send message to FTC task ft_gl_customer_token = ft_header->token; FT_Custom_Operation(ptrMsg); break; } #if defined(__UMTS_TDD128_MODE__) && defined(__AST_TL1_TDD__) case FT_AUX_REQ_ID: { if(KAL_TRUE == tl1_is_tdd_hw_exist()) //20130206 { // send message to FTA task ft_gl_customer_token = ft_header->token; FT_Aux_Operation(ptrMsg); } else { sprintf(g_FT_debug_buf, "[FT_DispatchMessage][FT_AUX_REQ_ID] HW TDD does not exist."); tst_sys_trace(g_FT_debug_buf); } break; } #endif // #if defined(__UMTS_TDD128_MODE__) && defined(__AST_TL1_TDD__) default: break; } } else if( (ptrMsg->src_mod_id == MOD_FTC) ) { ft_gl_token = ft_gl_customer_token; FT_Handle_FTC_CNF(ptrMsg); ptrMsg->peer_buff_ptr=NULL; /* make sure the TST will release the mem*/ } #if defined(__UMTS_TDD128_MODE__) && defined(__AST_TL1_TDD__) else if( (ptrMsg->src_mod_id == MOD_FTA) ) { ft_gl_token = ft_gl_customer_token; FT_Handle_FTA_CNF(ptrMsg); ptrMsg->peer_buff_ptr=NULL; /* make sure the TST will release the mem*/ } #endif // #if defined(__UMTS_TDD128_MODE__) && defined(__AST_TL1_TDD__) #if defined(__MOD_NVRAM__) else if( (ptrMsg->src_mod_id == MOD_NVRAM) ) { switch (ptrMsg->msg_id) { case MSG_ID_NVRAM_READ_CNF: { nvram_read_cnf_struct *msg_ptr = NULL; // restore the previous token id to ft_gl_token, ft_gl_token will be used in FT_SEND_MSG(). ft_gl_token = ft_gl_nvram_token; msg_ptr=(nvram_read_cnf_struct*)ptrMsg->local_para_ptr; FT_ReadFrom_NVRAM_CNF(msg_ptr, ptrMsg->peer_buff_ptr ); ptrMsg->peer_buff_ptr=NULL; /* make sure the TST will release the mem*/ break; } #if defined(__MOD_NVRAM__)&& defined(__SYSDRV_BACKUP_DISK_RAW__) case MSG_ID_NVRAM_CREATE_IMAGE_CNF: case MSG_ID_NVRAM_VERIFY_IMAGE_CNF: { FT_Handle_CNF_From_NVRAM(ptrMsg); break; } #endif // #if defined(__MOD_NVRAM__)&& defined(__SYSDRV_BACKUP_DISK_RAW__) case MSG_ID_NVRAM_WRITE_CNF: { nvram_write_cnf_struct* msg_ptr = NULL; // restore the previous token id to ft_gl_token, ft_gl_token will be used in FT_SEND_MSG(). ft_gl_token = ft_gl_nvram_token; msg_ptr=(nvram_write_cnf_struct*)ptrMsg->local_para_ptr; FT_WriteTo_NVRAM_CNF(msg_ptr); break; } case MSG_ID_NVRAM_RESET_CNF: { nvram_reset_cnf_struct* msg_ptr; ilm_struct ilm_ptr; ft_nvram_reset_cnf_struct_T* pMsg; // restore the previous token id to ft_gl_token, ft_gl_token will be used in FT_SEND_MSG(). ft_gl_token = ft_gl_nvram_token; msg_ptr=(nvram_reset_cnf_struct*)ptrMsg->local_para_ptr; FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_nvram_reset_cnf_struct_T)); /* if ptrMsg != NULL*/ pMsg=(ft_nvram_reset_cnf_struct_T*)ilm_ptr.local_para_ptr; pMsg->header.ft_msg_id=FT_NVRAM_RESET_CNF_ID; pMsg->status = msg_ptr->result; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr); break; } case MSG_ID_NVRAM_SET_LOCK_CNF: { nvram_set_lock_cnf_struct* msg_ptr; ilm_struct ilm_ptr; ft_nvram_lock_cnf_struct_T* pMsg; // restore the previous token id to ft_gl_token, ft_gl_token will be used in FT_SEND_MSG(). ft_gl_token = ft_gl_nvram_token; msg_ptr=(nvram_set_lock_cnf_struct*)ptrMsg->local_para_ptr; FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_nvram_lock_cnf_struct_T)); /* if ptrMsg != NULL*/ pMsg=(ft_nvram_lock_cnf_struct_T*)ilm_ptr.local_para_ptr; pMsg->header.ft_msg_id=FT_NVRAM_LOCK_CNF_ID; pMsg->status = msg_ptr->result; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr); 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 !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ #endif //#if defined(__MTK_INTERNAL__) case MSG_ID_NVRAM_SDS_CNF: case MSG_ID_NVRAM_BIN_REGION_CNF: { FT_Handle_CNF_From_NVRAM(ptrMsg); break; } default: break; } } #endif // end of #if defined(__MOD_NVRAM__) #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) else if( (ptrMsg->src_mod_id == MOD_UL1TST) ) { FT_UL1TST_SEND_CNF_BACK(ptrMsg); } #endif // #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) else if( MOD_L1HISR == ptrMsg->src_mod_id && MSG_ID_L1TASK_WAKEUP == ptrMsg->msg_id ) { /******************************************** * * Dispatch report from L1 * ********************************************/ L1T_DispatchReports(); } #ifndef SIM_NOT_PRESENT else if( (ptrMsg->src_mod_id == MOD_SIM) && (ft_gl_sim_cmd_type != FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED)) { switch (ptrMsg->msg_id) { case MSG_ID_SIM_RESET_CNF: { FT_MISC_CNF misc_cnf; sim_reset_cnf_struct *msg_ptr; msg_ptr=(sim_reset_cnf_struct*)ptrMsg->local_para_ptr; misc_cnf.type = FT_MISC_OP_CHECK_SIM1_INSERTED; misc_cnf.result.m_u1SIMInserted = (kal_bool)msg_ptr->is_sim_inserted; // get SIM inserted status here. 1:insert , 0: not insert misc_cnf.status = FT_CNF_OK; FT_MISC_SendCnf(&misc_cnf, NULL); } break; default: break; } } #ifdef __GEMINI__ else if((ptrMsg->src_mod_id == MOD_SIM_2) && (ft_gl_sim_cmd_type != FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED)) { switch (ptrMsg->msg_id) { case MSG_ID_SIM_RESET_CNF: { FT_MISC_CNF misc_cnf; sim_reset_cnf_struct *msg_ptr; msg_ptr=(sim_reset_cnf_struct*)ptrMsg->local_para_ptr; misc_cnf.type = FT_MISC_OP_CHECK_SIM2_INSERTED; misc_cnf.result.m_u1SIMInserted = (kal_bool)msg_ptr->is_sim_inserted; // get SIM inserted status here. 1:insert , 0: not insert misc_cnf.status = FT_CNF_OK; FT_MISC_SendCnf(&misc_cnf, NULL); break; } default: break; } } #endif // __GEMINI__ #ifdef GEMINI_PLUS else if((ptrMsg->src_mod_id >= MOD_SIM) && (ptrMsg->src_mod_id < MOD_SIM + GEMINI_PLUS) && (ft_gl_sim_cmd_type == FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED)) { switch (ptrMsg->msg_id) { case MSG_ID_SIM_RESET_CNF: { FT_MISC_CNF misc_cnf; sim_reset_cnf_struct *msg_ptr; msg_ptr=(sim_reset_cnf_struct*)ptrMsg->local_para_ptr; misc_cnf.type = FT_MISC_OP_CHECK_GEMINI_PLUS_SIM_INSERTED; misc_cnf.result.m_u1SIMInserted = (kal_bool)msg_ptr->is_sim_inserted; // get SIM inserted status here. 1:insert , 0: not insert misc_cnf.status = FT_CNF_OK; FT_MISC_SendCnf(&misc_cnf, NULL); break; } default: break; } } #endif // GEMINI_PLUS #endif // SIM_NOT_PRESENT }
/******************************************************************************* * FUNCTION * FT_WriteTo_NVRAM_CNF * * DESCRIPTION * Handle the confirmation of writting * * CALLS * * * PARAMETERS * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_WriteTo_NVRAM_CNF(nvram_write_cnf_struct* cnf_result) { ilm_struct* ptr_ilm; ft_nvram_write_cnf_struct_T *ptrMsg ; kal_uint8 ok; if (cnf_result->result ==0) ok = FT_CNF_OK; else ok = FT_CNF_FAIL; if(ok==FT_CNF_OK) { switch(cnf_result->file_idx) { #if defined(__WIFI_SUPPORT__) case NVRAM_EF_WNDRV_MAC_ADDRESS_LID: if(wndrv_chip_isOK()) wndrv_cal_macaddr((wndrv_cal_mac_addr_struct *)&ft_rf_data_pt); break; case NVRAM_EF_WNDRV_TX_POWER_2400M_LID: if(wndrv_chip_isOK()) wndrv_cal_txpwr_2400M((wndrv_cal_txpwr_2400M_struct *)&ft_rf_data_pt); break; case NVRAM_EF_WNDRV_TX_POWER_5000M_LID: if(wndrv_chip_isOK()) wndrv_cal_txpwr_5000M((wndrv_cal_txpwr_5000M_struct *)&ft_rf_data_pt); break; case NVRAM_EF_WNDRV_DAC_DC_OFFSET_LID: if(wndrv_chip_isOK()) wndrv_cal_dac_dc_offset((wndrv_cal_dac_dc_offset_struct *)&ft_rf_data_pt); break; case NVRAM_EF_WNDRV_TX_ALC_POWER_LID: if(wndrv_chip_isOK()) wndrv_cal_tx_ALC_power_2400M((wndrv_cal_tx_ALC_2400M_struct *)&ft_rf_data_pt); break; case NVRAM_EF_WNDRV_ALC_SLOPE_LID: if(wndrv_chip_isOK()) wndrv_cal_ALC_Slope_2400M((wndrv_cal_ALC_Slope_2400M_struct *)&ft_rf_data_pt); break; #endif default: /**V \brief 2G update runtime value after wrote nvram */ L1TST_UpdateCalibrationData( cnf_result->file_idx ); #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) /* under construction !*/ /* under construction !*/ #endif // #if defined(__UMTS_RAT__) && defined(__MTK_UL1_FDD__) break; } } if(!g_b_ft_nvram_proc_locally || cnf_result->file_idx != NVRAM_EF_CAL_DATA_CHECK_LID) { #if defined(__WIFI_SUPPORT__) #if defined(__MTK_INTERNAL__) /* 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__) #endif // #if defined(__WIFI_SUPPORT__) ptr_ilm = FT_ALLOC_MSG( sizeof(ft_nvram_write_cnf_struct_T) ); /* if ptrMsg != NULL*/ ptrMsg = (ft_nvram_write_cnf_struct_T *)ptr_ilm->local_para_ptr; ptrMsg->header.ft_msg_id = FT_NVRAM_WRITE_CNF_ID; ptrMsg->file_idx=cnf_result->file_idx; ptrMsg->para=cnf_result->para; ptrMsg->status = cnf_result->result; /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ FT_SEND_MSG(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, ptr_ilm); } else // write locally complete, return misc confirm to PC side { #if !defined(NVRAM_NOT_PRESENT) ft_misc_cal_data_write_to_nvram_cnf(cnf_result); #endif // #if !defined(NVRAM_NOT_PRESENT) } if(ok == FT_CNF_OK && g_b_ft_nvram_rec) { // get the nvram checksum from nvram kal_uint16 u2_checksum; bool bValid = ft_misc_cal_data_get_checksum((kal_uint16)cnf_result->file_idx, cnf_result->para,&u2_checksum); if(bValid) { // update the misc_buffer ft_misc_cal_data_update_local_buf((kal_uint16)cnf_result->file_idx, cnf_result->para, u2_checksum); } } }
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); }