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