void FTC_DispatchMessage(ilm_struct* ptrMsg)
{
ilm_struct* ptr_ilm;
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_pdu_ptr( 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_pdu_ptr( peer_buff_new, &pdu_length_new );
kal_mem_cpy(pdu_ptr_new, pdu_ptr , pdu_length);
peer_buff_new->pdu_len = pdu_length;
}
ptr_ilm = FTC_ALLOC_MSG( sizeof(ftc_basic_cnf_struct) );
if(ptr_ilm)
{
ptr_ilm->peer_buff_ptr = peer_buff_new; //ptrMsg->peer_buff_ptr;
ftc_ptr_loc_para=(ftc_basic_cnf_struct *)(ptr_ilm->local_para_ptr);
ftc_ptr_loc_para->status = FTC_CNF_OK;
FTC_SEND_MSG(MOD_FTC, MOD_FT, FTC_FT_SAP, (msg_type)MSG_ID_FTC_BASIC_CNF, ptr_ilm);
peer_buff_new = NULL;
}
break;
}
default:
break;
}
}
else if( (ptrMsg->src_mod_id == MOD_NVRAM) )
{
}
}
static void e_compass_write_nvram(E_CompassSensorCalibratedDataStruct *calibrated_data)
{
ilm_struct *ec_ilm_ptr = 0;
void *parm_stream = 0;
void *data_stream = 0;
kal_uint16 pdu_len;
nvram_ef_ecompass_calibration ec_nvram;
module_type module_id;
module_id = MOD_EC_TASK;
/* for now we just save three fields */
ec_nvram.usr_moffset_x = calibrated_data->usr_moffset_x;
ec_nvram.usr_moffset_y = calibrated_data->usr_moffset_y;
ec_nvram.usr_moffset_z = calibrated_data->usr_moffset_z;
ec_nvram.cali_result = calibrated_data->cali_result;
ec_nvram.x_axis_sensitivity = calibrated_data->x_axis_sensitivity;
ec_nvram.y_axis_sensitivity = calibrated_data->y_axis_sensitivity;
ec_nvram.x_max = calibrated_data->x_max;
ec_nvram.y_max = calibrated_data->y_max;
ec_nvram.x_min = calibrated_data->x_min;
ec_nvram.y_min = calibrated_data->y_min;
/* E_COMPASS_DEBUG_OUTPUT("Calibrated result usr_moffset_x = %d, usr_moffset_y = %d, usr_moffset_z = %d, misc = %d", ec_nvram.usr_moffset_x, ec_nvram.usr_moffset_y, ec_nvram.usr_moffset_z, 0); */
drv_trace4(TRACE_GROUP_10, EC_NVRAM_SAVE, ec_nvram.usr_moffset_x, ec_nvram.usr_moffset_y, ec_nvram.usr_moffset_z, ec_nvram.cali_result);
ec_ilm_ptr = allocate_ilm(module_id);
ec_ilm_ptr->msg_id = MSG_ID_NVRAM_WRITE_REQ;
parm_stream = construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
data_stream = construct_peer_buff(sizeof(nvram_ef_ecompass_calibration), 0, 0, TD_CTRL);
((nvram_write_req_struct*) parm_stream)->file_idx = NVRAM_EF_ECOMPASS_DATA_LID;
((nvram_write_req_struct*) parm_stream)->para = 1;
pdu_len = sizeof(nvram_ef_ecompass_calibration);
kal_mem_cpy(get_pdu_ptr(data_stream, &pdu_len), (void*)&ec_nvram, sizeof(nvram_ef_ecompass_calibration));
ec_ilm_ptr->local_para_ptr = (local_para_struct*) parm_stream;
ec_ilm_ptr->peer_buff_ptr = (peer_buff_struct*) data_stream;
ec_ilm_ptr->src_mod_id = module_id;
ec_ilm_ptr->dest_mod_id = MOD_NVRAM;
ec_ilm_ptr->sap_id = PS_NVRAM_SAP;
msg_send_ext_queue(ec_ilm_ptr);
}
void ft_util_get_vpa_voltage_list(const FT_UTILITY_COMMAND_REQ *req, FT_UTILITY_COMMAND_CNF *cnf, peer_buff_struct **peer_buff_ret)
{
DCL_HANDLE handle;
PMU_CTRL_VPA_GET_VOLTAGE_LIST voltageList;
handle=DclPMU_Open(DCL_PMU, FLAGS_NONE);
if(DclPMU_Control(handle, VPA_GET_VOLTAGE_LIST, (DCL_CTRL_DATA_T *)&voltageList) != STATUS_OK)
{
cnf->status = FT_CNF_FAIL;
}
else
{
cnf->status = FT_CNF_OK;
}
DclPMU_Close(handle);
if(cnf->status == FT_CNF_OK)
{
if( NULL != (*peer_buff_ret=construct_peer_buff(sizeof(FtUtilCmdCnfVpaVoltageList), 0, 0, TD_CTRL)) )
{
kal_uint32 i;
FtUtilCmdCnfVpaVoltageList * pdu_ptr = get_pdu_ptr( *peer_buff_ret, &((*peer_buff_ret)->pdu_len) );
if(pdu_ptr != NULL)
{
kal_mem_set(pdu_ptr, 0, sizeof(FtUtilCmdCnfVpaVoltageList));
for(i=0;i<voltageList.number;i++)
{
/******************************************************
* if the voltage is valid, pass the information to PC
*****************************************************/
if(voltageList.pVoltageList[i] != PMU_VOLT_INVALID)
{
pdu_ptr->voltageList[pdu_ptr->validNumber] = voltageList.pVoltageList[i];
pdu_ptr->registerValue[pdu_ptr->validNumber] = i;
pdu_ptr->validNumber++;
}
}
}
else
{
ASSERT(pdu_ptr);
}
}
else
{
ASSERT(0);
}
}
}
/*****************************************************************************
* FUNCTION
* nvram_send_L1_cal
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void nvram_send_L1_cal(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/**
* file_idx should be the first L1 element in the logical data item ID enum
* Currently, L1 calibration data element is as following:
* NVRAM_EF_L1_AGCPATHLOSS_LID, NVRAM_EF_L1_RAMPTABLE_GSM900_LID,
* NVRAM_EF_L1_RAMPTABLE_DCS1800_LID, NVRAM_EF_L1_RAMPTABLE_PCS1900_LID,
* NVRAM_EF_L1_AFCDATA_LID, VRAM_EF_L1_L1SPFC_LID,
*/
nvram_lid_enum file_idx;
ltable_entry_struct *ldi;
peer_buff_struct *peer_buf_ptr;
kal_uint8 *pdu_ptr;
kal_uint16 pdu_length;
nvram_read_req_struct *local_data;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
local_data = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL);
for (file_idx = NVRAM_EF_L1_START; file_idx <= NVRAM_EF_L1_END; file_idx++)
{
if (!NVRAM_IS_LID_VALID(file_idx))
{
continue;
}
switch(file_idx)
{
case NVRAM_EF_L1_AGCPATHLOSS_LID:
case NVRAM_EF_L1_RAMPTABLE_GSM850_LID:
case NVRAM_EF_L1_RAMPTABLE_GSM900_LID:
case NVRAM_EF_L1_RAMPTABLE_DCS1800_LID:
case NVRAM_EF_L1_RAMPTABLE_PCS1900_LID:
#if defined(__EPSK_TX__)
case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM850_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM900_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_DCS1800_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_PCS1900_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM850_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM900_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_DCS1800_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_PCS1900_LID:
#endif /* __EPSK_TX__ */
case NVRAM_EF_L1_AFCDATA_LID:
case NVRAM_EF_L1_TXIQ_LID:
case NVRAM_EF_L1_RFSPECIALCOEF_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_GSM850_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_GSM900_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_DCS1800_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_PCS1900_LID:
case NVRAM_EF_L1_CRYSTAL_AFCDATA_LID:
case NVRAM_EF_L1_CRYSTAL_CAPDATA_LID:
{
nvram_get_data_item(ldi, file_idx);
local_data->access_id = 0;
local_data->file_idx = file_idx;
local_data->para = 1;
pdu_length = ldi->size;
peer_buf_ptr = construct_peer_buff(pdu_length, 0, 0, TD_CTRL);
ASSERT(peer_buf_ptr != NULL);
pdu_ptr = get_pdu_ptr(peer_buf_ptr, &pdu_length);
ASSERT(pdu_ptr != NULL);
nvram_read_confirm
(MOD_L1, nvram_read_data_item(ldi, 1, 1, pdu_ptr, pdu_length), local_data, ldi->size, peer_buf_ptr);
break;
}
}
}
free_local_para((local_para_struct*) local_data);
} /* end of nvram_send_L1_cal function */
static BOOL mmi_da_wps_send_set_channel_req(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_set_channel_req_struct *set_channel_req;
peer_buff_struct *peer_buff_ptr = NULL;
wps_set_channel_req_var_struct set_channel_req_var;
U16 len, pdu_length;
U16 msg_len, ref_count;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_SET_CHANNEL_REQ);
set_channel_req = (wps_set_channel_req_struct *) construct_local_para(sizeof(wps_set_channel_req_struct), TD_CTRL);
msg_len = set_channel_req->msg_len;
ref_count = set_channel_req->ref_count;
memset(set_channel_req, 0 , sizeof(wps_set_channel_req_struct));
set_channel_req->msg_len = msg_len;
set_channel_req->ref_count = ref_count;
set_channel_req->use_default = KAL_TRUE;
set_channel_req_var.static_header_len = len =
strlen("User-Agent: ")+
strlen((S8*)da_wps_context.user_agent)+
strlen("\r\n")+
strlen(STATIC_HEADER);
set_channel_req_var.static_header = get_ctrl_buffer((len+1));
sprintf((S8*)set_channel_req_var.static_header,"User-Agent: %s\r\n%s",
da_wps_context.user_agent, STATIC_HEADER);
pdu_length= wps_pun_var_part(WPS_PUN_SIZE,MSG_ID_WPS_SET_CHANNEL_REQ,&set_channel_req_var,NULL);
if( pdu_length > 0)
{
peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET);
if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_SET_CHANNEL_REQ, &set_channel_req_var, get_pdu_ptr(peer_buff_ptr, &len)) !=
pdu_length)
{
free_peer_buff(peer_buff_ptr);
peer_buff_ptr = NULL;
}
}
free_ctrl_buffer(set_channel_req_var.static_header);
mmi_da_send_ilm(set_channel_req, peer_buff_ptr, MSG_ID_WPS_SET_CHANNEL_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_set_channel_rsp, MSG_ID_WPS_SET_CHANNEL_RSP);
return MMI_TRUE;
}
static BOOL mmi_da_wps_send_http_req(U8 request_id, U8 http_method,
S8 * url, S8 * post_data, PU16 file_path)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_http_req_struct *http_req;
wps_http_req_var_struct http_req_var;
peer_buff_struct *peer_buff_ptr = NULL;
U16 pdu_length;
U16 len;
FS_HANDLE hd;
static S8 range_header[30];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_HTTP_REQ, request_id);
ASSERT(_da_wps_is_ready());
ASSERT(request_id < MMI_DA_WPS_REQUEST_ID_RANGE);
http_req = (wps_http_req_struct *) construct_local_para(sizeof(wps_http_req_struct), TD_CTRL);
http_req->channel_id = da_wps_context.channel_id;
http_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE;
http_req->method = http_method;
http_req->option = WPS_HTTP_OPTION_NO_CACHE;
http_req_var.request_url_len = (kal_uint32) strlen(url);
http_req_var.request_url = (kal_uint8 *) url;
http_req_var.request_header_len = 0;
http_req_var.request_header = NULL;
if (http_method == WPS_HTTP_METHOD_POST)
{
ASSERT(post_data != NULL);
http_req->reply_type = WPS_DATA_TYPE_BUFFER;
http_req->reply_segment_len = 0; /* no use here */
http_req->post_type = WPS_DATA_TYPE_BUFFER;
http_req->post_path[0] = '\0';
http_req->post_path[1] = '\0';
http_req->post_total_len = strlen(post_data);
http_req->more_post = MMI_FALSE;
http_req_var.post_segment_len = strlen(post_data);
http_req_var.post_segment = (kal_uint8 *) post_data;
http_req_var.request_header_len = strlen("Content-Type: text/plain; charset=UTF-8\r\n");
http_req_var.request_header = (kal_uint8 *)"Content-Type: text/plain; charset=UTF-8\r\n";
}
else
{
ASSERT(file_path != NULL && mmi_ucs2strlen((S8 *) file_path) < 256);
http_req->reply_type = WPS_DATA_TYPE_FILE;
mmi_ucs2cpy((S8 *) http_req->reply_path, (S8 *) file_path);
http_req->reply_segment_len = 0; /* no use here */
http_req->post_type = WPS_DATA_TYPE_BUFFER;
http_req->post_path[0] = '\0';
http_req->post_path[1] = '\0';
http_req->post_total_len = 0;
http_req->more_post = MMI_FALSE;
http_req_var.post_segment_len = 0;
http_req_var.post_segment = NULL;
// If the target file exist, it means RESUME
if ((hd = FS_Open((PU16)file_path, FS_READ_ONLY)) >= 0)
{
UINT file_size;
FS_GetFileSize(hd, &file_size);
sprintf(range_header, "Range:bytes=%d-", file_size);
FS_Close(hd);
http_req_var.request_header_len = strlen(range_header);
http_req_var.request_header = (kal_uint8 *)range_header;
}
}
pdu_length = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WPS_HTTP_REQ, &http_req_var, NULL);
if (pdu_length > 0)
{
peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET);
if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_HTTP_REQ, &http_req_var, get_pdu_ptr(peer_buff_ptr, &len)) !=
pdu_length)
{
free_peer_buff(peer_buff_ptr);
peer_buff_ptr = NULL;
}
}
mmi_da_send_ilm(http_req, peer_buff_ptr, MSG_ID_WPS_HTTP_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_rsp, MSG_ID_WPS_HTTP_RSP);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_dl_progress_ind, MSG_ID_WPS_DL_PROGRESS_IND);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_auth_ind, MSG_ID_WPS_HTTP_AUTH_IND);
return MMI_TRUE;
}
/*****************************************************************************
* FUNCTION
* phb_search_continue
* DESCRIPTION
* This is phb_search_continue function of PHB module.
*
* Note:
* Only searching PHB_PHBONEBOOK and PHB_BYNUMBER can reach this function.
* PARAMETERS
* ilm_ptr [IN] The primitives
* control_block [?]
* RETURNS
* void
*****************************************************************************/
void phb_search_continue(ilm_struct *ilm_ptr, control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CONT);
/* It's time to write prepared dat */
if (ilm_ptr == NULL)
{
phb_issue_IO_read(control_block);
}
/* Read confirmed. Now verify the entry! */
else
{
/* Only PHB_BYNUMBER can reach here */
/* Query pattern is stored in local_param_ptr */
l4_addr_bcd_struct *given = (l4_addr_bcd_struct*) control_block->local_param_ptr;
/* The just read back candidate is stored in control_block->data */
phb_entry_struct *candidate_entry = (phb_entry_struct*) control_block->data;
l4_addr_bcd_struct *candidate = &candidate_entry->tel_number;
match_result_enum result = phb_compare_tel_number(given, candidate);
/**
* First we have to verify the candidate. The most possible candidate is
* copied into the first element of l4cphb_phb_entry_array_struct stored
* in control_block->peer_buf_ptr.
*/
/**
* Verification passed: perfect matched: CC/NDC/SN are all matched.
* Finally we found it!
*/
if ((result == MATCH_PERFECT) ||
/**
* Verification passed: partial matched: only NDC/SN are matched
* Other candidate still have chances to match.
* *Sigh*, Retain this candidate and go on verification.
*/
(result == MATCH_PARTIAL))
{
kal_uint8 *pdu_ptr;
kal_uint16 pdu_length;
++control_block->actual_count;
pdu_ptr = get_pdu_ptr(control_block->peer_buf_ptr, &pdu_length);
kal_mem_cpy(
(phb_entry_struct*) & ((l4cphb_phb_entry_array_struct*) get_32bits_aligned_val(pdu_ptr))-> array[0],
(void const*)candidate_entry,
sizeof(phb_entry_struct));
if (result == MATCH_PERFECT)
{
(*control_block->controller) (NULL, control_block);
return;
}
}
/* *Sigh*, Continue verification. */
/* Verification complete, finally control can be returned back to controller */
/* if (control_block->actual_count > control_block->candidate_count) */
if (!phb_se_is_next_also_candidate(
(name_num_index_type*) control_block->candidate_name_num_index,
control_block->candidate,
KAL_FALSE))
{
(*control_block->controller) (NULL, control_block);
}
/**
* Still others to verify.
* Since index, total is in ensured to be in range, tested in handler(), it is uncessary
* to test it here.
*/
else
{
name_num_index_type *name_num_index;
data_entry_struct *data_entry;
/* Set index field of next entry to read */
control_block->index = ++control_block->candidate;
/**
* Read specific record for verification.
*/
phb_control_block_set_IO(control_block, control_block->type, (kal_uint16) PHB_INVALID_VALUE, 1);
/* set storage, record_index, primary_ID, and secondary_ID */
name_num_index = (name_num_index_type*) control_block->candidate_name_num_index;
data_entry =
&name_num_index->data_entry_table.table[name_num_index->num_index.table[control_block->candidate].
position];
if (phb_se_set_control_block(
control_block,
OP_READ,
data_entry->storage,
data_entry->record_index) == KAL_FALSE)
{
phb_search_err_handler(NULL, control_block);
return;
}
control_block->proc_stage = SEARCH_CONTINUE;
control_block->data = (kal_uint8*) & control_block->temp_entry;
control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID, control_block->storage));
phb_issue_IO_read(control_block);
return;
}
}
} /* end of phb_search_continue */
/*****************************************************************************
* FUNCTION
* phb_search_handler
* DESCRIPTION
* This is phb_search_handler function of PHB module.
* Handles write request from L4C.
* PARAMETERS
* ilm_ptr [IN] The primitives
* control_block [?]
* RETURNS
* void
*****************************************************************************/
void phb_search_handler(ilm_struct *ilm_ptr, control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH);
if (ilm_ptr != NULL)
{
l4cphb_search_req_struct *l4cphb_search_req;
l4cphb_search_req = (l4cphb_search_req_struct*) ilm_ptr->local_para_ptr;
/* Cannot allocate, means that PHB is still operating. Reject request! */
control_block = phb_alloc_control_block();
if (control_block == NULL)
{
phb_search_confirm(PHB_ERRNO_BUSY, 0, l4cphb_search_req->src_id, MSG_ID_INVALID_TYPE, control_block);
return;
}
control_block->src_id = l4cphb_search_req->src_id;
/* Retain msg_id */
control_block->cnf_msg_id = ilm_ptr->msg_id;
if ((phb_ptr->state == PHB_STATE_READY) &&
((l4cphb_search_req->type == PHB_PHONEBOOK) ||
(l4cphb_search_req->type == PHB_FDN) ||
(l4cphb_search_req->type == PHB_BDN)) && ((l4cphb_search_req->pattern_tag == PHB_BYNAME) ||
#ifdef __PHB_SORT_ENABLE__
(l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT) ||
#endif
(l4cphb_search_req->pattern_tag == PHB_BYNUMBER)))
{
if (control_block->proc_stage == SEARCH_NONE)
{
kal_bool is_more_candidates;
l4_name_struct *alpha_id;
#ifdef __PHB_SORT_ENABLE__
l4_addr_bcd_struct *tel_number;
#endif
/**
* Here we borrow total_piggyback to store pattern_tag.
* When used!?
*/
/* control_block->total_piggyback = l4cphb_search_req->pattern_tag; */
control_block->total_piggyback = l4cphb_search_req->total;
/* Search by name, valid for both of PHB_PHONEBOOK, PHB_FDN and PHB_BDN */
if ((l4cphb_search_req->pattern_tag == PHB_BYNAME) ||
(l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT))
{
alpha_id = &l4cphb_search_req->pattern_value.alpha_id;
control_block->candidate_name_num_index = phb_se_search_by_name(
l4cphb_search_req->type,
(alpha_id_type*) alpha_id,
&control_block->candidate,
&is_more_candidates);
/**
* For SEARCH_BYNAME, no candidate is impossible.
* Because a nearest one is always found,
* therefore candidate_count is at least 1.
*/
}
#ifdef __PHB_SORT_ENABLE__
/* Search by telephone number, only valid for PHB_PHONEBOOK */
else if ((l4cphb_search_req->pattern_tag == PHB_BYNUMBER) && (l4cphb_search_req->type == PHB_PHONEBOOK))
{
tel_number = &l4cphb_search_req->pattern_value.tel_number;
control_block->candidate_name_num_index = phb_se_search_by_tel_num(
l4cphb_search_req->type,
tel_number,
&control_block->candidate,
&is_more_candidates);
}
#endif /* __PHB_SORT_ENABLE__ */
/* Illegal comination of parameters. */
else
{
phb_search_err_handler(NULL, control_block);
return;
}
/* Search telephone number in phonebook: nvram_ef_phb_lid and ADN */
/* No candidate, great!! */
if ((control_block->candidate == (kal_uint16) PHB_INVALID_VALUE) ||
(control_block->candidate_name_num_index == NULL))
{
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
/* Exactly only one candidate is found! Great!! */
/**
* Q: The query pattern may exceeds ALPHA_ID_DEPTH,
* why NOT exact match alpha_id, then retrieves the following
* entries begun from the index to that one?
*
* A: Though exact matching is possible, retrieves from that index is
* non-sense, because the sorted array is not precise, that means
* the following entries begun from that index could be erroneous.
*/
if (l4cphb_search_req->pattern_tag == PHB_BYNAME)
{
kal_uint16 index;
/**
* Search BYNAME, if alpha_id.name_length <= PHB_ALPHA_ID_DEPTH,
* then there must be exactly one nearest hit!
*
* Note: hit must start from 1.
*/
index = control_block->candidate;
if (l4cphb_search_req->total < 1)
{
l4cphb_search_req->total = 1;
}
phb_control_block_set_IO(control_block, l4cphb_search_req->type, ++index, l4cphb_search_req->total);
if (phb_se_is_in_range(control_block->type, index, &control_block->total) == KAL_FALSE)
{
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_FAIL,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
/* Piggyback is ALWAYS required. */
/**
* Now we have to transform the state to a *FAKE* read state.
* The fakes status ALWAYS read from index, instead of specific record.
*/
/* If any critial error occured. read_err_handler will handle it. */
if (phb_read_fake(control_block, NULL) == KAL_FALSE)
{
return;
}
/* Finally, faking complete....Now continue reading */
phb_read_continue(NULL, control_block);
return;
}
#ifdef __PHB_SORT_ENABLE__
else if (l4cphb_search_req->pattern_tag == PHB_BYNAME_EXACT)
{
kal_uint16 i, start, count = 0;
pindex_type *name_index;
data_entry_table_type *desc_table;
if (l4cphb_search_req->type == PHB_PHONEBOOK)
{
control_block->type = l4cphb_search_req->type;
name_index = (pindex_type*) & phb_ptr->indices.phb_index.name_index;
desc_table = (data_entry_table_type*) & phb_ptr->indices.phb_index.data_entry_table;
}
else
{
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_FAIL,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
for (i = control_block->candidate; i < name_index->used_count; i++)
if (phb_is_prefix(
(alpha_id_type*) & l4cphb_search_req->pattern_value.alpha_id,
(alpha_id_type*) & desc_table->table[name_index->table[i].position]. alpha_id))
{
break;
}
if (i == name_index->used_count)
{
/* NOT found any match */
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
return;
}
count++;
start = i;
for (i = start + 1; i < name_index->used_count; i++)
if (phb_is_prefix(
(alpha_id_type*) & l4cphb_search_req->pattern_value.alpha_id,
(alpha_id_type*) & desc_table->table[name_index->table[i].position]. alpha_id))
{
count++;
}
/* total "count" matches starting from "start" */
control_block->index = start + 1;
control_block->record_index = (kal_uint16) PHB_INVALID_VALUE;
if (count > 15)
{
count = 15;
}
control_block->total = count;
/* If any critial error occured. read_err_handler will handle it. */
if (phb_read_fake(control_block, NULL) == KAL_FALSE)
{
return;
}
/* Finally, faking complete....Now continue reading */
phb_read_continue(NULL, control_block);
return;
}
#endif /* __PHB_SORT_ENABLE__ */
/* For PHB_BYNAME, more than 1 candidate exists, sigh, verification is necessary */
/**
* Even only exactly one candidate is found for searching BYNUMBER,
* verification is still needed.
*/
/**
* Only search of PHB_BYNUMBER can reach here.
*
* Candidates of searching telephone number are selected.
* Now verify them. So lousy..
*/
/**
* Initialize hit and same_count of control_block, also
* increment index to candidate, since it begins from 1.
*/
control_block->match_result = MATCH_FAIL;
phb_search_fake(
control_block,
ilm_ptr,
l4cphb_search_req->type,
&l4cphb_search_req->pattern_value.tel_number);
phb_search_continue(NULL, control_block);
}
/* error */
else
{
phb_search_err_handler(NULL, control_block);
return;
}
}
/* error, either STATE_NOT_READY or incorrect type requested for searching */
else
{
kal_trace(TRACE_ERROR, ERROR_PHB_STATE);
if (phb_ptr->state != PHB_STATE_READY)
{
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_NOT_READY,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
else
{
phb_search_err_handler(NULL, control_block);
}
return;
}
}
else
{
/* Verification over. */
if (control_block->proc_stage == SEARCH_CONTINUE)
{
/**
* Only search of PHB_BYNUMBER can reach here.
* And no piggyback is provided, so confirmation can be sent back now.
* Hence, if found, actual_count is 1 and will be transfered to `total' field of
* confirmation primitive; otherwise it is 0.
*/
/* No candidate matches! */
if (control_block->actual_count == 0)
{
control_block->actual_count = 0;
phb_search_confirm(
PHB_ERRNO_FAIL,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
else
{
name_num_index_type *name_num_index = (name_num_index_type*) control_block->candidate_name_num_index;
data_entry_struct *data_entry;
l4cphb_phb_entry_array_struct *phb_entry_array;
kal_uint8 *pdu_ptr;
kal_uint16 pdu_length;
data_entry =
&name_num_index->data_entry_table.table[name_num_index->num_index.table[control_block->candidate].
position];
/**
* To reduce code size, another possible function which
* searches index to name_index by index to num_index
* is not implemented .
*/
pdu_ptr = get_pdu_ptr(control_block->peer_buf_ptr, &pdu_length);
phb_entry_array = ((l4cphb_phb_entry_array_struct*) get_32bits_aligned_val(pdu_ptr));
phb_entry_array->array[0].index = phb_se_search_by_record_index_name(
control_block->type,
data_entry->storage,
data_entry->record_index,
&data_entry->alpha_id);
phb_entry_array->array[0].index++;
control_block->actual_count = 1;
phb_search_confirm(
PHB_ERRNO_SUCCESS,
control_block->actual_count,
control_block->src_id,
control_block->cnf_msg_id,
control_block);
}
}
/* error */
else
{
phb_search_err_handler(NULL, control_block);
return;
}
}
} /* end of phb_search_handler */
void das_send_file_dl_ind(das_job_t *job)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
int len;
kal_uint16 length;
ilm_struct *ilm_ptr = NULL;
wap_mmi_file_dl_ind_struct *p;
peer_buff_struct *peer_buff_ptr = NULL;
wap_mmi_file_dl_var_struct var = {0};
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
p = (wap_mmi_file_dl_ind_struct*) construct_local_para(sizeof(wap_mmi_file_dl_ind_struct), TD_RESET);
p->session_id = job->id;
memset(p->url, 0, WAP_DL_MAX_URL_LEN);
if(job->url)
{
len = strlen(job->url);
strncpy((char *)p->url, job->url, len > WAP_DL_MAX_URL_LEN ? WAP_DL_MAX_URL_LEN : len);
}
memset(p->mime_type, 0, WAP_DL_MAX_MIME_TYPE_LEN);
if(job->mime_type)
{
len = strlen(job->mime_type);
strncpy((char *)p->mime_type, job->mime_type, len > WAP_DL_MAX_MIME_TYPE_LEN ? WAP_DL_MAX_MIME_TYPE_LEN : len);
}
memset(p->file_name, 0, WAP_DL_MAX_FILE_NAME_LEN);
widget_utf8_to_ucs2_string(p->file_name, WAP_DL_MAX_FILE_NAME_LEN, (const kal_uint8 *)job->file_name);
p->file_length = job->total_size;
if (job->header)
{
var.header_len = strlen(job->header);
var.header = (kal_uint8*) job->header;
}
else
{
var.header_len = 0;
}
if (job->buffer_tail > 0)
{
var.content_len = job->buffer_tail;
var.content = (kal_uint8*) job->buffer;
}
else
{
var.content_len = 0;
}
len = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WAP_MMI_FILE_DL_IND, (void*)&var, NULL);
if (len > 0)
{
peer_buff_ptr = construct_peer_buff(len, 0, 0, TD_RESET);
if (wps_pun_var_part
(WPS_PUN_PACK, MSG_ID_WAP_MMI_FILE_DL_IND, (void*)&var, get_pdu_ptr(peer_buff_ptr, &length)) != len)
{
free_peer_buff(peer_buff_ptr);
peer_buff_ptr = NULL;
}
}
ilm_ptr = allocate_ilm(MOD_WAP);
ilm_ptr->msg_id = (kal_uint16) MSG_ID_WAP_MMI_FILE_DL_IND; /* Set the message id */
ilm_ptr->peer_buff_ptr = peer_buff_ptr;
ilm_ptr->local_para_ptr = (local_para_struct*) p;
SEND_ILM(MOD_WAP, MOD_MMI, WAP_MMI_SAP, ilm_ptr);
}
/*****************************************************************************
* FUNCTION
* das_send_dl_ind
* DESCRIPTION
*
* PARAMETERS
* mod_src [IN]
* data_type [IN]
* url [?]
* mime_type [?]
* file_name [?]
* RETURNS
*
*****************************************************************************/
int das_send_dl_ind(MSF_UINT8 mod_src, MSF_UINT8 data_type, const char *url, const char *mime_type, const kal_uint8 *file_name, const char *header, MSF_INT32 network_account_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
ilm_struct *ilm_ptr = NULL;
peer_buff_struct *peer_buff_ptr = NULL;
mmi_da_dispatch_file_var_struct *peer_pdu = NULL;
mmi_da_dispatch_file_req_struct *p;
kal_uint16 length;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
p = (mmi_da_dispatch_file_req_struct*) construct_local_para(sizeof(mmi_da_dispatch_file_req_struct), TD_RESET);
p->mime_type = 0;
p->mime_subtype = 0;
memset(p->url, 0, sizeof(p->url));
if (data_type == MsfResourceBuffer)
{
#ifndef __MMI_DUAL_SIM__
p->action = MMI_DA_PUSH;
#else
if(always_ask_get_sim_info_data_account((kal_uint32)network_account_id) == ALWAYS_ASK_SIM_INFO_SIM2)
{
p->action = MMI_DA_PUSH_SIM2;
}
else
{
p->action = MMI_DA_PUSH_SIM1;
}
#endif
}
else if (mod_src == MSF_MODID_SMA || mod_src == MSF_MODID_MEA)
{
p->action = MMI_DA_SAVE_AS;
strcpy((char *)p->url, "mms://");
}
else if (data_type == MsfResourceFile)
{
p->action = MMI_DA_SAVE_AS;
}
else
{
p->action = MMI_DA_WAP_DOWNLOAD;
if (strlen(url) > 0)
{
strncpy((char *)p->url, url, strlen(url) > sizeof(p->url) ? sizeof(p->url) : strlen(url));
}
else
{
strcpy((char *)p->url, "http://");
}
}
memset(p->filepath, 0, sizeof(p->filepath));
widget_ucs2_strcpy((kal_uint8*) p->filepath, (const kal_uint8*)file_name);
strcpy((char *)p->mime_type_string, (const char*)mime_type);
peer_buff_ptr = construct_peer_buff(sizeof(mmi_da_dispatch_file_var_struct) + strlen(header), 0, 0, TD_RESET);
peer_pdu = (mmi_da_dispatch_file_var_struct *)get_pdu_ptr(peer_buff_ptr, &length);
peer_pdu->header_len = strlen(header);
memcpy(peer_pdu->header, header, peer_pdu->header_len);
ilm_ptr = allocate_ilm(MOD_WAP);
ilm_ptr->msg_id = (kal_uint16) MSG_ID_MMI_DA_DISPATCH_FILE_REQ; /* Set the message id */
ilm_ptr->peer_buff_ptr = peer_buff_ptr; /* there are no peer message */
ilm_ptr->local_para_ptr = (local_para_struct*) p;
SEND_ILM(MOD_WAP, MOD_MMI, WAP_MMI_SAP, ilm_ptr);
return 1;
}
void ft_util_check_vers(FT_UTILITY_COMMAND_REQ *req, FT_UTILITY_COMMAND_CNF *cnf, peer_buff_struct **pp_peer_buff_ret)
{
META_UTIL_CHECK_TARGET_VER_CNF_T *p_dt = NULL;
kal_uint16 pdu_length = 0;
// allocate peer buffer
*pp_peer_buff_ret = construct_peer_buff(sizeof(META_UTIL_CHECK_TARGET_VER_CNF_T), 0, 0, TD_CTRL);
p_dt = (META_UTIL_CHECK_TARGET_VER_CNF_T *)get_pdu_ptr(*pp_peer_buff_ret, &pdu_length);
kal_mem_set(p_dt, 0, sizeof(META_UTIL_CHECK_TARGET_VER_CNF_T));
if(req->cmd.m_rCheckMetaVerReq.m_eVerType == META_VERSION_META_DLL_UTIL_VER ||
req->cmd.m_rCheckMetaVerReq.m_eVerType == META_VERSION_USER_DEFINE)
{
// checkin
// main version first, if >, pass the check!, if < fail,
// if main version is the same, check minor version
// if minor version the same, check build number
if(req->cmd.m_rCheckMetaVerReq.m_u4MainVersion < FT_REQUIRED_META_DLL_MAIN_VER)
{
g_b_ver_Incorrect = KAL_TRUE;
}
else if(req->cmd.m_rCheckMetaVerReq.m_u4MainVersion == FT_REQUIRED_META_DLL_MAIN_VER)
{
if(req->cmd.m_rCheckMetaVerReq.m_u4MinorVersion < FT_REQUIRED_META_DLL_MINOR_VER)
{
g_b_ver_Incorrect = KAL_TRUE;
}
else if(req->cmd.m_rCheckMetaVerReq.m_u4MinorVersion == FT_REQUIRED_META_DLL_MINOR_VER)
{
if(req->cmd.m_rCheckMetaVerReq.m_u4BuildNum < FT_REQUIRED_META_DLL_BUILD_NUM)
g_b_ver_Incorrect = KAL_TRUE;
}
}
// assign the target version information
p_dt->m_u4TargetMainVersion = FT_REQUIRED_META_DLL_MAIN_VER;
p_dt->m_u4TargetMinorVersion = FT_REQUIRED_META_DLL_MINOR_VER;
p_dt->m_u4TargetBuildNum = FT_REQUIRED_META_DLL_BUILD_NUM;
}
else // other type version check // so far, none, just assign version info to 0xFFFFFFFF
{
// in this case: version check pass
p_dt->m_u4TargetMainVersion = FT_REQUIRED_VERSION_UNKNOWN;
p_dt->m_u4TargetMinorVersion = FT_REQUIRED_VERSION_UNKNOWN;
p_dt->m_u4TargetBuildNum = FT_REQUIRED_VERSION_UNKNOWN;
g_b_ver_Incorrect = KAL_FALSE;
}
if(g_b_ver_Incorrect == KAL_TRUE) // version check fail
{
p_dt->m_bCheckPass = KAL_FALSE;
//g_b_ft_assert_check_enable = req->cmd.m_rCheckMetaVerReq.b_AssertWhenVerCheckFail;
}
else // g_b_ver_Incorrect = KAL_FALSE; --> version check pass!
{
p_dt->m_bCheckPass = KAL_TRUE;
g_b_ft_assert_check_enable = KAL_FALSE; // version pass: so stop checking!
}
g_u1_msg_recv_times = 0;
cnf->status = FT_CNF_OK;
}
/*******************************************************************************
* 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* ptr_ilm;
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_pdu_ptr( 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__
ptr_ilm = FT_ALLOC_OTHER_MSG( sizeof(nvram_read_req_struct) );
/* if ptrMsg != NULL*/
ptrMsg = (nvram_read_req_struct *)ptr_ilm->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, ptr_ilm);// wait READ_CNF
}
void FT_WriteTo_NVRAM(ft_nvram_write_req_struct_T* req, peer_buff_struct* peer_buff, ilm_struct* ptrMsg)
{
ilm_struct *ptr_ilm;
nvram_write_req_struct *nvram_ptr_loc_para;
kal_uint16 pdu_length;
kal_uint8 *pdu_ptr = get_pdu_ptr( 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_pdu_ptr( 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__
ptr_ilm = FT_ALLOC_OTHER_MSG( sizeof(nvram_write_req_struct) );
nvram_ptr_loc_para=(nvram_write_req_struct *)(ptr_ilm->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);
}
ptr_ilm->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, ptr_ilm);
if(ptrMsg != NULL)
ptrMsg->peer_buff_ptr=NULL;/* make sure the NVRAM will release the mem*/
}
