/*
* FUNCTION
* bmt_get_adc_channel_voltage
*
* DESCRIPTION
* This function is used to obtain the Battery voltage of specific channel
*
* CALLS
*
* PARAMETERS
* ch: specific channel
* voltage: pointer for read the voltage
*
* RETURNS
* KAL_FALSE: invalid channel
* KAL_TRUE: finish the measurement
*
* GLOBALS AFFECTED
* None
*/
kal_bool bmt_get_adc_channel_voltage(DCL_ADC_CHANNEL_TYPE_ENUM ch, kal_uint32 *voltage)
{
DCL_HANDLE adc_handle;
ADC_CTRL_GET_PHYSICAL_CHANNEL_T adc_get_channel;
ADC_CTRL_GET_DATA_T adc_data;
ADC_CTRL_TRANSFORM_INTO_VOLT_T adcTransV;
if(ch > DCL_VCHARGER_ADC_CHANNEL)
return KAL_FALSE;
adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
if(adc_handle == DCL_HANDLE_INVALID)
{
ASSERT(0);
}
adc_get_channel.u2AdcName = ch;
DclSADC_Control(adc_handle, ADC_CMD_GET_CHANNEL, (DCL_CTRL_DATA_T *)&adc_get_channel);
adc_data.u1Channel = adc_get_channel.u1AdcPhyCh;
DclHADC_Control(adc_handle, ADC_CMD_GET_DATA,(DCL_CTRL_DATA_T *)&adc_data);
adcTransV.u1AdcPhyCh = adc_get_channel.u1AdcPhyCh;
adcTransV.d8AdcValue = adc_data.u4ADCData;
DclSADC_Control(adc_handle, ADC_CMD_TRANSFORM_INTO_VOLT, (DCL_CTRL_DATA_T *)&adcTransV);
*voltage = adcTransV.u4Volt;
DclSADC_Close(adc_handle);
return KAL_TRUE;
}
kal_int32 bmt_change_Voltage_To_ISense(DCL_UINT32 TransformVolt)
{
DCL_HANDLE dcl_adc_handle;
ADC_CTRL_TRANSFORM_INTO_CURR_T rTransformCurr;
dcl_adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
rTransformCurr.u4Volt = TransformVolt;
DclSADC_Control(dcl_adc_handle, ADC_CMD_TRANSFORM_INTO_CURR, (DCL_CTRL_DATA_T *)&rTransformCurr);
DclSADC_Close(dcl_adc_handle);
return (kal_int32)rTransformCurr.u4Curr;
}
kal_int32 bmt_change_VBatTmp_To_BatTmp(kal_int32 VbatTmp)
{
DCL_HANDLE dcl_adc_handle;
ADC_CTRL_TRANSFORM_INTO_TEMP_T adc_get_vbattmp;
adc_get_vbattmp.u4Volt = VbatTmp;
dcl_adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
DclSADC_Control(dcl_adc_handle, ADC_CMD_TRANSFORM_INTO_TEMP, (DCL_CTRL_DATA_T *)&adc_get_vbattmp);
DclSADC_Close(dcl_adc_handle);
return (kal_int32)adc_get_vbattmp.u4Temp;
}
kal_uint8 FT_GetAdcMaxChannel(void)
{
// HAL modification
DCL_HANDLE adc_handle;
ADC_CTRL_GET_MAX_PHYSICAL_CH_T prGetMaxPhyCh;
kal_uint8 adc_max_channel;
adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
if(DclHADC_Control(adc_handle, ADC_CMD_GET_MAX_PHYSICAL_CH, (DCL_CTRL_DATA_T *)&prGetMaxPhyCh) != STATUS_OK)
{
// error handling (prevent from access out-of bound)
adc_max_channel = 1;
}
adc_max_channel = prGetMaxPhyCh.u4Adc_max_ch;
if(DclSADC_Close(adc_handle) != STATUS_OK)
{
// error handling (prevent from access out-of bound)
adc_max_channel = 1;
}
return adc_max_channel;
}
/*
* FUNCTION
* BMT_Current_Voltage
*
* DESCRIPTION
* This function is used to obtain the Battery voltage of specific channel
*
* CALLS
*
* PARAMETERS
* ch: specific channel
* voltage: pointer for read the voltage
*
* RETURNS
* KAL_FALSE: invalid channel
* KAL_TRUE: finish the measurement
*
* GLOBALS AFFECTED
* None
*/
kal_bool BMT_Current_Voltage(DCL_ADC_CHANNEL_TYPE_ENUM ch, kal_uint32 *voltage, double *adc_value)
{
kal_uint8 adc_channel;
DCL_HANDLE adc_handle;
ADC_CTRL_GET_PHYSICAL_CHANNEL_T adc_ch;
if(ch > DCL_VCHARGER_ADC_CHANNEL)
return KAL_FALSE;
adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
if(adc_handle == DCL_HANDLE_INVALID)
{
ASSERT(0);
}
adc_ch.u2AdcName = ch;
DclSADC_Control(adc_handle, ADC_CMD_GET_CHANNEL, (DCL_CTRL_DATA_T *)&adc_ch);
adc_channel = adc_ch.u1AdcPhyCh;
*voltage = adc_measureVoltage(adc_channel, adc_value);
DclSADC_Close(adc_handle);
return KAL_TRUE;
}
/*
* FUNCTION
* BMT_ObtainBMTPHYSTAT
*
* DESCRIPTION
* This function is used to obtain the ADC measure result.
* Average the received Phy. data
*
* CALLS
*
* PARAMETERS
* Data: None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
kal_bool BMT_ObtainBMTPHYSTAT(BATPHYStruct *BATPHYS)
{
#ifndef __BMT_NO_ISENSE_RESISTOR__
DCL_HANDLE dcl_adc_handle;
ADC_CTRL_TRANSFORM_INTO_CURR_T rTransformCurr;
#endif
#if defined(__DRV_BMT_ISENSE_OFFSET_COMPENSATION__)
static kal_int32 ISense_Offset;
#endif
drv_trace0(TRACE_GROUP_10, BMT_OBTAIN_PHY_STAT_TRC);
BATPHYS->VBAT = BMT_VOL_RESULT[BMT_ADC_VBAT];
drv_trace1(TRACE_GROUP_10, BMT_VBAT_TRC, BATPHYS->VBAT);
#ifndef __BMT_NO_ISENSE_RESISTOR__
dcl_adc_handle = DclSADC_Open(DCL_ADC, FLAGS_NONE);
#if defined(__DRV_BMT_ISENSE_OFFSET_COMPENSATION__)
if(BMT.pmictrl_state == PMIC_CHARGEOFF)
{
ISense_Offset = BMT_VOL_RESULT[BMT_ADC_VISENSE] - BMT_VOL_RESULT[BMT_ADC_VBAT];
}
BATPHYS->ISense_Offset = ISense_Offset;
rTransformCurr.u4Volt = BMT_VOL_RESULT[BMT_ADC_VISENSE] - BMT_VOL_RESULT[BMT_ADC_VBAT]-BATPHYS->ISense_Offset;
#else
rTransformCurr.u4Volt = BMT_VOL_RESULT[BMT_ADC_VISENSE] - BMT_VOL_RESULT[BMT_ADC_VBAT];
#endif
DclSADC_Control(dcl_adc_handle, ADC_CMD_TRANSFORM_INTO_CURR, (DCL_CTRL_DATA_T *)&rTransformCurr);
BATPHYS->ICHARGE = rTransformCurr.u4Curr;
DclSADC_Close(dcl_adc_handle);
#if defined(__DRV_BMT_ISENSE_OFFSET_COMPENSATION__)
drv_trace1(TRACE_GROUP_10, BMT_VSENSE_TRC, BMT_VOL_RESULT[BMT_ADC_VISENSE]);
drv_trace1(TRACE_GROUP_10, BMT_ICHARGE_TRC, BATPHYS->ICHARGE);
drv_trace1(TRACE_GROUP_10, BMT_VSENSE_VBAT_OFFSET_TRC, BATPHYS->ISense_Offset);
#else
BATPHYS->ICHARGE -= bmt_charging_para->CurrOffset[BMT.call_state];
drv_trace1(TRACE_GROUP_10, BMT_ICHARGE_TRC, BATPHYS->ICHARGE);
if((BMT.pmictrl_state == PMIC_CHARGEOFF) && ((BATPHYS->ICHARGE + bmt_charging_para->CurrOffset[BMT.call_state]) > bmt_charging_para->ICHARGE_ON_LOW))
{
drv_trace1(TRACE_GROUP_10, BMT_ADC_CALIBRATION_FAIL_TRC, BATPHYS->ICHARGE + bmt_charging_para->CurrOffset[BMT.call_state]);
}
#endif
#endif // #ifndef __BMT_NO_ISENSE_RESISTOR__
if(bmt_charging_para->bmt_check_temp)
{
BATPHYS->BATTMP = BMT_VOL_RESULT[BMT_ADC_VBATTMP];
drv_trace1(TRACE_GROUP_10, BMT_BATTMP_TRC, BATPHYS->BATTMP);
}
if(bmt_charging_para->bmt_check_charger)
{
BATPHYS->VCHARGER = BMT_VOL_RESULT[BMT_ADC_VCHARGER];
drv_trace1(TRACE_GROUP_10, BMT_VCHARGER_TRC, BATPHYS->VCHARGER);
}
if ((BMT.pmictrl_state == PMIC_CHARGEOFF) ||
(BMT.pmictrl_state == PMIC_CHARGEON ) &&
( (BMT.bat_state == CHR_TOPOFF) || (BMT.bat_state == CHR_BATFULL) ))
{
VBAT_OFF = BATPHYS->VBAT;
ADCBAT_OFF = BMT_ADC_RESULT[BMT_ADC_VBAT];
}
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);
}
