/*
* FUNCTION
* e_compass_nvram_init
*
* DESCRIPTION
* This function is to read calibrated data from NvRAM
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*/
void e_compass_nvram_init(void)
{
static kal_bool is_e_compass_nvram_init = KAL_FALSE;
nvram_ef_ecompass_calibration ec_nvram;
if (KAL_FALSE == is_e_compass_nvram_init)
{
/* read data from NvRAM */
nvram_external_read_data(NVRAM_EF_ECOMPASS_DATA_LID, 1, (kal_uint8 *)&ec_nvram, sizeof(nvram_ef_ecompass_calibration));
/* E_COMPASS_DEBUG_OUTPUT("Read from NvRAM 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_READBACK, ec_nvram.usr_moffset_x, ec_nvram.usr_moffset_y, ec_nvram.usr_moffset_z, ec_nvram.cali_result);
e_compass_calibrated_data.usr_moffset_x = ec_nvram.usr_moffset_x;
e_compass_calibrated_data.usr_moffset_y = ec_nvram.usr_moffset_y;
e_compass_calibrated_data.usr_moffset_z = ec_nvram.usr_moffset_z;
e_compass_calibrated_data.cali_result = ec_nvram.cali_result;
e_compass_calibrated_data.x_axis_sensitivity = ec_nvram.x_axis_sensitivity;
e_compass_calibrated_data.y_axis_sensitivity = ec_nvram.y_axis_sensitivity;
e_compass_calibrated_data.x_max = ec_nvram.x_max;
e_compass_calibrated_data.y_max = ec_nvram.y_max;
e_compass_calibrated_data.x_min = ec_nvram.x_min;
e_compass_calibrated_data.y_min = ec_nvram.y_min;
nvram_cali_result = ec_nvram.cali_result;
/* we just read NvRAM once */
is_e_compass_nvram_init = KAL_TRUE;
}
}
/*****************************************************************************
* FUNCTION
* nvram_config_com_port
* DESCRIPTION
* To init COM port setting
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void custom_em_nvram_config_com_port(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 *buffer = NULL;
kal_bool result;
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
kal_bool for_usbat = KAL_FALSE;
#endif
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_PORT_SETTING_SIZE);
if (buffer)
{
port_setting_struct *port_setting;
#if defined(MT6280) && defined(__MODEM_CCCI_EXIST__) && defined(__SMART_PHONE_MODEM__)
result = nvram_external_read_data(NVRAM_EF_PORT_SETTING_LID, 2, buffer, NVRAM_EF_PORT_SETTING_SIZE);
#else
result = nvram_external_read_data(NVRAM_EF_PORT_SETTING_LID, 1, buffer, NVRAM_EF_PORT_SETTING_SIZE);
#endif
/* Ok, now config UART/IrCOMM ports for L4 and TST, and filters to TST */
if (result)
{
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
for_usbat = INT_IsBootForUSBAT();
#endif
port_setting = (port_setting_struct*) buffer;
#ifdef __TST_MODULE__
#ifdef __IRDA_SUPPORT__
if ( (uart_port_irda == (UART_PORT) port_setting->tst_port_ps) ||
(uart_port_irda == (UART_PORT) port_setting->tst_port_l1))
{
init_ircomm_module();
IRDA_Open();
}
#endif /* __IRDA_SUPPORT__ */
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
if (for_usbat)
{
TST_PORT = (UART_PORT) uart_port1;
TST_PORT_L1 = (UART_PORT) uart_port1;
}
else
#endif
{
TST_PORT = (UART_PORT) port_setting->tst_port_ps;
TST_PORT_L1 = (UART_PORT) port_setting->tst_port_l1;
}
TST_BAUDRATE = port_setting->tst_baudrate_ps;
TST_BAUDRATE_L1 = port_setting->tst_baudrate_l1;
#ifndef L4_NOT_PRESENT
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
if (for_usbat)
{
PS_UART_PORT = (UART_PORT) uart_port_usb;
}
else
#endif
{
PS_UART_PORT = (UART_PORT) port_setting->ps_port;
}
PS_BAUDRATE = port_setting->ps_baudrate;
#endif /* L4_NOT_PRESENT */
#if defined(__DSP_FCORE4__)
TST_PORT_DSP = (UART_PORT) port_setting->tst_port_dsp;
TST_BAUDRATE_DSP = port_setting->tst_baud_rate_dsp;
#endif //#if defined(__DSP_FCORE4__)
#endif /* __TST_MODULE__ */
High_Speed_SIM = port_setting->High_Speed_SIM_Enabled;
if (High_Speed_SIM)
{
// remove
}
SWDBG_Profile = port_setting->swdbg;
UART_POWER_SETTING = port_setting->uart_power_setting;
CTI_UART_PORT = port_setting->cti_uart_port;
CTI_BAUD_RATE = port_setting->cti_baudrate;
#ifdef __TST_WRITE_TO_FILE__
TST_OUTPUT_MODE = port_setting->tst_output_mode;
#endif
#if defined(__USB_LOGGING__)
g_usb_logging_mode = port_setting->usb_logging_mode;
#endif
#ifdef __MTK_TARGET__
#ifndef __L1_STANDALONE__
/* To determine if in META mode */
if (FACTORY_BOOT != kal_query_boot_mode())
{
//kal_bool enable;
if (custom_em_is_uart_used(uart_port1))
{
custom_em_uart_turnon_power(uart_port1, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port1, KAL_FALSE);
}
#ifndef __SMART_PHONE_MODEM__
if (custom_em_is_uart_used(uart_port2))
{
custom_em_uart_turnon_power(uart_port2, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port2, KAL_FALSE);
}
if (custom_em_is_uart_used(uart_port3))
{
custom_em_uart_turnon_power(uart_port3, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port3, KAL_FALSE);
}
#endif
}
else /* In META Mode, Turn on every UART power */
#endif /* __L1_STANDALONE__ */
{
#ifndef __SMART_PHONE_MODEM__
custom_em_uart_turnon_power(uart_port1, KAL_TRUE);
custom_em_uart_turnon_power(uart_port2, KAL_TRUE);
custom_em_uart_turnon_power(uart_port3, KAL_TRUE);
#endif
}
#endif /* __MTK_TARGET__ */
#ifdef __MULTIPLE_PPP_DIALUP_SUPPORT__ //TRIPLE_PPP for MT6280 IOT
//20120917, support SPEECH(DCT) + TRIPLE PPP IOT test cases
// Target USB Enum, Function, Initial Owner, PC Device Naming
// usb, PPP1, ATCI, MTK Modem
// usb2, PPP23/CMUX, ATCI, MTK Modem
// usb3, AT, ATCI, Application Port
// usb4, Speech, ATCI, Speech Port
// usb5, Catcher Log, TST, Debug Port
TST_PORT = uart_port_usb5;
TST_PORT_L1 = uart_port_usb5;
PS_UART_PORT = uart_port_usb2; //20120917, support SPEECH(DCT) + TRIPLE PPP IOT test cases
g_usb_cdrom_config = 1;
#else
g_usb_cdrom_config = port_setting->usb_cdrom_config;
#endif /* __MULTIPLE_PPP_DIALUP_SUPPORT__ */
#ifdef __SPEECH_OVER_USB__
#ifdef __MTK_TARGET__
SPEECH_PORT = port_setting->speech_port; //uart_port_usb4;
#endif
#endif
}
free_ctrl_buffer(buffer);
}
buffer = NULL;
#if (!defined(L4_NOT_PRESENT)) || defined(__TST_MODULE__)
/* If L4 or TST exist */
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_TST_FILTER_SIZE);
if (buffer != NULL)
{
result = nvram_external_read_data(NVRAM_EF_TST_FILTER_LID, 1, buffer, NVRAM_EF_TST_FILTER_SIZE);
/* Ok, now config UART/IrCOMM ports for L4 and TST, and filters to TST */
if (result)
{
#ifdef __TST_MODULE__
tst_init_filters((kal_char*) buffer, NVRAM_EF_TST_FILTER_SIZE);
#endif
}
free_ctrl_buffer(buffer);
}
#if defined(__TST_MODULE__) && defined(__MTK_TARGET__)
//Shengkai: check if we need to enable the spare ram logging mechanism
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_TST_CONFIG_SIZE);
if (buffer != NULL)
{
result = nvram_external_read_data(NVRAM_EF_TST_CONFIG_LID, 1, buffer, NVRAM_EF_TST_CONFIG_SIZE);
if (result)
{
extern kal_bool tst_spare_ram_nvram_enabled_flag;
extern kal_bool tst_alc_logging_enable;
extern kal_bool tst_usb_dma_logging_enabled_flag;
extern kal_uint8 tst_meta_mode_trace_nvram_enable_flag;
extern kal_bool tst_is_auto_memory_dump;
tst_spare_ram_nvram_enabled_flag = ((tst_config_struct_t *)buffer)->spare_logging_enabled;
tst_usb_dma_logging_enabled_flag = ((tst_config_struct_t *)buffer)->usb_dma_logging_enable;
tst_meta_mode_trace_nvram_enable_flag = ((tst_config_struct_t *)buffer)->meta_mode_trace_enable;
if(tst_meta_mode_trace_nvram_enable_flag != 1 && tst_meta_mode_trace_nvram_enable_flag != 2)
tst_meta_mode_trace_nvram_enable_flag = 0;
if(tst_meta_mode_trace_nvram_enable_flag == 2)
tst_is_auto_memory_dump = KAL_TRUE;
if (((tst_config_struct_t *)buffer)->malmo_disable == 1)
tst_alc_logging_enable = KAL_FALSE;
else
tst_alc_logging_enable = KAL_TRUE;
//tst_alc_logging_enable = ~(((tst_config_struct_t *)buffer)->malmo_disable);
}
free_ctrl_buffer(buffer);
}
#endif // #if defined(__TST_MODULE__) && defined(__MTK_TARGET__)
#endif /* (!defined(L4_NOT_PRESENT)) || defined(__TST_MODULE__) */
}
/*****************************************************************************
* FUNCTION
* custom_nvram_set_sbp_id
* DESCRIPTION
* similar to custom_nvram_config()
* PARAMETERS
* none
* RETURNS
* none
*****************************************************************************/
kal_bool custom_nvram_set_sbp_id(kal_uint32 sbp_id)
{
nvram_ef_sbp_modem_config_struct sbp_feature_buf;
/* Update related NVRAM files according to SBP ID */
if(sbp_id != 0)
{
// Read current settings in NVRAM
nvram_external_read_data(NVRAM_EF_SBP_MODEM_CONFIG_LID,
1,
(kal_uint8*)&sbp_feature_buf,
NVRAM_EF_SBP_MODEM_CONFIG_SIZE);
if (sbp_id == 3) //for Orange
{
sbp_set_md_feature(SBP_HPPLMN_REGARDLESS_ANY_MCC, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_DISABLE_RPLMN_FROM_GLOCI, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_ORANGE_H_PLUS, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
#if defined(__UMTS_FDD_MODE__) || defined(__UMTS_TDD128_MODE__)
// ORG_FD
{
kal_uint8 buf[NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_SIZE];
nvram_ef_umts_usime_rrc_dynamic_struct* pUMTS_USIME_RRC_dynamic_cap;
nvram_external_read_data(NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_LID,
1,
buf,
NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_SIZE);
pUMTS_USIME_RRC_dynamic_cap = (nvram_ef_umts_usime_rrc_dynamic_struct*)buf;
pUMTS_USIME_RRC_dynamic_cap->rrce_feature_cap |= 0x10;
nvram_external_write_data(NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_LID,
1,
buf,
NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_SIZE);
}
#endif
}
else if (sbp_id == 6) //for Vodafone
{
nvram_ef_regional_phone_mode_struct regional_phone_mode;
regional_phone_mode.mode = 1;
nvram_external_write_data(NVRAM_EF_REGIONAL_PHONE_MODE_LID,
1,
(kal_uint8*)®ional_phone_mode,
NVRAM_EF_REGIONAL_PHONE_MODE_SIZE);
sbp_set_md_feature(SBP_MM_TRY_ABNORMAL_LAI_ONCE_MORE, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_USE_SM_QOS_SUBSCRIBED, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
}
else if (sbp_id == 7) //for AT&T
{
sbp_set_md_feature(SBP_USIM_CSP_SUPPORT, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_ENS, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_ENS_RAT_BALANCING, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_ATNT_HPPLMN_SEARCH, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_DISABLE_AUTO_RETURN_PRE_RPLMN, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_DISABLE_RPLMN_FROM_GLOCI, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_AT_ME_IDENTIFICATION_WITHOUT_HEADER, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_SAT_NO_EVDL_IN_SESSION, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_IMEI_LOCK_SUPPORT, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_STAR_SHORT_STRING_AS_CALL, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_CUSTOMIZED_IDLE_STRING_AS_CALL, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_MM_DISABLE_RETRY_ABNORMAL_LAI, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_MM_ILL_MS_ME_CAUSE_PS_INVALID_SIM, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_MM_NOT_TRY_ANOTHER_RAT_FOR_LU_ABNORMAL, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
}
else if (sbp_id == 8) //for T-Mobile
{
sbp_set_md_feature(SBP_ATNT_HPPLMN_SEARCH, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_TMO_PLMN_MATCHING, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_TMO_ECC_NOTIFICATION_ENABLE, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
}
else if (sbp_id == 11) //for H3G
{
sbp_set_md_feature(SBP_PERMANENT_AUTO_SEL_MODE, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_MM_TRY_ABNORMAL_LAI_ONCE_MORE, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_MM_HPPLMN_1ST_ATTEMPT_ENHANCE, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
sbp_set_md_feature(SBP_RPLMN_HPLMN_COMBINED_SEARCH, KAL_TRUE, (nvram_ef_sbp_modem_config_struct*)&sbp_feature_buf);
}
sbp_feature_buf.sbp_mode = sbp_id;
// Write new settings to NVRAM
nvram_external_write_data(NVRAM_EF_SBP_MODEM_CONFIG_LID,
1,
(kal_uint8*)&sbp_feature_buf,
NVRAM_EF_SBP_MODEM_CONFIG_SIZE);
}
else
{
/* incorect sbp id */
return KAL_FALSE;
}
return KAL_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);
}
