/******************************************************************************* * FUNCTION * FT_FtADC_GetMeaData() * * DESCRIPTION * Handle the request of Getting MeaData * * CALLS * ADC_GetData2Meta(.) * * PARAMETERS * *req * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_FtADC_GetMeaData(ft_FtADC_GetMeaData_req_T* req) { //extern uint32 ADC_GetData2Meta(uint8 sel, uint16 meacount); ilm_struct ilm_ptr; ft_FtADC_GetMeaData_cnf_T *ptrMsg ; ADC_CTRL_GET_DATA_2_META_T data2meta; DCL_HANDLE adc_handle; FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_FtADC_GetMeaData_cnf_T)); ptrMsg = (ft_FtADC_GetMeaData_cnf_T *)ilm_ptr.local_para_ptr; ASSERT(ptrMsg); ptrMsg->status=FT_CNF_OK; ptrMsg->header.ft_msg_id = FT_ADC_GETMEADATA_CNF_ID; adc_handle = DclHADC_Open(DCL_ADC, FLAGS_NONE); data2meta.u1Channel = req->Sel; data2meta.u2MeaCount = req->Meacount; if(DclHADC_Control(adc_handle, ADC_CMD_GET_DATA_2_META, (DCL_CTRL_DATA_T *)& data2meta) != STATUS_OK) { ptrMsg->status = FT_CNF_FAIL; } ptrMsg->value = data2meta.u4ADCData; if(DclHADC_Close(adc_handle) != STATUS_OK) { ptrMsg->status = FT_CNF_FAIL; } FT_SEND_MSG_TO_PC(&ilm_ptr); }
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; }
kal_uint8 FT_MISC_SendCnf(FT_MISC_CNF *ft_misc_ret, peer_buff_struct *peer_buff) { ilm_struct ilm_ptr; FT_MISC_CNF *ptrMsg; FT_ALLOC_MSG(&ilm_ptr, sizeof(FT_MISC_CNF)); /* if ptrMsg != NULL*/ ptrMsg = (FT_MISC_CNF *)ilm_ptr.local_para_ptr; // assign primitive id ptrMsg->header.ft_msg_id = FT_MISC_CMD_CNF_ID; // assign return structure ptrMsg->type = ft_misc_ret->type; // copy the result directly without checking its cmd type kal_mem_cpy(&(ptrMsg->result), &(ft_misc_ret->result), sizeof(FT_MISC_CNF_U)); ptrMsg->status = ft_misc_ret->status; // assign peer buffer if( NULL != peer_buff ) { ilm_ptr.peer_buff_ptr = peer_buff; } /* FT_SEND_MSG(src_mod, dest_mod, sap_id, msg_id, ilm_ptr) */ _FT_SendFtMsgByToken(MOD_FT, MOD_TST, FT_TST_SAP, MSG_ID_FT_TO_TST, &ilm_ptr, ft_gl_misc_token); return 0; }
/******************************************************************************* * * FT task test alive * *******************************************************************************/ void FT_TestAlive(void) { FT_IS_ALIVE_CNF *pMsg; ilm_struct ilm_ptr; FT_ALLOC_MSG(&ilm_ptr, sizeof(FT_IS_ALIVE_CNF)); pMsg=(FT_IS_ALIVE_CNF *)ilm_ptr.local_para_ptr; pMsg->header.ft_msg_id = FT_IS_ALIVE_CNF_ID; FT_SEND_MSG_TO_PC(&ilm_ptr); }
/******************************************************************************* * 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); } } }
/** * This function handles the PMIC register write operation * @param req FT task PMIC register write request * @param Regtype register type */ void FT_FtPMICRegisterWrite(ft_PMICRegisterWrite_req_T* req,unsigned char RegType) { ilm_struct ilm_ptr; ft_PMICRegisterWrite_cnf_T *ptrMsg ; FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_PMICRegisterWrite_cnf_T)); ptrMsg = (ft_PMICRegisterWrite_cnf_T *)ilm_ptr.local_para_ptr; ptrMsg->status = KAL_FALSE; if(RegType ==FT_PMICReg) { ptrMsg->header.ft_msg_id = FT_PMIC_REG_WRITE_CNF_ID; /* * Note: The custom_pmic_reg_write interface is changed due to HAL, * the reference is changed to ft_pmic_reg_write */ ptrMsg->status = ft_pmic_reg_write(req->value, (kal_uint16)req->addr); } FT_SEND_MSG_TO_PC(&ilm_ptr); }
/******************************************************************************* * * Version Info functionality * *******************************************************************************/ void FT_GetVersionInfo(void) { ilm_struct ilm_ptr; FT_VER_INFO_CNF *ptrMsg; version_struct ver_struct; FT_ALLOC_MSG(&ilm_ptr, sizeof(FT_VER_INFO_CNF)); // if ptrMsg != NULL ptrMsg = (FT_VER_INFO_CNF *)ilm_ptr.local_para_ptr; // assign primitive id ptrMsg->header.ft_msg_id = FT_VER_INFO_CNF_ID; // get version info INT_VersionNumbers(&ver_struct); // check if( NULL == ver_struct.bb_chip ) { ver_struct.bb_chip = "Unknown"; } if( NULL == ver_struct.dsp_fw ) { ver_struct.dsp_fw = "Unknown"; } if( NULL == ver_struct.dsp_ptch ) { ver_struct.dsp_ptch = "Unknown"; } if( NULL == ver_struct.mcu_sw ) { ver_struct.mcu_sw = "Unknown"; } if( NULL == ver_struct.bb_board ) { ver_struct.bb_board = "Unknown"; } // assign BaseBand chip version string strcpy((kal_char *)ptrMsg->bb_chip, ver_struct.bb_chip); // assign ECO version kal_mem_set(ptrMsg->eco_ver, 0, 4); // assign DSP firmware version string strcpy((kal_char *)ptrMsg->dsp_fw, ver_struct.dsp_fw); // assign DSP patch version string strcpy((kal_char *)ptrMsg->dsp_patch, ver_struct.dsp_ptch); // assign S/W version string strcpy((kal_char *)ptrMsg->sw_ver, ver_struct.mcu_sw); // assign H/W version string strcpy((kal_char *)ptrMsg->hw_ver, ver_struct.bb_board); // assign Melody version string strcpy((kal_char *)ptrMsg->melody_ver, "Unknown"); FT_SEND_MSG_TO_PC(&ilm_ptr); }
/******************************************************************************* * FUNCTION * FT_FtRegisterWrite() * * DESCRIPTION * Handle the request of Writing Register Req * * CALLS * Drv_WriteReg(.) * * PARAMETERS * *req * * RETURNS * None * * GLOBALS AFFECTED * None *******************************************************************************/ void FT_FtRegisterWrite(ft_RegisterWrite_req_T* req,unsigned char RegType) { kal_uint8 status; ilm_struct ilm_ptr; ft_RegisterWrite_cnf_T *ptrMsg ; FT_ALLOC_MSG(&ilm_ptr, sizeof(ft_RegisterWrite_cnf_T)); status = KAL_FALSE; // for build warning /* if ptrMsg != NULL*/ ptrMsg = (ft_RegisterWrite_cnf_T *)ilm_ptr.local_para_ptr; if(RegType ==FT_BaseBandReg) { ptrMsg->header.ft_msg_id = FT_REG_WRITE_CNF_ID; status=Drv_WriteReg(req->addr,req->value); } if(status==KAL_TRUE) { status=FT_CNF_OK; } else { status=FT_CNF_FAIL; } ptrMsg->status = status; FT_SEND_MSG_TO_PC(&ilm_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) } }
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); } } }