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