//-----------------------------------------------------------------------------
bool META_Editor_ReadFile_OP(FT_AP_Editor_read_req *pReq)
{
FT_AP_Editor_read_cnf kCnf;
F_INFO kFileInfo;
int iNvmRecSize = 0, iReadSize;
F_ID iFD;
char* pBuffer = NULL;
bool IsRead =true;
memset(&kCnf, 0, sizeof(FT_AP_Editor_read_cnf));
kCnf.header.id = pReq->header.id + 1;
kCnf.header.token = pReq->header.token;
kCnf.file_idx = pReq->file_idx;
kCnf.para = pReq->para;
iFD = NVM_GetFileDesc(pReq->file_idx,&(kFileInfo.i4RecSize),&(kFileInfo.i4RecNum),IsRead);
if (iFD.iFileDesc == -1)
{
NVRAM_LOG("Error AP_Editor_ReadFile can't open file: file index-%d, %d\n", pReq->file_idx, iNvmRecSize);
kCnf.status = META_FAILED;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), NULL, 0);
return false;
}
iNvmRecSize = kFileInfo.i4RecSize;
if (pReq->para > kFileInfo.i4RecNum)
{
NVRAM_LOG("Error AP_Editor_ReadFile para: %d, %d\n", pReq->file_idx, pReq->para);
NVM_CloseFileDesc(iFD);
kCnf.status = META_FAILED;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), NULL, 0);
return false;
}
/* Open NVRAM realted files */
pBuffer = (char*)malloc(iNvmRecSize);
lseek(iFD.iFileDesc, (pReq->para - 1) * iNvmRecSize, SEEK_CUR);
iReadSize=read(iFD.iFileDesc, pBuffer, iNvmRecSize);
if(iNvmRecSize != iReadSize){
NVRAM_LOG("Error AP_Editor_ReadFile :Read size not match:iReadSize(%d),iNvmRecSize(%d),error:%s\n",iReadSize,iNvmRecSize,strerror(errno));
NVM_CloseFileDesc(iFD);
kCnf.status = META_FAILED;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), NULL, 0);
return false;
}
NVM_CloseFileDesc(iFD);
kCnf.read_status = META_STATUS_SUCCESS;
kCnf.status = META_SUCCESS;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), pBuffer, iNvmRecSize);
NVRAM_LOG("AP_Editor_ReadFile result: file_idx ~ %d para ~ %d read ~ %d\n", pReq->file_idx, pReq->para, iReadSize);
free(pBuffer);
return true;
}
/********************************************************************************
//FUNCTION:
// META_FM_OP
//DESCRIPTION:
// META FM test main process function.
//
//PARAMETERS:
// req: FM Req struct
// peer_buff: peer buffer pointer
// peer_len: peer buffer length
//RETURN VALUE:
// void
//
********************************************************************************/
void META_CLR_EMMC_OP(FT_EMMC_REQ *req)
{
LOGD("req->op:%d\n", req->op);
int ret = 0;
FT_EMMC_CNF emmc_cnf;
memcpy(&emmc_cnf, req, sizeof(FT_H) + sizeof(FT_EMMC_OP));
emmc_cnf.header.id ++;
switch (req->op) {
case FT_EMMC_OP_CLEAR:
ret = clear_emmc_entry();
LOGD("clr emmc clear ret is %d\n", ret);
emmc_cnf.m_status = META_SUCCESS;
if (!ret) {
emmc_cnf.result.clear_cnf.status = 1;
} else {
emmc_cnf.result.clear_cnf.status = 0;
}
WriteDataToPC(&emmc_cnf, sizeof(FT_EMMC_CNF), NULL, 0);
reboot(RB_AUTOBOOT);
break;
case FT_EMMC_OP_FORMAT_TCARD:
ret = clear_emmc_internal_sd();
LOGD("clr emmc clear internal sd ret is %d\n", ret);
emmc_cnf.m_status = META_SUCCESS;
if (!ret) {
emmc_cnf.result.form_tcard_cnf.status = 1;
} else {
emmc_cnf.result.form_tcard_cnf.status = 0;
}
WriteDataToPC(&emmc_cnf, sizeof(FT_EMMC_CNF), NULL, 0);
break;
case FT_EMMC_OP_CLEAR_WITHOUT_TCARD:
ret = clear_emmc_nomedia_entry("/data");
LOGD("clear emmc no mediaret is %d\n", ret);
emmc_cnf.m_status = META_SUCCESS;
if (!ret) {
emmc_cnf.result.clear_without_tcard_cnf.status = 1;
} else {
emmc_cnf.result.clear_without_tcard_cnf.status = 0;
}
WriteDataToPC(&emmc_cnf, sizeof(FT_EMMC_CNF), NULL, 0);
reboot(RB_AUTOBOOT);
LOGD("success to call 143 op 3\n");
break;
default:
emmc_cnf.m_status = META_SUCCESS;
emmc_cnf.result.clear_cnf.status = META_STATUS_FAILED;
WriteDataToPC(&emmc_cnf, sizeof(FT_EMMC_CNF), NULL, 0);
break;
}
}
//-----------------------------------------------------------------------------
bool META_Editor_ReadFile_OP(FT_AP_Editor_read_req *pReq)
{
FT_AP_Editor_read_cnf kCnf;
F_INFO kFileInfo;
int iNvmRecSize, iReadSize;
int iFD;
char* pBuffer = NULL;
memset(&kCnf, 0, sizeof(FT_AP_Editor_read_cnf));
kCnf.header.id = pReq->header.id + 1;
kCnf.header.token = pReq->header.token;
kCnf.file_idx = pReq->file_idx;
kCnf.para = pReq->para;
kFileInfo = NVM_ReadFileVerInfo(pReq->file_idx);
iNvmRecSize = kFileInfo.i4RecSize;
if (pReq->para > kFileInfo.i4RecNum)
{
printf("Error AP_Editor_ReadFile para: %d, %d\n", pReq->file_idx, pReq->para);
kCnf.status = META_FAILED;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), NULL, 0);
return false;
}
/* Open NVRAM realted files */
iFD = open(kFileInfo.cFileName, O_RDONLY, S_IRUSR);
if (iFD == -1)
{
NVRAM_LOG("Error AP_Editor_ReadFile can't open file: file index-%d, %d\n", pReq->file_idx, iNvmRecSize);
kCnf.status = META_FAILED;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), NULL, 0);
return false;
}
pBuffer = (char*)malloc(iNvmRecSize);
lseek(iFD, (pReq->para - 1) * iNvmRecSize, SEEK_SET);
iReadSize = read(iFD, pBuffer, iNvmRecSize);
close(iFD);
kCnf.read_status = META_STATUS_SUCCESS;
kCnf.status = META_SUCCESS;
WriteDataToPC(&kCnf, sizeof(FT_AP_Editor_read_cnf), pBuffer, iNvmRecSize);
NVRAM_LOG("AP_Editor_ReadFile result: file_idx ~ %d para ~ %d read ~ %d\n", pReq->file_idx, pReq->para, iReadSize);
free(pBuffer);
return true;
}
/********************************************************************************
//FUNCTION:
// META_CRYPTFS_OP
//DESCRIPTION:
// META CRYPTFS test main process function.
//
//PARAMETERS:
//
//RETURN VALUE:
// void
//
********************************************************************************/
void META_CRYPTFS_OP(FT_CRYPTFS_REQ *req)
{
LOGD("req->op:%d\n", req->op);
int ret = 0;
FT_CRYPTFS_CNF cryptfs_cnf;
memcpy(&cryptfs_cnf, req, sizeof(FT_H) + sizeof(CRYPTFS_OP));
cryptfs_cnf.header.id ++;
switch (req->op) {
case CRYPTFS_OP_QUERY_STATUS:
{
bool encrypted_status = 0;
cryptfs_cnf.m_status = META_SUCCESS;
encrypted_status = get_encrypt_phone_status();
LOGD("encrypted_status:%d \n", encrypted_status);
cryptfs_cnf.result.query_status_cnf.status = encrypted_status;
WriteDataToPC(&cryptfs_cnf, sizeof(FT_CRYPTFS_CNF), NULL, 0);
}
break;
case CRYPTFS_OP_VERIFY:
{
char* pw = req->cmd.verify_req.pwd;
int pw_len = req->cmd.verify_req.length;
cryptfs_cnf.m_status = META_SUCCESS;
LOGD("pw = %s, pw_len = %d \n", pw, pw_len);
if (pw_len < 4 || pw_len > 16) {
cryptfs_cnf.result.verify_cnf.decrypt_result = 0;
LOGE("Invalid passwd length =%d \n", pw_len);
WriteDataToPC(&cryptfs_cnf, sizeof(FT_CRYPTFS_CNF), NULL, 0);
break;
}
if(!decrypt_data(pw)) {
cryptfs_cnf.result.verify_cnf.decrypt_result = 1;
}
else {
cryptfs_cnf.result.verify_cnf.decrypt_result = 0;
}
LOGD("verify result:%d \n", cryptfs_cnf.result.verify_cnf.decrypt_result);
WriteDataToPC(&cryptfs_cnf, sizeof(FT_CRYPTFS_CNF), NULL, 0);
}
break;
default:
LOGE("Error: unsupport op code = %d\n", req->op);
break;
}
}
void Meta_Touch_OP(Touch_REQ *req, char *peer_buff, unsigned short peer_len)
{
Touch_CNF TouchMetaReturn;
int ret, fd = -1;
int status = 0;
memset(&TouchMetaReturn, 0, sizeof(TouchMetaReturn));
TouchMetaReturn.header.id=req->header.id+1;
TouchMetaReturn.header.token = req->header.token;
TouchMetaReturn.status=META_FAILED;
/* open file */
fd = open(FILENAME,O_RDWR, 0);
if (fd < 0) {
TOUCH_LOG("Open %s : ERROR \n", FILENAME);
TOUCH_LOG("Open %s : ERROR \n", FILENAME);
goto Touch_Finish;
}
ret = read(fd, &status, sizeof(int));
if((status & 0X0ff) == '1')
TouchMetaReturn.status=META_SUCCESS;
TOUCH_LOG("Cap touch status:%d\n", status);
close(fd);
Touch_Finish:
if (false == WriteDataToPC(&TouchMetaReturn,sizeof(Touch_CNF),NULL,0)) {
TOUCH_LOG("%s : WriteDataToPC() fail 2\n", __FUNCTION__);
}
TOUCH_LOG("%s : Finish !\n", __FUNCTION__);
}
static void meta_sdcard_send_resp(SDCARD_CNF *cnf)
{
if (cnf_cb)
cnf_cb(cnf);
else
WriteDataToPC(cnf, sizeof(SDCARD_CNF), NULL, 0);
}
static void wifi_send_resp(FT_WM_WIFI_CNF *cnf, void *buf, unsigned int size)
{
if (cnf_cb)
cnf_cb(cnf, buf, size);
else
WriteDataToPC(cnf, sizeof(FT_WM_WIFI_CNF), buf, size);
}
void *GPS_MetaThread(void *arg)
{
int read_leng = 0;
int cnt = 0;
char *ptr;
unsigned char buf[10240];
cnt = 0;
while(1)
{
memset(buf, 0, sizeof(buf));
read_leng = 0;
read_leng = read(sockfd, buf, sizeof(buf));
if (read_leng < 0)
{
META_LOG("ERROR reading from socket");
return (void *)(-1);
}
else if(read_leng > 0)
{
ptr=strtok(buf, "\r\n");
if(ptr == NULL)
{
continue;
}
do
{
/*if(strncmp(ptr, "$PMTK", 5) == 0)
{
if((ptr[5] >= '0' && ptr[5] <= '9') &&
(ptr[6] >= '0' && ptr[6] <= '9') &&
(ptr[7] >= '0' && ptr[7] <= '9')) // $PMTK000~$PMTK999*/
//{
META_LOG("GPS_MetaThread: %s", ptr);
strncpy(&gps_cnf2.gps_ack.buff[cnt], ptr, (sizeof(gps_cnf2.gps_ack.buff) - cnt));
cnt += strlen(ptr);
gps_cnf2.gps_ack.buff[cnt++] = '\r';
gps_cnf2.gps_ack.buff[cnt++] = '\n';
// }
//}
}while((ptr=strtok(NULL, "\r\n")) != NULL);
if(cnt > 0)
{
gps_cnf2.gps_ack.len = cnt;
gps_cnf2.gps_status = TRUE;
gps_cnf2.status = META_SUCCESS;
META_LOG("GPS_MetaThread, status:%d, gps_cnf.gps_ack.len:%d\r\n", gps_cnf2.status, gps_cnf2.gps_ack.len);
WriteDataToPC(&gps_cnf2, sizeof(GPS_CNF), NULL, 0);
cnt = 0;
}
}
}
return (void *)0;
}
void Meta_AUXADC_OP(AUXADC_REQ *req, char *peer_buff, unsigned short peer_len)
{
AUXADC_CNF ADCMetaReturn;
int ret;
memset(&ADCMetaReturn, 0, sizeof(ADCMetaReturn));
ADCMetaReturn.header.id=req->header.id+1;
ADCMetaReturn.header.token=req->header.token;
ADCMetaReturn.status=META_SUCCESS;
ADCMetaReturn.ADCStatus=TRUE;
/* open file */
meta_adc_fd = open("/dev/mtk-adc-cali",O_RDWR, 0);
if (meta_adc_fd == -1) {
printf("Open /dev/mtk-adc-cali : ERROR \n");
META_LOG("Open /dev/mtk-adc-cali : ERROR \n");
ADCMetaReturn.status=META_FAILED;
goto ADC_Finish;
}
adc_in_data[0] = req->dwChannel;
adc_in_data[1] = req->dwCount;
ret = ioctl(meta_adc_fd, ADC_CHANNEL_READ, adc_in_data);
if (ret == -1)
{
ADCMetaReturn.dwData = 0;
ADCMetaReturn.status = META_FAILED;
}
else
{
if (adc_in_data[1]==0) {
ADCMetaReturn.dwData = adc_in_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
else {
ADCMetaReturn.dwData = 0;
ADCMetaReturn.status = META_FAILED;
}
}
printf("Meta_AUXADC_OP : CH[%d] in %d times : %d\n", req->dwChannel, req->dwCount, adc_in_data[0]);
META_LOG("Meta_AUXADC_OP : CH[%d] in %d times : %d\n", req->dwChannel, req->dwCount, adc_in_data[0]);
META_LOG("Meta_AUXADC_OP : CH[%d] in %d times : %d : dwdata\n", req->dwChannel, req->dwCount, ADCMetaReturn.dwData);
close(meta_adc_fd);
ADC_Finish:
if (false == WriteDataToPC(&ADCMetaReturn,sizeof(ADCMetaReturn),NULL,0)) {
printf("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
META_LOG("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
}
printf("Meta_AUXADC_OP : Finish !\n");
META_LOG("Meta_AUXADC_OP : Finish !\n");
}
void META_GPS_OP(GPS_REQ *req, char *peer_buff, unsigned short peer_len)
{
memset(&gps_cnf1, 0, sizeof(GPS_CNF));
gps_cnf1.header.id = FT_GPS_CNF_ID;
gps_cnf1.header.token = req->header.token;
gps_cnf1.op = req->op;
memset(&gps_cnf2, 0, sizeof(GPS_CNF));
gps_cnf2.header.id = FT_GPS_CNF_ID;
gps_cnf2.header.token = req->header.token;
gps_cnf2.op = req->op;
META_LOG("META_GPS_OP() 1, (%d)\n", req->op);
switch(req->op)
{
case GPS_OP_OPEN:
META_LOG("META_GPS_OP(), GPS_OP_OPEN 1\n");
if(META_GPS_Open() != 0) // open fail
{
META_LOG("META_GPS_OP(), GPS_OP_OPEN fail\n");
META_GPS_Close();
META_LOG("Can't open gps driver \r\n");
gps_cnf1.gps_status = FALSE;
gps_cnf1.status = META_FAILED;
}
else
{
META_LOG("META_GPS_OP(), GPS_OP_OPEN OK\n");
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
}
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), GPS_OP_OPEN 2\n");
break;
case GPS_OP_CLOSE:
META_LOG("META_GPS_OP(), GPS_OP_CLOSE 1\n");
META_GPS_Close();
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), GPS_OP_CLOSE 2\n");
break;
case GPS_OP_SEND_CMD:
META_LOG("META_GPS_OP(), GPS_OP_SEND_CMD\n");
if(sockfd != C_INVALID_SOCKET)
{
int n = write(sockfd, req->cmd.buff, req->cmd.len);
if (n < 0)
{
META_LOG("ERROR writing to socket\r\n");
}
META_LOG("META_GPS_OP(), GPS_OP_SEND_CMD: %s\r\n", req->cmd.buff);
}
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
META_LOG("GPS_OP_SEND_CMD, gps_cnf.status:%d\r\n", gps_cnf1.status);
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
break;
default:
META_LOG("META_GPS_OP(), default 1\n");
gps_cnf1.gps_status = FALSE;
gps_cnf1.status = META_FAILED;
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), default 2\n");
break;
}
META_LOG("META_GPS_OP() 2\n");
}
static void* META_NFC_read_cnf(void *arg)
{
int rec_bytes = 0;
// Read resonse
META_LOG("META_NFC_CMD:NFC read thread start");
bStop_ReadThread = 0;
while(bStop_ReadThread == 0)
{
ilm_struct nfc_ilm_rec;
nfc_msg_struct nfc_msg;
unsigned char nfc_msg_length;
unsigned char fgSupport = 1;
//clean struct buffer
memset(&nfc_ilm_rec, 0, sizeof(ilm_struct));
//read fd
//if get response break
rec_bytes = read(nfc_service_sockfd,(char*)&nfc_ilm_rec, sizeof(ilm_struct));
if (rec_bytes > 0)
{
// check msg id
META_LOG("META_NFC_CMD:NFC read (msg_id,dest_mod_id) = (%d,%d)",nfc_ilm_rec.msg_id, nfc_ilm_rec.dest_mod_id);
if ((nfc_ilm_rec.msg_id == MSG_ID_NFC_TEST_RSP) && (nfc_ilm_rec.dest_mod_id == MOD_NFC_APP))
{
nfc_msg_length = sizeof(nfc_msg_struct);
memcpy( &nfc_msg, (nfc_msg_struct*)nfc_ilm_rec.local_para_ptr, nfc_msg_length);
META_LOG("META_NFC_CMD:NFC read msg_type=%d,length=%d", nfc_msg.msg_type,nfc_msg_length);
switch (nfc_msg.msg_type)
{
case MSG_ID_NFC_SETTING_RSP:
{
nfc_cnf.op = NFC_OP_SETTING;
memcpy(&nfc_cnf.result.m_setting_cnf, (nfc_setting_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_setting_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_SETTING =%d/%d/%d/%d/%d/%d/%d/%d/%d/",
nfc_cnf.result.m_setting_cnf.status,
nfc_cnf.result.m_setting_cnf.debug_enable,
nfc_cnf.result.m_setting_cnf.fw_ver,
nfc_cnf.result.m_setting_cnf.get_capabilities,
nfc_cnf.result.m_setting_cnf.sw_ver,
nfc_cnf.result.m_setting_cnf.hw_ver,
nfc_cnf.result.m_setting_cnf.fw_ver,
nfc_cnf.result.m_setting_cnf.reader_mode,
nfc_cnf.result.m_setting_cnf.card_mode);
break;
}
case MSG_ID_NFC_NOTIFICATION_RSP:
{
nfc_cnf.op = NFC_OP_REG_NOTIFY;
memcpy(&nfc_cnf.result.m_reg_notify_cnf, (nfc_reg_notif_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length),sizeof(nfc_reg_notif_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_DISCOVERY =%d/",
nfc_cnf.result.m_reg_notify_cnf.status);
break;
}
case MSG_ID_NFC_SE_SET_RSP:
{
nfc_cnf.op = NFC_OP_SECURE_ELEMENT;
memcpy(&nfc_cnf.result.m_se_set_cnf, (nfc_se_set_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_se_set_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_SECURE_ELEMENT =%d/",
nfc_cnf.result.m_se_set_cnf.status);
break;
}
case MSG_ID_NFC_DISCOVERY_RSP:
{
nfc_cnf.op = NFC_OP_DISCOVERY;
memcpy(&nfc_cnf.result.m_dis_notify_cnf, (nfc_dis_notif_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_dis_notif_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_DISCOVERY =%d/%d/",
nfc_cnf.result.m_dis_notify_cnf.status,
nfc_cnf.result.m_dis_notify_cnf.type);
break;
}
case MSG_ID_NFC_TAG_READ_RSP:
{
nfc_cnf.op = NFC_OP_TAG_READ;
memcpy(&nfc_cnf.result.m_tag_read_cnf, (nfc_tag_read_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_tag_read_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_READ =%d/%d/",
nfc_cnf.result.m_tag_read_cnf.status,
nfc_cnf.result.m_tag_read_cnf.type);
break;
}
case MSG_ID_NFC_TAG_WRITE_RSP:
{
nfc_cnf.op = NFC_OP_TAG_WRITE;
memcpy(&nfc_cnf.result.m_tag_write_cnf, (nfc_tag_write_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_tag_write_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_WRITE =%d/%d/",
nfc_cnf.result.m_tag_write_cnf.status,
nfc_cnf.result.m_tag_write_cnf.type);
break;
}
case MSG_ID_NFC_TAG_DISCONN_RSP:
{
nfc_cnf.op = NFC_OP_TAG_DISCONN;
memcpy(&nfc_cnf.result.m_tag_discon_cnf, (nfc_tag_disconnect_request*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_tag_disconnect_request));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_DISCONN =%d/",
nfc_cnf.result.m_tag_discon_cnf.status);
break;
}
case MSG_ID_NFC_TAG_F2NDEF_RSP:
{
nfc_cnf.op = NFC_OP_TAG_FORMAT_NDEF;
memcpy(&nfc_cnf.result.m_tag_fromat2Ndef_cnf, (nfc_tag_fromat2Ndef_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_tag_fromat2Ndef_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_FORMAT_NDEF =%d/",
nfc_cnf.result.m_tag_fromat2Ndef_cnf.status);
break;
}
case MSG_ID_NFC_TAG_RAWCOM_RSP:
{
nfc_cnf.op = NFC_OP_TAG_RAW_COMM;
memcpy(&nfc_cnf.result.m_tag_raw_com_cnf, (nfc_tag_raw_com_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_tag_raw_com_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_RAW_COMM =%d/%d/",
nfc_cnf.result.m_tag_raw_com_cnf.status,
nfc_cnf.result.m_tag_raw_com_cnf.type);
break;
}
case MSG_ID_NFC_P2P_COMMUNICATION_RSP:
{
nfc_cnf.op = NFC_OP_P2P_COMM;
memcpy(&nfc_cnf.result.m_p2p_com_cnf, (nfc_p2p_com_response*)nfc_ilm_rec.local_para_ptr, sizeof(nfc_p2p_com_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_P2P_COMM =%d/%d/",
nfc_cnf.result.m_p2p_com_cnf.status,
nfc_cnf.result.m_p2p_com_cnf.length);
break;
}
case MSG_ID_NFC_RD_COMMUNICATION_RSP:
{
nfc_cnf.op = NFC_OP_RD_COMM;
memcpy(&nfc_cnf.result.m_rd_com_cnf, (nfc_rd_com_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_rd_com_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_RD_COMM =%d/%d/",
nfc_cnf.result.m_rd_com_cnf.status,
nfc_cnf.result.m_rd_com_cnf.length);
break;
}
case MSG_ID_NFC_TX_ALWAYSON_TEST_RSP:
{
nfc_cnf.op = NFC_OP_TX_ALWAYSON_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TX_ALWAYSON_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_TX_ALWAYSON_WO_ACK_TEST_RSP:
{
nfc_cnf.op = NFC_OP_TX_ALWAYSON_WO_ACK_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TX_ALWAYSON_WO_ACK_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_CARD_EMULATION_MODE_TEST_RSP:
{
nfc_cnf.op = NFC_OP_CARD_MODE_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_CARD_MODE_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_READER_MODE_TEST_RSP:
{
nfc_cnf.op = NFC_OP_READER_MODE_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_READER_MODE_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_P2P_MODE_TEST_RSP:
{
nfc_cnf.op = NFC_OP_P2P_MODE_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_P2P_MODE_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_SWP_SELF_TEST_RSP:
{
nfc_cnf.op = NFC_OP_SWP_SELF_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_SWP_SELF_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_ANTENNA_SELF_TEST_RSP:
{
nfc_cnf.op = NFC_OP_ANTENNA_SELF_TEST;
memcpy(&nfc_cnf.result.m_script_cnf, (nfc_script_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_ANTENNA_SELF_TEST =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_TAG_UID_RW_RSP:
{
nfc_cnf.op = NFC_OP_TAG_UID_RW;
memcpy(&nfc_cnf.result.m_script_uid_cnf, (nfc_script_uid_response*)(nfc_ilm_rec.local_para_ptr + nfc_msg_length), sizeof(nfc_script_uid_response));
META_LOG("META_NFC_CMD:NFC NFC_OP_TAG_UID_RW =%d/",
nfc_cnf.result.m_script_cnf.result);
break;
}
case MSG_ID_NFC_CARD_MODE_TEST_RSP:
case MSG_ID_NFC_STOP_TEST_RSP:
default:
{
fgSupport = 0;
META_LOG("META_NFC_CMD:Don't support CNF CMD %d",nfc_msg.msg_type);
break;
}
}
if (fgSupport == 1)
{
META_LOG("META_NFC_CMD:NFC read nfc_cnf.op=%d,nfc_msg.msg_type=%d", nfc_cnf.op,nfc_msg.msg_type);
nfc_cnf.status = META_SUCCESS;
#ifdef META_NFC_SELF_TEST_EN
if (meta_nfc_cnf_cb)
{
meta_nfc_cnf_cb(&nfc_cnf, NULL, 0);
}
else
#endif
{
WriteDataToPC(&nfc_cnf, sizeof(NFC_CNF), NULL, 0);
}
}
else
{
META_LOG("META_NFC_CMD:Don't Write to PC MSGID,%d,",nfc_msg.msg_type);
}
}
else
{
META_LOG("META_NFC_CMD:Don't support MSGID,%d,DestID,%d",nfc_ilm_rec.msg_id, nfc_ilm_rec.dest_mod_id);
}
}
// else
// {
// usleep(100000); // wake up every 0.1sec
// }
}
bStop_ReadThread = 1;
META_LOG("META_NFC_CMD:NFC read thread stop");
pthread_exit(NULL);
return NULL;
}
/********************************************************************************
//FUNCTION:
// META_NFC_OP
//DESCRIPTION:
// META NFC test main process function.
//
//PARAMETERS:
// req: NFC Req struct
// peer_buff: peer buffer pointer
// peer_len: peer buffer length
//RETURN VALUE:
// void
//
********************************************************************************/
void META_NFC_OP(NFC_REQ *req, char *peer_buff, unsigned short peer_len)
{
ilm_struct nfc_ilm_loc;
nfc_msg_struct nfc_msg;
memset(&nfc_cnf, 0, sizeof(NFC_CNF));
memset(&nfc_msg, 0, sizeof(nfc_msg_struct));
nfc_cnf.header.id = FT_NFC_CNF_ID;
nfc_cnf.header.token = req->header.token;
nfc_cnf.op = req->op;
memset(&nfc_ilm_loc, 0, sizeof(ilm_struct));
nfc_ilm_loc.msg_id = MSG_ID_NFC_TEST_REQ;
nfc_ilm_loc.src_mod_id = MOD_NFC_APP;
nfc_ilm_loc.dest_mod_id = MOD_NFC;
switch(req->op)
{
META_LOG("META_NFC_OP:NFC request op=%d", req->op);
case NFC_OP_SETTING:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_setting_request);
nfc_msg.msg_type = MSG_ID_NFC_SETTING_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)), (char*)&req->cmd.m_setting_req, sizeof(nfc_setting_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_REG_NOTIFY:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_reg_notif_request);
nfc_msg.msg_type = MSG_ID_NFC_NOTIFICATION_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),(char*)&req->cmd.m_reg_notify_req, sizeof(nfc_reg_notif_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_SECURE_ELEMENT:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_se_set_request);
nfc_msg.msg_type = MSG_ID_NFC_SE_SET_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_se_set_req, sizeof(nfc_se_set_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_DISCOVERY:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_dis_notif_request);
nfc_msg.msg_type = MSG_ID_NFC_DISCOVERY_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_dis_notify_req, sizeof(nfc_dis_notif_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TAG_READ:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_tag_read_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_READ_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_tag_read_req, sizeof(nfc_tag_read_request));
break;
}
case NFC_OP_TAG_WRITE:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_tag_write_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_WRITE_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_tag_write_req, sizeof(nfc_tag_write_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TAG_DISCONN:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_tag_disconnect_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_DISCONN_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_tag_discon_req, sizeof(nfc_tag_disconnect_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TAG_FORMAT_NDEF:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_tag_fromat2Ndef_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_F2NDEF_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_tag_fromat2Ndef_req, sizeof(nfc_tag_fromat2Ndef_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TAG_RAW_COMM:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_tag_raw_com_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_RAWCOM_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_tag_raw_com_req, sizeof(nfc_tag_raw_com_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_P2P_COMM:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_p2p_com_request);
nfc_msg.msg_type = MSG_ID_NFC_P2P_COMMUNICATION_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_p2p_com_req, sizeof(nfc_p2p_com_request));
if ((peer_buff != NULL) && (peer_len != 0))
{
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct) + sizeof(nfc_p2p_com_request)), peer_buff, peer_len);
}
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_RD_COMM:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_rd_com_request);
nfc_msg.msg_type = MSG_ID_NFC_RD_COMMUNICATION_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)), &req->cmd.m_rd_com_req, sizeof(nfc_rd_com_request));
if ((peer_buff != NULL) && (peer_len != 0))
{
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)+ sizeof(nfc_rd_com_request)), peer_buff, peer_len);
}
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TX_ALWAYSON_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_TX_ALWAYSON_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_nfc_tx_alwayson_req, sizeof(nfc_tx_alwayson_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TX_ALWAYSON_WO_ACK_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_TX_ALWAYSON_WO_ACK_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_nfc_tx_alwayson_req, sizeof(nfc_tx_alwayson_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_CARD_MODE_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_CARD_EMULATION_MODE_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_nfc_card_emulation_req, sizeof(nfc_card_emulation_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_READER_MODE_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_READER_MODE_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_script_req, sizeof(nfc_script_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_P2P_MODE_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_P2P_MODE_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_script_req, sizeof(nfc_script_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_SWP_SELF_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_SWP_SELF_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_script_req, sizeof(nfc_script_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_ANTENNA_SELF_TEST:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_request);
nfc_msg.msg_type = MSG_ID_NFC_ANTENNA_SELF_TEST_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_script_req, sizeof(nfc_script_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
case NFC_OP_TAG_UID_RW:
{
//Write handle function here
nfc_msg.msg_length = sizeof(nfc_script_uid_request);
nfc_msg.msg_type = MSG_ID_NFC_TAG_UID_RW_REQ;
META_LOG("META_NFC_OP:NFC msg_type,msg_length = (%d,%d)", nfc_msg.msg_type, nfc_msg.msg_length);
memcpy(nfc_ilm_loc.local_para_ptr, (char*)&nfc_msg, sizeof(nfc_msg_struct));
memcpy((nfc_ilm_loc.local_para_ptr + sizeof(nfc_msg_struct)),&req->cmd.m_script_uid_req, sizeof(nfc_script_uid_request));
META_NFC_CMD(&nfc_ilm_loc);
break;
}
default:
{
nfc_cnf.status = META_FAILED;
WriteDataToPC(&nfc_cnf, sizeof(NFC_CNF), NULL, 0);
break;
}
}
return;
}
/********************************************************************************
//FUNCTION:
// FT_DispatchMessage
//DESCRIPTION:
// this function is called to switch the testcase, del the header of peer buf.
//
//PARAMETERS:
// Local_buf: [IN] local buf (cnf cmd)
// Local_len: [IN] local buf size
// pPeerBuf [IN] peer buff
// Peer_len: [IN] peer buff size
//RETURN VALUE:
// TRUE is success, otherwise is fail
//
//DEPENDENCY:
// the FT module must have been loaded.
//
//GLOBALS AFFECTED
// None
********************************************************************************/
void FT_DispatchMessage(void *pLocalBuf, void *pPeerBuf, int local_len, int peer_len)
{
FT_H *ft_header;
ft_header =(FT_H *)pLocalBuf;
kal_int16 ft_peer_len = peer_len -8; //del the size of peer buf header
char *pft_PeerBuf = (char *)pPeerBuf;
pft_PeerBuf += 8; // skip the header of peer buffer
FT_LOG("[FTT_Drv:] FTMainThread ID : %d ", ft_header->id);
switch (ft_header->id)
{
case FT_IS_ALIVE_REQ_ID: //test alive
FT_TestAlive((FT_IS_ALIVE_REQ *)pLocalBuf);
break;
#ifdef FT_WIFI_FEATURE
case FT_WIFI_REQ_ID: //wifi test
FT_WIFI_OP((FT_WM_WIFI_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#endif
case FT_SDCARD_REQ_ID: //sdcard test
FT_SDcard_OP((SDCARD_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_NVRAM_READ_REQ_ID: //nvram read
FT_APEditorRead_OP((FT_AP_Editor_read_req *)pLocalBuf);
break;
case FT_NVRAM_WRITE_REQ_ID: //nvram write
FT_APEditorWrite_OP((FT_AP_Editor_write_req *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_NVRAM_RESET_REQ_ID: //nvram reset
FT_APEditorReset_OP((FT_AP_Editor_reset_req *)pLocalBuf);
break;
case FT_GPIO_REQ_ID:
FT_GPIO_OP((GPIO_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_VER_INFO_REQ_ID: //get version info
FT_GetVersionInfo((FT_VER_INFO_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
/*
case FT_CHECK_META_VER_REQ_ID: //require meta dll version
FT_CheckMetaDllVersion((FT_CHECK_META_VER_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
*/
case FT_POWER_OFF_REQ_ID: //power off target
FT_PowerOff((FT_POWER_OFF_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_REG_WRITE_ID: //baseband reg wirte
FT_CPURegW_OP((FT_REG_WRITE_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_REG_READ_ID: //baseband reg read
FT_CPURegR_OP((FT_REG_READ_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_CCT_REQ_ID:
FT_CCAP_OP((FT_CCT_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_UTILITY_COMMAND_REQ_ID: //utility command
FT_Peripheral_OP((FT_UTILITY_COMMAND_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_PMIC_REG_READ_ID: //pmic read
FT_PMICRegR_OP((FT_PMIC_REG_READ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_PMIC_REG_WRITE_ID: //pmic write
FT_PMICRegW_OP((FT_PMIC_REG_WRITE *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#ifdef FT_BT_FEATURE
case FT_BT_REQ_ID: //bt test
FT_BT_OP((BT_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#endif
/*
case FT_WM_DVB_REQ_ID: //dvb test
FT_DVBT_OP((FT_DVB_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_WM_BAT_REQ_ID:
FT_BAT_OP((FT_BATT_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
*/
case FT_ADC_GETMEADATA_ID: //adc test
FT_AUXADC_OP((AUXADC_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#ifdef FT_GPS_FEATURE
case FT_GPS_REQ_ID:
FT_GPS_OP((GPS_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#endif
case FT_BATT_READ_INFO_REQ_ID:
FT_BAT_FW_OP((FT_BATT_READ_INFO_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_BAT_CHIPUPDATE_REQ_ID:
FT_BAT_ChipUpdate_OP((FT_BATT_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#ifdef FT_FM_FEATURE
case FT_FM_REQ_ID:
FT_FM_OP((FM_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#endif
case FT_L4AUD_REQ_ID:
FT_L4AUDIO_OP((FT_L4AUD_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_LOW_POWER_REQ_ID:
FT_LOW_POWER_OP((FT_LOW_POWER_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_NVRAM_BACKUP_REQ_ID:
FT_NVRAM_Backup_OP((FT_NVRAM_BACKUP_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_NVRAM_RESTORE_REQ_ID:
FT_NVRAM_Restore_OP((FT_NVRAM_RESTORE_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_GSENSOR_REQ_ID:
FT_GSENSOR_OP((GS_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_MATV_CMD_REQ_ID:
#ifdef FT_MATV_FEATURE
FT_MATV_OP((FT_MATV_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
#else
FT_MATV_CNF matv_cnf;
memset(&matv_cnf, 0, sizeof(FT_MATV_CNF));
matv_cnf.header.id = FT_MATV_CMD_CNF_ID;
matv_cnf.header.token = ((FT_MATV_REQ *)pLocalBuf)->header.token;
matv_cnf.status = META_NOT_SUPPORT;
matv_cnf.type = ((FT_MATV_REQ *)pLocalBuf)->type;
WriteDataToPC(&matv_cnf, sizeof(matv_cnf), NULL, 0);
#endif
break;
// Reboot device
case FT_REBOOT_REQ_ID:
FT_Reboot((FT_META_REBOOT_REQ *)pLocalBuf);
break;
case FT_CUSTOMER_REQ_ID:
FT_CUSTOMER_OP((FT_CUSTOMER_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_GET_CHIPID_REQ_ID:
FT_GET_CHIPID_OP((FT_GET_CHIPID_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_MSENSOR_REQ_ID:
FT_MSENSOR_OP((FT_MSENSOR_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_ALSPS_REQ_ID:
FT_ALSPS_OP((FT_ALSPS_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
case FT_GYROSCOPE_REQ_ID:
FT_GYROSENSOR_OP((GYRO_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
// Touch panel
case FT_CTP_REQ_ID:
FT_CTP_OP((Touch_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
// Get version info V2
case FT_VER_INFO_V2_REQ_ID:
FT_GetVersionInfoV2((FT_VER_INFO_V2_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#ifdef FT_NFC_FEATURE
case FT_NFC_REQ_ID:
FT_NFC_OP((NFC_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
#endif
#ifdef FT_EMMC_FEATURE
case FT_EMMC_REQ_ID:
FT_CLR_EMMC_OP((FT_EMMC_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
case FT_CRYPTFS_REQ_ID:
FT_CRYPTFS_OP((FT_CRYPTFS_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
#endif
case FT_BUILD_PROP_REQ_ID:
FT_BUILD_PROP_OP((FT_BUILD_PROP_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
case FT_MODEM_REQ_ID:
FT_MODEM_INFO_OP((FT_MODEM_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
case FT_SIM_NUM_REQ_ID:
FT_SIM_NUM_OP((FT_GET_SIM_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
case FT_DFO_REQ_ID:
FT_DFO_OP((FT_DFO_REQ *)pLocalBuf,(char *)pft_PeerBuf, ft_peer_len);
break;
case FT_ADC_REQ_ID:
FT_ADC_OP((ADC_REQ *)pLocalBuf, (char *)pft_PeerBuf, ft_peer_len);
break;
default:
//printf((TEXT("[FTT_Drv:] FTMainThread Error:!!! ID: %hu "), ft_header->id));
FT_LOG("[FTT_Drv:] FTMainThread Error:!!! ID ");
break;
}
}
void Meta_ADC_OP(ADC_REQ *req, char *peer_buff, unsigned short peer_len)
{
ADC_CNF ADCMetaReturn;
int ret;
memset(&ADCMetaReturn, 0, sizeof(ADCMetaReturn));
ADCMetaReturn.header.id=req->header.id+1;
ADCMetaReturn.header.token=req->header.token;
ADCMetaReturn.status=META_SUCCESS;
ADCMetaReturn.type=req->type;
//add for meta tool-----------------------------------------
meta_adc_fd = open("/dev/MT_pmic_adc_cali",O_RDWR, 0);
if (meta_adc_fd == -1) {
printf("Open /dev/MT_pmic_adc_cali : ERROR \n");
ALOGD("Open /dev/MT_pmic_adc_cali : ERROR \n");
ADCMetaReturn.status=META_FAILED;
goto ADC_Finish;
}
adc_in_data[0] = req->type;
if(adc_in_data[0] == ADC_OP_BAT_VOL) {
ret = ioctl(meta_adc_fd, Get_META_BAT_VOL, adc_out_data);
if (ret == -1)
{
ADCMetaReturn.status = META_FAILED;
}
else
{
ADCMetaReturn.cnf.m_bat_vol.vol = (int)adc_out_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
}
else if(adc_in_data[0] == ADC_OP_BAT_CAPACITY){
ret = ioctl(meta_adc_fd, Get_META_BAT_SOC, adc_out_data);
if (ret == -1)
{
ADCMetaReturn.status = META_FAILED;
}
else
{
ADCMetaReturn.cnf.m_bat_capacity.capacity = (int)adc_out_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
}
printf("Meta_AUXADC_OP : ADC_OP = %d, %d\n", req->type, adc_out_data[0]);
close(meta_adc_fd);
//add for meta tool-----------------------------------------
/* open file */
/* meta_adc_fd = open("/dev/mtk-adc-cali",O_RDWR, 0);
if (meta_adc_fd == -1) {
printf("Open /dev/mtk-adc-cali : ERROR \n");
ALOGD("Open /dev/mtk-adc-cali : ERROR \n");
ADCMetaReturn.status=META_FAILED;
goto ADC_Finish;
}
adc_in_data[0] = req->type;
if(adc_in_data[0] == ADC_OP_GET_CHANNE_NUM) {
ret = ioctl(meta_adc_fd, GET_CHANNEL_NUM, adc_in_data);
if (ret == -1)
{
ADCMetaReturn.status = META_FAILED;
}
else
{
ADCMetaReturn.cnf.m_channel_num.num = (unsigned int)adc_in_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
}
else if(adc_in_data[0] == ADC_OP_QUERY_EFUSE_CAL_EXIST){
ret = ioctl(meta_adc_fd, ADC_EFUSE_ENABLE, adc_in_data);
if (ret == -1)
{
ADCMetaReturn.status = META_FAILED;
}
else
{
ADCMetaReturn.cnf.m_channel_num.num = (unsigned int)adc_in_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
}
printf("Meta_AUXADC_OP : ADC_OP = %d, %d\n", req->type, adc_in_data[0]);
close(meta_adc_fd); */
ADC_Finish:
if (false == WriteDataToPC(&ADCMetaReturn,sizeof(ADCMetaReturn),NULL,0)) {
printf("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
ALOGD("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
}
printf("Meta_AUXADC_OP : Finish !\n");
ALOGD("Meta_AUXADC_OP : Finish !\n");
}
