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